diff --git a/kbengine_ts/kbengine.bat b/kbengine_ts/kbengine.bat new file mode 100644 index 0000000..b0e3be7 --- /dev/null +++ b/kbengine_ts/kbengine.bat @@ -0,0 +1,15 @@ +REM 将这个脚本放于项目之中，项目框架更新后双击执行即可 +REM 首次使用会问是文件或文件夹,一律选文件 +REM 如果不是cocos creator,需要改下路径 + +REM 这里需要设置kbengine_ts路径 +set kbengine=%cd%\..\..\kbengine_js_plugins\kbengine_ts + +set libs=%cd%\assets\Libs +if not exist %libs% ( + mkdir %libs% +) + +xcopy /y /c /h /r %kbengine%\bin\kbengine.d.ts %cd%\kbengine.d.ts + +xcopy /y /c /h /r %kbengine%\bin\kbengine.js %libs%\kbengine.js diff --git a/kbengine_ts/kbengine/kbengine.d.ts b/kbengine_ts/kbengine/kbengine.d.ts new file mode 100644 index 0000000..1d33cfe --- /dev/null +++ b/kbengine_ts/kbengine/kbengine.d.ts @@ -0,0 +1,768 @@ +/** + * KBEngine的html5客户端扩展ts版 2.x版本 + * cocos creator 环境下使用方法 + * + * 注：（下面的是重点） + * 1、实体声明的命名空间为KBEngine.Entities,与官方的KBEngine不同 + * 2、 @KBEngine.registerEntity() /// TODO: <---组件使用@KBEngine.registerComponent() + export default class Account extends KBEngine.Entity { /// TODO: 组件继承自KBEngine.EntityComponent,类名等于服务器(实体/组件)名 + __comps__ = {组件名:组件类型} ///TODO: 因为组件类型不会从服务器同步，只能获取到EntityComponent，无法获取具体类型，所以需要在实体里进行手动设置，需要代码提示可以手动声明一下 + __init__() { + console.log('创建account') + } + } + //这里加入声明用于vscode代码提示 + declare global { + namespace KBEngine { + interface IEntities{ + Account:new ()=>Account + } + } + } + + * 3、cocos creator编辑器下会出现KBEngine未找到的问题，不影响运行，如果想去掉，将允许编辑器加载勾选 + 4、因为下班了，组件的basecall和cellcall还未测试，改天再继续 + */ +declare namespace KBEngine { + const CLIENT_VERSION = "2.5.0"; + const CLIENT_SCRIPT_VERSION = "0.1.0"; + const PACKET_MAX_SIZE = 1500; + const PACKET_MAX_SIZE_TCP = 1460; + const PACKET_MAX_SIZE_UDP = 1472; + const MESSAGE_ID_LENGTH = 2; + const MESSAGE_LENGTH_LENGTH = 2; + const MESSAGE_LENGTH1_LENGTH = 4; + const MESSAGE_MAX_SIZE = 65535; + const CLIENT_NO_FLOAT = 0; + const KBE_FLT_MAX = 3.402823466e+38; +} +declare namespace KBEngine { + class INT64 { + constructor(lo: any, hi: any); + lo: number; + hi: number; + sign: number; + toString(): string; + } + class UINT64 { + constructor(lo: any, hi: any); + lo: number; + hi: number; + toString(): string; + } +} +declare namespace KBEngine { + function getQualifiedClassName(value: any): any; +} +declare namespace KBEngine { + /** todo 调试输出模块，这里需要根据使用的引擎不同在这里加入判断条件 */ + function INFO_MSG(...args: any[]): void; + function DEBUG_MSG(...args: any[]): void; + function ERROR_MSG(...args: any[]): void; + function WARNING_MSG(...args: any[]): void; +} +declare namespace KBEngine { + function utf8ArrayToString(array: Array): any; + function stringToUTF8Bytes(str: string): any[]; +} +declare namespace KBEngine { + class EventInfo { + classinst: any; + callbackfn: any; + constructor(classinst: any, callbackfn: any); + } + class FiredEvent { + evtName: any; + evtInfo: any; + ars: any; + constructor(evtName: any, evtInfo: any, ars: any); + } + interface IEvents { + [evtName: string]: EventInfo[]; + } + class Events { + constructor(); + _events: IEvents; + _isPause: boolean; + _firedEvents: FiredEvent[]; + register(evtName: string, classinst: any, strCallback: string): void; + deregisterAll(classinst: any): void; + deregister(evtName: string, classinst: any): void; + removeAllFiredEvent(classinst: any): void; + removeFiredEvent(evtName: string, classinst: any): void; + fire(evtName: string, ...args: any[]): void; + pasue(): void; + resume(): void; + clear(): void; + } + const Event: Events; +} +declare namespace KBEngine { + class PackFloatXType { + _unionData: ArrayBuffer; + fv: Float32Array; + uv: Uint32Array; + iv: Int32Array; + } + const _xPackData: PackFloatXType; + const _yPackData: PackFloatXType; + const _zPackData: PackFloatXType; + class MemoryStream { + constructor(size_or_buffer: number | ArrayBuffer); + buffer: ArrayBuffer; + rpos: number; + wpos: number; + readInt8(): number; + readInt16(): number; + readInt32(): number; + readInt64(): INT64; + readUint8(): number; + readUint16(): number; + readUint32(): number; + readUint64(): UINT64; + readFloat(): any; + readDouble(): any; + readString(): string; + readBlob(): Uint8Array; + readStream(): MemoryStream; + readPackXZ(): any[]; + readPackY(): number; + writeInt8(v: any): void; + writeInt16(v: any): void; + writeInt32(v: any): void; + writeInt64(v: any): void; + writeUint8(v: any): void; + writeUint16(v: any): void; + writeUint32(v: any): void; + writeUint64(v: UINT64): void; + writeFloat(v: any): void; + writeDouble(v: any): void; + writeBlob(v: any): void; + writeString(v: any): void; + append(stream: MemoryStream, offset: number, size: number): void; + readSkip(v: any): void; + space(): number; + length(): number; + readEOF(): boolean; + done(): void; + getbuffer(): ArrayBuffer; + setbuffer(buffer: ArrayBuffer): void; + size(): number; + clear(): void; + reclaimObject(): void; + } + module MemoryStream { + const _objects: MemoryStream[]; + function createObject(): MemoryStream; + } +} +declare namespace KBEngine { + class Bundle { + static _objects: Bundle[]; + static createObject(): Bundle; + constructor(); + memorystreams: Array; + stream: MemoryStream; + numMessage: number; + messageLengthBuffer: Uint8Array; + msgtype: any; + messageLength: number; + newMessage(msgtype: any): void; + writeMsgLength(v: any): void; + fini(issend: any): void; + send(network: any): void; + checkStream(v: any): void; + writeInt8(v: any): void; + writeInt16(v: any): void; + writeInt32(v: any): void; + writeInt64(v: any): void; + writeUint8(v: any): void; + writeUint16(v: any): void; + writeUint32(v: any): void; + writeUint64(v: any): void; + writeFloat(v: any): void; + writeDouble(v: any): void; + writeString(v: any): void; + writeBlob(v: any): void; + clear(): void; + reclaimObject(): void; + } + const reader: MemoryStream; + interface IDataType2Id { + [type: string]: number; + } + let datatype2id: IDataType2Id; + function mappingDataType(): void; + function bindWriter(writer: any, argType: number): any; + function bindReader(argType: number): () => any; + class Message { + id: any; + name: any; + length: any; + argsType: any; + args: any; + handler: any; + constructor(id: any, name: any, length: any, argsType: any, args: any, handler: any); + createFromStream(msgstream: any): any; + handleMessage(msgstream: any): void; + } + module messages { + const loginapp: {}; + const baseapp: {}; + const Loginapp_importClientMessages: Message; + const Baseapp_importClientMessages: Message; + const Baseapp_importClientEntityDef: Message; + const onImportClientMessages: Message; + } + let clientmessages: {}; + let bufferedCreateEntityMessages: {}; +} +declare namespace KBEngine { + class Vector2 { + x: number; + y: number; + constructor(x: number, y: number); + distance(pos: Vector2): number; + add(vec2: Vector2): this; + sub(vec2: Vector2): this; + mul(num: number): this; + div(num: number): this; + neg(): this; + } + class Vector3 { + x: number; + y: number; + z: number; + constructor(x: number, y: number, z: number); + distance(pos: Vector3): number; + add(vec3: Vector3): this; + sub(vec3: Vector3): this; + mul(num: number): this; + div(num: number): this; + neg(): this; + } + class Vector4 { + x: number; + y: number; + z: number; + w: number; + constructor(x: number, y: number, z: number, w: number); + distance(pos: Vector4): number; + add(vec4: Vector4): this; + sub(vec4: Vector4): this; + mul(num: number): this; + div(num: number): this; + neg(): this; + } + function clampf(value: any, min_inclusive: any, max_inclusive: any): any; + function int82angle(angle: number, half: boolean): number; + function angle2int8(v: number, half: boolean): number; +} +declare namespace KBEngine { + interface IEntities { + } + const Entities: IEntities; + class Entity { + constructor(); + protected __comps__: { + [compName: string]: new () => EntityComponent; + }; + id: number; + className: string; + position: Vector3; + direction: Vector3; + velocity: number; + cell: any; + base: any; + inWorld: boolean; + inited: boolean; + isControlled: boolean; + entityLastLocalPos: Vector3; + entityLastLocalDir: Vector3; + isOnGround: boolean; + __init__(): void; + attachComponents(): void; + getComponents(compName: string, all?: boolean): any; + detachComponents(): void; + callPropertysSetMethods(): void; + onDestroy(): void; + onControlled(bIsControlled: any): void; + isPlayer(): boolean; + baseCall(type: string, ...params: any[]): void; + cellCall(type: string, ...params: any[]): void; + enterWorld(): void; + onComponentsEnterworld(): void; + onComponentsLeaveworld(): void; + onEnterWorld(): void; + leaveWorld(): void; + onLeaveWorld(): void; + enterSpace(): void; + onEnterSpace(): void; + leaveSpace(): void; + onLeaveSpace(): void; + set_position(): void; + onUpdateVolatileData(): void; + onUpdatePropertys(stream: MemoryStream): void; + set_direction(old: any): void; + onRemoteMethodCall(stream: MemoryStream): void; + } + function registerEntity(): (ctor: new () => Entity) => void; +} +declare namespace KBEngine { + class EntityComponent { + id: number; + entityComponentPropertyID: number; + componentType: number; + ownerID: number; + owner: Entity; + className: string; + base: EntityComponentCall; + cell: EntityComponentCall; + protected onAttached(owner: Entity): void; + protected onDetached(owner: Entity): void; + protected onEnterWorld(): void; + protected onLeaveWorld(): void; + baseCall(type: string, ...params: any[]): void; + cellCall(type: string, ...params: any[]): void; + onUpdatePropertys(propUtype: number, stream: MemoryStream, maxCount: number): void; + onRemoteMethodCall(propUtype: number, stream: MemoryStream): void; + createFromStream(stream: MemoryStream, ecpId: number): void; + } + function registerComponent(): (ctor: new () => EntityComponent) => void; +} +declare namespace KBEngine { + const ENTITYCALL_TYPE_CELL = 0; + const ENTITYCALL_TYPE_BASE = 1; + class EntityCall { + constructor(); + id: number; + className: string; + type: number; + networkInterface: KBEngineApp; + bundle: any; + isBase(): boolean; + isCell(): boolean; + newCall(): any; + sendCall(bundle?: Bundle): void; + } + class EntityComponentCall extends EntityCall { + entityComponentPropertyID: number; + constructor(ecpId: number, eid: number, className: string); + } + class DATATYPE_UINT8 { + bind(): void; + createFromStream(stream: any): any; + addToStream(stream: any, v: any): void; + parseDefaultValStr(v: any): number; + isSameType(v: any): boolean; + } + class DATATYPE_UINT16 { + bind(): void; + createFromStream(stream: any): any; + addToStream(stream: any, v: any): void; + parseDefaultValStr(v: any): number; + isSameType(v: any): boolean; + } + class DATATYPE_UINT32 { + bind(): void; + createFromStream(stream: any): any; + addToStream(stream: any, v: any): void; + parseDefaultValStr(v: any): number; + isSameType(v: any): boolean; + } + class DATATYPE_UINT64 { + bind(): void; + createFromStream(stream: any): any; + addToStream(stream: any, v: any): void; + parseDefaultValStr(v: any): number; + isSameType(v: any): boolean; + } + class DATATYPE_INT8 { + bind(): void; + createFromStream(stream: any): any; + addToStream(stream: any, v: any): void; + parseDefaultValStr(v: any): number; + isSameType(v: any): boolean; + } + class DATATYPE_INT16 { + bind(): void; + createFromStream(stream: any): any; + addToStream(stream: any, v: any): void; + parseDefaultValStr(v: any): number; + isSameType(v: any): boolean; + } + class DATATYPE_INT32 { + bind(): void; + createFromStream(stream: any): any; + addToStream(stream: any, v: any): void; + parseDefaultValStr(v: any): number; + isSameType(v: any): boolean; + } + class DATATYPE_INT64 { + bind(): void; + createFromStream(stream: any): any; + addToStream(stream: any, v: any): void; + parseDefaultValStr(v: any): number; + isSameType(v: any): boolean; + } + class DATATYPE_FLOAT { + bind(): void; + createFromStream(stream: any): any; + addToStream(stream: any, v: any): void; + parseDefaultValStr(v: any): number; + isSameType(v: any): boolean; + } + class DATATYPE_DOUBLE extends DATATYPE_FLOAT { + createFromStream(stream: any): any; + addToStream(stream: any, v: any): void; + } + class DATATYPE_STRING { + bind(): void; + createFromStream(stream: any): any; + addToStream(stream: any, v: any): void; + parseDefaultValStr(v: any): string; + isSameType(v: any): boolean; + } + class DATATYPE_VECTOR2 { + bind(): void; + createFromStream(stream: any): Vector2; + addToStream(stream: any, v: any): void; + parseDefaultValStr(v: any): Vector2; + isSameType(v: any): boolean; + } + class DATATYPE_VECTOR3 { + bind(): void; + createFromStream(stream: any): Vector3; + addToStream(stream: any, v: any): void; + parseDefaultValStr(v: any): Vector3; + isSameType(v: any): boolean; + } + class DATATYPE_VECTOR4 { + bind(): void; + createFromStream(stream: any): Vector4; + addToStream(stream: any, v: any): void; + parseDefaultValStr(v: any): Vector4; + isSameType(v: any): boolean; + } + class DATATYPE_PYTHON { + bind(): void; + createFromStream(stream: any): any; + addToStream(stream: any, v: any): void; + parseDefaultValStr(v: any): Uint8Array; + isSameType(v: any): boolean; + } + class DATATYPE_UNICODE { + bind(): void; + createFromStream(stream: any): any; + addToStream(stream: any, v: any): void; + parseDefaultValStr(v: any): string; + isSameType(v: any): boolean; + } + class DATATYPE_ENTITYCALL { + bind(): void; + createFromStream(stream: any): void; + addToStream(stream: any, v: any): void; + parseDefaultValStr(v: any): Uint8Array; + isSameType(v: any): boolean; + } + class DATATYPE_BLOB { + bind(): void; + createFromStream(stream: any): Uint8Array; + addToStream(stream: any, v: any): void; + parseDefaultValStr(v: any): Uint8Array; + isSameType(v: any): boolean; + } + class DATATYPE_ARRAY { + type: any; + bind(): void; + createFromStream(stream: any): any[]; + addToStream(stream: any, v: any): void; + parseDefaultValStr(v: any): any[]; + isSameType(v: any): boolean; + } + class DATATYPE_FIXED_DICT { + dicttype: {}; + implementedBy: any; + bind(): void; + createFromStream(stream: any): {}; + addToStream(stream: any, v: any): void; + parseDefaultValStr(v: any): {}; + isSameType(v: any): boolean; + } + module datatypes { + const UINT8: DATATYPE_UINT8; + const UINT16: DATATYPE_UINT16; + const UINT32: DATATYPE_UINT32; + const UINT64: DATATYPE_UINT64; + const INT8: DATATYPE_INT8; + const INT16: DATATYPE_INT16; + const INT32: DATATYPE_INT32; + const INT64: DATATYPE_INT64; + const FLOAT: DATATYPE_FLOAT; + const DOUBLE: DATATYPE_DOUBLE; + const STRING: DATATYPE_STRING; + const VECTOR2: DATATYPE_VECTOR2; + const VECTOR3: DATATYPE_VECTOR3; + const VECTOR4: DATATYPE_VECTOR4; + const PYTHON: DATATYPE_PYTHON; + const UNICODE: DATATYPE_UNICODE; + const ENTITYCALL: DATATYPE_ENTITYCALL; + const BLOB: DATATYPE_BLOB; + } +} +declare namespace KBEngine { + class KBEngineArgs { + ip: string; + port: number; + updateHZ: number; + serverHeartbeatTick: number; + isWss: boolean; + readonly protocol: string; + forceBasePort: number; + clientType: number; + isOnInitCallPropertysSetMethods: boolean; + } + const EventTypes: { + createAccount: string; + login: string; + logout: string; + reloginBaseapp: string; + bindAccountEmail: string; + newPassword: string; + onKicked: string; + onDisconnected: string; + onConnectionState: string; + onCreateAccountResult: string; + onVersionNotMatch: string; + onScriptVersionNotMatch: string; + onLoginFailed: string; + onLoginBaseapp: string; + onLoginBaseappFailed: string; + onReloginBaseapp: string; + onReloginBaseappSuccessfully: string; + onReloginBaseappFailed: string; + onEnterWorld: string; + onLeaveWorld: string; + onEnterSpace: string; + onLeaveSpace: string; + set_position: string; + set_direction: string; + updatePosition: string; + addSpaceGeometryMapping: string; + onSetSpaceData: string; + onDelSpaceData: string; + onControlled: string; + onLoseControlledEntity: string; + onStreamDataStarted: string; + onStreamDataRecv: string; + onStreamDataCompleted: string; + }; +} +declare namespace KBEngine { + const moduledefs: {}; + class KBEngineApp { + args: KBEngineArgs; + constructor(args: KBEngineArgs); + baseappIp: string; + username: string; + password: string; + clientdatas: string; + encryptedKey: string; + loginappMessageImported: boolean; + baseappMessageImported: boolean; + serverErrorsDescrImported: boolean; + entitydefImported: boolean; + useAliasEntityID: boolean; + serverErrs: { + [err: string]: ServerErr; + }; + baseappIP: string; + baseappPort: number; + baseappUdpPort: number; + currMsgID: number; + currMsgCount: number; + currMsgLen: number; + fragmentStream: any; + fragmentDatasFlag: number; + fragmentDatasRemain: number; + socket: any; + currserver: string; + currstate: string; + currconnect: string; + serverdatas: string; + serverVersion: string; + serverScriptVersion: string; + serverProtocolMD5: string; + serverEntityDefMD5: string; + clientVersion: string; + clientScriptVersion: string; + entity_uuid: any; + entity_id: number; + entity_type: string; + entityServerPos: Vector3; + entities: {}; + entityIDAliasIDList: any[]; + controlledEntities: any[]; + spacedata: {}; + spaceID: number; + spaceResPath: string; + isLoadedGeometry: boolean; + lastTickTime: number; + lastTickCBTime: number; + component: any; + msgStream: MemoryStream; + resetSocket(): void; + reset(): void; + installEvents(): void; + uninstallEvents(): void; + hello(): void; + player(): any; + findEntity(entityID: any): any; + connect(host: any, port: any): void; + disconnect(): void; + onopen(): void; + onerror_before_onopen(evt: any): void; + onerror_after_onopen(evt: any): void; + onmessage(msg: any): void; + writeFragmentMessage(FragmentDataType: any, stream: MemoryStream, datasize: any): void; + mergeFragmentMessage(stream: MemoryStream): boolean | 0; + onclose(): void; + send(msg: any): void; + close(): void; + update(): void; + Client_onAppActiveTickCB(): void; + serverErr(id: any): string; + Client_onImportServerErrorsDescr(stream: any): void; + Client_onImportClientSdk(stream: MemoryStream): void; + onOpenLoginapp_login(): void; + onOpenLoginapp_createAccount(): void; + onImportClientMessagesCompleted(): void; + createDataTypeFromStreams(stream: any, canprint: any): void; + createDataTypeFromStream(stream: any, canprint: any): void; + Client_onImportClientEntityDef(stream: any): void; + Client_onVersionNotMatch(stream: any): void; + Client_onScriptVersionNotMatch(stream: any): void; + onImportEntityDefCompleted(): void; + importClientMessages(stream: any): void; + Client_onImportClientMessages(msg: any): void; + createAccount(username: any, password: any, datas: any): void; + createAccount_loginapp(noconnect: any): void; + bindAccountEmail(emailAddress: any): void; + newPassword(old_password: any, new_password: any): void; + logout(): void; + login(username: any, password: any, datas: any): void; + login_loginapp(noconnect: any): void; + onOpenLoginapp_resetpassword(): void; + reset_password(username: any): void; + resetpassword_loginapp(noconnect: any): void; + onOpenBaseapp(): void; + login_baseapp(noconnect: any): void; + reloginBaseapp(): void; + onReOpenBaseapp(): void; + Client_onHelloCB(args: any): void; + Client_onLoginFailed(args: any): void; + Client_onLoginSuccessfully(args: any): void; + Client_onLoginBaseappFailed(failedcode: any): void; + Client_onReloginBaseappFailed(failedcode: any): void; + Client_onReloginBaseappSuccessfully(stream: any): void; + entityclass: {}; + getentityclass(entityType: any): any; + Client_onCreatedProxies(rndUUID: any, eid: any, entityType: any): void; + getViewEntityIDFromStream(stream: any): number; + onUpdatePropertys_(eid: any, stream: any): void; + Client_onUpdatePropertysOptimized(stream: any): void; + Client_onUpdatePropertys(stream: any): void; + onRemoteMethodCall_(eid: any, stream: any): void; + Client_onRemoteMethodCallOptimized(stream: any): void; + Client_onRemoteMethodCall(stream: any): void; + Client_onEntityEnterWorld(stream: any): void; + Client_onEntityLeaveWorldOptimized(stream: any): void; + Client_onEntityLeaveWorld(eid: any): void; + Client_onEntityDestroyed(eid: any): void; + Client_onEntityEnterSpace(stream: any): void; + Client_onEntityLeaveSpace(eid: any): void; + Client_onKicked(failedcode: any): void; + Client_onCreateAccountResult(stream: any): void; + Client_onControlEntity(eid: any, isControlled: any): void; + updatePlayerToServer(): void; + addSpaceGeometryMapping(spaceID: any, respath: any): void; + clearSpace(isAll: any): void; + clearEntities(isAll: any): void; + Client_initSpaceData(stream: any): void; + Client_setSpaceData(spaceID: any, key: any, value: any): void; + Client_delSpaceData(spaceID: any, key: any): void; + Client_getSpaceData(spaceID: any, key: any): any; + Client_onUpdateBasePos(x: any, y: any, z: any): void; + Client_onUpdateBasePosXZ(x: any, z: any): void; + Client_onUpdateData(stream: any): void; + Client_onSetEntityPosAndDir(stream: any): void; + Client_onUpdateData_ypr(stream: any): void; + Client_onUpdateData_yp(stream: any): void; + Client_onUpdateData_yr(stream: any): void; + Client_onUpdateData_pr(stream: any): void; + Client_onUpdateData_y(stream: any): void; + Client_onUpdateData_p(stream: any): void; + Client_onUpdateData_r(stream: any): void; + Client_onUpdateData_xz(stream: any): void; + Client_onUpdateData_xz_ypr(stream: any): void; + Client_onUpdateData_xz_yp(stream: any): void; + Client_onUpdateData_xz_yr(stream: any): void; + Client_onUpdateData_xz_pr(stream: any): void; + Client_onUpdateData_xz_y(stream: any): void; + Client_onUpdateData_xz_p(stream: any): void; + Client_onUpdateData_xz_r(stream: any): void; + Client_onUpdateData_xyz(stream: any): void; + Client_onUpdateData_xyz_ypr(stream: any): void; + Client_onUpdateData_xyz_yp(stream: any): void; + Client_onUpdateData_xyz_yr(stream: any): void; + Client_onUpdateData_xyz_pr(stream: any): void; + Client_onUpdateData_xyz_y(stream: any): void; + Client_onUpdateData_xyz_p(stream: any): void; + Client_onUpdateData_xyz_r(stream: any): void; + Client_onUpdateData_ypr_optimized(stream: any): void; + Client_onUpdateData_yp_optimized(stream: any): void; + Client_onUpdateData_yr_optimized(stream: any): void; + Client_onUpdateData_pr_optimized(stream: any): void; + Client_onUpdateData_y_optimized(stream: any): void; + Client_onUpdateData_p_optimized(stream: any): void; + Client_onUpdateData_r_optimized(stream: any): void; + Client_onUpdateData_xz_optimized(stream: any): void; + Client_onUpdateData_xz_ypr_optimized(stream: any): void; + Client_onUpdateData_xz_yp_optimized(stream: any): void; + Client_onUpdateData_xz_yr_optimized(stream: any): void; + Client_onUpdateData_xz_pr_optimized(stream: any): void; + Client_onUpdateData_xz_y_optimized(stream: any): void; + Client_onUpdateData_xz_p_optimized(stream: any): void; + Client_onUpdateData_xz_r_optimized(stream: any): void; + Client_onUpdateData_xyz_optimized(stream: any): void; + Client_onUpdateData_xyz_ypr_optimized(stream: any): void; + Client_onUpdateData_xyz_yp_optimized(stream: any): void; + Client_onUpdateData_xyz_yr_optimized(stream: any): void; + Client_onUpdateData_xyz_pr_optimized(stream: any): void; + Client_onUpdateData_xyz_y_optimized(stream: any): void; + Client_onUpdateData_xyz_p_optimized(stream: any): void; + Client_onUpdateData_xyz_r_optimized(stream: any): void; + _updateVolatileData(entityID: any, x: any, y: any, z: any, yaw: any, pitch: any, roll: any, isOnGround: any, isOptimized?: boolean): void; + Client_onStreamDataStarted(id: any, datasize: any, descr: any): void; + Client_onStreamDataRecv(stream: any): void; + Client_onStreamDataCompleted(id: any): void; + Client_onReqAccountResetPasswordCB(failedcode: any): void; + Client_onReqAccountBindEmailCB(failedcode: any): void; + Client_onReqAccountNewPasswordCB(failedcode: any): void; + } + class ServerErr { + name: string; + descr: string; + id: number; + } + const FragmentDataTypes: { + FRAGMENT_DATA_UNKNOW: number; + FRAGMENT_DATA_MESSAGE_ID: number; + FRAGMENT_DATA_MESSAGE_LENGTH: number; + FRAGMENT_DATA_MESSAGE_LENGTH1: number; + FRAGMENT_DATA_MESSAGE_BODY: number; + }; + let app: KBEngineApp; + function create(args: KBEngineArgs): void; + function destroy(): void; +} diff --git a/kbengine_ts/kbengine/kbengine.js b/kbengine_ts/kbengine/kbengine.js new file mode 100644 index 0000000..6e0be4b --- /dev/null +++ b/kbengine_ts/kbengine/kbengine.js @@ -0,0 +1,4291 @@ +var __reflect = (this && this.__reflect) || function (p, c, t) { + p.__class__ = c, t ? t.push(c) : t = [c], p.__types__ = p.__types__ ? t.concat(p.__types__) : t; +}; +var __extends = this && this.__extends || function __extends(t, e) { + function r() { + this.constructor = t; +} +for (var i in e) e.hasOwnProperty(i) && (t[i] = e[i]); +r.prototype = e.prototype, t.prototype = new r(); +}; +/** + * KBEngine的html5客户端扩展ts版 2.x版本 + * cocos creator 环境下使用方法 + * + * 注：（下面的是重点） + * 1、实体声明的命名空间为KBEngine.Entities,与官方的KBEngine不同 + * 2、 @KBEngine.registerEntity() /// TODO: <---组件使用@KBEngine.registerComponent() + export default class Account extends KBEngine.Entity { /// TODO: 组件继承自KBEngine.EntityComponent,类名等于服务器(实体/组件)名 + __comps__ = {组件名:组件类型} ///TODO: 因为组件类型不会从服务器同步，只能获取到EntityComponent，无法获取具体类型，所以需要在实体里进行手动设置，需要代码提示可以手动声明一下 + __init__() { + console.log('创建account') + } + } + //这里加入声明用于vscode代码提示 + declare global { + namespace KBEngine { + interface IEntities{ + Account:new ()=>Account + } + } + } + + * 3、cocos creator编辑器下会出现KBEngine未找到的问题，不影响运行，如果想去掉，将允许编辑器加载勾选 + 4、因为下班了，组件的basecall和cellcall还未测试，改天再继续 + */ +/*----------------------------------------------------------------------------------------- + global +-----------------------------------------------------------------------------------------*/ +var KBEngine; +(function (KBEngine) { + KBEngine.CLIENT_VERSION = '2.5.0'; + KBEngine.CLIENT_SCRIPT_VERSION = '0.1.0'; + KBEngine.PACKET_MAX_SIZE = 1500; + KBEngine.PACKET_MAX_SIZE_TCP = 1460; + KBEngine.PACKET_MAX_SIZE_UDP = 1472; + KBEngine.MESSAGE_ID_LENGTH = 2; + KBEngine.MESSAGE_LENGTH_LENGTH = 2; + KBEngine.MESSAGE_LENGTH1_LENGTH = 4; + KBEngine.MESSAGE_MAX_SIZE = 65535; + KBEngine.CLIENT_NO_FLOAT = 0; + KBEngine.KBE_FLT_MAX = 3.402823466e+38; +})(KBEngine || (KBEngine = {})); +/** + * 加上声明避免cocos creator编辑器报错 + */ +window['KBEngine'] = KBEngine; +if (!ArrayBuffer['transfer']) { + ArrayBuffer['transfer'] = function (source, length) { + var dest = new ArrayBuffer(length); + if (!(source instanceof ArrayBuffer) || !(dest instanceof ArrayBuffer)) { + throw new TypeError("ArrayBuffer.transfer, error: Source and destination must be ArrayBuffer instances"); + } + if (dest.byteLength >= source.byteLength) { + var buf = new Uint8Array(dest); + buf.set(new Uint8Array(source), 0); + } + else { + throw new RangeError("ArrayBuffer.transfer, error: destination has not enough space"); + } + return dest; + }; +} +; +/*----------------------------------------------------------------------------------------- + number64bits +-----------------------------------------------------------------------------------------*/ +(function (KBEngine) { + var INT64 = (function () { + function INT64(lo, hi) { + this.sign = 1; + this.lo = lo; + this.hi = hi; + if (hi >= 2147483648) { + this.sign = -1; + if (this.lo > 0) { + this.lo = (4294967296 - this.lo) & 0xffffffff; + this.hi = 4294967295 - this.hi; + } + else { + this.lo = (4294967296 - this.lo) & 0xffffffff; + this.hi = 4294967296 - this.hi; + } + } + } + INT64.prototype.toString = function () { + var result = ""; + if (this.sign < 0) { + result += "-"; + } + var low = this.lo.toString(16); + var high = this.hi.toString(16); + if (this.hi > 0) { + result += high; + for (var i = 8 - low.length; i > 0; --i) { + result += "0"; + } + } + result += low; + return result; + }; + return INT64; + }()); + KBEngine.INT64 = INT64; + __reflect(INT64.prototype, "KBEngine.INT64"); + var UINT64 = (function () { + function UINT64(lo, hi) { + this.lo = lo; + this.hi = hi; + } + UINT64.prototype.toString = function () { + var low = this.lo.toString(16); + var high = this.hi.toString(16); + var result = ""; + if (this.hi > 0) { + result += high; + for (var i = 8 - low.length; i > 0; --i) { + result += "0"; + } + } + result += low; + return result; + }; + return UINT64; + }()); + KBEngine.UINT64 = UINT64; + __reflect(UINT64.prototype, "KBEngine.UINT64"); +})(KBEngine || (KBEngine = {})); +(function (KBEngine) { + function getQualifiedClassName(value) { + var type = typeof value; + if (!value || (type != "object" && !value.prototype)) { + return type; + } + var prototype = value.prototype ? value.prototype : Object.getPrototypeOf(value); + if (prototype.hasOwnProperty("__class__")) { + return prototype["__class__"]; + } + var constructorString = prototype.constructor.toString().trim(); + var index = constructorString.indexOf("("); + var className = constructorString.substring(9, index); + var c = className.split('.'); + Object.defineProperty(prototype, "__class__", { + value: c[c.length - 1], + enumerable: false, + writable: true + }); + return c[c.length - 1]; + } + KBEngine.getQualifiedClassName = getQualifiedClassName; +})(KBEngine || (KBEngine = {})); +/*----------------------------------------------------------------------------------------- + debug +-----------------------------------------------------------------------------------------*/ +(function (KBEngine) { + /** todo 调试输出模块，这里需要根据使用的引擎不同在这里加入判断条件 */ + function INFO_MSG() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + console.info.apply(console, args); + } + KBEngine.INFO_MSG = INFO_MSG; + function DEBUG_MSG() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + console.debug.apply(console, args); + } + KBEngine.DEBUG_MSG = DEBUG_MSG; + function ERROR_MSG() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + console.error.apply(console, args); + } + KBEngine.ERROR_MSG = ERROR_MSG; + function WARNING_MSG() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + console.warn.apply(console, args); + } + KBEngine.WARNING_MSG = WARNING_MSG; +})(KBEngine || (KBEngine = {})); +/*----------------------------------------------------------------------------------------- + string +-----------------------------------------------------------------------------------------*/ +(function (KBEngine) { + function utf8ArrayToString(array) { + var out, i, len, c; + var char2, char3; + out = ""; + len = array.length; + i = 0; + while (i < len) { + c = array[i++]; + switch (c >> 4) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + // 0xxxxxxx + out += String.fromCharCode(c); + break; + case 12: + case 13: + // 110x xxxx 10xx xxxx + char2 = array[i++]; + out += String.fromCharCode(((c & 0x1F) << 6) | (char2 & 0x3F)); + break; + case 14: + // 1110 xxxx 10xx xxxx 10xx xxxx + char2 = array[i++]; + char3 = array[i++]; + out += String.fromCharCode(((c & 0x0F) << 12) | + ((char2 & 0x3F) << 6) | + ((char3 & 0x3F) << 0)); + break; + } + } + return out; + } + KBEngine.utf8ArrayToString = utf8ArrayToString; + function stringToUTF8Bytes(str) { + var utf8 = []; + for (var i = 0; i < str.length; i++) { + var charcode = str.charCodeAt(i); + if (charcode < 0x80) + utf8.push(charcode); + else if (charcode < 0x800) { + utf8.push(0xc0 | (charcode >> 6), 0x80 | (charcode & 0x3f)); + } + else if (charcode < 0xd800 || charcode >= 0xe000) { + utf8.push(0xe0 | (charcode >> 12), 0x80 | ((charcode >> 6) & 0x3f), 0x80 | (charcode & 0x3f)); + } + else { + i++; + // UTF-16 encodes 0x10000-0x10FFFF by + // subtracting 0x10000 and splitting the + // 20 bits of 0x0-0xFFFFF into two halves + charcode = 0x10000 + (((charcode & 0x3ff) << 10) + | (str.charCodeAt(i) & 0x3ff)); + utf8.push(0xf0 | (charcode >> 18), 0x80 | ((charcode >> 12) & 0x3f), 0x80 | ((charcode >> 6) & 0x3f), 0x80 | (charcode & 0x3f)); + } + } + return utf8; + } + KBEngine.stringToUTF8Bytes = stringToUTF8Bytes; +})(KBEngine || (KBEngine = {})); +/*----------------------------------------------------------------------------------------- + event +-----------------------------------------------------------------------------------------*/ +(function (KBEngine) { + var EventInfo = (function () { + function EventInfo(classinst, callbackfn) { + this.classinst = classinst; + this.callbackfn = callbackfn; + } + return EventInfo; + }()); + KBEngine.EventInfo = EventInfo; + __reflect(EventInfo.prototype, "KBEngine.EventInfo"); + var FiredEvent = (function () { + function FiredEvent(evtName, evtInfo, ars) { + this.evtName = evtName; + this.evtInfo = evtInfo; + this.ars = ars; + } + return FiredEvent; + }()); + KBEngine.FiredEvent = FiredEvent; + __reflect(FiredEvent.prototype, "KBEngine.FiredEvent"); + var Events = (function () { + function Events() { + this._events = {}; + this._isPause = false; + this._firedEvents = []; + } + Events.prototype.register = function (evtName, classinst, strCallback) { + var callbackfn = classinst[strCallback]; + if (callbackfn == undefined) { + KBEngine.ERROR_MSG('export class Event::fire: not found strCallback(' + classinst + ")!" + strCallback); + return; + } + var evtlst = this._events[evtName]; + if (evtlst == undefined) { + evtlst = []; + this._events[evtName] = evtlst; + } + var info = new EventInfo(classinst, callbackfn); + evtlst.push(info); + }; + Events.prototype.deregisterAll = function (classinst) { + for (var itemkey in this._events) { + this.deregister(itemkey, classinst); + } + }; + Events.prototype.deregister = function (evtName, classinst) { + var evtlst = this._events[evtName]; + if (!evtlst) + return; + for (var i = evtlst.length - 1; i >= 0; i--) { + var info = evtlst[i]; + if (info.classinst == classinst) { + evtlst.splice(i, 1); + } + } + }; + Events.prototype.removeAllFiredEvent = function (classinst) { + this.removeFiredEvent("", classinst); + }; + Events.prototype.removeFiredEvent = function (evtName, classinst) { + var firedEvents = this._firedEvents; + for (var i = firedEvents.length - 1; i >= 0; i--) { + var evt = firedEvents[i]; + if ((evtName == "" || evt.evtName == evtName) && evt.evtInfo.classinst == classinst) { + firedEvents.splice(i, 1); + } + } + }; + Events.prototype.fire = function (evtName) { + var args = []; + for (var _i = 1; _i < arguments.length; _i++) { + args[_i - 1] = arguments[_i]; + } + if (!evtName) { + KBEngine.ERROR_MSG('export class Event::fire: not found eventName!'); + return; + } + var evtlst = this._events[evtName]; + if (evtlst == undefined) { + return; + } + // let ars = []; + // for (let i = 0; i < args.length; i++) + // ars.push(args[i]); + for (var i = 0; i < evtlst.length; i++) { + var info = evtlst[i]; + if (!this._isPause) { + info.callbackfn.apply(info.classinst, args || []); + } + else { + var eobj = new FiredEvent(evtName, info, args || []); + this._firedEvents.push(eobj); + } + // if (args.length < 1) { + // info.callbackfn.apply(info.classinst); + // } + // else { + // info.callbackfn.apply(info.classinst, args); + // } + } + }; + Events.prototype.pasue = function () { + this._isPause = true; + }; + Events.prototype.resume = function () { + this._isPause = false; + var firedEvents = this._firedEvents; + while (firedEvents.length > 0) { + var evt = firedEvents.shift(); + var info = evt.evtInfo; + var ars = evt.ars; + if (ars.length < 1) { + info.callbackfn.apply(info.classinst); + } + else { + info.callbackfn.apply(info.classinst, ars); + } + } + }; + Events.prototype.clear = function () { + this._events = {}; + this._firedEvents.splice(0, this._firedEvents.length); + }; + return Events; + }()); + KBEngine.Events = Events; + __reflect(Events.prototype, "KBEngine.Events"); + KBEngine.Event = new Events(); +})(KBEngine || (KBEngine = {})); +/*----------------------------------------------------------------------------------------- + memorystream +-----------------------------------------------------------------------------------------*/ +(function (KBEngine) { + var PackFloatXType = (function () { + function PackFloatXType() { + this._unionData = new ArrayBuffer(4); + this.fv = new Float32Array(this._unionData, 0, 1); + this.uv = new Uint32Array(this._unionData, 0, 1); + this.iv = new Int32Array(this._unionData, 0, 1); + } + return PackFloatXType; + }()); + KBEngine.PackFloatXType = PackFloatXType; + __reflect(PackFloatXType.prototype, "KBEngine.PackFloatXType"); + KBEngine._xPackData = new PackFloatXType(); + KBEngine._yPackData = new PackFloatXType(); + KBEngine._zPackData = new PackFloatXType(); + var MemoryStream = (function () { + function MemoryStream(size_or_buffer) { + this.rpos = 0; + this.wpos = 0; + if (size_or_buffer instanceof ArrayBuffer) { + this.buffer = size_or_buffer; + } + else { + this.buffer = new ArrayBuffer(size_or_buffer); + } + this.rpos = 0; + this.wpos = 0; + } + //--------------------------------------------------------------------------------- + MemoryStream.prototype.readInt8 = function () { + var buf = new Int8Array(this.buffer, this.rpos, 1); + this.rpos += 1; + return buf[0]; + }; + MemoryStream.prototype.readInt16 = function () { + var v = this.readUint16(); + if (v >= 32768) + v -= 65536; + return v; + }; + MemoryStream.prototype.readInt32 = function () { + var v = this.readUint32(); + if (v >= 2147483648) + v -= 4294967296; + return v; + }; + MemoryStream.prototype.readInt64 = function () { + var lo = this.readUint32(); + var hi = this.readUint32(); + return new KBEngine.INT64(lo, hi); + }; + MemoryStream.prototype.readUint8 = function () { + var buf = new Uint8Array(this.buffer, this.rpos, 1); + this.rpos += 1; + return buf[0]; + }; + MemoryStream.prototype.readUint16 = function () { + var buf = new Uint8Array(this.buffer, this.rpos); + this.rpos += 2; + return ((buf[1] & 0xff) << 8) + (buf[0] & 0xff); + }; + MemoryStream.prototype.readUint32 = function () { + var buf = new Uint8Array(this.buffer, this.rpos); + this.rpos += 4; + return (buf[3] << 24) + (buf[2] << 16) + (buf[1] << 8) + buf[0]; + }; + MemoryStream.prototype.readUint64 = function () { + var lo = this.readUint32(); + var hi = this.readUint32(); + return new KBEngine.UINT64(lo, hi); + }; + MemoryStream.prototype.readFloat = function () { + var buf; + try { + buf = new Float32Array(this.buffer, this.rpos, 1); + } + catch (e) { + buf = new Float32Array(this.buffer.slice(this.rpos, this.rpos + 4)); + } + this.rpos += 4; + return buf[0]; + }; + MemoryStream.prototype.readDouble = function () { + var buf; + try { + buf = new Float64Array(this.buffer, this.rpos, 1); + } + catch (e) { + buf = new Float64Array(this.buffer.slice(this.rpos, this.rpos + 8), 0, 1); + } + this.rpos += 8; + return buf[0]; + }; + MemoryStream.prototype.readString = function () { + var buf = new Uint8Array(this.buffer, this.rpos); + var i = 0; + var s = ""; + while (true) { + if (buf[i] != 0) { + s += String.fromCharCode(buf[i]); + } + else { + i++; + break; + } + i++; + if (this.rpos + i >= this.buffer.byteLength) + throw (new Error("export class MemoryStream::readString: rpos(" + (this.rpos + i) + ")>=" + + this.buffer.byteLength + " overflow!")); + } + this.rpos += i; + return s; + }; + MemoryStream.prototype.readBlob = function () { + var size = this.readUint32(); + var buf = new Uint8Array(this.buffer, this.rpos, size); + this.rpos += size; + return buf; + }; + MemoryStream.prototype.readStream = function () { + var buf = new Uint8Array(this.buffer, this.rpos, this.buffer.byteLength - this.rpos); + this.rpos = this.buffer.byteLength; + return new MemoryStream(buf); + }; + MemoryStream.prototype.readPackXZ = function () { + var xPackData = KBEngine._xPackData; + var zPackData = KBEngine._zPackData; + xPackData.fv[0] = 0.0; + zPackData.fv[0] = 0.0; + xPackData.uv[0] = 0x40000000; + zPackData.uv[0] = 0x40000000; + var v1 = this.readUint8(); + var v2 = this.readUint8(); + var v3 = this.readUint8(); + var data = 0; + data |= (v1 << 16); + data |= (v2 << 8); + data |= v3; + xPackData.uv[0] |= (data & 0x7ff000) << 3; + zPackData.uv[0] |= (data & 0x0007ff) << 15; + xPackData.fv[0] -= 2.0; + zPackData.fv[0] -= 2.0; + xPackData.uv[0] |= (data & 0x800000) << 8; + zPackData.uv[0] |= (data & 0x000800) << 20; + var d = new Array(2); + d[0] = xPackData.fv[0]; + d[1] = zPackData.fv[0]; + return d; + }; + MemoryStream.prototype.readPackY = function () { + var v = this.readUint16(); + var yPackData = KBEngine._yPackData; + yPackData.uv[0] = 0x40000000; + yPackData.uv[0] |= (v & 0x7fff) << 12; + yPackData.fv[0] -= 2.0; + yPackData.uv[0] |= (v & 0x8000) << 16; + return yPackData.fv[0]; + }; + //--------------------------------------------------------------------------------- + MemoryStream.prototype.writeInt8 = function (v) { + var buf = new Int8Array(this.buffer, this.wpos, 1); + buf[0] = v; + this.wpos += 1; + }; + MemoryStream.prototype.writeInt16 = function (v) { + this.writeInt8(v & 0xff); + this.writeInt8(v >> 8 & 0xff); + }; + MemoryStream.prototype.writeInt32 = function (v) { + for (var i = 0; i < 4; i++) + this.writeInt8(v >> i * 8 & 0xff); + }; + MemoryStream.prototype.writeInt64 = function (v) { + this.writeInt32(v.lo); + this.writeInt32(v.hi); + }; + MemoryStream.prototype.writeUint8 = function (v) { + var buf = new Uint8Array(this.buffer, this.wpos, 1); + buf[0] = v; + this.wpos += 1; + }; + MemoryStream.prototype.writeUint16 = function (v) { + this.writeUint8(v & 0xff); + this.writeUint8(v >> 8 & 0xff); + }; + MemoryStream.prototype.writeUint32 = function (v) { + for (var i = 0; i < 4; i++) + this.writeUint8(v >> i * 8 & 0xff); + }; + MemoryStream.prototype.writeUint64 = function (v) { + this.writeUint32(v.lo); + this.writeUint32(v.hi); + }; + MemoryStream.prototype.writeFloat = function (v) { + try { + var buf = new Float32Array(this.buffer, this.wpos, 1); + buf[0] = v; + } + catch (e) { + var buf = new Float32Array(1); + buf[0] = v; + var buf1 = new Uint8Array(this.buffer); + var buf2 = new Uint8Array(buf.buffer); + buf1.set(buf2, this.wpos); + } + this.wpos += 4; + }; + MemoryStream.prototype.writeDouble = function (v) { + try { + var buf = new Float64Array(this.buffer, this.wpos, 1); + buf[0] = v; + } + catch (e) { + var buf = new Float64Array(1); + buf[0] = v; + var buf1 = new Uint8Array(this.buffer); + var buf2 = new Uint8Array(buf.buffer); + buf1.set(buf2, this.wpos); + } + this.wpos += 8; + }; + MemoryStream.prototype.writeBlob = function (v) { + var size = v.length; + if (size + 4 > this.space()) { + KBEngine.ERROR_MSG("memorystream::writeBlob: no free!"); + return; + } + this.writeUint32(size); + var buf = new Uint8Array(this.buffer, this.wpos, size); + if (typeof (v) == "string") { + for (var i = 0; i < size; i++) { + buf[i] = v.charCodeAt(i); + } + } + else { + for (var i = 0; i < size; i++) { + buf[i] = v[i]; + } + } + this.wpos += size; + }; + MemoryStream.prototype.writeString = function (v) { + if (v.length > this.space()) { + KBEngine.ERROR_MSG("memorystream::writeString: no free!"); + return; + } + var buf = new Uint8Array(this.buffer, this.wpos); + var i = 0; + for (var idx = 0; idx < v.length; idx++) { + buf[i++] = v.charCodeAt(idx); + } + buf[i++] = 0; + this.wpos += i; + }; + MemoryStream.prototype.append = function (stream, offset, size) { + if (size > this.space()) { + this.buffer = ArrayBuffer['transfer'](this.buffer, this.buffer.byteLength + size * 2); + } + var buf = new Uint8Array(this.buffer, this.wpos, size); + buf.set(new Uint8Array(stream.buffer, offset, size), 0); + this.wpos += size; + }; + //--------------------------------------------------------------------------------- + MemoryStream.prototype.readSkip = function (v) { + this.rpos += v; + }; + //--------------------------------------------------------------------------------- + MemoryStream.prototype.space = function () { + return this.buffer.byteLength - this.wpos; + }; + //--------------------------------------------------------------------------------- + MemoryStream.prototype.length = function () { + return this.wpos - this.rpos; + }; + //--------------------------------------------------------------------------------- + MemoryStream.prototype.readEOF = function () { + return this.buffer.byteLength - this.rpos <= 0; + }; + //--------------------------------------------------------------------------------- + MemoryStream.prototype.done = function () { + this.rpos = this.wpos; + }; + //--------------------------------------------------------------------------------- + MemoryStream.prototype.getbuffer = function () { + return this.buffer.slice(this.rpos, this.wpos); + }; + MemoryStream.prototype.setbuffer = function (buffer) { + this.clear(); + this.buffer = buffer; + }; + MemoryStream.prototype.size = function () { + return this.buffer.byteLength; + }; + MemoryStream.prototype.clear = function () { + this.rpos = this.wpos = 0; + if (this.buffer.byteLength > KBEngine.PACKET_MAX_SIZE) { + this.buffer = new ArrayBuffer(KBEngine.PACKET_MAX_SIZE); + } + }; + MemoryStream.prototype.reclaimObject = function () { + this.clear(); + if (MemoryStream._objects != undefined) { + MemoryStream._objects.push(this); + } + }; + return MemoryStream; + }()); + KBEngine.MemoryStream = MemoryStream; + __reflect(MemoryStream.prototype, "KBEngine.MemoryStream"); + (function (MemoryStream) { + MemoryStream._objects = []; + function createObject() { + return MemoryStream._objects.length > 0 ? MemoryStream._objects.pop() : new MemoryStream(KBEngine.PACKET_MAX_SIZE_TCP); + } + MemoryStream.createObject = createObject; + })(MemoryStream = KBEngine.MemoryStream || (KBEngine.MemoryStream = {})); +})(KBEngine || (KBEngine = {})); +/*----------------------------------------------------------------------------------------- + bundle +-----------------------------------------------------------------------------------------*/ +(function (KBEngine) { + var Bundle = (function () { + function Bundle() { + this.memorystreams = new Array(); + this.numMessage = 0; + this.messageLengthBuffer = null; + this.msgtype = null; + this.messageLength = 0; + this.stream = KBEngine.MemoryStream.createObject(); + } + Bundle.createObject = function () { + return Bundle._objects.length > 0 ? Bundle._objects.pop() : new Bundle(); + }; + //--------------------------------------------------------------------------------- + Bundle.prototype.newMessage = function (msgtype) { + this.fini(false); + this.msgtype = msgtype; + this.numMessage += 1; + if (this.msgtype.length == -1) { + this.messageLengthBuffer = new Uint8Array(this.stream.buffer, this.stream.wpos + KBEngine.MESSAGE_ID_LENGTH, 2); + } + this.writeUint16(msgtype.id); + if (this.messageLengthBuffer) { + this.writeUint16(0); + this.messageLengthBuffer[0] = 0; + this.messageLengthBuffer[1] = 0; + this.messageLength = 0; + } + }; + //--------------------------------------------------------------------------------- + Bundle.prototype.writeMsgLength = function (v) { + if (this.messageLengthBuffer) { + this.messageLengthBuffer[0] = v & 0xff; + this.messageLengthBuffer[1] = v >> 8 & 0xff; + } + }; + //--------------------------------------------------------------------------------- + Bundle.prototype.fini = function (issend) { + if (this.numMessage > 0) { + this.writeMsgLength(this.messageLength); + if (this.stream) + this.memorystreams.push(this.stream); + this.stream = KBEngine.MemoryStream.createObject(); + } + if (issend) { + this.messageLengthBuffer = null; + this.numMessage = 0; + this.msgtype = null; + } + }; + //--------------------------------------------------------------------------------- + Bundle.prototype.send = function (network) { + this.fini(true); + for (var i = 0; i < this.memorystreams.length; i++) { + var tmpStream = this.memorystreams[i]; + network.send(tmpStream.getbuffer()); + } + this.reclaimObject(); + }; + //--------------------------------------------------------------------------------- + Bundle.prototype.checkStream = function (v) { + if (v > this.stream.space()) { + this.memorystreams.push(this.stream); + this.stream = KBEngine.MemoryStream.createObject(); + } + this.messageLength += v; + }; + //--------------------------------------------------------------------------------- + Bundle.prototype.writeInt8 = function (v) { + this.checkStream(1); + this.stream.writeInt8(v); + }; + Bundle.prototype.writeInt16 = function (v) { + this.checkStream(2); + this.stream.writeInt16(v); + }; + Bundle.prototype.writeInt32 = function (v) { + this.checkStream(4); + this.stream.writeInt32(v); + }; + Bundle.prototype.writeInt64 = function (v) { + this.checkStream(8); + this.stream.writeInt64(v); + }; + Bundle.prototype.writeUint8 = function (v) { + this.checkStream(1); + this.stream.writeUint8(v); + }; + Bundle.prototype.writeUint16 = function (v) { + this.checkStream(2); + this.stream.writeUint16(v); + }; + Bundle.prototype.writeUint32 = function (v) { + this.checkStream(4); + this.stream.writeUint32(v); + }; + Bundle.prototype.writeUint64 = function (v) { + this.checkStream(8); + this.stream.writeUint64(v); + }; + Bundle.prototype.writeFloat = function (v) { + this.checkStream(4); + this.stream.writeFloat(v); + }; + Bundle.prototype.writeDouble = function (v) { + this.checkStream(8); + this.stream.writeDouble(v); + }; + Bundle.prototype.writeString = function (v) { + this.checkStream(v.length + 1); + this.stream.writeString(v); + }; + Bundle.prototype.writeBlob = function (v) { + this.checkStream(v.length + 4); + this.stream.writeBlob(v); + }; + Bundle.prototype.clear = function () { + for (var i = 0; i < this.memorystreams.length; i++) { + if (this.stream != this.memorystreams[i]) + this.memorystreams[i].reclaimObject(); + } + if (this.stream) + this.stream.clear(); + else + this.stream = KBEngine.MemoryStream.createObject(); + this.memorystreams = new Array(); + this.numMessage = 0; + this.messageLengthBuffer = null; + this.messageLength = 0; + this.msgtype = null; + }; + Bundle.prototype.reclaimObject = function () { + this.clear(); + if (Bundle._objects != undefined) + Bundle._objects.push(this); + }; + Bundle._objects = []; + return Bundle; + }()); + KBEngine.Bundle = Bundle; + __reflect(Bundle.prototype, "KBEngine.Bundle"); + KBEngine.reader = new KBEngine.MemoryStream(0); + KBEngine.datatype2id = {}; + function mappingDataType() { + KBEngine.datatype2id = {}; + KBEngine.datatype2id["STRING"] = 1; + KBEngine.datatype2id["STD::STRING"] = 1; + KBEngine.datatype2id["UINT8"] = 2; + KBEngine.datatype2id["BOOL"] = 2; + KBEngine.datatype2id["DATATYPE"] = 2; + KBEngine.datatype2id["CHAR"] = 2; + KBEngine.datatype2id["DETAIL_TYPE"] = 2; + KBEngine.datatype2id["ENTITYCALL_CALL_TYPE"] = 2; + KBEngine.datatype2id["UINT16"] = 3; + KBEngine.datatype2id["UNSIGNED SHORT"] = 3; + KBEngine.datatype2id["SERVER_ERROR_CODE"] = 3; + KBEngine.datatype2id["ENTITY_TYPE"] = 3; + KBEngine.datatype2id["ENTITY_PROPERTY_UID"] = 3; + KBEngine.datatype2id["ENTITY_METHOD_UID"] = 3; + KBEngine.datatype2id["ENTITY_SCRIPT_UID"] = 3; + KBEngine.datatype2id["DATATYPE_UID"] = 3; + KBEngine.datatype2id["UINT32"] = 4; + KBEngine.datatype2id["UINT"] = 4; + KBEngine.datatype2id["UNSIGNED INT"] = 4; + KBEngine.datatype2id["ARRAYSIZE"] = 4; + KBEngine.datatype2id["SPACE_ID"] = 4; + KBEngine.datatype2id["GAME_TIME"] = 4; + KBEngine.datatype2id["TIMER_ID"] = 4; + KBEngine.datatype2id["UINT64"] = 5; + KBEngine.datatype2id["DBID"] = 5; + KBEngine.datatype2id["COMPONENT_ID"] = 5; + KBEngine.datatype2id["INT8"] = 6; + KBEngine.datatype2id["COMPONENT_ORDER"] = 6; + KBEngine.datatype2id["INT16"] = 7; + KBEngine.datatype2id["SHORT"] = 7; + KBEngine.datatype2id["INT32"] = 8; + KBEngine.datatype2id["INT"] = 8; + KBEngine.datatype2id["ENTITY_ID"] = 8; + KBEngine.datatype2id["CALLBACK_ID"] = 8; + KBEngine.datatype2id["COMPONENT_TYPE"] = 8; + KBEngine.datatype2id["INT64"] = 9; + KBEngine.datatype2id["PYTHON"] = 10; + KBEngine.datatype2id["PY_DICT"] = 10; + KBEngine.datatype2id["PY_TUPLE"] = 10; + KBEngine.datatype2id["PY_LIST"] = 10; + KBEngine.datatype2id["ENTITYCALL"] = 10; + KBEngine.datatype2id["BLOB"] = 11; + KBEngine.datatype2id["UNICODE"] = 12; + KBEngine.datatype2id["FLOAT"] = 13; + KBEngine.datatype2id["DOUBLE"] = 14; + KBEngine.datatype2id["VECTOR2"] = 15; + KBEngine.datatype2id["VECTOR3"] = 16; + KBEngine.datatype2id["VECTOR4"] = 17; + KBEngine.datatype2id["FIXED_DICT"] = 18; + KBEngine.datatype2id["ARRAY"] = 19; + KBEngine.datatype2id["ENTITYCALL"] = 20; + } + KBEngine.mappingDataType = mappingDataType; + mappingDataType(); + function bindWriter(writer, argType) { + switch (argType) { + case KBEngine.datatype2id["UINT8"]: return writer.writeUint8; + case KBEngine.datatype2id["UINT16"]: return writer.writeUint16; + case KBEngine.datatype2id["UINT32"]: return writer.writeUint32; + case KBEngine.datatype2id["UINT64"]: return writer.writeUint64; + case KBEngine.datatype2id["INT8"]: return writer.writeInt8; + case KBEngine.datatype2id["INT16"]: return writer.writeInt16; + case KBEngine.datatype2id["INT32"]: return writer.writeInt32; + case KBEngine.datatype2id["INT64"]: return writer.writeInt64; + case KBEngine.datatype2id["FLOAT"]: return writer.writeFloat; + case KBEngine.datatype2id["DOUBLE"]: return writer.writeDouble; + case KBEngine.datatype2id["STRING"]: return writer.writeString; + case KBEngine.datatype2id["FIXED_DICT"]: return writer.writeStream; + case KBEngine.datatype2id["ARRAY"]: return writer.writeStream; + default: return writer.writeStream; + } + } + KBEngine.bindWriter = bindWriter; + function bindReader(argType) { + switch (argType) { + case KBEngine.datatype2id["UINT8"]: return KBEngine.reader.readUint8; + case KBEngine.datatype2id["UINT16"]: return KBEngine.reader.readUint16; + case KBEngine.datatype2id["UINT32"]: return KBEngine.reader.readUint32; + case KBEngine.datatype2id["UINT64"]: return KBEngine.reader.readUint64; + case KBEngine.datatype2id["INT8"]: return KBEngine.reader.readInt8; + case KBEngine.datatype2id["INT16"]: return KBEngine.reader.readInt16; + case KBEngine.datatype2id["INT32"]: return KBEngine.reader.readInt32; + case KBEngine.datatype2id["INT64"]: return KBEngine.reader.readInt64; + case KBEngine.datatype2id["FLOAT"]: return KBEngine.reader.readFloat; + case KBEngine.datatype2id["DOUBLE"]: return KBEngine.reader.readDouble; + case KBEngine.datatype2id["STRING"]: return KBEngine.reader.readString; + case KBEngine.datatype2id["FIXED_DICT"]: return KBEngine.reader.readStream; + case KBEngine.datatype2id["ARRAY"]: return KBEngine.reader.readStream; + default: return KBEngine.reader.readStream; + } + } + KBEngine.bindReader = bindReader; + var Message = (function () { + function Message(id, name, length, argsType, args, handler) { + this.id = id; + this.name = name; + this.length = length; + this.argsType = argsType; + this.args = args; + this.handler = handler; + for (var i = 0; i < args.length; i++) { + args[i] = bindReader(args[i]); + } + } + Message.prototype.createFromStream = function (msgstream) { + if (this.args.length <= 0) + return msgstream; + var result = new Array(this.args.length); + for (var i = 0; i < this.args.length; i++) { + result[i] = this.args[i].call(msgstream); + } + return result; + }; + Message.prototype.handleMessage = function (msgstream) { + if (this.handler == null) { + KBEngine.ERROR_MSG("Message::handleMessage: interface(" + this.name + "/" + this.id + ") no implement!"); + return; + } + if (this.args.length <= 0) { + if (this.argsType < 0) + this.handler(msgstream); + else + this.handler(); + } + else { + this.handler.apply(KBEngine.app, this.createFromStream(msgstream)); + } + }; + return Message; + }()); + KBEngine.Message = Message; + __reflect(Message.prototype, "KBEngine.Message"); + var messages; + (function (messages) { + messages.loginapp = {}; + messages.baseapp = {}; + messages.Loginapp_importClientMessages = new Message(5, "importClientMessages", 0, 0, new Array(), null); + messages.Baseapp_importClientMessages = new Message(207, "importClientMessages", 0, 0, new Array(), null); + messages.Baseapp_importClientEntityDef = new Message(208, "importClientEntityDef", 0, 0, new Array(), null); + messages.onImportClientMessages = new Message(518, "onImportClientMessages", -1, -1, new Array(), null); + })(messages = KBEngine.messages || (KBEngine.messages = {})); + KBEngine.clientmessages = {}; + KBEngine.bufferedCreateEntityMessages = {}; +})(KBEngine || (KBEngine = {})); +/*----------------------------------------------------------------------------------------- + math +-----------------------------------------------------------------------------------------*/ +(function (KBEngine) { + var Vector2 = (function () { + function Vector2(x, y) { + this.x = x; + this.y = y; + } + Vector2.prototype.distance = function (pos) { + var x = pos.x - this.x; + var y = pos.y - this.y; + return Math.sqrt(x * x + y * y); + }; + Vector2.prototype.add = function (vec2) { + this.x += vec2.x; + this.y += vec2.y; + return this; + }; + Vector2.prototype.sub = function (vec2) { + this.x -= vec2.x; + this.y -= vec2.y; + return this; + }; + Vector2.prototype.mul = function (num) { + this.x *= num; + this.y *= num; + return this; + }; + Vector2.prototype.div = function (num) { + this.x /= num; + this.y /= num; + return this; + }; + Vector2.prototype.neg = function () { + this.x = -this.x; + this.y = -this.y; + return this; + }; + return Vector2; + }()); + KBEngine.Vector2 = Vector2; + __reflect(Vector2.prototype, "KBEngine.Vector2"); + var Vector3 = (function () { + function Vector3(x, y, z) { + this.x = x; + this.y = y; + this.z = z; + this.x = x; + this.y = y; + this.z = z; + } + Vector3.prototype.distance = function (pos) { + var x = pos.x - this.x; + var y = pos.y - this.y; + var z = pos.z - this.z; + return Math.sqrt(x * x + y * y + z * z); + }; + //向量加法 + Vector3.prototype.add = function (vec3) { + this.x += vec3.x; + this.y += vec3.y; + this.z += vec3.z; + return this; + }; + //向量减法 + Vector3.prototype.sub = function (vec3) { + this.x -= vec3.x; + this.y -= vec3.y; + this.z -= vec3.z; + return this; + }; + //向量乘法 + Vector3.prototype.mul = function (num) { + this.x *= num; + this.y *= num; + this.z *= num; + return this; + }; + //向量除法 + Vector3.prototype.div = function (num) { + this.x /= num; + this.y /= num; + this.z /= num; + return this; + }; + // 向量取反 + Vector3.prototype.neg = function () { + this.x = -this.x; + this.y = -this.y; + this.z = -this.z; + return this; + }; + return Vector3; + }()); + KBEngine.Vector3 = Vector3; + __reflect(Vector3.prototype, "KBEngine.Vector3"); + var Vector4 = (function () { + function Vector4(x, y, z, w) { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } + Vector4.prototype.distance = function (pos) { + var x = pos.x - this.x; + var y = pos.y - this.y; + var z = pos.z - this.z; + var w = pos.w - this.w; + return Math.sqrt(x * x + y * y + z * z + w * w); + }; + Vector4.prototype.add = function (vec4) { + this.x += vec4.x; + this.y += vec4.y; + this.z += vec4.z; + this.w += vec4.w; + return this; + }; + Vector4.prototype.sub = function (vec4) { + this.x -= vec4.x; + this.y -= vec4.y; + this.z -= vec4.z; + this.w -= vec4.w; + return this; + }; + Vector4.prototype.mul = function (num) { + this.x *= num; + this.y *= num; + this.z *= num; + this.w *= num; + return this; + }; + Vector4.prototype.div = function (num) { + this.x /= num; + this.y /= num; + this.z /= num; + this.w /= num; + return this; + }; + Vector4.prototype.neg = function () { + this.x = -this.x; + this.y = -this.y; + this.z = -this.z; + this.w = -this.w; + return this; + }; + return Vector4; + }()); + KBEngine.Vector4 = Vector4; + __reflect(Vector4.prototype, "KBEngine.Vector4"); + function clampf(value, min_inclusive, max_inclusive) { + if (min_inclusive > max_inclusive) { + var temp = min_inclusive; + min_inclusive = max_inclusive; + max_inclusive = temp; + } + return value < min_inclusive ? min_inclusive : value < max_inclusive ? value : max_inclusive; + } + KBEngine.clampf = clampf; + function int82angle(angle, half) { + return angle * (Math.PI / (half ? 254.0 : 128.0)); + } + KBEngine.int82angle = int82angle; + function angle2int8(v, half) { + var angle = 0; + if (!half) { + //todo 原来写的float(Math.PI)，因为js没有float这个方法所以去掉了 + angle = Math.floor((v * 128.0) / Math.PI + 0.5); + } + else { + angle = clampf(Math.floor((v * 254.0) / Math.PI + 0.5), -128.0, 127.0); + } + return angle; + } + KBEngine.angle2int8 = angle2int8; +})(KBEngine || (KBEngine = {})); +/*----------------------------------------------------------------------------------------- + entity +-----------------------------------------------------------------------------------------*/ +(function (KBEngine) { + KBEngine.Entities = {}; + var Entity = (function () { + function Entity() { + this.__comps__ = {}; + this.id = 0; + this.className = ""; + this.position = new KBEngine.Vector3(0, 0, 0); + this.direction = new KBEngine.Vector3(0, 0, 0); + this.velocity = 0; + this.cell = null; + this.base = null; + // enterworld之后设置为true + this.inWorld = false; + // __init__调用之后设置为true + this.inited = false; + // 是否被控制 + this.isControlled = false; + this.entityLastLocalPos = new KBEngine.Vector3(0.0, 0.0, 0.0); + this.entityLastLocalDir = new KBEngine.Vector3(0.0, 0.0, 0.0); + // 玩家是否在地面上 + this.isOnGround = false; + for (var i in this.__comps__) { + this[i] = new this.__comps__[i](); + } + } + Entity.prototype.__init__ = function () { + }; + Entity.prototype.attachComponents = function () { + for (var i in this.__comps__) { + this[i].onAttached(this); + } + }; + Entity.prototype.getComponents = function (compName, all) { + if (all === void 0) { all = false; } + var res = []; + for (var i in this.__comps__) { + if (KBEngine.getQualifiedClassName(this.__comps__[i]) === compName) { + if (!all) { + return this[i]; + } + res.push(this[i]); + } + } + return res; + }; + Entity.prototype.detachComponents = function () { + for (var i in this.__comps__) { + this[i].onDetached(this); + } + }; + Entity.prototype.callPropertysSetMethods = function () { + var currModule = KBEngine.moduledefs[this.className]; + for (var name_1 in currModule.propertys) { + var propertydata = currModule.propertys[name_1]; + var properUtype = propertydata[0]; + name_1 = propertydata[2]; + var setmethod = propertydata[5]; + var flags = propertydata[6]; + var oldval = this[name_1]; + if (setmethod != null) { + // base类属性或者进入世界后cell类属性会触发set_*方法 + // ED_FLAG_BASE_AND_CLIENT、ED_FLAG_BASE + if (flags == 0x00000020 || flags == 0x00000040) { + if (this.inited && !this.inWorld) + setmethod.call(this, oldval); + } + else { + if (this.inWorld) { + if (flags == 0x00000008 || flags == 0x00000010) { + if (!this.isPlayer()) + continue; + } + setmethod.call(this, oldval); + } + } + } + } + ; + }; + Entity.prototype.onDestroy = function () { + this.detachComponents(); + }; + Entity.prototype.onControlled = function (bIsControlled) { + }; + Entity.prototype.isPlayer = function () { + return this.id == KBEngine.app.entity_id; + }; + Entity.prototype.baseCall = function (type) { + // if (params.length < 1) { + // ERROR_MSG('Entity::baseCall: not fount interfaceName!'); + // return; + // } + var params = []; + for (var _i = 1; _i < arguments.length; _i++) { + params[_i - 1] = arguments[_i]; + } + if (this.base == undefined) { + KBEngine.ERROR_MSG('Entity::baseCall: base is None!'); + return; + } + var method = KBEngine.moduledefs[this.className].base_methods[type]; + if (method == undefined) { + KBEngine.ERROR_MSG("Entity::baseCall: The server did not find the def_method(" + this.className + "." + type + ")!"); + return; + } + var methodID = method[0]; + var args = method[3]; + if (params.length != args.length) { + KBEngine.ERROR_MSG("Entity::baseCall: args(" + (params.length - 1) + "!= " + args.length + ") size is error!"); + return; + } + this.base.newCall(); + this.base.bundle.writeUint16(0); + this.base.bundle.writeUint16(methodID); + try { + for (var i = 0; i < params.length; i++) { + if (args[i].isSameType(params[i])) { + args[i].addToStream(this.base.bundle, params[i]); + } + else { + throw new Error("Entity::baseCall: arg[" + i + "] is error!"); + } + } + } + catch (e) { + KBEngine.ERROR_MSG(e.toString()); + KBEngine.ERROR_MSG('Entity::baseCall: args is error!'); + this.base.bundle = null; + return; + } + this.base.sendCall(); + }; + Entity.prototype.cellCall = function (type) { + // if (params.length < 1) { + // ERROR_MSG('Entity::cellCall: not fount interfaceName!'); + // return; + // } + var params = []; + for (var _i = 1; _i < arguments.length; _i++) { + params[_i - 1] = arguments[_i]; + } + if (this.cell == undefined) { + KBEngine.ERROR_MSG('Entity::cellCall: cell is None!'); + return; + } + var method = KBEngine.moduledefs[this.className].cell_methods[type]; + if (method == undefined) { + KBEngine.ERROR_MSG("Entity::cellCall: The server did not find the def_method(" + this.className + "." + type + ")!"); + return; + } + var methodID = method[0]; + var args = method[3]; + if (params.length != args.length) { + KBEngine.ERROR_MSG("Entity::cellCall: args(" + (params.length) + "!= " + args.length + ") size is error!"); + return; + } + this.cell.newCall(); + this.cell.bundle.writeUint16(0); + this.cell.bundle.writeUint16(methodID); + try { + for (var i = 0; i < args.length; i++) { + if (args[i].isSameType(params[i])) { + args[i].addToStream(this.cell.bundle, params[i]); + } + else { + throw new Error("Entity::cellCall: arg[" + i + "] is error!"); + } + } + } + catch (e) { + KBEngine.ERROR_MSG(e.toString()); + KBEngine.ERROR_MSG('Entity::cellCall: args is error!'); + this.cell.bundle = null; + return; + } + this.cell.sendCall(); + }; + Entity.prototype.enterWorld = function () { + KBEngine.INFO_MSG(this.className + '::enterWorld: ' + this.id); + this.inWorld = true; + this.onEnterWorld(); + this.onComponentsEnterworld(); + KBEngine.Event.fire("onEnterWorld", this); + }; + Entity.prototype.onComponentsEnterworld = function () { + for (var i in this.__comps__) { + this[i].onEnterWorld(); + } + }; + Entity.prototype.onComponentsLeaveworld = function () { + for (var i in this.__comps__) { + this[i].onLeaveWorld(); + } + }; + Entity.prototype.onEnterWorld = function () { + }; + Entity.prototype.leaveWorld = function () { + KBEngine.INFO_MSG(this.className + '::leaveWorld: ' + this.id); + this.inWorld = false; + this.onLeaveWorld(); + this.onComponentsLeaveworld(); + KBEngine.Event.fire("onLeaveWorld", this); + }; + Entity.prototype.onLeaveWorld = function () { + }; + Entity.prototype.enterSpace = function () { + KBEngine.INFO_MSG(this.className + '::enterSpace: ' + this.id); + this.onEnterSpace(); + KBEngine.Event.fire("onEnterSpace", this); + // 要立即刷新表现层对象的位置 + KBEngine.Event.fire("set_position", this); + KBEngine.Event.fire("set_direction", this); + }; + Entity.prototype.onEnterSpace = function () { + }; + Entity.prototype.leaveSpace = function () { + KBEngine.INFO_MSG(this.className + '::leaveSpace: ' + this.id); + this.onLeaveSpace(); + KBEngine.Event.fire("onLeaveSpace", this); + }; + Entity.prototype.onLeaveSpace = function () { + }; + Entity.prototype.set_position = function () { + KBEngine.DEBUG_MSG(this.className + "::set_position: " + this.position); + if (this.isPlayer()) { + KBEngine.app.entityServerPos.x = this.position.x; + KBEngine.app.entityServerPos.y = this.position.y; + KBEngine.app.entityServerPos.z = this.position.z; + } + KBEngine.Event.fire("set_position", this); + }; + Entity.prototype.onUpdateVolatileData = function () { + }; + Entity.prototype.onUpdatePropertys = function (stream) { + var currModule = KBEngine.moduledefs[KBEngine.getQualifiedClassName(this)]; + var pdatas = currModule.propertys; + while (stream.length() > 0) { + var utype = 0, cId = 0; + if (currModule.usePropertyDescrAlias) { + cId = stream.readUint8(); + utype = stream.readUint8(); + } + else { + cId = stream.readUint16(); + utype = stream.readUint16(); + } + if (cId !== 0) { + var comp = pdatas[cId]; + if (this[comp[2]]) { + this[comp[2]].onUpdatePropertys(utype, stream, -1); + } + continue; + } + var propertydata = pdatas[utype]; + var setmethod = propertydata[5]; + var flags = propertydata[6]; + if (!propertydata[4]) { + if (this[propertydata[2]] && typeof this[propertydata[2]].createFromStream === 'function') + this[propertydata[2]].createFromStream(stream, propertydata[0]); + continue; + } + var val = propertydata[4].createFromStream(stream); + var oldval = this[propertydata[2]]; + KBEngine.INFO_MSG("KBEngineApp::Client_onUpdatePropertys: " + this.className + "(id=" + this.id + " " + propertydata[2] + ", val=" + val + ")!"); + this[propertydata[2]] = val; + if (setmethod != null) { + // base类属性或者进入世界后cell类属性会触发set_*方法 + if (flags == 0x00000020 || flags == 0x00000040) { + if (this.inited) + setmethod.call(this, oldval); + } + else { + if (this.inWorld) + setmethod.call(this, oldval); + } + } + } + }; + Entity.prototype.set_direction = function (old) { + KBEngine.DEBUG_MSG(this.className + "::set_direction: " + this.direction); + KBEngine.Event.fire("set_direction", this); + }; + Entity.prototype.onRemoteMethodCall = function (stream) { + var sm = KBEngine.moduledefs[this.className]; + var ComponentID = sm.usePropertyDescrAlias ? stream.readUint8() : stream.readUint16(); + var methodUtype = sm.useMethodDescrAlias ? stream.readUint8() : stream.readUint16(); + if (ComponentID !== 0) { + var comp = this[sm.propertys[ComponentID][2]]; + if (comp) + comp.onRemoteMethodCall(methodUtype, stream); + return; + } + var methoddata = KBEngine.moduledefs[this.className].methods[methodUtype]; + var args = []; + var argsdata = methoddata[3]; + for (var i = 0; i < argsdata.length; i++) { + args.push(argsdata[i].createFromStream(stream)); + } + if (this[methoddata[2]] != undefined) { + this[methoddata[2]].apply(this, args); + } + else { + KBEngine.ERROR_MSG("KBEngineApp::Client_onRemoteMethodCall: entity(" + this.id + ") not found method(" + methoddata[2] + ")!"); + } + }; + return Entity; + }()); + KBEngine.Entity = Entity; + __reflect(Entity.prototype, "KBEngine.Entity"); + function registerEntity() { + return function (ctor) { + var name = KBEngine.getQualifiedClassName(ctor); + // KBEngine['Entities'] = KBEngine['Entities'] || {} + KBEngine['Entities'][name] = ctor; + }; + } + KBEngine.registerEntity = registerEntity; +})(KBEngine || (KBEngine = {})); +(function (KBEngine) { + var EntityComponent = (function () { + function EntityComponent() { + this.id = 0; + this.entityComponentPropertyID = 0; + this.componentType = 0; + this.ownerID = 0; + this.owner = null; + this.className = ''; + this.base = null; + this.cell = null; + } + EntityComponent.prototype.onAttached = function (owner) { }; + EntityComponent.prototype.onDetached = function (owner) { }; + EntityComponent.prototype.onEnterWorld = function () { }; + EntityComponent.prototype.onLeaveWorld = function () { }; + EntityComponent.prototype.baseCall = function (type) { + var params = []; + for (var _i = 1; _i < arguments.length; _i++) { + params[_i - 1] = arguments[_i]; + } + var className = this.className; + if (this.base == undefined) { + KBEngine.ERROR_MSG('Entity::baseCall: base is None!'); + return; + } + var method = KBEngine.moduledefs[className].base_methods[type]; + if (method == undefined) { + KBEngine.ERROR_MSG("Entity::baseCall: The server did not find the def_method(" + className + "." + type + ")!"); + return; + } + var methodID = method[0]; + var args = method[3]; + if (params.length != args.length) { + KBEngine.ERROR_MSG("Entity::baseCall: args(" + (params.length - 1) + "!= " + args.length + ") size is error!"); + return; + } + this.base.newCall(); + this.base.bundle.writeUint16(this.entityComponentPropertyID); + this.base.bundle.writeUint16(methodID); + try { + for (var i = 0; i < params.length; i++) { + if (args[i].isSameType(params[i])) { + args[i].addToStream(this.base.bundle, params[i]); + } + else { + throw new Error("Entity::baseCall: arg[" + i + "] is error!"); + } + } + } + catch (e) { + KBEngine.ERROR_MSG(e.toString()); + KBEngine.ERROR_MSG('Entity::baseCall: args is error!'); + this.base.bundle = null; + return; + } + this.base.sendCall(); + }; + EntityComponent.prototype.cellCall = function (type) { + var params = []; + for (var _i = 1; _i < arguments.length; _i++) { + params[_i - 1] = arguments[_i]; + } + var className = this.className; + if (this.cell == undefined) { + KBEngine.ERROR_MSG('Entity::cellCall: cell is None!'); + return; + } + var method = KBEngine.moduledefs[className].cell_methods[type]; + if (method == undefined) { + KBEngine.ERROR_MSG("Entity::cellCall: The server did not find the def_method(" + className + "." + type + ")!"); + return; + } + var methodID = method[0]; + var args = method[3]; + if (params.length != args.length) { + KBEngine.ERROR_MSG("Entity::cellCall: args(" + (params.length) + "!= " + args.length + ") size is error!"); + return; + } + this.cell.newCall(); + this.cell.bundle.writeUint16(this.entityComponentPropertyID); + this.cell.bundle.writeUint16(methodID); + try { + for (var i = 0; i < args.length; i++) { + if (args[i].isSameType(params[i])) { + args[i].addToStream(this.cell.bundle, params[i]); + } + else { + throw new Error("Entity::cellCall: arg[" + i + "] is error!"); + } + } + } + catch (e) { + KBEngine.ERROR_MSG(e.toString()); + KBEngine.ERROR_MSG('Entity::cellCall: args is error!'); + this.cell.bundle = null; + return; + } + this.cell.sendCall(); + }; + EntityComponent.prototype.onUpdatePropertys = function (propUtype, stream, maxCount) { + var className = KBEngine.getQualifiedClassName(this); + var currModule = KBEngine.moduledefs[className]; + var pdatas = currModule.propertys; + while (stream.length() > 0 && maxCount-- != 0) { + var utype = propUtype, cId = 0; + if (utype === 0) { + if (currModule.usePropertyDescrAlias) { + cId = stream.readUint8(); + utype = stream.readUint8(); + } + else { + cId = stream.readUint16(); + utype = stream.readUint16(); + } + } + var propertydata = pdatas[utype]; + var setmethod = propertydata[5]; + var flags = propertydata[6]; + var val = propertydata[4].createFromStream(stream); + var oldval = this[propertydata[2]]; + KBEngine.INFO_MSG("KBEngineApp::Client_onUpdatePropertys: " + className + "(id=" + this.id + " " + propertydata[2] + ", val=" + val + ")!"); + this[propertydata[2]] = val; + if (setmethod != null) { + // base类属性或者进入世界后cell类属性会触发set_*方法 + if (flags == 0x00000020 || flags == 0x00000040) { + if (this.owner.inited) + setmethod.call(this, oldval); + } + else { + if (this.owner.inWorld) + setmethod.call(this, oldval); + } + } + } + }; + EntityComponent.prototype.onRemoteMethodCall = function (propUtype, stream) { + var sm = KBEngine.moduledefs[this.className].methods[propUtype]; + var args = []; + var argsdata = sm[3]; + for (var i = 0; i < argsdata.length; i++) { + args.push(argsdata[i].createFromStream(stream)); + } + typeof this[sm[2]] === 'function' && this[sm[2]].apply(this, args); + }; + EntityComponent.prototype.createFromStream = function (stream, ecpId) { + this.entityComponentPropertyID = ecpId; + this.componentType = stream.readInt32(); + this.ownerID = stream.readInt32(); + this.owner = KBEngine.app.entities[this.ownerID]; + //UInt16 ComponentDescrsType; + stream.readUint16(); + var count = stream.readUint16(); + if (count > 0) { + this.onUpdatePropertys(0, stream, count); + } + this.className = KBEngine.getQualifiedClassName(this); + this.base = new KBEngine.EntityComponentCall(this.entityComponentPropertyID, this.ownerID, this.className); + this.base.type = KBEngine.ENTITYCALL_TYPE_BASE; + this.cell = new KBEngine.EntityComponentCall(this.entityComponentPropertyID, this.ownerID, this.className); + this.cell.type = KBEngine.ENTITYCALL_TYPE_CELL; + }; + return EntityComponent; + }()); + KBEngine.EntityComponent = EntityComponent; + __reflect(EntityComponent.prototype, "KBEngine.EntityComponent"); + function registerComponent() { + return function (ctor) { + var name = KBEngine.getQualifiedClassName(ctor); + // KBEngine['Entities'] = KBEngine['Entities'] || {} + KBEngine['Entities'][name] = ctor; + }; + } + KBEngine.registerComponent = registerComponent; +})(KBEngine || (KBEngine = {})); +/*----------------------------------------------------------------------------------------- + EntityCall +-----------------------------------------------------------------------------------------*/ +(function (KBEngine) { + KBEngine.ENTITYCALL_TYPE_CELL = 0; + KBEngine.ENTITYCALL_TYPE_BASE = 1; + var EntityCall = (function () { + function EntityCall() { + this.id = 0; + this.className = ''; + this.type = KBEngine.ENTITYCALL_TYPE_CELL; + this.networkInterface = KBEngine.app; + this.bundle = null; + } + EntityCall.prototype.isBase = function () { + return this.type == KBEngine.ENTITYCALL_TYPE_BASE; + }; + EntityCall.prototype.isCell = function () { + return this.type == KBEngine.ENTITYCALL_TYPE_CELL; + }; + EntityCall.prototype.newCall = function () { + if (this.bundle == null) + this.bundle = KBEngine.Bundle.createObject(); + if (this.type == KBEngine.ENTITYCALL_TYPE_CELL) + this.bundle.newMessage(KBEngine.messages['Baseapp_onRemoteCallCellMethodFromClient']); + else + this.bundle.newMessage(KBEngine.messages['Entity_onRemoteMethodCall']); + this.bundle.writeInt32(this.id); + return this.bundle; + }; + EntityCall.prototype.sendCall = function (bundle) { + if (bundle == undefined) + bundle = this.bundle; + bundle.send(this.networkInterface); + if (this.bundle == bundle) + this.bundle = null; + }; + return EntityCall; + }()); + KBEngine.EntityCall = EntityCall; + __reflect(EntityCall.prototype, "KBEngine.EntityCall"); + var EntityComponentCall = (function (_super) { + __extends(EntityComponentCall, _super); + function EntityComponentCall(ecpId, eid, className) { + var _this = _super.call(this) || this; + _this.entityComponentPropertyID = 0; + _this.entityComponentPropertyID = ecpId; + _this.id = eid; + _this.className = className; + return _this; + } + return EntityComponentCall; + }(EntityCall)); + KBEngine.EntityComponentCall = EntityComponentCall; + __reflect(EntityComponentCall.prototype, "KBEngine.EntityComponentCall"); + var DATATYPE_UINT8 = (function () { + function DATATYPE_UINT8() { + } + DATATYPE_UINT8.prototype.bind = function () { + }; + DATATYPE_UINT8.prototype.createFromStream = function (stream) { + return KBEngine.reader.readUint8.call(stream); + }; + DATATYPE_UINT8.prototype.addToStream = function (stream, v) { + stream.writeUint8(v); + }; + DATATYPE_UINT8.prototype.parseDefaultValStr = function (v) { + return parseInt(v); + }; + DATATYPE_UINT8.prototype.isSameType = function (v) { + if (typeof (v) != "number") { + return false; + } + if (v < 0 || v > 0xff) { + return false; + } + return true; + }; + return DATATYPE_UINT8; + }()); + KBEngine.DATATYPE_UINT8 = DATATYPE_UINT8; + __reflect(DATATYPE_UINT8.prototype, "KBEngine.DATATYPE_UINT8"); + var DATATYPE_UINT16 = (function () { + function DATATYPE_UINT16() { + } + DATATYPE_UINT16.prototype.bind = function () { + }; + DATATYPE_UINT16.prototype.createFromStream = function (stream) { + return KBEngine.reader.readUint16.call(stream); + }; + DATATYPE_UINT16.prototype.addToStream = function (stream, v) { + stream.writeUint16(v); + }; + DATATYPE_UINT16.prototype.parseDefaultValStr = function (v) { + return parseInt(v); + }; + DATATYPE_UINT16.prototype.isSameType = function (v) { + if (typeof (v) != "number") { + return false; + } + if (v < 0 || v > 0xffff) { + return false; + } + return true; + }; + return DATATYPE_UINT16; + }()); + KBEngine.DATATYPE_UINT16 = DATATYPE_UINT16; + __reflect(DATATYPE_UINT16.prototype, "KBEngine.DATATYPE_UINT16"); + var DATATYPE_UINT32 = (function () { + function DATATYPE_UINT32() { + } + DATATYPE_UINT32.prototype.bind = function () { + }; + DATATYPE_UINT32.prototype.createFromStream = function (stream) { + return KBEngine.reader.readUint32.call(stream); + }; + DATATYPE_UINT32.prototype.addToStream = function (stream, v) { + stream.writeUint32(v); + }; + DATATYPE_UINT32.prototype.parseDefaultValStr = function (v) { + return parseInt(v); + }; + DATATYPE_UINT32.prototype.isSameType = function (v) { + if (typeof (v) != "number") { + return false; + } + if (v < 0 || v > 0xffffffff) { + return false; + } + return true; + }; + return DATATYPE_UINT32; + }()); + KBEngine.DATATYPE_UINT32 = DATATYPE_UINT32; + __reflect(DATATYPE_UINT32.prototype, "KBEngine.DATATYPE_UINT32"); + var DATATYPE_UINT64 = (function () { + function DATATYPE_UINT64() { + } + DATATYPE_UINT64.prototype.bind = function () { + }; + DATATYPE_UINT64.prototype.createFromStream = function (stream) { + return KBEngine.reader.readUint64.call(stream); + }; + DATATYPE_UINT64.prototype.addToStream = function (stream, v) { + stream.writeUint64(v); + }; + DATATYPE_UINT64.prototype.parseDefaultValStr = function (v) { + return parseInt(v); + }; + DATATYPE_UINT64.prototype.isSameType = function (v) { + return v instanceof KBEngine.UINT64; + }; + return DATATYPE_UINT64; + }()); + KBEngine.DATATYPE_UINT64 = DATATYPE_UINT64; + __reflect(DATATYPE_UINT64.prototype, "KBEngine.DATATYPE_UINT64"); + var DATATYPE_INT8 = (function () { + function DATATYPE_INT8() { + } + DATATYPE_INT8.prototype.bind = function () { + }; + DATATYPE_INT8.prototype.createFromStream = function (stream) { + return KBEngine.reader.readInt8.call(stream); + }; + DATATYPE_INT8.prototype.addToStream = function (stream, v) { + stream.writeInt8(v); + }; + DATATYPE_INT8.prototype.parseDefaultValStr = function (v) { + return parseInt(v); + }; + DATATYPE_INT8.prototype.isSameType = function (v) { + if (typeof (v) != "number") { + return false; + } + if (v < -0x80 || v > 0x7f) { + return false; + } + return true; + }; + return DATATYPE_INT8; + }()); + KBEngine.DATATYPE_INT8 = DATATYPE_INT8; + __reflect(DATATYPE_INT8.prototype, "KBEngine.DATATYPE_INT8"); + var DATATYPE_INT16 = (function () { + function DATATYPE_INT16() { + } + DATATYPE_INT16.prototype.bind = function () { + }; + DATATYPE_INT16.prototype.createFromStream = function (stream) { + return KBEngine.reader.readInt16.call(stream); + }; + DATATYPE_INT16.prototype.addToStream = function (stream, v) { + stream.writeInt16(v); + }; + DATATYPE_INT16.prototype.parseDefaultValStr = function (v) { + return parseInt(v); + }; + DATATYPE_INT16.prototype.isSameType = function (v) { + if (typeof (v) != "number") { + return false; + } + if (v < -0x8000 || v > 0x7fff) { + return false; + } + return true; + }; + return DATATYPE_INT16; + }()); + KBEngine.DATATYPE_INT16 = DATATYPE_INT16; + __reflect(DATATYPE_INT16.prototype, "KBEngine.DATATYPE_INT16"); + var DATATYPE_INT32 = (function () { + function DATATYPE_INT32() { + } + DATATYPE_INT32.prototype.bind = function () { + }; + DATATYPE_INT32.prototype.createFromStream = function (stream) { + return KBEngine.reader.readInt32.call(stream); + }; + DATATYPE_INT32.prototype.addToStream = function (stream, v) { + stream.writeInt32(v); + }; + DATATYPE_INT32.prototype.parseDefaultValStr = function (v) { + return parseInt(v); + }; + DATATYPE_INT32.prototype.isSameType = function (v) { + if (typeof (v) != "number") { + return false; + } + if (v < -0x80000000 || v > 0x7fffffff) { + return false; + } + return true; + }; + return DATATYPE_INT32; + }()); + KBEngine.DATATYPE_INT32 = DATATYPE_INT32; + __reflect(DATATYPE_INT32.prototype, "KBEngine.DATATYPE_INT32"); + var DATATYPE_INT64 = (function () { + function DATATYPE_INT64() { + } + DATATYPE_INT64.prototype.bind = function () { + }; + DATATYPE_INT64.prototype.createFromStream = function (stream) { + return KBEngine.reader.readInt64.call(stream); + }; + DATATYPE_INT64.prototype.addToStream = function (stream, v) { + stream.writeInt64(v); + }; + DATATYPE_INT64.prototype.parseDefaultValStr = function (v) { + return parseInt(v); + }; + DATATYPE_INT64.prototype.isSameType = function (v) { + return v instanceof KBEngine.INT64; + }; + return DATATYPE_INT64; + }()); + KBEngine.DATATYPE_INT64 = DATATYPE_INT64; + __reflect(DATATYPE_INT64.prototype, "KBEngine.DATATYPE_INT64"); + var DATATYPE_FLOAT = (function () { + function DATATYPE_FLOAT() { + } + DATATYPE_FLOAT.prototype.bind = function () { + }; + DATATYPE_FLOAT.prototype.createFromStream = function (stream) { + return KBEngine.reader.readFloat.call(stream); + }; + DATATYPE_FLOAT.prototype.addToStream = function (stream, v) { + stream.writeFloat(v); + }; + DATATYPE_FLOAT.prototype.parseDefaultValStr = function (v) { + return parseFloat(v); + }; + DATATYPE_FLOAT.prototype.isSameType = function (v) { + return typeof (v) == "number"; + }; + return DATATYPE_FLOAT; + }()); + KBEngine.DATATYPE_FLOAT = DATATYPE_FLOAT; + __reflect(DATATYPE_FLOAT.prototype, "KBEngine.DATATYPE_FLOAT"); + var DATATYPE_DOUBLE = (function (_super) { + __extends(DATATYPE_DOUBLE, _super); + function DATATYPE_DOUBLE() { + return _super !== null && _super.apply(this, arguments) || this; + } + DATATYPE_DOUBLE.prototype.createFromStream = function (stream) { + return KBEngine.reader.readDouble.call(stream); + }; + DATATYPE_DOUBLE.prototype.addToStream = function (stream, v) { + stream.writeDouble(v); + }; + return DATATYPE_DOUBLE; + }(DATATYPE_FLOAT)); + KBEngine.DATATYPE_DOUBLE = DATATYPE_DOUBLE; + __reflect(DATATYPE_DOUBLE.prototype, "KBEngine.DATATYPE_DOUBLE"); + var DATATYPE_STRING = (function () { + function DATATYPE_STRING() { + } + DATATYPE_STRING.prototype.bind = function () { + }; + DATATYPE_STRING.prototype.createFromStream = function (stream) { + return KBEngine.reader.readString.call(stream); + }; + DATATYPE_STRING.prototype.addToStream = function (stream, v) { + stream.writeString(v); + }; + DATATYPE_STRING.prototype.parseDefaultValStr = function (v) { + if (typeof (v) == "string") + return v; + return ""; + }; + DATATYPE_STRING.prototype.isSameType = function (v) { + return typeof (v) == "string"; + }; + return DATATYPE_STRING; + }()); + KBEngine.DATATYPE_STRING = DATATYPE_STRING; + __reflect(DATATYPE_STRING.prototype, "KBEngine.DATATYPE_STRING"); + var DATATYPE_VECTOR2 = (function () { + function DATATYPE_VECTOR2() { + } + DATATYPE_VECTOR2.prototype.bind = function () { + }; + DATATYPE_VECTOR2.prototype.createFromStream = function (stream) { + if (KBEngine.CLIENT_NO_FLOAT) { + var x = KBEngine.reader.readInt32.call(stream); + var y = KBEngine.reader.readInt32.call(stream); + return new KBEngine.Vector2(x, y); + } + else { + var x = KBEngine.reader.readFloat.call(stream); + var y = KBEngine.reader.readFloat.call(stream); + return new KBEngine.Vector2(x, y); + } + }; + DATATYPE_VECTOR2.prototype.addToStream = function (stream, v) { + if (KBEngine.CLIENT_NO_FLOAT) { + stream.writeInt32(v.x); + stream.writeInt32(v.y); + } + else { + stream.writeFloat(v.x); + stream.writeFloat(v.y); + } + }; + DATATYPE_VECTOR2.prototype.parseDefaultValStr = function (v) { + return new KBEngine.Vector2(0.0, 0.0); + ; + }; + DATATYPE_VECTOR2.prototype.isSameType = function (v) { + if (!(v instanceof KBEngine.Vector2)) { + return false; + } + return true; + }; + return DATATYPE_VECTOR2; + }()); + KBEngine.DATATYPE_VECTOR2 = DATATYPE_VECTOR2; + __reflect(DATATYPE_VECTOR2.prototype, "KBEngine.DATATYPE_VECTOR2"); + var DATATYPE_VECTOR3 = (function () { + function DATATYPE_VECTOR3() { + } + DATATYPE_VECTOR3.prototype.bind = function () { + }; + DATATYPE_VECTOR3.prototype.createFromStream = function (stream) { + if (KBEngine.CLIENT_NO_FLOAT) { + return new KBEngine.Vector3(KBEngine.reader.readInt32.call(stream), KBEngine.reader.readInt32.call(stream), KBEngine.reader.readInt32.call(stream)); + } + else { + return new KBEngine.Vector3(KBEngine.reader.readFloat.call(stream), KBEngine.reader.readFloat.call(stream), KBEngine.reader.readFloat.call(stream)); + } + }; + DATATYPE_VECTOR3.prototype.addToStream = function (stream, v) { + if (KBEngine.CLIENT_NO_FLOAT) { + stream.writeInt32(v.x); + stream.writeInt32(v.y); + stream.writeInt32(v.z); + } + else { + stream.writeFloat(v.x); + stream.writeFloat(v.y); + stream.writeFloat(v.z); + } + }; + DATATYPE_VECTOR3.prototype.parseDefaultValStr = function (v) { + return new KBEngine.Vector3(0.0, 0.0, 0.0); + }; + DATATYPE_VECTOR3.prototype.isSameType = function (v) { + if (!(v instanceof KBEngine.Vector3)) { + return false; + } + return true; + }; + return DATATYPE_VECTOR3; + }()); + KBEngine.DATATYPE_VECTOR3 = DATATYPE_VECTOR3; + __reflect(DATATYPE_VECTOR3.prototype, "KBEngine.DATATYPE_VECTOR3"); + var DATATYPE_VECTOR4 = (function () { + function DATATYPE_VECTOR4() { + } + DATATYPE_VECTOR4.prototype.bind = function () { + }; + DATATYPE_VECTOR4.prototype.createFromStream = function (stream) { + if (KBEngine.CLIENT_NO_FLOAT) { + return new KBEngine.Vector4(KBEngine.reader.readInt32.call(stream), KBEngine.reader.readInt32.call(stream), KBEngine.reader.readInt32.call(stream), KBEngine.reader.readInt32.call(stream)); + } + else { + return new KBEngine.Vector4(KBEngine.reader.readFloat.call(stream), KBEngine.reader.readFloat.call(stream), KBEngine.reader.readFloat.call(stream), KBEngine.reader.readFloat.call(stream)); + } + }; + DATATYPE_VECTOR4.prototype.addToStream = function (stream, v) { + if (KBEngine.CLIENT_NO_FLOAT) { + stream.writeInt32(v.x); + stream.writeInt32(v.y); + stream.writeInt32(v.z); + stream.writeInt32(v.w); + } + else { + stream.writeFloat(v.x); + stream.writeFloat(v.y); + stream.writeFloat(v.z); + stream.writeFloat(v.w); + } + }; + DATATYPE_VECTOR4.prototype.parseDefaultValStr = function (v) { + return new KBEngine.Vector4(0.0, 0.0, 0.0, 0.0); + }; + DATATYPE_VECTOR4.prototype.isSameType = function (v) { + if (!(v instanceof KBEngine.Vector4)) { + return false; + } + return true; + }; + return DATATYPE_VECTOR4; + }()); + KBEngine.DATATYPE_VECTOR4 = DATATYPE_VECTOR4; + __reflect(DATATYPE_VECTOR4.prototype, "KBEngine.DATATYPE_VECTOR4"); + var DATATYPE_PYTHON = (function () { + function DATATYPE_PYTHON() { + } + DATATYPE_PYTHON.prototype.bind = function () { + }; + DATATYPE_PYTHON.prototype.createFromStream = function (stream) { + return stream.readBlob(); + }; + DATATYPE_PYTHON.prototype.addToStream = function (stream, v) { + stream.writeBlob(v); + }; + DATATYPE_PYTHON.prototype.parseDefaultValStr = function (v) { + return new Uint8Array(0); + }; + DATATYPE_PYTHON.prototype.isSameType = function (v) { + return false; + }; + return DATATYPE_PYTHON; + }()); + KBEngine.DATATYPE_PYTHON = DATATYPE_PYTHON; + __reflect(DATATYPE_PYTHON.prototype, "KBEngine.DATATYPE_PYTHON"); + var DATATYPE_UNICODE = (function () { + function DATATYPE_UNICODE() { + } + DATATYPE_UNICODE.prototype.bind = function () { + }; + DATATYPE_UNICODE.prototype.createFromStream = function (stream) { + return KBEngine.utf8ArrayToString(KBEngine.reader.readBlob.call(stream)); + }; + DATATYPE_UNICODE.prototype.addToStream = function (stream, v) { + stream.writeBlob(KBEngine.stringToUTF8Bytes(v)); + }; + DATATYPE_UNICODE.prototype.parseDefaultValStr = function (v) { + if (typeof (v) == "string") + return v; + return ""; + }; + DATATYPE_UNICODE.prototype.isSameType = function (v) { + return typeof (v) == "string"; + }; + return DATATYPE_UNICODE; + }()); + KBEngine.DATATYPE_UNICODE = DATATYPE_UNICODE; + __reflect(DATATYPE_UNICODE.prototype, "KBEngine.DATATYPE_UNICODE"); + var DATATYPE_ENTITYCALL = (function () { + function DATATYPE_ENTITYCALL() { + } + DATATYPE_ENTITYCALL.prototype.bind = function () { + }; + DATATYPE_ENTITYCALL.prototype.createFromStream = function (stream) { + }; + DATATYPE_ENTITYCALL.prototype.addToStream = function (stream, v) { + }; + DATATYPE_ENTITYCALL.prototype.parseDefaultValStr = function (v) { + return new Uint8Array(0); + ; + }; + DATATYPE_ENTITYCALL.prototype.isSameType = function (v) { + return false; + }; + return DATATYPE_ENTITYCALL; + }()); + KBEngine.DATATYPE_ENTITYCALL = DATATYPE_ENTITYCALL; + __reflect(DATATYPE_ENTITYCALL.prototype, "KBEngine.DATATYPE_ENTITYCALL"); + var DATATYPE_BLOB = (function () { + function DATATYPE_BLOB() { + } + DATATYPE_BLOB.prototype.bind = function () { + }; + DATATYPE_BLOB.prototype.createFromStream = function (stream) { + var size = KBEngine.reader.readUint32.call(stream); + var buf = new Uint8Array(stream.buffer, stream.rpos, size); + stream.rpos += size; + return buf; + }; + DATATYPE_BLOB.prototype.addToStream = function (stream, v) { + stream.writeBlob(v); + }; + DATATYPE_BLOB.prototype.parseDefaultValStr = function (v) { + return new Uint8Array(0); + }; + DATATYPE_BLOB.prototype.isSameType = function (v) { + return true; + }; + return DATATYPE_BLOB; + }()); + KBEngine.DATATYPE_BLOB = DATATYPE_BLOB; + __reflect(DATATYPE_BLOB.prototype, "KBEngine.DATATYPE_BLOB"); + var DATATYPE_ARRAY = (function () { + function DATATYPE_ARRAY() { + this.type = null; + } + DATATYPE_ARRAY.prototype.bind = function () { + if (typeof (this.type) == "number") + this.type = datatypes[this.type]; + }; + DATATYPE_ARRAY.prototype.createFromStream = function (stream) { + var size = stream.readUint32(); + var datas = []; + while (size > 0) { + size--; + datas.push(this.type.createFromStream(stream)); + } + ; + return datas; + }; + DATATYPE_ARRAY.prototype.addToStream = function (stream, v) { + stream.writeUint32(v.length); + for (var i = 0; i < v.length; i++) { + this.type.addToStream(stream, v[i]); + } + }; + DATATYPE_ARRAY.prototype.parseDefaultValStr = function (v) { + return []; + }; + DATATYPE_ARRAY.prototype.isSameType = function (v) { + for (var i = 0; i < v.length; i++) { + if (!this.type.isSameType(v[i])) { + return false; + } + } + return true; + }; + return DATATYPE_ARRAY; + }()); + KBEngine.DATATYPE_ARRAY = DATATYPE_ARRAY; + __reflect(DATATYPE_ARRAY.prototype, "KBEngine.DATATYPE_ARRAY"); + var DATATYPE_FIXED_DICT = (function () { + function DATATYPE_FIXED_DICT() { + this.dicttype = {}; + this.implementedBy = null; + } + DATATYPE_FIXED_DICT.prototype.bind = function () { + for (var itemkey in this.dicttype) { + var utype = this.dicttype[itemkey]; + if (typeof (this.dicttype[itemkey]) == "number") + this.dicttype[itemkey] = datatypes[utype]; + } + }; + DATATYPE_FIXED_DICT.prototype.createFromStream = function (stream) { + var datas = {}; + for (var itemkey in this.dicttype) { + datas[itemkey] = this.dicttype[itemkey].createFromStream(stream); + } + return datas; + }; + DATATYPE_FIXED_DICT.prototype.addToStream = function (stream, v) { + for (var itemkey in this.dicttype) { + this.dicttype[itemkey].addToStream(stream, v[itemkey]); + } + }; + DATATYPE_FIXED_DICT.prototype.parseDefaultValStr = function (v) { + return {}; + }; + DATATYPE_FIXED_DICT.prototype.isSameType = function (v) { + for (var itemkey in this.dicttype) { + if (!this.dicttype[itemkey].isSameType(v[itemkey])) { + return false; + } + } + return true; + }; + return DATATYPE_FIXED_DICT; + }()); + KBEngine.DATATYPE_FIXED_DICT = DATATYPE_FIXED_DICT; + __reflect(DATATYPE_FIXED_DICT.prototype, "KBEngine.DATATYPE_FIXED_DICT"); + var datatypes; + (function (datatypes) { + datatypes.UINT8 = new DATATYPE_UINT8(); + datatypes.UINT16 = new DATATYPE_UINT16(); + datatypes.UINT32 = new DATATYPE_UINT32(); + datatypes.UINT64 = new DATATYPE_UINT64(); + datatypes.INT8 = new DATATYPE_INT8(); + datatypes.INT16 = new DATATYPE_INT16(); + datatypes.INT32 = new DATATYPE_INT32(); + datatypes.INT64 = new DATATYPE_INT64(); + datatypes.FLOAT = new DATATYPE_FLOAT(); + datatypes.DOUBLE = new DATATYPE_DOUBLE(); + datatypes.STRING = new DATATYPE_STRING(); + datatypes.VECTOR2 = new DATATYPE_VECTOR2(); + datatypes.VECTOR3 = new DATATYPE_VECTOR3(); + datatypes.VECTOR4 = new DATATYPE_VECTOR4(); + datatypes.PYTHON = new DATATYPE_PYTHON(); + // export const PY_DICT = new DATATYPE_PYTHON(); + // export const PY_LIST = new DATATYPE_PYTHON(); + datatypes.UNICODE = new DATATYPE_UNICODE(); + datatypes.ENTITYCALL = new DATATYPE_ENTITYCALL(); + datatypes.BLOB = new DATATYPE_BLOB(); + })(datatypes = KBEngine.datatypes || (KBEngine.datatypes = {})); + ; +})(KBEngine || (KBEngine = {})); +/*----------------------------------------------------------------------------------------- + KBEngine args +-----------------------------------------------------------------------------------------*/ +(function (KBEngine) { + var KBEngineArgs = (function () { + function KBEngineArgs() { + this.ip = '127.0.0.1'; + this.port = 20013; + this.updateHZ = 100; + this.serverHeartbeatTick = 15; + this.isWss = false; + this.forceBasePort = 0; + // Reference: http://github.io/docs/programming/clientsdkprogramming.html, client types + this.clientType = 5; + // 在Entity初始化时是否触发属性的set_*事件(callPropertysSetMethods) + this.isOnInitCallPropertysSetMethods = true; + } + Object.defineProperty(KBEngineArgs.prototype, "protocol", { + //TODO wss需要参数，因为服务器不支持wss，需要使用Nginx转发一次，在这里设置强制修改baseapp连接端口到Nginx端口 + get: function () { return this.isWss ? "wss://" : "ws://"; }, + enumerable: true, + configurable: true + }); + return KBEngineArgs; + }()); + KBEngine.KBEngineArgs = KBEngineArgs; + __reflect(KBEngineArgs.prototype, "KBEngine.KBEngineArgs"); + KBEngine.EventTypes = { + // Create new account. + // param1(string): accountName + // param2(string): password + // param3(bytes): datas // Datas by user defined. Data will be recorded into the KBE account database, you can access the datas through the script layer. If you use third-party account system, datas will be submitted to the third-party system. + createAccount: "createAccount", + // Login to server. + // param1(string): accountName + // param2(string): password + // param3(bytes): datas // Datas by user defined. Data will be recorded into the KBE account database, you can access the datas through the script layer. If you use third-party account system, datas will be submitted to the third-party system. + login: "login", + // Logout to baseapp, called when exiting the client. + logout: "logout", + // Relogin to baseapp. + reloginBaseapp: "reloginBaseapp", + // Request server binding account Email. + // param1(string): emailAddress + bindAccountEmail: "bindAccountEmail", + // Request to set up a new password for the account. Note: account must be online. + // param1(string): old_password + // param2(string): new_password + newPassword: "newPassword", + // ------------------------------------连接相关------------------------------------ + // Kicked of the current server. + // param1(uint16): retcode. // server_errors + onKicked: "onKicked", + // Disconnected from the server. + onDisconnected: "onDisconnected", + // Status of connection server. + // param1(bool): success or fail + onConnectionState: "onConnectionState", + // ------------------------------------logon相关------------------------------------ + // Create account feedback results. + // param1(uint16): retcode. // server_errors + // param2(bytes): datas. // If you use third-party account system, the system may fill some of the third-party additional datas. + onCreateAccountResult: "onCreateAccountResult", + // Engine version mismatch. + // param1(string): clientVersion + // param2(string): serverVersion + onVersionNotMatch: "onVersionNotMatch", + // script version mismatch. + // param1(string): clientScriptVersion + // param2(string): serverScriptVersion + onScriptVersionNotMatch: "onScriptVersionNotMatch", + // Login failed. + // param1(uint16): retcode. // server_errors + onLoginFailed: "onLoginFailed", + // Login to baseapp. + onLoginBaseapp: "onLoginBaseapp", + // Login baseapp failed. + // param1(uint16): retcode. // server_errors + onLoginBaseappFailed: "onLoginBaseappFailed", + // Relogin to baseapp. + onReloginBaseapp: "onReloginBaseapp", + // Relogin baseapp success. + onReloginBaseappSuccessfully: "onReloginBaseappSuccessfully", + // Relogin baseapp failed. + // param1(uint16): retcode. // server_errors + onReloginBaseappFailed: "onReloginBaseappFailed", + // ------------------------------------实体cell相关事件------------------------------------ + // Entity enter the client-world. + // param1: Entity + onEnterWorld: "onEnterWorld", + // Entity leave the client-world. + // param1: Entity + onLeaveWorld: "onLeaveWorld", + // Player enter the new space. + // param1: Entity + onEnterSpace: "onEnterSpace", + // Player leave the space. + // param1: Entity + onLeaveSpace: "onLeaveSpace", + // Sets the current position of the entity. + // param1: Entity + set_position: "set_position", + // Sets the current direction of the entity. + // param1: Entity + set_direction: "set_direction", + // The entity position is updated, you can smooth the moving entity to new location. + // param1: Entity + updatePosition: "updatePosition", + // The current space is specified by the geometry mapping. + // Popular said is to load the specified Map Resources. + // param1(string): resPath + addSpaceGeometryMapping: "addSpaceGeometryMapping", + // Server spaceData set data. + // param1(int32): spaceID + // param2(string): key + // param3(string): value + onSetSpaceData: "onSetSpaceData", + // Start downloading data. + // param1(int32): rspaceID + // param2(string): key + onDelSpaceData: "onDelSpaceData", + // Triggered when the entity is controlled or out of control. + // param1: Entity + // param2(bool): isControlled + onControlled: "onControlled", + // Lose controlled entity. + // param1: Entity + onLoseControlledEntity: "onLoseControlledEntity", + // ------------------------------------数据下载相关------------------------------------ + // Start downloading data. + // param1(uint16): resouce id + // param2(uint32): data size + // param3(string): description + onStreamDataStarted: "onStreamDataStarted", + // Receive data. + // param1(uint16): resouce id + // param2(bytes): datas + onStreamDataRecv: "onStreamDataRecv", + // The downloaded data is completed. + // param1(uint16): resouce id + onStreamDataCompleted: "onStreamDataCompleted", + }; +})(KBEngine || (KBEngine = {})); +/*----------------------------------------------------------------------------------------- + KBEngine app +-----------------------------------------------------------------------------------------*/ +(function (KBEngine) { + KBEngine.moduledefs = {}; + var KBEngineApp = (function () { + function KBEngineApp(args) { + this.args = args; + this.username = "testhtml51"; + this.password = "123456"; + this.clientdatas = ""; + this.encryptedKey = ""; + this.loginappMessageImported = false; + this.baseappMessageImported = false; + this.serverErrorsDescrImported = false; + this.entitydefImported = false; + // 这个参数的选择必须与kbengine_defs.xml::cellapp/aliasEntityID的参数保持一致 + this.useAliasEntityID = true; + this.serverErrs = {}; + // // 登录loginapp的地址 + // ip: string; + // port: number; + // 服务端分配的baseapp地址 + this.baseappIP = ''; + this.baseappPort = 0; + this.baseappUdpPort = 0; + this.currMsgID = 0; + this.currMsgCount = 0; + this.currMsgLen = 0; + this.fragmentStream = null; + this.fragmentDatasFlag = KBEngine.FragmentDataTypes.FRAGMENT_DATA_UNKNOW; + this.fragmentDatasRemain = 0; + this.currstate = "create"; + this.currconnect = 'loginapp'; + // 扩展数据 + this.serverdatas = ""; + // 版本信息 + this.serverVersion = ""; + this.serverScriptVersion = ""; + this.serverProtocolMD5 = ""; + this.serverEntityDefMD5 = ""; + this.clientVersion = KBEngine.CLIENT_VERSION; + this.clientScriptVersion = KBEngine.CLIENT_SCRIPT_VERSION; + // player的相关信息 + this.entity_uuid = null; + this.entity_id = 0; + this.entity_type = ""; + // 当前玩家最后一次同步到服务端的位置与朝向与服务端最后一次同步过来的位置 + this.entityServerPos = new KBEngine.Vector3(0.0, 0.0, 0.0); + // 客户端所有的实体 + this.entities = {}; + this.entityIDAliasIDList = []; + this.controlledEntities = []; + // 空间的信息 + this.spacedata = {}; + this.spaceID = 0; + this.spaceResPath = ""; + this.isLoadedGeometry = false; + this.lastTickTime = Date.now(); + this.lastTickCBTime = Date.now(); + this.msgStream = new KBEngine.MemoryStream(KBEngine.PACKET_MAX_SIZE_TCP); + this.entityclass = {}; + // console.assert(app == null || app == undefined, "Assertion of app not is null"); + KBEngine.app = this; + } + KBEngineApp.prototype.resetSocket = function () { + try { + if (KBEngine.app.socket != undefined && KBEngine.app.socket != null) { + var sock = KBEngine.app.socket; + sock.onopen = undefined; + sock.onerror = undefined; + sock.onmessage = undefined; + sock.onclose = undefined; + KBEngine.app.socket = null; + sock.close(); + } + } + catch (e) { + } + }; + KBEngineApp.prototype.reset = function () { + if (KBEngine.app.entities != undefined && KBEngine.app.entities != null) { + KBEngine.app.clearEntities(true); + } + KBEngine.app.resetSocket(); + KBEngine.app.currserver = "loginapp"; + KBEngine.app.currstate = "create"; + KBEngine.app.currconnect = 'loginapp'; + // 扩展数据 + KBEngine.app.serverdatas = ""; + // 版本信息 + KBEngine.app.serverVersion = ""; + KBEngine.app.serverScriptVersion = ""; + KBEngine.app.serverProtocolMD5 = ""; + KBEngine.app.serverEntityDefMD5 = ""; + // app.clientVersion = "1.1.5"; + // app.clientScriptVersion = "0.1.0"; + // player的相关信息 + KBEngine.app.entity_uuid = null; + KBEngine.app.entity_id = 0; + KBEngine.app.entity_type = ""; + // 当前玩家最后一次同步到服务端的位置与朝向与服务端最后一次同步过来的位置 + KBEngine.app.entityServerPos = new KBEngine.Vector3(0.0, 0.0, 0.0); + // 客户端所有的实体 + KBEngine.app.entities = {}; + KBEngine.app.entityIDAliasIDList = []; + KBEngine.app.controlledEntities = []; + // 空间的信息 + KBEngine.app.spacedata = {}; + KBEngine.app.spaceID = 0; + KBEngine.app.spaceResPath = ""; + KBEngine.app.isLoadedGeometry = false; + var dateObject = new Date(); + KBEngine.app.lastTickTime = dateObject.getTime(); + KBEngine.app.lastTickCBTime = dateObject.getTime(); + KBEngine.mappingDataType(); + // 当前组件类别， 配套服务端体系 + KBEngine.app.component = "client"; + }; + KBEngineApp.prototype.installEvents = function () { + KBEngine.Event.register(KBEngine.EventTypes.createAccount, KBEngine.app, "createAccount"); + KBEngine.Event.register(KBEngine.EventTypes.login, KBEngine.app, "login"); + KBEngine.Event.register(KBEngine.EventTypes.logout, KBEngine.app, 'logout'); + KBEngine.Event.register(KBEngine.EventTypes.reloginBaseapp, KBEngine.app, "reloginBaseapp"); + KBEngine.Event.register(KBEngine.EventTypes.bindAccountEmail, KBEngine.app, "bindAccountEmail"); + KBEngine.Event.register(KBEngine.EventTypes.newPassword, KBEngine.app, "newPassword"); + }; + KBEngineApp.prototype.uninstallEvents = function () { + KBEngine.Event.deregister(KBEngine.EventTypes.createAccount, KBEngine.app); + KBEngine.Event.deregister(KBEngine.EventTypes.login, KBEngine.app); + KBEngine.Event.deregister(KBEngine.EventTypes.logout, KBEngine.app); + KBEngine.Event.deregister(KBEngine.EventTypes.reloginBaseapp, KBEngine.app); + KBEngine.Event.deregister(KBEngine.EventTypes.bindAccountEmail, KBEngine.app); + KBEngine.Event.deregister(KBEngine.EventTypes.newPassword, KBEngine.app); + }; + KBEngineApp.prototype.hello = function () { + var bundle = KBEngine.Bundle.createObject(); + if (KBEngine.app.currserver == "loginapp") + bundle.newMessage(KBEngine.messages['Loginapp_hello']); + else + bundle.newMessage(KBEngine.messages['Baseapp_hello']); + bundle.writeString(KBEngine.app.clientVersion); + bundle.writeString(KBEngine.app.clientScriptVersion); + bundle.writeBlob(KBEngine.app.encryptedKey); + bundle.send(KBEngine.app); + }; + KBEngineApp.prototype.player = function () { + return KBEngine.app.entities[KBEngine.app.entity_id]; + }; + KBEngineApp.prototype.findEntity = function (entityID) { + return KBEngine.app.entities[entityID]; + }; + KBEngineApp.prototype.connect = function (host, port) { + // console.assert(app.socket == null, "Assertion of socket not is null"); + try { + var addr = KBEngine.app.args.protocol + host + ':' + port; + //todo 应该是在这里设置wss + KBEngine.app.socket = new WebSocket(addr); + } + catch (e) { + KBEngine.ERROR_MSG('WebSocket init error!'); + KBEngine.Event.fire(KBEngine.EventTypes.onConnectionState, false); + return; + } + KBEngine.app.socket.binaryType = "arraybuffer"; + KBEngine.app.socket.onopen = KBEngine.app.onopen; + KBEngine.app.socket.onerror = KBEngine.app.onerror_before_onopen; + KBEngine.app.socket.onmessage = KBEngine.app.onmessage; + KBEngine.app.socket.onclose = KBEngine.app.onclose; + }; + KBEngineApp.prototype.disconnect = function () { + KBEngine.app.resetSocket(); + }; + KBEngineApp.prototype.onopen = function () { + KBEngine.INFO_MSG('connect success!'); + KBEngine.app.socket.onerror = KBEngine.app.onerror_after_onopen; + KBEngine.Event.fire(KBEngine.EventTypes.onConnectionState, true); + }; + KBEngineApp.prototype.onerror_before_onopen = function (evt) { + KBEngine.ERROR_MSG('connect error:' + evt.data); + KBEngine.app.resetSocket(); + KBEngine.Event.fire(KBEngine.EventTypes.onConnectionState, false); + }; + KBEngineApp.prototype.onerror_after_onopen = function (evt) { + KBEngine.ERROR_MSG('connect error:' + evt.data); + KBEngine.app.resetSocket(); + KBEngine.Event.fire(KBEngine.EventTypes.onDisconnected); + }; + KBEngineApp.prototype.onmessage = function (msg) { + var stream = KBEngine.app.msgStream; + stream.setbuffer(msg.data); + stream.wpos = msg.data.byteLength; + while (stream.length() > 0 || KBEngine.app.fragmentStream != null) { + if (KBEngine.app.fragmentDatasFlag == KBEngine.FragmentDataTypes.FRAGMENT_DATA_UNKNOW) { + if (KBEngine.app.currMsgID == 0) { + if (KBEngine.MESSAGE_ID_LENGTH > 1 && stream.length() < KBEngine.MESSAGE_ID_LENGTH) { + KBEngine.app.writeFragmentMessage(KBEngine.FragmentDataTypes.FRAGMENT_DATA_MESSAGE_ID, stream, KBEngine.MESSAGE_ID_LENGTH); + break; + } + KBEngine.app.currMsgID = stream.readUint16(); + } + var msgHandler = KBEngine.clientmessages[KBEngine.app.currMsgID]; + if (!msgHandler) { + KBEngine.app.currMsgID = 0; + KBEngine.app.currMsgLen = 0; + KBEngine.ERROR_MSG("KBEngineApp::onmessage[" + KBEngine.app.currserver + "]: not found msg(" + KBEngine.app.currMsgID + ")!"); + break; + } + var msglen = msgHandler.length; + if (KBEngine.app.currMsgLen == 0) { + if (msglen == -1) { + if (stream.length() < KBEngine.MESSAGE_LENGTH_LENGTH) { + KBEngine.app.writeFragmentMessage(KBEngine.FragmentDataTypes.FRAGMENT_DATA_MESSAGE_LENGTH, stream, KBEngine.MESSAGE_LENGTH_LENGTH); + break; + } + else { + msglen = stream.readUint16(); + KBEngine.app.currMsgLen = msglen; + // 扩展长度 + if (msglen == KBEngine.MESSAGE_MAX_SIZE) { + if (stream.length() < KBEngine.MESSAGE_LENGTH1_LENGTH) { + KBEngine.app.writeFragmentMessage(KBEngine.FragmentDataTypes.FRAGMENT_DATA_MESSAGE_LENGTH1, stream, KBEngine.MESSAGE_LENGTH1_LENGTH); + break; + } + KBEngine.app.currMsgLen = stream.readUint32(); + } + } + } + else { + KBEngine.app.currMsgLen = msglen; + } + } + if (KBEngine.app.fragmentStream != null && KBEngine.app.fragmentStream.length() >= KBEngine.app.currMsgLen) { + msgHandler.handleMessage(KBEngine.app.fragmentStream); + KBEngine.app.fragmentStream = null; + } + else if (stream.length() < KBEngine.app.currMsgLen && stream.length() > 0) { + KBEngine.app.writeFragmentMessage(KBEngine.FragmentDataTypes.FRAGMENT_DATA_MESSAGE_BODY, stream, KBEngine.app.currMsgLen); + break; + } + else { + var wpos = stream.wpos; + var rpos = stream.rpos + msglen; + stream.wpos = rpos; + msgHandler.handleMessage(stream); + stream.wpos = wpos; + stream.rpos = rpos; + } + KBEngine.app.currMsgID = 0; + KBEngine.app.currMsgLen = 0; + KBEngine.app.fragmentStream = null; + } + else { + if (KBEngine.app.mergeFragmentMessage(stream)) + break; + } + } + }; + KBEngineApp.prototype.writeFragmentMessage = function (FragmentDataType, stream, datasize) { + var opsize = stream.length(); + KBEngine.app.fragmentDatasRemain = datasize - opsize; + KBEngine.app.fragmentDatasFlag = FragmentDataType; + KBEngine.app.fragmentStream = stream; + }; + KBEngineApp.prototype.mergeFragmentMessage = function (stream) { + var opsize = stream.length(); + if (opsize == 0) + return 0; + var fragmentStream = KBEngine.app.fragmentStream; + // console.assert(fragmentStream != null); + if (opsize >= KBEngine.app.fragmentDatasRemain) { + fragmentStream.append(stream, stream.rpos, KBEngine.app.fragmentDatasRemain); + switch (KBEngine.app.fragmentDatasFlag) { + case KBEngine.FragmentDataTypes.FRAGMENT_DATA_MESSAGE_ID: + KBEngine.app.currMsgID = fragmentStream.readUint16(); + KBEngine.app.fragmentStream = null; + break; + case KBEngine.FragmentDataTypes.FRAGMENT_DATA_MESSAGE_LENGTH: + KBEngine.app.currMsgLen = fragmentStream.readUint16(); + KBEngine.app.fragmentStream = null; + break; + case KBEngine.FragmentDataTypes.FRAGMENT_DATA_MESSAGE_LENGTH1: + KBEngine.app.currMsgLen = fragmentStream.readUint32(); + KBEngine.app.fragmentStream = null; + break; + case KBEngine.FragmentDataTypes.FRAGMENT_DATA_MESSAGE_BODY: + default: + break; + } + stream.rpos += KBEngine.app.fragmentDatasRemain; + KBEngine.app.fragmentDatasFlag = KBEngine.FragmentDataTypes.FRAGMENT_DATA_UNKNOW; + KBEngine.app.fragmentDatasRemain = 0; + return false; + } + else { + fragmentStream.append(stream, stream.rpos, opsize); + KBEngine.app.fragmentDatasRemain -= opsize; + stream.done(); + return true; + } + }; + KBEngineApp.prototype.onclose = function () { + KBEngine.INFO_MSG('connect close:' + KBEngine.app.currserver); + if (KBEngine.app.currconnect != KBEngine.app.currstate) + return; + KBEngine.app.resetSocket(); + KBEngine.Event.fire(KBEngine.EventTypes.onDisconnected); + //if(app.currserver != "loginapp") + // app.reset(); + }; + KBEngineApp.prototype.send = function (msg) { + KBEngine.app.socket.send(msg); + }; + KBEngineApp.prototype.close = function () { + KBEngine.INFO_MSG('KBEngine::close()'); + KBEngine.app.socket.close(); + KBEngine.app.reset(); + }; + KBEngineApp.prototype.update = function () { + if (KBEngine.app.socket == null) + return; + var dateObject = new Date(); + if ((dateObject.getTime() - KBEngine.app.lastTickTime) / 1000 > KBEngine.app.args.serverHeartbeatTick / 2) { + // 如果心跳回调接收时间小于心跳发送时间，说明没有收到回调 + // 此时应该通知客户端掉线了 + if (KBEngine.app.lastTickCBTime < KBEngine.app.lastTickTime) { + KBEngine.ERROR_MSG("sendTick: Receive appTick timeout!"); + KBEngine.app.socket.close(); + } + if (KBEngine.app.currserver == "loginapp") { + if (KBEngine.messages['Loginapp_onClientActiveTick'] != undefined) { + var bundle = KBEngine.Bundle.createObject(); + bundle.newMessage(KBEngine.messages['Loginapp_onClientActiveTick']); + bundle.send(KBEngine.app); + } + } + else { + if (KBEngine.messages['Baseapp_onClientActiveTick'] != undefined) { + var bundle = KBEngine.Bundle.createObject(); + bundle.newMessage(KBEngine.messages['Baseapp_onClientActiveTick']); + bundle.send(KBEngine.app); + } + } + KBEngine.app.lastTickTime = dateObject.getTime(); + } + KBEngine.app.updatePlayerToServer(); + }; + KBEngineApp.prototype.Client_onAppActiveTickCB = function () { + // let dateObject = new Date(); + KBEngine.app.lastTickCBTime = Date.now(); //dateObject.getTime(); + }; + KBEngineApp.prototype.serverErr = function (id) { + var e = KBEngine.app.serverErrs[id]; + if (e == undefined) { + return ""; + } + return e.name + " [" + e.descr + "]"; + }; + KBEngineApp.prototype.Client_onImportServerErrorsDescr = function (stream) { + var size = stream.readUint16(); + while (size > 0) { + size -= 1; + var e = new ServerErr(); + e.id = stream.readUint16(); + e.name = KBEngine.utf8ArrayToString(stream.readBlob()); + e.descr = KBEngine.utf8ArrayToString(stream.readBlob()); + KBEngine.app.serverErrs[e.id] = e; + KBEngine.INFO_MSG("Client_onImportServerErrorsDescr: id=" + e.id + ", name=" + e.name + ", descr=" + e.descr); + } + }; + KBEngineApp.prototype.Client_onImportClientSdk = function (stream) { + var remainingFiles = stream.readInt32(); + var fileName = stream.readString(); + var fileSize = stream.readInt32(); + var fileDatas = stream.readBlob(); + KBEngine.Event.fire("onImportClientSDK", remainingFiles, fileName, fileSize, fileDatas); + }; + KBEngineApp.prototype.onOpenLoginapp_login = function () { + KBEngine.INFO_MSG("KBEngineApp::onOpenLoginapp_login: successfully!"); + KBEngine.Event.fire(KBEngine.EventTypes.onConnectionState, true); + KBEngine.app.currserver = "loginapp"; + KBEngine.app.currstate = "login"; + if (!KBEngine.app.loginappMessageImported) { + var bundle = KBEngine.Bundle.createObject(); + bundle.newMessage(KBEngine.messages.Loginapp_importClientMessages); + bundle.send(KBEngine.app); + KBEngine.app.socket.onmessage = KBEngine.app.Client_onImportClientMessages; + KBEngine.INFO_MSG("KBEngineApp::onOpenLoginapp_login: start importClientMessages ..."); + KBEngine.Event.fire("Loginapp_importClientMessages"); + } + else { + KBEngine.app.onImportClientMessagesCompleted(); + } + }; + KBEngineApp.prototype.onOpenLoginapp_createAccount = function () { + KBEngine.Event.fire("onConnectionState", true); + KBEngine.INFO_MSG("KBEngineApp::onOpenLoginapp_createAccount: successfully!"); + KBEngine.app.currserver = "loginapp"; + KBEngine.app.currstate = "createAccount"; + if (!KBEngine.app.loginappMessageImported) { + var bundle = KBEngine.Bundle.createObject(); + bundle.newMessage(KBEngine.messages.Loginapp_importClientMessages); + bundle.send(KBEngine.app); + KBEngine.app.socket.onmessage = KBEngine.app.Client_onImportClientMessages; + KBEngine.INFO_MSG("KBEngineApp::onOpenLoginapp_createAccount: start importClientMessages ..."); + KBEngine.Event.fire("Loginapp_importClientMessages"); + } + else { + KBEngine.app.onImportClientMessagesCompleted(); + } + }; + KBEngineApp.prototype.onImportClientMessagesCompleted = function () { + KBEngine.INFO_MSG("KBEngineApp::onImportClientMessagesCompleted: successfully!"); + KBEngine.app.socket.onmessage = KBEngine.app.onmessage; + KBEngine.app.hello(); + if (KBEngine.app.currserver == "loginapp") { + if (!KBEngine.app.serverErrorsDescrImported) { + KBEngine.INFO_MSG("KBEngine::onImportClientMessagesCompleted(): send importServerErrorsDescr!"); + KBEngine.app.serverErrorsDescrImported = true; + var bundle = KBEngine.Bundle.createObject(); + bundle.newMessage(KBEngine.messages['Loginapp_importServerErrorsDescr']); + bundle.send(KBEngine.app); + } + if (KBEngine.app.currstate == "login") + KBEngine.app.login_loginapp(false); + else if (KBEngine.app.currstate == "resetpassword") + KBEngine.app.resetpassword_loginapp(false); + else + KBEngine.app.createAccount_loginapp(false); + KBEngine.app.loginappMessageImported = true; + } + else { + KBEngine.app.baseappMessageImported = true; + if (!KBEngine.app.entitydefImported) { + KBEngine.INFO_MSG("KBEngineApp::onImportClientMessagesCompleted: start importEntityDef ..."); + var bundle = KBEngine.Bundle.createObject(); + bundle.newMessage(KBEngine.messages.Baseapp_importClientEntityDef); + bundle.send(KBEngine.app); + KBEngine.Event.fire("Baseapp_importClientEntityDef"); + } + else { + KBEngine.app.onImportEntityDefCompleted(); + } + } + }; + KBEngineApp.prototype.createDataTypeFromStreams = function (stream, canprint) { + var aliassize = stream.readUint16(); + KBEngine.INFO_MSG("KBEngineApp::createDataTypeFromStreams: importAlias(size=" + aliassize + ")!"); + while (aliassize > 0) { + aliassize--; + KBEngine.app.createDataTypeFromStream(stream, canprint); + } + ; + for (var datatype in KBEngine.datatypes) { + if (KBEngine.datatypes[datatype] != undefined) { + KBEngine.datatypes[datatype].bind(); + } + } + }; + KBEngineApp.prototype.createDataTypeFromStream = function (stream, canprint) { + var utype = stream.readUint16(); + var name = stream.readString(); + var valname = stream.readString(); + var length; + /* 有一些匿名类型，我们需要提供一个唯一名称放到datatypes中 + 如： + + ARRAY INT8 + + */ + if (valname.length == 0) + length = "Null_" + utype; + if (canprint) + KBEngine.INFO_MSG("KBEngineApp::Client_onImportClientEntityDef: importAlias(" + name + ":" + valname + ")!"); + if (name == "FIXED_DICT") { + var datatype = new KBEngine.DATATYPE_FIXED_DICT(); + var keysize = stream.readUint8(); + datatype.implementedBy = stream.readString(); + while (keysize > 0) { + keysize--; + var keyname = stream.readString(); + var keyutype = stream.readUint16(); + datatype.dicttype[keyname] = keyutype; + } + ; + KBEngine.datatypes[valname] = datatype; + } + else if (name == "ARRAY") { + var uitemtype = stream.readUint16(); + var datatype = new KBEngine.DATATYPE_ARRAY(); + datatype.type = uitemtype; + KBEngine.datatypes[valname] = datatype; + } + else { + KBEngine.datatypes[valname] = KBEngine.datatypes[name]; + } + KBEngine.datatypes[utype] = KBEngine.datatypes[valname]; + // 将用户自定义的类型补充到映射表中 + KBEngine.datatype2id[valname] = utype; + }; + KBEngineApp.prototype.Client_onImportClientEntityDef = function (stream) { + KBEngine.app.createDataTypeFromStreams(stream, true); + while (stream.length() > 0) { + var scriptmodule_name = stream.readString(); + var scriptUtype = stream.readUint16(); + var propertysize = stream.readUint16(); + var methodsize = stream.readUint16(); + var base_methodsize = stream.readUint16(); + var cell_methodsize = stream.readUint16(); + KBEngine.INFO_MSG("KBEngineApp::Client_onImportClientEntityDef: import(" + scriptmodule_name + "), propertys(" + propertysize + "), " + + "clientMethods(" + methodsize + "), baseMethods(" + base_methodsize + "), cellMethods(" + cell_methodsize + ")!"); + KBEngine.moduledefs[scriptmodule_name] = {}; + var currModuleDefs = KBEngine.moduledefs[scriptmodule_name]; + currModuleDefs["name"] = scriptmodule_name; + currModuleDefs["propertys"] = {}; + currModuleDefs["methods"] = {}; + currModuleDefs["base_methods"] = {}; + currModuleDefs["cell_methods"] = {}; + KBEngine.moduledefs[scriptUtype] = currModuleDefs; + var self_propertys = currModuleDefs["propertys"]; + var self_methods = currModuleDefs["methods"]; + var self_base_methods = currModuleDefs["base_methods"]; + var self_cell_methods = currModuleDefs["cell_methods"]; + var Class = KBEngine['Entities'][scriptmodule_name]; + while (propertysize > 0) { + propertysize--; + var properUtype = stream.readUint16(); + var properFlags = stream.readUint32(); + var aliasID = stream.readInt16(); + var name_2 = stream.readString(); + var defaultValStr = stream.readString(); + var utype = KBEngine.datatypes[stream.readUint16()]; + var setmethod = null; + if (Class != undefined) { + setmethod = Class.prototype["set_" + name_2]; + if (setmethod == undefined) + setmethod = null; + } + var savedata = [properUtype, aliasID, name_2, defaultValStr, utype, setmethod, properFlags]; + self_propertys[name_2] = savedata; + if (aliasID != -1) { + self_propertys[aliasID] = savedata; + currModuleDefs["usePropertyDescrAlias"] = true; + } + else { + self_propertys[properUtype] = savedata; + currModuleDefs["usePropertyDescrAlias"] = false; + } + KBEngine.INFO_MSG("KBEngineApp::Client_onImportClientEntityDef: add(" + scriptmodule_name + "), property(" + name_2 + "/" + properUtype + ")."); + } + ; + while (methodsize > 0) { + methodsize--; + var methodUtype = stream.readUint16(); + var aliasID = stream.readInt16(); + var name_3 = stream.readString(); + var argssize = stream.readUint8(); + var args = []; + while (argssize > 0) { + argssize--; + args.push(KBEngine.datatypes[stream.readUint16()]); + } + ; + var savedata = [methodUtype, aliasID, name_3, args]; + self_methods[name_3] = savedata; + if (aliasID != -1) { + self_methods[aliasID] = savedata; + currModuleDefs["useMethodDescrAlias"] = true; + } + else { + self_methods[methodUtype] = savedata; + currModuleDefs["useMethodDescrAlias"] = false; + } + KBEngine.INFO_MSG("KBEngineApp::Client_onImportClientEntityDef: add(" + scriptmodule_name + "), method(" + name_3 + ")."); + } + ; + while (base_methodsize > 0) { + base_methodsize--; + var methodUtype = stream.readUint16(); + var aliasID = stream.readInt16(); + var name_4 = stream.readString(); + var argssize = stream.readUint8(); + var args = []; + while (argssize > 0) { + argssize--; + args.push(KBEngine.datatypes[stream.readUint16()]); + } + ; + self_base_methods[name_4] = [methodUtype, aliasID, name_4, args]; + KBEngine.INFO_MSG("KBEngineApp::Client_onImportClientEntityDef: add(" + scriptmodule_name + "), base_method(" + name_4 + ")."); + } + ; + while (cell_methodsize > 0) { + cell_methodsize--; + var methodUtype = stream.readUint16(); + var aliasID = stream.readInt16(); + var name_5 = stream.readString(); + var argssize = stream.readUint8(); + var args = []; + while (argssize > 0) { + argssize--; + args.push(KBEngine.datatypes[stream.readUint16()]); + } + ; + self_cell_methods[name_5] = [methodUtype, aliasID, name_5, args]; + KBEngine.INFO_MSG("KBEngineApp::Client_onImportClientEntityDef: add(" + scriptmodule_name + "), cell_method(" + name_5 + ")."); + } + ; + var defmethod = void 0; + try { + defmethod = KBEngine['Entities'][scriptmodule_name]; + } + catch (e) { + KBEngine.ERROR_MSG("KBEngineApp::Client_onImportClientEntityDef: module(" + scriptmodule_name + ") not found!"); + defmethod = undefined; + } + for (var name_6 in currModuleDefs.propertys) { + var infos = currModuleDefs.propertys[name_6]; + var properUtype = infos[0]; + var aliasID = infos[1]; + var n = infos[2]; + var defaultValStr = infos[3]; + var utype = infos[4]; + if (defmethod != undefined && utype) + defmethod.prototype[n] = utype.parseDefaultValStr(defaultValStr); + } + ; + for (var name_7 in currModuleDefs.methods) { + var infos = currModuleDefs.methods[name_7]; + var properUtype = infos[0]; + var aliasID = infos[1]; + var n = infos[2]; + var args = infos[3]; + if (defmethod != undefined && defmethod.prototype[n] == undefined) { + KBEngine.WARNING_MSG(scriptmodule_name + ":: method(" + n + ") no implement!"); + } + } + ; + } + KBEngine.app.onImportEntityDefCompleted(); + }; + KBEngineApp.prototype.Client_onVersionNotMatch = function (stream) { + KBEngine.app.serverVersion = stream.readString(); + KBEngine.ERROR_MSG("Client_onVersionNotMatch: verInfo=" + KBEngine.app.clientVersion + " not match(server: " + KBEngine.app.serverVersion + ")"); + KBEngine.Event.fire(KBEngine.EventTypes.onVersionNotMatch, KBEngine.app.clientVersion, KBEngine.app.serverVersion); + }; + KBEngineApp.prototype.Client_onScriptVersionNotMatch = function (stream) { + KBEngine.app.serverScriptVersion = stream.readString(); + KBEngine.ERROR_MSG("Client_onScriptVersionNotMatch: verInfo=" + KBEngine.app.clientScriptVersion + " not match(server: " + KBEngine.app.serverScriptVersion + ")"); + KBEngine.Event.fire(KBEngine.EventTypes.onScriptVersionNotMatch, KBEngine.app.clientScriptVersion, KBEngine.app.serverScriptVersion); + }; + KBEngineApp.prototype.onImportEntityDefCompleted = function () { + KBEngine.INFO_MSG("KBEngineApp::onImportEntityDefCompleted: successfully!"); + KBEngine.app.entitydefImported = true; + KBEngine.app.login_baseapp(false); + }; + KBEngineApp.prototype.importClientMessages = function (stream) { + while (KBEngine.app.currMsgCount > 0) { + KBEngine.app.currMsgCount--; + var msgid = stream.readUint16(); + var msglen = stream.readInt16(); + var msgname = stream.readString(); + var argtype = stream.readInt8(); + var argsize = stream.readUint8(); + var argstypes = new Array(argsize); + for (var i = 0; i < argsize; i++) { + argstypes[i] = stream.readUint8(); + } + var handler = null; + var isClientMethod = msgname.indexOf("Client_") >= 0; + if (isClientMethod) { + handler = KBEngine.app[msgname]; + if (handler == null || handler == undefined) { + KBEngine.WARNING_MSG("KBEngineApp::onImportClientMessages[" + KBEngine.app.currserver + "]: interface(" + msgname + "/" + msgid + ") no implement!"); + handler = null; + } + else { + KBEngine.INFO_MSG("KBEngineApp::onImportClientMessages: import(" + msgname + ") successfully!"); + } + } + if (msgname.length > 0) { + KBEngine.messages[msgname] = new KBEngine.Message(msgid, msgname, msglen, argtype, argstypes, handler); + if (isClientMethod) + KBEngine.clientmessages[msgid] = KBEngine.messages[msgname]; + else + KBEngine.messages[KBEngine.app.currserver][msgid] = KBEngine.messages[msgname]; + } + else { + KBEngine.messages[KBEngine.app.currserver][msgid] = new KBEngine.Message(msgid, msgname, msglen, argtype, argstypes, handler); + } + } + ; + KBEngine.app.onImportClientMessagesCompleted(); + KBEngine.app.currMsgID = 0; + KBEngine.app.currMsgLen = 0; + KBEngine.app.currMsgCount = 0; + KBEngine.app.fragmentStream = null; + }; + KBEngineApp.prototype.Client_onImportClientMessages = function (msg) { + var stream = new KBEngine.MemoryStream(msg.data); + stream.wpos = msg.data.byteLength; + if (KBEngine.app.currMsgID == 0) { + KBEngine.app.currMsgID = stream.readUint16(); + } + if (KBEngine.app.currMsgID == KBEngine.messages.onImportClientMessages.id) { + if (KBEngine.app.currMsgLen == 0) { + KBEngine.app.currMsgLen = stream.readUint16(); + KBEngine.app.currMsgCount = stream.readUint16(); + } + if (stream.length() + 2 < KBEngine.app.currMsgLen && KBEngine.app.fragmentStream == null) { + KBEngine.app.writeFragmentMessage(KBEngine.FragmentDataTypes.FRAGMENT_DATA_MESSAGE_BODY, stream, KBEngine.app.currMsgLen - 2); + } + else if (KBEngine.app.fragmentStream != null) { + KBEngine.app.mergeFragmentMessage(stream); + if (KBEngine.app.fragmentStream.length() + 2 >= KBEngine.app.currMsgLen) { + KBEngine.app.importClientMessages(KBEngine.app.fragmentStream); + } + } + else { + KBEngine.app.importClientMessages(stream); + } + } + else { + KBEngine.ERROR_MSG("KBEngineApp::onmessage: not found msg(" + KBEngine.app.currMsgID + ")!"); + } + }; + KBEngineApp.prototype.createAccount = function (username, password, datas) { + KBEngine.app.reset(); + KBEngine.app.username = username; + KBEngine.app.password = password; + KBEngine.app.clientdatas = datas; + KBEngine.app.createAccount_loginapp(true); + }; + KBEngineApp.prototype.createAccount_loginapp = function (noconnect) { + if (noconnect) { + KBEngine.INFO_MSG("KBEngineApp::createAccount_loginapp: start connect to ws://" + KBEngine.app.args.ip + ":" + KBEngine.app.args.port + "!"); + KBEngine.app.currconnect = "loginapp"; + KBEngine.app.connect(KBEngine.app.args.ip, KBEngine.app.args.port); + KBEngine.app.socket.onopen = KBEngine.app.onOpenLoginapp_createAccount; + } + else { + var bundle = KBEngine.Bundle.createObject(); + bundle.newMessage(KBEngine.messages['Loginapp_reqCreateAccount']); + bundle.writeString(KBEngine.app.username); + bundle.writeString(KBEngine.app.password); + bundle.writeBlob(KBEngine.app.clientdatas); + bundle.send(KBEngine.app); + } + }; + KBEngineApp.prototype.bindAccountEmail = function (emailAddress) { + var bundle = KBEngine.Bundle.createObject(); + bundle.newMessage(KBEngine.messages['Baseapp_reqAccountBindEmail']); + bundle.writeInt32(KBEngine.app.entity_id); + bundle.writeString(KBEngine.app.password); + bundle.writeString(emailAddress); + bundle.send(KBEngine.app); + }; + KBEngineApp.prototype.newPassword = function (old_password, new_password) { + var bundle = KBEngine.Bundle.createObject(); + bundle.newMessage(KBEngine.messages['Baseapp_reqAccountNewPassword']); + bundle.writeInt32(KBEngine.app.entity_id); + bundle.writeString(old_password); + bundle.writeString(new_password); + bundle.send(KBEngine.app); + }; + KBEngineApp.prototype.logout = function () { + var bundle = new KBEngine.Bundle(); + bundle.newMessage(KBEngine.messages['Baseapp_logoutBaseapp']); + bundle.writeUint64(KBEngine.app.entity_uuid); + bundle.writeInt32(KBEngine.app.entity_id); + bundle.send(KBEngine.app); + }; + KBEngineApp.prototype.login = function (username, password, datas) { + KBEngine.app.reset(); + KBEngine.app.username = username; + KBEngine.app.password = password; + KBEngine.app.clientdatas = datas; + KBEngine.app.login_loginapp(true); + }; + KBEngineApp.prototype.login_loginapp = function (noconnect) { + if (noconnect) { + KBEngine.INFO_MSG("KBEngineApp::login_loginapp: start connect to ws://" + KBEngine.app.args.ip + ":" + KBEngine.app.args.port + "!"); + KBEngine.app.currconnect = "loginapp"; + KBEngine.app.connect(KBEngine.app.args.ip, KBEngine.app.args.port); + KBEngine.app.socket.onopen = KBEngine.app.onOpenLoginapp_login; + } + else { + var bundle = KBEngine.Bundle.createObject(); + bundle.newMessage(KBEngine.messages['Loginapp_login']); + bundle.writeInt8(KBEngine.app.args.clientType); // clientType + bundle.writeBlob(KBEngine.app.clientdatas); + bundle.writeString(KBEngine.app.username); + bundle.writeString(KBEngine.app.password); + bundle.send(KBEngine.app); + } + }; + KBEngineApp.prototype.onOpenLoginapp_resetpassword = function () { + KBEngine.INFO_MSG("KBEngineApp::onOpenLoginapp_resetpassword: successfully!"); + KBEngine.app.currserver = "loginapp"; + KBEngine.app.currstate = "resetpassword"; + if (!KBEngine.app.loginappMessageImported) { + var bundle = KBEngine.Bundle.createObject(); + bundle.newMessage(KBEngine.messages.Loginapp_importClientMessages); + bundle.send(KBEngine.app); + KBEngine.app.socket.onmessage = KBEngine.app.Client_onImportClientMessages; + KBEngine.INFO_MSG("KBEngineApp::onOpenLoginapp_resetpassword: start importClientMessages ..."); + } + else { + KBEngine.app.onImportClientMessagesCompleted(); + } + }; + KBEngineApp.prototype.reset_password = function (username) { + KBEngine.app.reset(); + KBEngine.app.username = username; + KBEngine.app.resetpassword_loginapp(true); + }; + KBEngineApp.prototype.resetpassword_loginapp = function (noconnect) { + if (noconnect) { + KBEngine.INFO_MSG("KBEngineApp::createAccount_loginapp: start connect to ws://" + KBEngine.app.args.ip + ":" + KBEngine.app.args.port + "!"); + KBEngine.app.currconnect = "loginapp"; + KBEngine.app.connect(KBEngine.app.args.ip, KBEngine.app.args.port); + KBEngine.app.socket.onopen = KBEngine.app.onOpenLoginapp_resetpassword; + } + else { + var bundle = KBEngine.Bundle.createObject(); + bundle.newMessage(KBEngine.messages['Loginapp_reqAccountResetPassword']); + bundle.writeString(KBEngine.app.username); + bundle.send(KBEngine.app); + } + }; + KBEngineApp.prototype.onOpenBaseapp = function () { + KBEngine.INFO_MSG("KBEngineApp::onOpenBaseapp: successfully!"); + KBEngine.app.currserver = "baseapp"; + if (!KBEngine.app.baseappMessageImported) { + var bundle = KBEngine.Bundle.createObject(); + bundle.newMessage(KBEngine.messages.Baseapp_importClientMessages); + bundle.send(KBEngine.app); + KBEngine.app.socket.onmessage = KBEngine.app.Client_onImportClientMessages; + KBEngine.Event.fire("Baseapp_importClientMessages"); + } + else { + KBEngine.app.onImportClientMessagesCompleted(); + } + }; + KBEngineApp.prototype.login_baseapp = function (noconnect) { + if (noconnect) { + KBEngine.Event.fire("onLoginBaseapp"); + KBEngine.INFO_MSG("KBEngineApp::login_baseapp: start connect to ws://" + KBEngine.app.baseappIp + ":" + KBEngine.app.baseappPort + "!"); + KBEngine.app.currconnect = "baseapp"; + KBEngine.app.connect(KBEngine.app.baseappIp, KBEngine.app.baseappPort); + if (KBEngine.app.socket != undefined && KBEngine.app.socket != null) + KBEngine.app.socket.onopen = KBEngine.app.onOpenBaseapp; + } + else { + var bundle = KBEngine.Bundle.createObject(); + bundle.newMessage(KBEngine.messages['Baseapp_loginBaseapp']); + bundle.writeString(KBEngine.app.username); + bundle.writeString(KBEngine.app.password); + bundle.send(KBEngine.app); + } + }; + KBEngineApp.prototype.reloginBaseapp = function () { + KBEngine.app.lastTickCBTime = KBEngine.app.lastTickTime = Date.now(); + if (KBEngine.app.socket != undefined && KBEngine.app.socket != null) + return; + KBEngine.app.resetSocket(); + KBEngine.Event.fire(KBEngine.EventTypes.onReloginBaseapp); + KBEngine.INFO_MSG("KBEngineApp::reloginBaseapp: start connect to ws://" + KBEngine.app.baseappIp + ":" + KBEngine.app.baseappPort + "!"); + KBEngine.app.currconnect = "baseapp"; + KBEngine.app.connect(KBEngine.app.baseappIp, KBEngine.app.baseappPort); + if (KBEngine.app.socket != undefined && KBEngine.app.socket != null) + KBEngine.app.socket.onopen = KBEngine.app.onReOpenBaseapp; + }; + KBEngineApp.prototype.onReOpenBaseapp = function () { + KBEngine.INFO_MSG("KBEngineApp::onReOpenBaseapp: successfully!"); + KBEngine.app.currserver = "baseapp"; + var bundle = KBEngine.Bundle.createObject(); + bundle.newMessage(KBEngine.messages['Baseapp_reloginBaseapp']); + bundle.writeString(KBEngine.app.username); + bundle.writeString(KBEngine.app.password); + bundle.writeUint64(KBEngine.app.entity_uuid); + bundle.writeInt32(KBEngine.app.entity_id); + bundle.send(KBEngine.app); + var dateObject = new Date(); + KBEngine.app.lastTickCBTime = dateObject.getTime(); + }; + KBEngineApp.prototype.Client_onHelloCB = function (args) { + KBEngine.app.serverVersion = args.readString(); + KBEngine.app.serverScriptVersion = args.readString(); + KBEngine.app.serverProtocolMD5 = args.readString(); + KBEngine.app.serverEntityDefMD5 = args.readString(); + var ctype = args.readInt32(); + KBEngine.INFO_MSG("KBEngineApp::Client_onHelloCB: verInfo(" + KBEngine.app.serverVersion + "), scriptVerInfo(" + + KBEngine.app.serverScriptVersion + "), serverProtocolMD5(" + KBEngine.app.serverProtocolMD5 + "), serverEntityDefMD5(" + + KBEngine.app.serverEntityDefMD5 + "), ctype(" + ctype + ")!"); + var dateObject = new Date(); + KBEngine.app.lastTickCBTime = dateObject.getTime(); + }; + KBEngineApp.prototype.Client_onLoginFailed = function (args) { + var failedcode = args.readUint16(); + KBEngine.app.serverdatas = args.readBlob(); + KBEngine.ERROR_MSG("KBEngineApp::Client_onLoginFailed: failedcode(" + KBEngine.app.serverErrs[failedcode].name + "), datas(" + KBEngine.app.serverdatas.length + ")!"); + KBEngine.Event.fire("onLoginFailed", failedcode); + }; + KBEngineApp.prototype.Client_onLoginSuccessfully = function (args) { + var accountName = args.readString(); + KBEngine.app.username = accountName; + KBEngine.app.baseappIp = args.readString(); + KBEngine.app.baseappPort = args.readUint16(); + KBEngine.app.baseappUdpPort = args.readUint16(); + KBEngine.app.serverdatas = args.readBlob(); + KBEngine.INFO_MSG("KBEngineApp::Client_onLoginSuccessfully: accountName(" + accountName + "), addr(" + + KBEngine.app.baseappIp + ":" + KBEngine.app.baseappPort + "), datas(" + KBEngine.app.serverdatas.length + ")!"); + KBEngine.app.disconnect(); + KBEngine.app.login_baseapp(true); + }; + KBEngineApp.prototype.Client_onLoginBaseappFailed = function (failedcode) { + KBEngine.ERROR_MSG("KBEngineApp::Client_onLoginBaseappFailed: failedcode(" + KBEngine.app.serverErrs[failedcode].name + ")!"); + KBEngine.Event.fire(KBEngine.EventTypes.onLoginBaseappFailed, failedcode); + }; + KBEngineApp.prototype.Client_onReloginBaseappFailed = function (failedcode) { + KBEngine.ERROR_MSG("KBEngineApp::Client_onReloginBaseappFailed: failedcode(" + KBEngine.app.serverErrs[failedcode].name + ")!"); + KBEngine.Event.fire(KBEngine.EventTypes.onReloginBaseappFailed, failedcode); + }; + KBEngineApp.prototype.Client_onReloginBaseappSuccessfully = function (stream) { + KBEngine.app.entity_uuid = stream.readUint64(); + KBEngine.DEBUG_MSG("KBEngineApp::Client_onReloginBaseappSuccessfully: " + KBEngine.app.username); + KBEngine.Event.fire(KBEngine.EventTypes.onReloginBaseappSuccessfully); + }; + KBEngineApp.prototype.getentityclass = function (entityType) { + var runclass = KBEngine['Entities'][entityType]; + if (runclass == undefined) { + KBEngine.ERROR_MSG("KBEngineApp::getentityclass: entityType(" + entityType + ") is error!"); + return runclass; + } + return runclass; + }; + KBEngineApp.prototype.Client_onCreatedProxies = function (rndUUID, eid, entityType) { + KBEngine.INFO_MSG("KBEngineApp::Client_onCreatedProxies: eid(" + eid + "), entityType(" + entityType + ")!"); + var entity = KBEngine.app.entities[eid]; + KBEngine.app.entity_uuid = rndUUID; + KBEngine.app.entity_id = eid; + if (entity == undefined) { + var runclass = KBEngine.app.getentityclass(entityType); + if (runclass == undefined) + return; + var entity_1 = new runclass(); + entity_1.id = eid; + entity_1.className = entityType; + entity_1.base = new KBEngine.EntityCall(); + entity_1.base.id = eid; + entity_1.base.className = entityType; + entity_1.base.type = KBEngine.ENTITYCALL_TYPE_BASE; + KBEngine.app.entities[eid] = entity_1; + var entityMessage = KBEngine.bufferedCreateEntityMessages[eid]; + if (entityMessage != undefined) { + KBEngine.app.Client_onUpdatePropertys(entityMessage); + delete KBEngine.bufferedCreateEntityMessages[eid]; + } + entity_1.__init__(); + entity_1.attachComponents(); + entity_1.inited = true; + if (KBEngine.app.args.isOnInitCallPropertysSetMethods) + entity_1.callPropertysSetMethods(); + } + else { + var entityMessage = KBEngine.bufferedCreateEntityMessages[eid]; + if (entityMessage != undefined) { + KBEngine.app.Client_onUpdatePropertys(entityMessage); + delete KBEngine.bufferedCreateEntityMessages[eid]; + } + } + }; + KBEngineApp.prototype.getViewEntityIDFromStream = function (stream) { + var id = 0; + if (KBEngine.app.entityIDAliasIDList.length > 255) { + id = stream.readInt32(); + } + else { + var aliasID = stream.readUint8(); + // 如果为0且客户端上一步是重登陆或者重连操作并且服务端entity在断线期间一直处于在线状态 + // 则可以忽略这个错误, 因为cellapp可能一直在向baseapp发送同步消息， 当客户端重连上时未等 + // 服务端初始化步骤开始则收到同步信息, 此时这里就会出错。 + if (KBEngine.app.entityIDAliasIDList.length <= aliasID) + return 0; + id = KBEngine.app.entityIDAliasIDList[aliasID]; + } + return id; + }; + KBEngineApp.prototype.onUpdatePropertys_ = function (eid, stream) { + var entity = KBEngine.app.entities[eid]; + if (entity == undefined) { + var entityMessage = KBEngine.bufferedCreateEntityMessages[eid]; + if (entityMessage != undefined) { + KBEngine.ERROR_MSG("KBEngineApp::Client_onUpdEntityComponentatePropertys: entity(" + eid + ") not found!"); + return; + } + var stream1 = new KBEngine.MemoryStream(stream.buffer); + stream1.wpos = stream.wpos; + stream1.rpos = stream.rpos - 4; + KBEngine.bufferedCreateEntityMessages[eid] = stream1; + return; + } + entity.onUpdatePropertys(stream); + }; + KBEngineApp.prototype.Client_onUpdatePropertysOptimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + KBEngine.app.onUpdatePropertys_(eid, stream); + }; + KBEngineApp.prototype.Client_onUpdatePropertys = function (stream) { + var eid = stream.readInt32(); + KBEngine.app.onUpdatePropertys_(eid, stream); + }; + KBEngineApp.prototype.onRemoteMethodCall_ = function (eid, stream) { + var entity = KBEngine.app.entities[eid]; + if (entity == undefined) { + KBEngine.ERROR_MSG("KBEngineApp::Client_onRemoteMethodCall: entity(" + eid + ") not found!"); + return; + } + entity.onRemoteMethodCall(stream); + }; + KBEngineApp.prototype.Client_onRemoteMethodCallOptimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + KBEngine.app.onRemoteMethodCall_(eid, stream); + }; + KBEngineApp.prototype.Client_onRemoteMethodCall = function (stream) { + var eid = stream.readInt32(); + KBEngine.app.onRemoteMethodCall_(eid, stream); + }; + KBEngineApp.prototype.Client_onEntityEnterWorld = function (stream) { + var eid = stream.readInt32(); + if (KBEngine.app.entity_id > 0 && eid != KBEngine.app.entity_id) + KBEngine.app.entityIDAliasIDList.push(eid); + var entityType; + if (KBEngine.moduledefs['Length'] > 255) + entityType = stream.readUint16(); + else + entityType = stream.readUint8(); + var isOnGround = true; + if (stream.length() > 0) + isOnGround = stream.readInt8(); + entityType = KBEngine.moduledefs[entityType].name; + KBEngine.INFO_MSG("KBEngineApp::Client_onEntityEnterWorld: " + entityType + "(" + eid + "), spaceID(" + KBEngine.app.spaceID + "), isOnGround(" + isOnGround + ")!"); + var entity = KBEngine.app.entities[eid]; + if (entity == undefined) { + var entityMessage = KBEngine.bufferedCreateEntityMessages[eid]; + if (entityMessage == undefined) { + KBEngine.ERROR_MSG("KBEngineApp::Client_onEntityEnterWorld: entity(" + eid + ") not found!"); + return; + } + var runclass = KBEngine.app.getentityclass(entityType); + if (runclass == undefined) + return; + var entity_2 = new runclass(); + entity_2.id = eid; + entity_2.className = entityType; + entity_2.cell = new KBEngine.EntityCall(); + entity_2.cell.id = eid; + entity_2.cell.className = entityType; + entity_2.cell.type = KBEngine.ENTITYCALL_TYPE_CELL; + KBEngine.app.entities[eid] = entity_2; + KBEngine.app.Client_onUpdatePropertys(entityMessage); + delete KBEngine.bufferedCreateEntityMessages[eid]; + // entity.isOnGround = isOnGround > 0; + entity_2.isOnGround = isOnGround; + entity_2.__init__(); + entity_2.attachComponents(); + entity_2.inited = true; + entity_2.inWorld = true; + entity_2.enterWorld(); + if (KBEngine.app.args.isOnInitCallPropertysSetMethods) + entity_2.callPropertysSetMethods(); + entity_2.set_direction(entity_2.direction); + entity_2.set_position(entity_2.position); + } + else { + if (!entity.inWorld) { + entity.cell = new KBEngine.EntityCall(); + entity.cell.id = eid; + entity.cell.className = entityType; + entity.cell.type = KBEngine.ENTITYCALL_TYPE_CELL; + // 安全起见， 这里清空一下 + // 如果服务端上使用giveClientTo切换控制权 + // 之前的实体已经进入世界， 切换后的实体也进入世界， 这里可能会残留之前那个实体进入世界的信息 + KBEngine.app.entityIDAliasIDList = []; + KBEngine.app.entities = {}; + KBEngine.app.entities[entity.id] = entity; + entity.set_direction(entity.direction); + entity.set_position(entity.position); + KBEngine.app.entityServerPos.x = entity.position.x; + KBEngine.app.entityServerPos.y = entity.position.y; + KBEngine.app.entityServerPos.z = entity.position.z; + entity.isOnGround = isOnGround; + // entity.isOnGround = isOnGround > 0; + entity.inWorld = true; + entity.enterWorld(); + if (KBEngine.app.args.isOnInitCallPropertysSetMethods) + entity.callPropertysSetMethods(); + } + } + }; + KBEngineApp.prototype.Client_onEntityLeaveWorldOptimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + KBEngine.app.Client_onEntityLeaveWorld(eid); + }; + KBEngineApp.prototype.Client_onEntityLeaveWorld = function (eid) { + var entity = KBEngine.app.entities[eid]; + if (entity == undefined) { + KBEngine.ERROR_MSG("KBEngineApp::Client_onEntityLeaveWorld: entity(" + eid + ") not found!"); + return; + } + if (entity.inWorld) + entity.leaveWorld(); + if (KBEngine.app.entity_id > 0 && eid != KBEngine.app.entity_id) { + var newArray0 = []; + for (var i = 0; i < KBEngine.app.controlledEntities.length; i++) { + if (KBEngine.app.controlledEntities[i] != eid) { + newArray0.push(KBEngine.app.controlledEntities[i]); + } + else { + KBEngine.Event.fire("onLoseControlledEntity"); + } + } + KBEngine.app.controlledEntities = newArray0; + delete KBEngine.app.entities[eid]; + var newArray = []; + for (var i = 0; i < KBEngine.app.entityIDAliasIDList.length; i++) { + if (KBEngine.app.entityIDAliasIDList[i] != eid) { + newArray.push(KBEngine.app.entityIDAliasIDList[i]); + } + } + KBEngine.app.entityIDAliasIDList = newArray; + } + else { + KBEngine.app.clearSpace(false); + entity.cell = null; + } + }; + KBEngineApp.prototype.Client_onEntityDestroyed = function (eid) { + KBEngine.INFO_MSG("KBEngineApp::Client_onEntityDestroyed: entity(" + eid + ")!"); + var entity = KBEngine.app.entities[eid]; + if (entity == undefined) { + KBEngine.ERROR_MSG("KBEngineApp::Client_onEntityDestroyed: entity(" + eid + ") not found!"); + return; + } + if (entity.inWorld) { + if (KBEngine.app.entity_id == eid) + KBEngine.app.clearSpace(false); + entity.leaveWorld(); + } + delete KBEngine.app.entities[eid]; + }; + KBEngineApp.prototype.Client_onEntityEnterSpace = function (stream) { + var eid = stream.readInt32(); + KBEngine.app.spaceID = stream.readUint32(); + var isOnGround = true; + if (stream.length() > 0) + isOnGround = stream.readInt8(); + var entity = KBEngine.app.entities[eid]; + if (entity == undefined) { + KBEngine.ERROR_MSG("KBEngineApp::Client_onEntityEnterSpace: entity(" + eid + ") not found!"); + return; + } + entity.isOnGround = isOnGround; + KBEngine.app.entityServerPos.x = entity.position.x; + KBEngine.app.entityServerPos.y = entity.position.y; + KBEngine.app.entityServerPos.z = entity.position.z; + entity.enterSpace(); + }; + KBEngineApp.prototype.Client_onEntityLeaveSpace = function (eid) { + var entity = KBEngine.app.entities[eid]; + if (entity == undefined) { + KBEngine.ERROR_MSG("KBEngineApp::Client_onEntityLeaveSpace: entity(" + eid + ") not found!"); + return; + } + KBEngine.app.clearSpace(false); + entity.leaveSpace(); + }; + KBEngineApp.prototype.Client_onKicked = function (failedcode) { + KBEngine.ERROR_MSG("KBEngineApp::Client_onKicked: failedcode(" + KBEngine.app.serverErrs[failedcode].name + ")!"); + KBEngine.Event.fire(KBEngine.EventTypes.onKicked, failedcode); + }; + KBEngineApp.prototype.Client_onCreateAccountResult = function (stream) { + var retcode = stream.readUint16(); + var datas = stream.readBlob(); + KBEngine.Event.fire("onCreateAccountResult", retcode, datas); + if (retcode != 0) { + KBEngine.ERROR_MSG("KBEngineApp::Client_onCreateAccountResult: " + KBEngine.app.username + " create is failed! code=" + KBEngine.app.serverErrs[retcode].name + "!"); + return; + } + KBEngine.INFO_MSG("KBEngineApp::Client_onCreateAccountResult: " + KBEngine.app.username + " create is successfully!"); + }; + KBEngineApp.prototype.Client_onControlEntity = function (eid, isControlled) { + // eid = stream.readInt32(); + var entity = KBEngine.app.entities[eid]; + if (entity == undefined) { + KBEngine.ERROR_MSG("KBEngineApp::Client_onControlEntity: entity(" + eid + ") not found!"); + return; + } + var isCont = isControlled != 0; + if (isCont) { + // 如果被控制者是玩家自己，那表示玩家自己被其它人控制了 + // 所以玩家自己不应该进入这个被控制列表 + if (KBEngine.app.player().id != entity.id) { + KBEngine.app.controlledEntities.push(entity); + } + } + else { + var newArray = []; + for (var i = 0; i < KBEngine.app.controlledEntities.length; i++) + if (KBEngine.app.controlledEntities[i] != entity.id) + newArray.push(KBEngine.app.controlledEntities[i]); + KBEngine.app.controlledEntities = newArray; + } + entity.isControlled = isCont; + try { + entity.onControlled(isCont); + KBEngine.Event.fire(KBEngine.EventTypes.onControlled, entity, isCont); + } + catch (e) { + KBEngine.ERROR_MSG("KBEngine::Client_onControlEntity: entity id = '" + eid + "', is controlled = '" + isCont + "', error = '" + e + "'"); + } + }; + KBEngineApp.prototype.updatePlayerToServer = function () { + var player = KBEngine.app.player(); + if (player == undefined || player.inWorld == false || KBEngine.app.spaceID == 0 || player.isControlled) + return; + if (player.entityLastLocalPos.distance(player.position) > 0.001 || player.entityLastLocalDir.distance(player.direction) > 0.001) { + // 记录玩家最后一次上报位置时自身当前的位置 + player.entityLastLocalPos.x = player.position.x; + player.entityLastLocalPos.y = player.position.y; + player.entityLastLocalPos.z = player.position.z; + player.entityLastLocalDir.x = player.direction.x; + player.entityLastLocalDir.y = player.direction.y; + player.entityLastLocalDir.z = player.direction.z; + var bundle = KBEngine.Bundle.createObject(); + bundle.newMessage(KBEngine.messages['Baseapp_onUpdateDataFromClient']); + bundle.writeFloat(player.position.x); + bundle.writeFloat(player.position.y); + bundle.writeFloat(player.position.z); + bundle.writeFloat(player.direction.x); + bundle.writeFloat(player.direction.y); + bundle.writeFloat(player.direction.z); + bundle.writeUint8(player.isOnGround); + bundle.writeUint32(KBEngine.app.spaceID); + bundle.send(KBEngine.app); + } + // 开始同步所有被控制了的entity的位置 + for (var i in KBEngine.app.controlledEntities) { + var entity = KBEngine.app.controlledEntities[i]; + var position = entity.position; + var direction = entity.direction; + var posHasChanged = entity.entityLastLocalPos.distance(position) > 0.001; + var dirHasChanged = entity.entityLastLocalDir.distance(direction) > 0.001; + if (posHasChanged || dirHasChanged) { + entity.entityLastLocalPos = position; + entity.entityLastLocalDir = direction; + var bundle = KBEngine.Bundle.createObject(); + bundle.newMessage(KBEngine.messages['Baseapp_onUpdateDataFromClientForControlledEntity']); + bundle.writeInt32(entity.id); + bundle.writeFloat(position.x); + bundle.writeFloat(position.y); + bundle.writeFloat(position.z); + bundle.writeFloat(direction.x); + bundle.writeFloat(direction.y); + bundle.writeFloat(direction.z); + bundle.writeUint8(entity.isOnGround); + bundle.writeUint32(KBEngine.app.spaceID); + bundle.send(KBEngine.app); + } + } + }; + KBEngineApp.prototype.addSpaceGeometryMapping = function (spaceID, respath) { + KBEngine.INFO_MSG("KBEngineApp::addSpaceGeometryMapping: spaceID(" + spaceID + "), respath(" + respath + ")!"); + KBEngine.app.spaceID = spaceID; + KBEngine.app.spaceResPath = respath; + KBEngine.Event.fire(KBEngine.EventTypes.addSpaceGeometryMapping, respath); + }; + KBEngineApp.prototype.clearSpace = function (isAll) { + KBEngine.app.entityIDAliasIDList = []; + KBEngine.app.spacedata = {}; + KBEngine.app.clearEntities(isAll); + KBEngine.app.isLoadedGeometry = false; + KBEngine.app.spaceID = 0; + }; + KBEngineApp.prototype.clearEntities = function (isAll) { + KBEngine.app.controlledEntities = []; + if (!isAll) { + var entity = KBEngine.app.player(); + for (var eid in KBEngine.app.entities) { + if (eid == entity.id) + continue; + if (KBEngine.app.entities[eid].inWorld) { + KBEngine.app.entities[eid].leaveWorld(); + } + KBEngine.app.entities[eid].onDestroy(); + } + KBEngine.app.entities = {}; + KBEngine.app.entities[entity.id] = entity; + } + else { + for (var eid in KBEngine.app.entities) { + if (KBEngine.app.entities[eid].inWorld) { + KBEngine.app.entities[eid].leaveWorld(); + } + KBEngine.app.entities[eid].onDestroy(); + } + KBEngine.app.entities = {}; + } + }; + KBEngineApp.prototype.Client_initSpaceData = function (stream) { + KBEngine.app.clearSpace(false); + KBEngine.app.spaceID = stream.readInt32(); + while (stream.length() > 0) { + var key = stream.readString(); + var value = stream.readString(); + KBEngine.app.Client_setSpaceData(KBEngine.app.spaceID, key, value); + } + KBEngine.INFO_MSG("KBEngineApp::Client_initSpaceData: spaceID(" + KBEngine.app.spaceID + "), datas(" + KBEngine.app.spacedata + ")!"); + }; + KBEngineApp.prototype.Client_setSpaceData = function (spaceID, key, value) { + KBEngine.INFO_MSG("KBEngineApp::Client_setSpaceData: spaceID(" + spaceID + "), key(" + key + "), value(" + value + ")!"); + KBEngine.app.spacedata[key] = value; + if (key == "_mapping") + KBEngine.app.addSpaceGeometryMapping(spaceID, value); + KBEngine.Event.fire("onSetSpaceData", spaceID, key, value); + }; + KBEngineApp.prototype.Client_delSpaceData = function (spaceID, key) { + KBEngine.INFO_MSG("KBEngineApp::Client_delSpaceData: spaceID(" + spaceID + "), key(" + key + ")!"); + delete KBEngine.app.spacedata[key]; + KBEngine.Event.fire("onDelSpaceData", spaceID, key); + }; + KBEngineApp.prototype.Client_getSpaceData = function (spaceID, key) { + return KBEngine.app.spacedata[key]; + }; + KBEngineApp.prototype.Client_onUpdateBasePos = function (x, y, z) { + KBEngine.app.entityServerPos.x = x; + KBEngine.app.entityServerPos.y = y; + KBEngine.app.entityServerPos.z = z; + }; + KBEngineApp.prototype.Client_onUpdateBasePosXZ = function (x, z) { + KBEngine.app.entityServerPos.x = x; + KBEngine.app.entityServerPos.z = z; + }; + KBEngineApp.prototype.Client_onUpdateData = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var entity = KBEngine.app.entities[eid]; + if (entity == undefined) { + KBEngine.ERROR_MSG("KBEngineApp::Client_onUpdateData: entity(" + eid + ") not found!"); + return; + } + }; + KBEngineApp.prototype.Client_onSetEntityPosAndDir = function (stream) { + var eid = stream.readInt32(); + var entity = KBEngine.app.entities[eid]; + if (entity == undefined) { + KBEngine.ERROR_MSG("KBEngineApp::Client_onSetEntityPosAndDir: entity(" + eid + ") not found!"); + return; + } + entity.position.x = stream.readFloat(); + entity.position.y = stream.readFloat(); + entity.position.z = stream.readFloat(); + entity.direction.x = stream.readFloat(); + entity.direction.y = stream.readFloat(); + entity.direction.z = stream.readFloat(); + // 记录玩家最后一次上报位置时自身当前的位置 + entity.entityLastLocalPos.x = entity.position.x; + entity.entityLastLocalPos.y = entity.position.y; + entity.entityLastLocalPos.z = entity.position.z; + entity.entityLastLocalDir.x = entity.direction.x; + entity.entityLastLocalDir.y = entity.direction.y; + entity.entityLastLocalDir.z = entity.direction.z; + entity.set_direction(entity.direction); + entity.set_position(entity.position); + }; + KBEngineApp.prototype.Client_onUpdateData_ypr = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var y = stream.readFloat(); + var p = stream.readFloat(); + var r = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, y, p, r, -1); + }; + KBEngineApp.prototype.Client_onUpdateData_yp = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var y = stream.readFloat(); + var p = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, y, p, KBEngine.KBE_FLT_MAX, -1); + }; + KBEngineApp.prototype.Client_onUpdateData_yr = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var y = stream.readFloat(); + var r = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, y, KBEngine.KBE_FLT_MAX, r, -1); + }; + KBEngineApp.prototype.Client_onUpdateData_pr = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var p = stream.readFloat(); + var r = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, p, r, -1); + }; + KBEngineApp.prototype.Client_onUpdateData_y = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var y = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, y, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, -1); + }; + KBEngineApp.prototype.Client_onUpdateData_p = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var p = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, p, KBEngine.KBE_FLT_MAX, -1); + }; + KBEngineApp.prototype.Client_onUpdateData_r = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var r = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, r, -1); + }; + KBEngineApp.prototype.Client_onUpdateData_xz = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + // let x = stream.readFloat(); let z = stream.readFloat(); + var x = stream.readFloat(); + var z = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, x, KBEngine.KBE_FLT_MAX, z, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, 1); + }; + KBEngineApp.prototype.Client_onUpdateData_xz_ypr = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var x = stream.readFloat(); + var z = stream.readFloat(); + var y = stream.readFloat(); + var p = stream.readFloat(); + var r = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, x, KBEngine.KBE_FLT_MAX, z, y, p, r, 1); + }; + KBEngineApp.prototype.Client_onUpdateData_xz_yp = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var x = stream.readFloat(); + var z = stream.readFloat(); + var y = stream.readFloat(); + var p = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, x, KBEngine.KBE_FLT_MAX, z, y, p, KBEngine.KBE_FLT_MAX, 1); + }; + KBEngineApp.prototype.Client_onUpdateData_xz_yr = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var x = stream.readFloat(); + var z = stream.readFloat(); + var y = stream.readFloat(); + var r = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, x, KBEngine.KBE_FLT_MAX, z, y, KBEngine.KBE_FLT_MAX, r, 1); + }; + KBEngineApp.prototype.Client_onUpdateData_xz_pr = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var x = stream.readFloat(); + var z = stream.readFloat(); + var p = stream.readFloat(); + var r = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, x, KBEngine.KBE_FLT_MAX, z, KBEngine.KBE_FLT_MAX, p, r, 1); + }; + KBEngineApp.prototype.Client_onUpdateData_xz_y = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var x = stream.readFloat(); + var z = stream.readFloat(); + var y = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, x, KBEngine.KBE_FLT_MAX, z, y, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, 1); + }; + KBEngineApp.prototype.Client_onUpdateData_xz_p = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var x = stream.readFloat(); + var z = stream.readFloat(); + var p = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, x, KBEngine.KBE_FLT_MAX, z, KBEngine.KBE_FLT_MAX, p, KBEngine.KBE_FLT_MAX, 1); + }; + KBEngineApp.prototype.Client_onUpdateData_xz_r = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var x = stream.readFloat(); + var z = stream.readFloat(); + var r = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, x, KBEngine.KBE_FLT_MAX, z, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, r, 1); + }; + KBEngineApp.prototype.Client_onUpdateData_xyz = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var x = stream.readFloat(); + var y = stream.readFloat(); + var z = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, x, y, z, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, 0); + }; + KBEngineApp.prototype.Client_onUpdateData_xyz_ypr = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var x = stream.readFloat(); + var y = stream.readFloat(); + var z = stream.readFloat(); + var yaw = stream.readFloat(); + var p = stream.readFloat(); + var r = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, x, y, z, yaw, p, r, 0); + }; + KBEngineApp.prototype.Client_onUpdateData_xyz_yp = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var x = stream.readFloat(); + var z = stream.readFloat(); + var y = stream.readFloat(); + var yaw = stream.readFloat(); + var p = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, x, y, z, yaw, p, KBEngine.KBE_FLT_MAX, 0); + }; + KBEngineApp.prototype.Client_onUpdateData_xyz_yr = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var x = stream.readFloat(); + var z = stream.readFloat(); + var y = stream.readFloat(); + var yaw = stream.readFloat(); + var r = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, x, y, z, yaw, KBEngine.KBE_FLT_MAX, r, 0); + }; + KBEngineApp.prototype.Client_onUpdateData_xyz_pr = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var x = stream.readFloat(); + var z = stream.readFloat(); + var y = stream.readFloat(); + var p = stream.readFloat(); + var r = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, x, y, z, KBEngine.KBE_FLT_MAX, p, r, 0); + }; + KBEngineApp.prototype.Client_onUpdateData_xyz_y = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var x = stream.readFloat(); + var z = stream.readFloat(); + var y = stream.readFloat(); + var yaw = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, x, y, z, yaw, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, 0); + }; + KBEngineApp.prototype.Client_onUpdateData_xyz_p = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var x = stream.readFloat(); + var z = stream.readFloat(); + var y = stream.readFloat(); + var p = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, x, y, z, KBEngine.KBE_FLT_MAX, p, KBEngine.KBE_FLT_MAX, 0); + }; + KBEngineApp.prototype.Client_onUpdateData_xyz_r = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var x = stream.readFloat(); + var z = stream.readFloat(); + var y = stream.readFloat(); + //todo 这个是自己加的，如果错误再修改 + var r = stream.readFloat(); + // let p = stream.readFloat(); + KBEngine.app._updateVolatileData(eid, x, y, z, r, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, 0); + }; + KBEngineApp.prototype.Client_onUpdateData_ypr_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var y = stream.readInt8(); + var p = stream.readInt8(); + var r = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, y, p, r, -1, true); + }; + KBEngineApp.prototype.Client_onUpdateData_yp_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var y = stream.readInt8(); + var p = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, y, p, KBEngine.KBE_FLT_MAX, -1, true); + }; + KBEngineApp.prototype.Client_onUpdateData_yr_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var y = stream.readInt8(); + var r = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, y, KBEngine.KBE_FLT_MAX, r, -1, true); + }; + KBEngineApp.prototype.Client_onUpdateData_pr_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var p = stream.readInt8(); + var r = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, p, r, -1, true); + }; + KBEngineApp.prototype.Client_onUpdateData_y_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var y = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, y, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, -1, true); + }; + KBEngineApp.prototype.Client_onUpdateData_p_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var p = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, p, KBEngine.KBE_FLT_MAX, -1, true); + }; + KBEngineApp.prototype.Client_onUpdateData_r_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var r = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, r, -1, true); + }; + KBEngineApp.prototype.Client_onUpdateData_xz_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var xz = stream.readPackXZ(); + KBEngine.app._updateVolatileData(eid, xz[0], KBEngine.KBE_FLT_MAX, xz[1], KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, 1, true); + }; + KBEngineApp.prototype.Client_onUpdateData_xz_ypr_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var xz = stream.readPackXZ(); + var y = stream.readInt8(); + var p = stream.readInt8(); + var r = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, xz[0], KBEngine.KBE_FLT_MAX, xz[1], y, p, r, 1, true); + }; + KBEngineApp.prototype.Client_onUpdateData_xz_yp_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var xz = stream.readPackXZ(); + var y = stream.readInt8(); + var p = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, xz[0], KBEngine.KBE_FLT_MAX, xz[1], y, p, KBEngine.KBE_FLT_MAX, 1, true); + }; + KBEngineApp.prototype.Client_onUpdateData_xz_yr_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var xz = stream.readPackXZ(); + var y = stream.readInt8(); + var r = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, xz[0], KBEngine.KBE_FLT_MAX, xz[1], y, KBEngine.KBE_FLT_MAX, r, 1, true); + }; + KBEngineApp.prototype.Client_onUpdateData_xz_pr_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var xz = stream.readPackXZ(); + var p = stream.readInt8(); + var r = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, xz[0], KBEngine.KBE_FLT_MAX, xz[1], KBEngine.KBE_FLT_MAX, p, r, 1, true); + }; + KBEngineApp.prototype.Client_onUpdateData_xz_y_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var xz = stream.readPackXZ(); + var y = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, xz[0], KBEngine.KBE_FLT_MAX, xz[1], y, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, 1, true); + }; + KBEngineApp.prototype.Client_onUpdateData_xz_p_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var xz = stream.readPackXZ(); + var p = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, xz[0], KBEngine.KBE_FLT_MAX, xz[1], KBEngine.KBE_FLT_MAX, p, KBEngine.KBE_FLT_MAX, 1, true); + }; + KBEngineApp.prototype.Client_onUpdateData_xz_r_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var xz = stream.readPackXZ(); + var r = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, xz[0], KBEngine.KBE_FLT_MAX, xz[1], KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, r, 1, true); + }; + KBEngineApp.prototype.Client_onUpdateData_xyz_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var xz = stream.readPackXZ(); + var y = stream.readPackY(); + KBEngine.app._updateVolatileData(eid, xz[0], y, xz[1], KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, 0, true); + }; + KBEngineApp.prototype.Client_onUpdateData_xyz_ypr_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var xz = stream.readPackXZ(); + var y = stream.readPackY(); + var yaw = stream.readInt8(); + var p = stream.readInt8(); + var r = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, xz[0], y, xz[1], yaw, p, r, 0, true); + }; + KBEngineApp.prototype.Client_onUpdateData_xyz_yp_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var xz = stream.readPackXZ(); + var y = stream.readPackY(); + var yaw = stream.readInt8(); + var p = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, xz[0], y, xz[1], yaw, p, KBEngine.KBE_FLT_MAX, 0, true); + }; + KBEngineApp.prototype.Client_onUpdateData_xyz_yr_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var xz = stream.readPackXZ(); + var y = stream.readPackY(); + var yaw = stream.readInt8(); + var r = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, xz[0], y, xz[1], yaw, KBEngine.KBE_FLT_MAX, r, 0, true); + }; + KBEngineApp.prototype.Client_onUpdateData_xyz_pr_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var xz = stream.readPackXZ(); + var y = stream.readPackY(); + var p = stream.readInt8(); + var r = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, xz[0], y, xz[1], KBEngine.KBE_FLT_MAX, p, r, 0, true); + }; + KBEngineApp.prototype.Client_onUpdateData_xyz_y_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var xz = stream.readPackXZ(); + var y = stream.readPackY(); + var yaw = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, xz[0], y, xz[1], yaw, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, 0, true); + }; + KBEngineApp.prototype.Client_onUpdateData_xyz_p_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var xz = stream.readPackXZ(); + var y = stream.readPackY(); + var p = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, xz[0], y, xz[1], KBEngine.KBE_FLT_MAX, p, KBEngine.KBE_FLT_MAX, 0, true); + }; + KBEngineApp.prototype.Client_onUpdateData_xyz_r_optimized = function (stream) { + var eid = KBEngine.app.getViewEntityIDFromStream(stream); + var xz = stream.readPackXZ(); + var y = stream.readPackY(); + var r = stream.readInt8(); + KBEngine.app._updateVolatileData(eid, xz[0], y, xz[1], r, KBEngine.KBE_FLT_MAX, KBEngine.KBE_FLT_MAX, 0, true); + }; + KBEngineApp.prototype._updateVolatileData = function (entityID, x, y, z, yaw, pitch, roll, isOnGround, isOptimized) { + if (isOptimized === void 0) { isOptimized = false; } + var entity = KBEngine.app.entities[entityID]; + if (entity == undefined) { + // 如果为0且客户端上一步是重登陆或者重连操作并且服务端entity在断线期间一直处于在线状态 + // 则可以忽略这个错误, 因为cellapp可能一直在向baseapp发送同步消息， 当客户端重连上时未等 + // 服务端初始化步骤开始则收到同步信息, 此时这里就会出错。 + KBEngine.ERROR_MSG("KBEngineApp::_updateVolatileData: entity(" + entityID + ") not found!"); + return; + } + // 小于0不设置 + if (isOnGround >= 0) { + entity.isOnGround = (isOnGround > 0); + } + var changeDirection = false; + if (roll != KBEngine.KBE_FLT_MAX) { + changeDirection = true; + entity.direction.x = KBEngine.int82angle(roll, false); + } + if (pitch != KBEngine.KBE_FLT_MAX) { + changeDirection = true; + entity.direction.y = KBEngine.int82angle(pitch, false); + } + if (yaw != KBEngine.KBE_FLT_MAX) { + changeDirection = true; + entity.direction.z = KBEngine.int82angle(yaw, false); + } + var done = false; + if (changeDirection == true) { + KBEngine.Event.fire("set_direction", entity); + done = true; + } + var positionChanged = false; + if (x != KBEngine.KBE_FLT_MAX || y != KBEngine.KBE_FLT_MAX || z != KBEngine.KBE_FLT_MAX) + positionChanged = true; + if (x == KBEngine.KBE_FLT_MAX) + x = 0.0; + if (y == KBEngine.KBE_FLT_MAX) + y = 0.0; + if (z == KBEngine.KBE_FLT_MAX) + z = 0.0; + if (positionChanged) { + if (isOptimized) { + entity.position.x = x + KBEngine.app.entityServerPos.x; + entity.position.y = y + KBEngine.app.entityServerPos.y; + entity.position.z = z + KBEngine.app.entityServerPos.z; + } + else { + entity.position.x = x; + entity.position.y = y; + entity.position.z = z; + } + done = true; + KBEngine.Event.fire("updatePosition", entity); + } + if (done) + entity.onUpdateVolatileData(); + }; + KBEngineApp.prototype.Client_onStreamDataStarted = function (id, datasize, descr) { + KBEngine.Event.fire(KBEngine.EventTypes.onStreamDataStarted, id, datasize, descr); + }; + KBEngineApp.prototype.Client_onStreamDataRecv = function (stream) { + var id = stream.readUint16(); + var data = stream.readBlob(); + KBEngine.Event.fire(KBEngine.EventTypes.onStreamDataRecv, id, data); + }; + KBEngineApp.prototype.Client_onStreamDataCompleted = function (id) { + KBEngine.Event.fire(KBEngine.EventTypes.onStreamDataCompleted, id); + }; + KBEngineApp.prototype.Client_onReqAccountResetPasswordCB = function (failedcode) { + if (failedcode != 0) { + KBEngine.ERROR_MSG("KBEngineApp::Client_onReqAccountResetPasswordCB: " + KBEngine.app.username + " is failed! code=" + KBEngine.app.serverErrs[failedcode].name + "!"); + return; + } + KBEngine.INFO_MSG("KBEngineApp::Client_onReqAccountResetPasswordCB: " + KBEngine.app.username + " is successfully!"); + }; + KBEngineApp.prototype.Client_onReqAccountBindEmailCB = function (failedcode) { + if (failedcode != 0) { + KBEngine.ERROR_MSG("KBEngineApp::Client_onReqAccountBindEmailCB: " + KBEngine.app.username + " is failed! code=" + KBEngine.app.serverErrs[failedcode].name + "!"); + return; + } + KBEngine.INFO_MSG("KBEngineApp::Client_onReqAccountBindEmailCB: " + KBEngine.app.username + " is successfully!"); + }; + KBEngineApp.prototype.Client_onReqAccountNewPasswordCB = function (failedcode) { + if (failedcode != 0) { + KBEngine.ERROR_MSG("KBEngineApp::Client_onReqAccountNewPasswordCB: " + KBEngine.app.username + " is failed! code=" + KBEngine.app.serverErrs[failedcode].name + "!"); + return; + } + KBEngine.INFO_MSG("KBEngineApp::Client_onReqAccountNewPasswordCB: " + KBEngine.app.username + " is successfully!"); + }; + return KBEngineApp; + }()); + KBEngine.KBEngineApp = KBEngineApp; + __reflect(KBEngineApp.prototype, "KBEngine.KBEngineApp"); + // 描述服务端返回的错误信息 + var ServerErr = (function () { + function ServerErr() { + this.name = ""; + this.descr = ""; + this.id = 0; + } + return ServerErr; + }()); + KBEngine.ServerErr = ServerErr; + __reflect(ServerErr.prototype, "KBEngine.ServerErr"); + KBEngine.FragmentDataTypes = { + FRAGMENT_DATA_UNKNOW: 0, + FRAGMENT_DATA_MESSAGE_ID: 1, + FRAGMENT_DATA_MESSAGE_LENGTH: 2, + FRAGMENT_DATA_MESSAGE_LENGTH1: 3, + FRAGMENT_DATA_MESSAGE_BODY: 4 + }; + var idInterval; + function create(args) { + if (KBEngine.app != undefined) + return; + new KBEngineApp(args); + KBEngine.app.reset(); + KBEngine.app.installEvents(); + idInterval = setInterval(KBEngine.app.update, args.updateHZ); + } + KBEngine.create = create; + function destroy() { + if (idInterval != undefined) + clearInterval(idInterval); + if (KBEngine.app == undefined) + return; + KBEngine.app.uninstallEvents(); + KBEngine.app.reset(); + KBEngine.app = undefined; + KBEngine.Event.clear(); + } + KBEngine.destroy = destroy; +})(KBEngine || (KBEngine = {})); diff --git a/kbengine_ts/kbengine/kbengine.min.js b/kbengine_ts/kbengine/kbengine.min.js new file mode 100644 index 0000000..cb84a38 --- /dev/null +++ b/kbengine_ts/kbengine/kbengine.min.js @@ -0,0 +1,3 @@ +var __reflect=this&&this.__reflect||function(t,e,n){t.__class__=e,n?n.push(e):n=[e],t.__types__=t.__types__?n.concat(t.__types__):n},__extends=this&&this.__extends||function(t,e){function n(){this.constructor=t}for(var r in e)e.hasOwnProperty(r)&&(t[r]=e[r]);n.prototype=e.prototype,t.prototype=new n},KBEngine;!function(t){t.CLIENT_VERSION="2.5.0",t.CLIENT_SCRIPT_VERSION="0.1.0",t.PACKET_MAX_SIZE=1500,t.PACKET_MAX_SIZE_TCP=1460,t.PACKET_MAX_SIZE_UDP=1472,t.MESSAGE_ID_LENGTH=2,t.MESSAGE_LENGTH_LENGTH=2,t.MESSAGE_LENGTH1_LENGTH=4,t.MESSAGE_MAX_SIZE=65535,t.CLIENT_NO_FLOAT=0,t.KBE_FLT_MAX=3.402823466e38}(KBEngine||(KBEngine={})),window.KBEngine=KBEngine,ArrayBuffer.transfer||(ArrayBuffer.transfer=function(t,e){var n=new ArrayBuffer(e);if(!(t instanceof ArrayBuffer&&n instanceof ArrayBuffer))throw new TypeError("ArrayBuffer.transfer, error: Source and destination must be ArrayBuffer instances");if(!(n.byteLength>=t.byteLength))throw new RangeError("ArrayBuffer.transfer, error: destination has not enough space");var r=new Uint8Array(n);return r.set(new Uint8Array(t),0),n}),function(t){var e=function(){function t(t,e){this.sign=1,this.lo=t,this.hi=e,e>=2147483648&&(this.sign=-1,this.lo>0?(this.lo=4294967296-this.lo&4294967295,this.hi=4294967295-this.hi):(this.lo=4294967296-this.lo&4294967295,this.hi=4294967296-this.hi))}return t.prototype.toString=function(){var t="";this.sign<0&&(t+="-");var e=this.lo.toString(16),n=this.hi.toString(16);if(this.hi>0){t+=n;for(var r=8-e.length;r>0;--r)t+="0"}return t+=e},t}();t.INT64=e,__reflect(e.prototype,"KBEngine.INT64");var n=function(){function t(t,e){this.lo=t,this.hi=e}return t.prototype.toString=function(){var t=this.lo.toString(16),e=this.hi.toString(16),n="";if(this.hi>0){n+=e;for(var r=8-t.length;r>0;--r)n+="0"}return n+=t},t}();t.UINT64=n,__reflect(n.prototype,"KBEngine.UINT64")}(KBEngine||(KBEngine={})),function(t){function e(t){var e=typeof t;if(!t||"object"!=e&&!t.prototype)return e;var n=t.prototype?t.prototype:Object.getPrototypeOf(t);if(n.hasOwnProperty("__class__"))return n.__class__;var r=n.constructor.toString().trim(),a=r.indexOf("("),i=r.substring(9,a),o=i.split(".");return Object.defineProperty(n,"__class__",{value:o[o.length-1],enumerable:!1,writable:!0}),o[o.length-1]}t.getQualifiedClassName=e}(KBEngine||(KBEngine={})),function(t){function e(){for(var t=[],e=0;en;)switch(a=t[n++],a>>4){case 0:case 1:case 2:case 3:case 4:case 5:case 6:case 7:e+=String.fromCharCode(a);break;case 12:case 13:i=t[n++],e+=String.fromCharCode((31&a)<<6|63&i);break;case 14:i=t[n++],o=t[n++],e+=String.fromCharCode((15&a)<<12|(63&i)<<6|(63&o)<<0)}return e}function n(t){for(var e=[],n=0;nr?e.push(r):2048>r?e.push(192|r>>6,128|63&r):55296>r||r>=57344?e.push(224|r>>12,128|r>>6&63,128|63&r):(n++,r=65536+((1023&r)<<10|1023&t.charCodeAt(n)),e.push(240|r>>18,128|r>>12&63,128|r>>6&63,128|63&r))}return e}t.utf8ArrayToString=e,t.stringToUTF8Bytes=n}(KBEngine||(KBEngine={})),function(t){var e=function(){function t(t,e){this.classinst=t,this.callbackfn=e}return t}();t.EventInfo=e,__reflect(e.prototype,"KBEngine.EventInfo");var n=function(){function t(t,e,n){this.evtName=t,this.evtInfo=e,this.ars=n}return t}();t.FiredEvent=n,__reflect(n.prototype,"KBEngine.FiredEvent");var r=function(){function r(){this._events={},this._isPause=!1,this._firedEvents=[]}return r.prototype.register=function(n,r,a){var i=r[a];if(void 0==i)return void t.ERROR_MSG("export class Event::fire: not found strCallback("+r+")!"+a);var o=this._events[n];void 0==o&&(o=[],this._events[n]=o);var p=new e(r,i);o.push(p)},r.prototype.deregisterAll=function(t){for(var e in this._events)this.deregister(e,t)},r.prototype.deregister=function(t,e){var n=this._events[t];if(n)for(var r=n.length-1;r>=0;r--){var a=n[r];a.classinst==e&&n.splice(r,1)}},r.prototype.removeAllFiredEvent=function(t){this.removeFiredEvent("",t)},r.prototype.removeFiredEvent=function(t,e){for(var n=this._firedEvents,r=n.length-1;r>=0;r--){var a=n[r];""!=t&&a.evtName!=t||a.evtInfo.classinst!=e||n.splice(r,1)}},r.prototype.fire=function(e){for(var r=[],a=1;a0;){var e=t.shift(),n=e.evtInfo,r=e.ars;r.length<1?n.callbackfn.apply(n.classinst):n.callbackfn.apply(n.classinst,r)}},r.prototype.clear=function(){this._events={},this._firedEvents.splice(0,this._firedEvents.length)},r}();t.Events=r,__reflect(r.prototype,"KBEngine.Events"),t.Event=new r}(KBEngine||(KBEngine={})),function(t){var e=function(){function t(){this._unionData=new ArrayBuffer(4),this.fv=new Float32Array(this._unionData,0,1),this.uv=new Uint32Array(this._unionData,0,1),this.iv=new Int32Array(this._unionData,0,1)}return t}();t.PackFloatXType=e,__reflect(e.prototype,"KBEngine.PackFloatXType"),t._xPackData=new e,t._yPackData=new e,t._zPackData=new e;var n=function(){function e(t){this.rpos=0,this.wpos=0,t instanceof ArrayBuffer?this.buffer=t:this.buffer=new ArrayBuffer(t),this.rpos=0,this.wpos=0}return e.prototype.readInt8=function(){var t=new Int8Array(this.buffer,this.rpos,1);return this.rpos+=1,t[0]},e.prototype.readInt16=function(){var t=this.readUint16();return t>=32768&&(t-=65536),t},e.prototype.readInt32=function(){var t=this.readUint32();return t>=2147483648&&(t-=4294967296),t},e.prototype.readInt64=function(){var e=this.readUint32(),n=this.readUint32();return new t.INT64(e,n)},e.prototype.readUint8=function(){var t=new Uint8Array(this.buffer,this.rpos,1);return this.rpos+=1,t[0]},e.prototype.readUint16=function(){var t=new Uint8Array(this.buffer,this.rpos);return this.rpos+=2,((255&t[1])<<8)+(255&t[0])},e.prototype.readUint32=function(){var t=new Uint8Array(this.buffer,this.rpos);return this.rpos+=4,(t[3]<<24)+(t[2]<<16)+(t[1]<<8)+t[0]},e.prototype.readUint64=function(){var e=this.readUint32(),n=this.readUint32();return new t.UINT64(e,n)},e.prototype.readFloat=function(){var t;try{t=new Float32Array(this.buffer,this.rpos,1)}catch(e){t=new Float32Array(this.buffer.slice(this.rpos,this.rpos+4))}return this.rpos+=4,t[0]},e.prototype.readDouble=function(){var t;try{t=new Float64Array(this.buffer,this.rpos,1)}catch(e){t=new Float64Array(this.buffer.slice(this.rpos,this.rpos+8),0,1)}return this.rpos+=8,t[0]},e.prototype.readString=function(){for(var t=new Uint8Array(this.buffer,this.rpos),e=0,n="";;){if(0==t[e]){e++;break}if(n+=String.fromCharCode(t[e]),e++,this.rpos+e>=this.buffer.byteLength)throw new Error("export class MemoryStream::readString: rpos("+(this.rpos+e)+")>="+this.buffer.byteLength+" overflow!")}return this.rpos+=e,n},e.prototype.readBlob=function(){var t=this.readUint32(),e=new Uint8Array(this.buffer,this.rpos,t);return this.rpos+=t,e},e.prototype.readStream=function(){var t=new Uint8Array(this.buffer,this.rpos,this.buffer.byteLength-this.rpos);return this.rpos=this.buffer.byteLength,new e(t)},e.prototype.readPackXZ=function(){var e=t._xPackData,n=t._zPackData;e.fv[0]=0,n.fv[0]=0,e.uv[0]=1073741824,n.uv[0]=1073741824;var r=this.readUint8(),a=this.readUint8(),i=this.readUint8(),o=0;o|=r<<16,o|=a<<8,o|=i,e.uv[0]|=(8384512&o)<<3,n.uv[0]|=(2047&o)<<15,e.fv[0]-=2,n.fv[0]-=2,e.uv[0]|=(8388608&o)<<8,n.uv[0]|=(2048&o)<<20;var p=new Array(2);return p[0]=e.fv[0],p[1]=n.fv[0],p},e.prototype.readPackY=function(){var e=this.readUint16(),n=t._yPackData;return n.uv[0]=1073741824,n.uv[0]|=(32767&e)<<12,n.fv[0]-=2,n.uv[0]|=(32768&e)<<16,n.fv[0]},e.prototype.writeInt8=function(t){var e=new Int8Array(this.buffer,this.wpos,1);e[0]=t,this.wpos+=1},e.prototype.writeInt16=function(t){this.writeInt8(255&t),this.writeInt8(t>>8&255)},e.prototype.writeInt32=function(t){for(var e=0;4>e;e++)this.writeInt8(t>>8*e&255)},e.prototype.writeInt64=function(t){this.writeInt32(t.lo),this.writeInt32(t.hi)},e.prototype.writeUint8=function(t){var e=new Uint8Array(this.buffer,this.wpos,1);e[0]=t,this.wpos+=1},e.prototype.writeUint16=function(t){this.writeUint8(255&t),this.writeUint8(t>>8&255)},e.prototype.writeUint32=function(t){for(var e=0;4>e;e++)this.writeUint8(t>>8*e&255)},e.prototype.writeUint64=function(t){this.writeUint32(t.lo),this.writeUint32(t.hi)},e.prototype.writeFloat=function(t){try{var e=new Float32Array(this.buffer,this.wpos,1);e[0]=t}catch(n){var e=new Float32Array(1);e[0]=t;var r=new Uint8Array(this.buffer),a=new Uint8Array(e.buffer);r.set(a,this.wpos)}this.wpos+=4},e.prototype.writeDouble=function(t){try{var e=new Float64Array(this.buffer,this.wpos,1);e[0]=t}catch(n){var e=new Float64Array(1);e[0]=t;var r=new Uint8Array(this.buffer),a=new Uint8Array(e.buffer);r.set(a,this.wpos)}this.wpos+=8},e.prototype.writeBlob=function(e){var n=e.length;if(n+4>this.space())return void t.ERROR_MSG("memorystream::writeBlob: no free!");this.writeUint32(n);var r=new Uint8Array(this.buffer,this.wpos,n);if("string"==typeof e)for(var a=0;n>a;a++)r[a]=e.charCodeAt(a);else for(var a=0;n>a;a++)r[a]=e[a];this.wpos+=n},e.prototype.writeString=function(e){if(e.length>this.space())return void t.ERROR_MSG("memorystream::writeString: no free!");for(var n=new Uint8Array(this.buffer,this.wpos),r=0,a=0;athis.space()&&(this.buffer=ArrayBuffer.transfer(this.buffer,this.buffer.byteLength+2*n));var r=new Uint8Array(this.buffer,this.wpos,n);r.set(new Uint8Array(t.buffer,e,n),0),this.wpos+=n},e.prototype.readSkip=function(t){this.rpos+=t},e.prototype.space=function(){return this.buffer.byteLength-this.wpos},e.prototype.length=function(){return this.wpos-this.rpos},e.prototype.readEOF=function(){return this.buffer.byteLength-this.rpos<=0},e.prototype.done=function(){this.rpos=this.wpos},e.prototype.getbuffer=function(){return this.buffer.slice(this.rpos,this.wpos)},e.prototype.setbuffer=function(t){this.clear(),this.buffer=t},e.prototype.size=function(){return this.buffer.byteLength},e.prototype.clear=function(){this.rpos=this.wpos=0,this.buffer.byteLength>t.PACKET_MAX_SIZE&&(this.buffer=new ArrayBuffer(t.PACKET_MAX_SIZE))},e.prototype.reclaimObject=function(){this.clear(),void 0!=e._objects&&e._objects.push(this)},e}();t.MemoryStream=n,__reflect(n.prototype,"KBEngine.MemoryStream"),function(e){function n(){return e._objects.length>0?e._objects.pop():new e(t.PACKET_MAX_SIZE_TCP)}e._objects=[],e.createObject=n}(n=t.MemoryStream||(t.MemoryStream={}))}(KBEngine||(KBEngine={})),function(t){function e(){t.datatype2id={},t.datatype2id.STRING=1,t.datatype2id["STD::STRING"]=1,t.datatype2id.UINT8=2,t.datatype2id.BOOL=2,t.datatype2id.DATATYPE=2,t.datatype2id.CHAR=2,t.datatype2id.DETAIL_TYPE=2,t.datatype2id.ENTITYCALL_CALL_TYPE=2,t.datatype2id.UINT16=3,t.datatype2id["UNSIGNED SHORT"]=3,t.datatype2id.SERVER_ERROR_CODE=3,t.datatype2id.ENTITY_TYPE=3,t.datatype2id.ENTITY_PROPERTY_UID=3,t.datatype2id.ENTITY_METHOD_UID=3,t.datatype2id.ENTITY_SCRIPT_UID=3,t.datatype2id.DATATYPE_UID=3,t.datatype2id.UINT32=4,t.datatype2id.UINT=4,t.datatype2id["UNSIGNED INT"]=4,t.datatype2id.ARRAYSIZE=4,t.datatype2id.SPACE_ID=4,t.datatype2id.GAME_TIME=4,t.datatype2id.TIMER_ID=4,t.datatype2id.UINT64=5,t.datatype2id.DBID=5,t.datatype2id.COMPONENT_ID=5,t.datatype2id.INT8=6,t.datatype2id.COMPONENT_ORDER=6,t.datatype2id.INT16=7,t.datatype2id.SHORT=7,t.datatype2id.INT32=8,t.datatype2id.INT=8,t.datatype2id.ENTITY_ID=8,t.datatype2id.CALLBACK_ID=8,t.datatype2id.COMPONENT_TYPE=8,t.datatype2id.INT64=9,t.datatype2id.PYTHON=10,t.datatype2id.PY_DICT=10,t.datatype2id.PY_TUPLE=10,t.datatype2id.PY_LIST=10,t.datatype2id.ENTITYCALL=10,t.datatype2id.BLOB=11,t.datatype2id.UNICODE=12,t.datatype2id.FLOAT=13,t.datatype2id.DOUBLE=14,t.datatype2id.VECTOR2=15,t.datatype2id.VECTOR3=16,t.datatype2id.VECTOR4=17,t.datatype2id.FIXED_DICT=18,t.datatype2id.ARRAY=19,t.datatype2id.ENTITYCALL=20}function n(e,n){switch(n){case t.datatype2id.UINT8:return e.writeUint8;case t.datatype2id.UINT16:return e.writeUint16;case t.datatype2id.UINT32:return e.writeUint32;case t.datatype2id.UINT64:return e.writeUint64;case t.datatype2id.INT8:return e.writeInt8;case t.datatype2id.INT16:return e.writeInt16;case t.datatype2id.INT32:return e.writeInt32;case t.datatype2id.INT64:return e.writeInt64;case t.datatype2id.FLOAT:return e.writeFloat;case t.datatype2id.DOUBLE:return e.writeDouble;case t.datatype2id.STRING:return e.writeString;case t.datatype2id.FIXED_DICT:return e.writeStream;case t.datatype2id.ARRAY:return e.writeStream;default:return e.writeStream}}function r(e){switch(e){case t.datatype2id.UINT8:return t.reader.readUint8;case t.datatype2id.UINT16:return t.reader.readUint16;case t.datatype2id.UINT32:return t.reader.readUint32;case t.datatype2id.UINT64:return t.reader.readUint64;case t.datatype2id.INT8:return t.reader.readInt8;case t.datatype2id.INT16:return t.reader.readInt16;case t.datatype2id.INT32:return t.reader.readInt32;case t.datatype2id.INT64:return t.reader.readInt64;case t.datatype2id.FLOAT:return t.reader.readFloat;case t.datatype2id.DOUBLE:return t.reader.readDouble;case t.datatype2id.STRING:return t.reader.readString;case t.datatype2id.FIXED_DICT:return t.reader.readStream;case t.datatype2id.ARRAY:return t.reader.readStream;default:return t.reader.readStream}}var a=function(){function e(){this.memorystreams=new Array,this.numMessage=0,this.messageLengthBuffer=null,this.msgtype=null,this.messageLength=0,this.stream=t.MemoryStream.createObject()}return e.createObject=function(){return e._objects.length>0?e._objects.pop():new e},e.prototype.newMessage=function(e){this.fini(!1),this.msgtype=e,this.numMessage+=1,-1==this.msgtype.length&&(this.messageLengthBuffer=new Uint8Array(this.stream.buffer,this.stream.wpos+t.MESSAGE_ID_LENGTH,2)),this.writeUint16(e.id),this.messageLengthBuffer&&(this.writeUint16(0),this.messageLengthBuffer[0]=0,this.messageLengthBuffer[1]=0,this.messageLength=0)},e.prototype.writeMsgLength=function(t){this.messageLengthBuffer&&(this.messageLengthBuffer[0]=255&t,this.messageLengthBuffer[1]=t>>8&255)},e.prototype.fini=function(e){this.numMessage>0&&(this.writeMsgLength(this.messageLength),this.stream&&this.memorystreams.push(this.stream),this.stream=t.MemoryStream.createObject()),e&&(this.messageLengthBuffer=null,this.numMessage=0,this.msgtype=null)},e.prototype.send=function(t){this.fini(!0);for(var e=0;ethis.stream.space()&&(this.memorystreams.push(this.stream),this.stream=t.MemoryStream.createObject()),this.messageLength+=e},e.prototype.writeInt8=function(t){this.checkStream(1),this.stream.writeInt8(t)},e.prototype.writeInt16=function(t){this.checkStream(2),this.stream.writeInt16(t)},e.prototype.writeInt32=function(t){this.checkStream(4),this.stream.writeInt32(t)},e.prototype.writeInt64=function(t){this.checkStream(8),this.stream.writeInt64(t)},e.prototype.writeUint8=function(t){this.checkStream(1),this.stream.writeUint8(t)},e.prototype.writeUint16=function(t){this.checkStream(2),this.stream.writeUint16(t)},e.prototype.writeUint32=function(t){this.checkStream(4),this.stream.writeUint32(t)},e.prototype.writeUint64=function(t){this.checkStream(8),this.stream.writeUint64(t)},e.prototype.writeFloat=function(t){this.checkStream(4),this.stream.writeFloat(t)},e.prototype.writeDouble=function(t){this.checkStream(8),this.stream.writeDouble(t)},e.prototype.writeString=function(t){this.checkStream(t.length+1),this.stream.writeString(t)},e.prototype.writeBlob=function(t){this.checkStream(t.length+4),this.stream.writeBlob(t)},e.prototype.clear=function(){for(var e=0;en){var r=e;e=n,n=r}return e>t?e:n>t?t:n}function n(t,e){return t*(Math.PI/(e?254:128))}function r(t,n){var r=0;return r=n?e(Math.floor(254*t/Math.PI+.5),-128,127):Math.floor(128*t/Math.PI+.5)}var a=function(){function t(t,e){this.x=t,this.y=e}return t.prototype.distance=function(t){var e=t.x-this.x,n=t.y-this.y;return Math.sqrt(e*e+n*n)},t.prototype.add=function(t){return this.x+=t.x,this.y+=t.y,this},t.prototype.sub=function(t){return this.x-=t.x,this.y-=t.y,this},t.prototype.mul=function(t){return this.x*=t,this.y*=t,this},t.prototype.div=function(t){return this.x/=t,this.y/=t,this},t.prototype.neg=function(){return this.x=-this.x,this.y=-this.y,this},t}();t.Vector2=a,__reflect(a.prototype,"KBEngine.Vector2");var i=function(){function t(t,e,n){this.x=t,this.y=e,this.z=n,this.x=t,this.y=e,this.z=n}return t.prototype.distance=function(t){var e=t.x-this.x,n=t.y-this.y,r=t.z-this.z;return Math.sqrt(e*e+n*n+r*r)},t.prototype.add=function(t){return this.x+=t.x,this.y+=t.y,this.z+=t.z,this},t.prototype.sub=function(t){return this.x-=t.x,this.y-=t.y,this.z-=t.z,this},t.prototype.mul=function(t){return this.x*=t,this.y*=t,this.z*=t,this},t.prototype.div=function(t){return this.x/=t,this.y/=t,this.z/=t,this},t.prototype.neg=function(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this},t}();t.Vector3=i,__reflect(i.prototype,"KBEngine.Vector3");var o=function(){function t(t,e,n,r){this.x=t,this.y=e,this.z=n,this.w=r,this.x=t,this.y=e,this.z=n,this.w=r}return t.prototype.distance=function(t){var e=t.x-this.x,n=t.y-this.y,r=t.z-this.z,a=t.w-this.w;return Math.sqrt(e*e+n*n+r*r+a*a)},t.prototype.add=function(t){return this.x+=t.x,this.y+=t.y,this.z+=t.z,this.w+=t.w,this},t.prototype.sub=function(t){return this.x-=t.x,this.y-=t.y,this.z-=t.z,this.w-=t.w,this},t.prototype.mul=function(t){return this.x*=t,this.y*=t,this.z*=t,this.w*=t,this},t.prototype.div=function(t){return this.x/=t,this.y/=t,this.z/=t,this.w/=t,this},t.prototype.neg=function(){return this.x=-this.x,this.y=-this.y,this.z=-this.z,this.w=-this.w,this},t}();t.Vector4=o,__reflect(o.prototype,"KBEngine.Vector4"),t.clampf=e,t.int82angle=n,t.angle2int8=r}(KBEngine||(KBEngine={})),function(t){function e(){return function(e){var n=t.getQualifiedClassName(e);t.Entities[n]=e}}t.Entities={};var n=function(){function e(){this.__comps__={},this.id=0,this.className="",this.position=new t.Vector3(0,0,0),this.direction=new t.Vector3(0,0,0),this.velocity=0,this.cell=null,this.base=null,this.inWorld=!1,this.inited=!1,this.isControlled=!1,this.entityLastLocalPos=new t.Vector3(0,0,0),this.entityLastLocalDir=new t.Vector3(0,0,0),this.isOnGround=!1;for(var e in this.__comps__)this[e]=new this.__comps__[e]}return e.prototype.__init__=function(){},e.prototype.attachComponents=function(){for(var t in this.__comps__)this[t].onAttached(this)},e.prototype.getComponents=function(e,n){void 0===n&&(n=!1);var r=[];for(var a in this.__comps__)if(t.getQualifiedClassName(this.__comps__[a])===e){if(!n)return this[a];r.push(this[a])}return r},e.prototype.detachComponents=function(){for(var t in this.__comps__)this[t].onDetached(this)},e.prototype.callPropertysSetMethods=function(){var e=t.moduledefs[this.className];for(var n in e.propertys){var r=e.propertys[n];r[0];n=r[2];var a=r[5],i=r[6],o=this[n];if(null!=a)if(32==i||64==i)this.inited&&!this.inWorld&&a.call(this,o);else if(this.inWorld){if((8==i||16==i)&&!this.isPlayer())continue;a.call(this,o)}}},e.prototype.onDestroy=function(){this.detachComponents()},e.prototype.onControlled=function(t){},e.prototype.isPlayer=function(){return this.id==t.app.entity_id},e.prototype.baseCall=function(e){for(var n=[],r=1;r0;){var a=0,i=0;if(n.usePropertyDescrAlias?(i=e.readUint8(),a=e.readUint8()):(i=e.readUint16(),a=e.readUint16()),0===i){var o=r[a],p=o[5],s=o[6];if(o[4]){var l=o[4].createFromStream(e),c=this[o[2]];t.INFO_MSG("KBEngineApp::Client_onUpdatePropertys: "+this.className+"(id="+this.id+" "+o[2]+", val="+l+")!"),this[o[2]]=l,null!=p&&(32==s||64==s?this.inited&&p.call(this,c):this.inWorld&&p.call(this,c))}else this[o[2]]&&"function"==typeof this[o[2]].createFromStream&&this[o[2]].createFromStream(e,o[0])}else{var d=r[i];this[d[2]]&&this[d[2]].onUpdatePropertys(a,e,-1)}}},e.prototype.set_direction=function(e){t.DEBUG_MSG(this.className+"::set_direction: "+this.direction),t.Event.fire("set_direction",this)},e.prototype.onRemoteMethodCall=function(e){var n=t.moduledefs[this.className],r=n.usePropertyDescrAlias?e.readUint8():e.readUint16(),a=n.useMethodDescrAlias?e.readUint8():e.readUint16();if(0!==r){var i=this[n.propertys[r][2]];return void(i&&i.onRemoteMethodCall(a,e))}for(var o=t.moduledefs[this.className].methods[a],p=[],s=o[3],l=0;l0&&0!=r--;){var p=e,s=0;0===p&&(i.usePropertyDescrAlias?(s=n.readUint8(),p=n.readUint8()):(s=n.readUint16(),p=n.readUint16()));var l=o[p],c=l[5],d=l[6],u=l[4].createFromStream(n),y=this[l[2]];t.INFO_MSG("KBEngineApp::Client_onUpdatePropertys: "+a+"(id="+this.id+" "+l[2]+", val="+u+")!"),this[l[2]]=u,null!=c&&(32==d||64==d?this.owner.inited&&c.call(this,y):this.owner.inWorld&&c.call(this,y))}},e.prototype.onRemoteMethodCall=function(e,n){for(var r=t.moduledefs[this.className].methods[e],a=[],i=r[3],o=0;o0&&this.onUpdatePropertys(0,e,r),this.className=t.getQualifiedClassName(this),this.base=new t.EntityComponentCall(this.entityComponentPropertyID,this.ownerID,this.className),this.base.type=t.ENTITYCALL_TYPE_BASE,this.cell=new t.EntityComponentCall(this.entityComponentPropertyID,this.ownerID,this.className),this.cell.type=t.ENTITYCALL_TYPE_CELL},e}();t.EntityComponent=n,__reflect(n.prototype,"KBEngine.EntityComponent"),t.registerComponent=e}(KBEngine||(KBEngine={})),function(t){t.ENTITYCALL_TYPE_CELL=0,t.ENTITYCALL_TYPE_BASE=1;var e=function(){function e(){this.id=0,this.className="",this.type=t.ENTITYCALL_TYPE_CELL,this.networkInterface=t.app,this.bundle=null}return e.prototype.isBase=function(){return this.type==t.ENTITYCALL_TYPE_BASE},e.prototype.isCell=function(){return this.type==t.ENTITYCALL_TYPE_CELL},e.prototype.newCall=function(){return null==this.bundle&&(this.bundle=t.Bundle.createObject()),this.type==t.ENTITYCALL_TYPE_CELL?this.bundle.newMessage(t.messages.Baseapp_onRemoteCallCellMethodFromClient):this.bundle.newMessage(t.messages.Entity_onRemoteMethodCall),this.bundle.writeInt32(this.id),this.bundle},e.prototype.sendCall=function(t){void 0==t&&(t=this.bundle),t.send(this.networkInterface),this.bundle==t&&(this.bundle=null)},e}();t.EntityCall=e,__reflect(e.prototype,"KBEngine.EntityCall");var n=function(t){function e(e,n,r){var a=t.call(this)||this;return a.entityComponentPropertyID=0,a.entityComponentPropertyID=e,a.id=n,a.className=r,a}return __extends(e,t),e}(e);t.EntityComponentCall=n,__reflect(n.prototype,"KBEngine.EntityComponentCall");var r=function(){function e(){}return e.prototype.bind=function(){},e.prototype.createFromStream=function(e){return t.reader.readUint8.call(e)},e.prototype.addToStream=function(t,e){t.writeUint8(e)},e.prototype.parseDefaultValStr=function(t){return parseInt(t)},e.prototype.isSameType=function(t){return"number"!=typeof t?!1:0>t||t>255?!1:!0},e}();t.DATATYPE_UINT8=r,__reflect(r.prototype,"KBEngine.DATATYPE_UINT8");var a=function(){function e(){}return e.prototype.bind=function(){},e.prototype.createFromStream=function(e){return t.reader.readUint16.call(e)},e.prototype.addToStream=function(t,e){t.writeUint16(e)},e.prototype.parseDefaultValStr=function(t){return parseInt(t)},e.prototype.isSameType=function(t){return"number"!=typeof t?!1:0>t||t>65535?!1:!0},e}();t.DATATYPE_UINT16=a,__reflect(a.prototype,"KBEngine.DATATYPE_UINT16");var i=function(){function e(){}return e.prototype.bind=function(){},e.prototype.createFromStream=function(e){return t.reader.readUint32.call(e) +},e.prototype.addToStream=function(t,e){t.writeUint32(e)},e.prototype.parseDefaultValStr=function(t){return parseInt(t)},e.prototype.isSameType=function(t){return"number"!=typeof t?!1:0>t||t>4294967295?!1:!0},e}();t.DATATYPE_UINT32=i,__reflect(i.prototype,"KBEngine.DATATYPE_UINT32");var o=function(){function e(){}return e.prototype.bind=function(){},e.prototype.createFromStream=function(e){return t.reader.readUint64.call(e)},e.prototype.addToStream=function(t,e){t.writeUint64(e)},e.prototype.parseDefaultValStr=function(t){return parseInt(t)},e.prototype.isSameType=function(e){return e instanceof t.UINT64},e}();t.DATATYPE_UINT64=o,__reflect(o.prototype,"KBEngine.DATATYPE_UINT64");var p=function(){function e(){}return e.prototype.bind=function(){},e.prototype.createFromStream=function(e){return t.reader.readInt8.call(e)},e.prototype.addToStream=function(t,e){t.writeInt8(e)},e.prototype.parseDefaultValStr=function(t){return parseInt(t)},e.prototype.isSameType=function(t){return"number"!=typeof t?!1:-128>t||t>127?!1:!0},e}();t.DATATYPE_INT8=p,__reflect(p.prototype,"KBEngine.DATATYPE_INT8");var s=function(){function e(){}return e.prototype.bind=function(){},e.prototype.createFromStream=function(e){return t.reader.readInt16.call(e)},e.prototype.addToStream=function(t,e){t.writeInt16(e)},e.prototype.parseDefaultValStr=function(t){return parseInt(t)},e.prototype.isSameType=function(t){return"number"!=typeof t?!1:-32768>t||t>32767?!1:!0},e}();t.DATATYPE_INT16=s,__reflect(s.prototype,"KBEngine.DATATYPE_INT16");var l=function(){function e(){}return e.prototype.bind=function(){},e.prototype.createFromStream=function(e){return t.reader.readInt32.call(e)},e.prototype.addToStream=function(t,e){t.writeInt32(e)},e.prototype.parseDefaultValStr=function(t){return parseInt(t)},e.prototype.isSameType=function(t){return"number"!=typeof t?!1:-2147483648>t||t>2147483647?!1:!0},e}();t.DATATYPE_INT32=l,__reflect(l.prototype,"KBEngine.DATATYPE_INT32");var c=function(){function e(){}return e.prototype.bind=function(){},e.prototype.createFromStream=function(e){return t.reader.readInt64.call(e)},e.prototype.addToStream=function(t,e){t.writeInt64(e)},e.prototype.parseDefaultValStr=function(t){return parseInt(t)},e.prototype.isSameType=function(e){return e instanceof t.INT64},e}();t.DATATYPE_INT64=c,__reflect(c.prototype,"KBEngine.DATATYPE_INT64");var d=function(){function e(){}return e.prototype.bind=function(){},e.prototype.createFromStream=function(e){return t.reader.readFloat.call(e)},e.prototype.addToStream=function(t,e){t.writeFloat(e)},e.prototype.parseDefaultValStr=function(t){return parseFloat(t)},e.prototype.isSameType=function(t){return"number"==typeof t},e}();t.DATATYPE_FLOAT=d,__reflect(d.prototype,"KBEngine.DATATYPE_FLOAT");var u=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return __extends(n,e),n.prototype.createFromStream=function(e){return t.reader.readDouble.call(e)},n.prototype.addToStream=function(t,e){t.writeDouble(e)},n}(d);t.DATATYPE_DOUBLE=u,__reflect(u.prototype,"KBEngine.DATATYPE_DOUBLE");var y=function(){function e(){}return e.prototype.bind=function(){},e.prototype.createFromStream=function(e){return t.reader.readString.call(e)},e.prototype.addToStream=function(t,e){t.writeString(e)},e.prototype.parseDefaultValStr=function(t){return"string"==typeof t?t:""},e.prototype.isSameType=function(t){return"string"==typeof t},e}();t.DATATYPE_STRING=y,__reflect(y.prototype,"KBEngine.DATATYPE_STRING");var _=function(){function e(){}return e.prototype.bind=function(){},e.prototype.createFromStream=function(e){if(t.CLIENT_NO_FLOAT){var n=t.reader.readInt32.call(e),r=t.reader.readInt32.call(e);return new t.Vector2(n,r)}var n=t.reader.readFloat.call(e),r=t.reader.readFloat.call(e);return new t.Vector2(n,r)},e.prototype.addToStream=function(e,n){t.CLIENT_NO_FLOAT?(e.writeInt32(n.x),e.writeInt32(n.y)):(e.writeFloat(n.x),e.writeFloat(n.y))},e.prototype.parseDefaultValStr=function(e){return new t.Vector2(0,0)},e.prototype.isSameType=function(e){return e instanceof t.Vector2?!0:!1},e}();t.DATATYPE_VECTOR2=_,__reflect(_.prototype,"KBEngine.DATATYPE_VECTOR2");var f=function(){function e(){}return e.prototype.bind=function(){},e.prototype.createFromStream=function(e){return t.CLIENT_NO_FLOAT?new t.Vector3(t.reader.readInt32.call(e),t.reader.readInt32.call(e),t.reader.readInt32.call(e)):new t.Vector3(t.reader.readFloat.call(e),t.reader.readFloat.call(e),t.reader.readFloat.call(e))},e.prototype.addToStream=function(e,n){t.CLIENT_NO_FLOAT?(e.writeInt32(n.x),e.writeInt32(n.y),e.writeInt32(n.z)):(e.writeFloat(n.x),e.writeFloat(n.y),e.writeFloat(n.z))},e.prototype.parseDefaultValStr=function(e){return new t.Vector3(0,0,0)},e.prototype.isSameType=function(e){return e instanceof t.Vector3?!0:!1},e}();t.DATATYPE_VECTOR3=f,__reflect(f.prototype,"KBEngine.DATATYPE_VECTOR3");var h=function(){function e(){}return e.prototype.bind=function(){},e.prototype.createFromStream=function(e){return t.CLIENT_NO_FLOAT?new t.Vector4(t.reader.readInt32.call(e),t.reader.readInt32.call(e),t.reader.readInt32.call(e),t.reader.readInt32.call(e)):new t.Vector4(t.reader.readFloat.call(e),t.reader.readFloat.call(e),t.reader.readFloat.call(e),t.reader.readFloat.call(e))},e.prototype.addToStream=function(e,n){t.CLIENT_NO_FLOAT?(e.writeInt32(n.x),e.writeInt32(n.y),e.writeInt32(n.z),e.writeInt32(n.w)):(e.writeFloat(n.x),e.writeFloat(n.y),e.writeFloat(n.z),e.writeFloat(n.w))},e.prototype.parseDefaultValStr=function(e){return new t.Vector4(0,0,0,0)},e.prototype.isSameType=function(e){return e instanceof t.Vector4?!0:!1},e}();t.DATATYPE_VECTOR4=h,__reflect(h.prototype,"KBEngine.DATATYPE_VECTOR4");var E=function(){function t(){}return t.prototype.bind=function(){},t.prototype.createFromStream=function(t){return t.readBlob()},t.prototype.addToStream=function(t,e){t.writeBlob(e)},t.prototype.parseDefaultValStr=function(t){return new Uint8Array(0)},t.prototype.isSameType=function(t){return!1},t}();t.DATATYPE_PYTHON=E,__reflect(E.prototype,"KBEngine.DATATYPE_PYTHON");var g=function(){function e(){}return e.prototype.bind=function(){},e.prototype.createFromStream=function(e){return t.utf8ArrayToString(t.reader.readBlob.call(e))},e.prototype.addToStream=function(e,n){e.writeBlob(t.stringToUTF8Bytes(n))},e.prototype.parseDefaultValStr=function(t){return"string"==typeof t?t:""},e.prototype.isSameType=function(t){return"string"==typeof t},e}();t.DATATYPE_UNICODE=g,__reflect(g.prototype,"KBEngine.DATATYPE_UNICODE");var m=function(){function t(){}return t.prototype.bind=function(){},t.prototype.createFromStream=function(t){},t.prototype.addToStream=function(t,e){},t.prototype.parseDefaultValStr=function(t){return new Uint8Array(0)},t.prototype.isSameType=function(t){return!1},t}();t.DATATYPE_ENTITYCALL=m,__reflect(m.prototype,"KBEngine.DATATYPE_ENTITYCALL");var v=function(){function e(){}return e.prototype.bind=function(){},e.prototype.createFromStream=function(e){var n=t.reader.readUint32.call(e),r=new Uint8Array(e.buffer,e.rpos,n);return e.rpos+=n,r},e.prototype.addToStream=function(t,e){t.writeBlob(e)},e.prototype.parseDefaultValStr=function(t){return new Uint8Array(0)},e.prototype.isSameType=function(t){return!0},e}();t.DATATYPE_BLOB=v,__reflect(v.prototype,"KBEngine.DATATYPE_BLOB");var T=function(){function t(){this.type=null}return t.prototype.bind=function(){"number"==typeof this.type&&(this.type=A[this.type])},t.prototype.createFromStream=function(t){for(var e=t.readUint32(),n=[];e>0;)e--,n.push(this.type.createFromStream(t));return n},t.prototype.addToStream=function(t,e){t.writeUint32(e.length);for(var n=0;n0||null!=t.app.fragmentStream;)if(t.app.fragmentDatasFlag==t.FragmentDataTypes.FRAGMENT_DATA_UNKNOW){if(0==t.app.currMsgID){if(t.MESSAGE_ID_LENGTH>1&&n.length()=t.app.currMsgLen)r.handleMessage(t.app.fragmentStream),t.app.fragmentStream=null;else{if(n.length()0){t.app.writeFragmentMessage(t.FragmentDataTypes.FRAGMENT_DATA_MESSAGE_BODY,n,t.app.currMsgLen);break}var i=n.wpos,o=n.rpos+a;n.wpos=o,r.handleMessage(n),n.wpos=i,n.rpos=o}t.app.currMsgID=0,t.app.currMsgLen=0,t.app.fragmentStream=null}else if(t.app.mergeFragmentMessage(n))break},e.prototype.writeFragmentMessage=function(e,n,r){var a=n.length();t.app.fragmentDatasRemain=r-a,t.app.fragmentDatasFlag=e,t.app.fragmentStream=n},e.prototype.mergeFragmentMessage=function(e){var n=e.length();if(0==n)return 0;var r=t.app.fragmentStream;if(n>=t.app.fragmentDatasRemain){switch(r.append(e,e.rpos,t.app.fragmentDatasRemain),t.app.fragmentDatasFlag){case t.FragmentDataTypes.FRAGMENT_DATA_MESSAGE_ID:t.app.currMsgID=r.readUint16(),t.app.fragmentStream=null;break;case t.FragmentDataTypes.FRAGMENT_DATA_MESSAGE_LENGTH:t.app.currMsgLen=r.readUint16(),t.app.fragmentStream=null;break;case t.FragmentDataTypes.FRAGMENT_DATA_MESSAGE_LENGTH1:t.app.currMsgLen=r.readUint32(),t.app.fragmentStream=null;break;case t.FragmentDataTypes.FRAGMENT_DATA_MESSAGE_BODY:}return e.rpos+=t.app.fragmentDatasRemain,t.app.fragmentDatasFlag=t.FragmentDataTypes.FRAGMENT_DATA_UNKNOW,t.app.fragmentDatasRemain=0,!1}return r.append(e,e.rpos,n),t.app.fragmentDatasRemain-=n,e.done(),!0},e.prototype.onclose=function(){t.INFO_MSG("connect close:"+t.app.currserver),t.app.currconnect==t.app.currstate&&(t.app.resetSocket(),t.Event.fire(t.EventTypes.onDisconnected))},e.prototype.send=function(e){t.app.socket.send(e)},e.prototype.close=function(){t.INFO_MSG("KBEngine::close()"),t.app.socket.close(),t.app.reset()},e.prototype.update=function(){if(null!=t.app.socket){var e=new Date;if((e.getTime()-t.app.lastTickTime)/1e3>t.app.args.serverHeartbeatTick/2){if(t.app.lastTickCBTime0;){n-=1;var r=new a;r.id=e.readUint16(),r.name=t.utf8ArrayToString(e.readBlob()),r.descr=t.utf8ArrayToString(e.readBlob()),t.app.serverErrs[r.id]=r,t.INFO_MSG("Client_onImportServerErrorsDescr: id="+r.id+", name="+r.name+", descr="+r.descr)}},e.prototype.Client_onImportClientSdk=function(e){var n=e.readInt32(),r=e.readString(),a=e.readInt32(),i=e.readBlob();t.Event.fire("onImportClientSDK",n,r,a,i)},e.prototype.onOpenLoginapp_login=function(){if(t.INFO_MSG("KBEngineApp::onOpenLoginapp_login: successfully!"),t.Event.fire(t.EventTypes.onConnectionState,!0),t.app.currserver="loginapp",t.app.currstate="login",t.app.loginappMessageImported)t.app.onImportClientMessagesCompleted();else{var e=t.Bundle.createObject();e.newMessage(t.messages.Loginapp_importClientMessages),e.send(t.app),t.app.socket.onmessage=t.app.Client_onImportClientMessages,t.INFO_MSG("KBEngineApp::onOpenLoginapp_login: start importClientMessages ..."),t.Event.fire("Loginapp_importClientMessages")}},e.prototype.onOpenLoginapp_createAccount=function(){if(t.Event.fire("onConnectionState",!0),t.INFO_MSG("KBEngineApp::onOpenLoginapp_createAccount: successfully!"),t.app.currserver="loginapp",t.app.currstate="createAccount",t.app.loginappMessageImported)t.app.onImportClientMessagesCompleted();else{var e=t.Bundle.createObject();e.newMessage(t.messages.Loginapp_importClientMessages),e.send(t.app),t.app.socket.onmessage=t.app.Client_onImportClientMessages,t.INFO_MSG("KBEngineApp::onOpenLoginapp_createAccount: start importClientMessages ..."),t.Event.fire("Loginapp_importClientMessages")}},e.prototype.onImportClientMessagesCompleted=function(){if(t.INFO_MSG("KBEngineApp::onImportClientMessagesCompleted: successfully!"),t.app.socket.onmessage=t.app.onmessage,t.app.hello(),"loginapp"==t.app.currserver){if(!t.app.serverErrorsDescrImported){t.INFO_MSG("KBEngine::onImportClientMessagesCompleted(): send importServerErrorsDescr!"),t.app.serverErrorsDescrImported=!0;var e=t.Bundle.createObject();e.newMessage(t.messages.Loginapp_importServerErrorsDescr),e.send(t.app)}"login"==t.app.currstate?t.app.login_loginapp(!1):"resetpassword"==t.app.currstate?t.app.resetpassword_loginapp(!1):t.app.createAccount_loginapp(!1),t.app.loginappMessageImported=!0}else if(t.app.baseappMessageImported=!0,t.app.entitydefImported)t.app.onImportEntityDefCompleted();else{t.INFO_MSG("KBEngineApp::onImportClientMessagesCompleted: start importEntityDef ...");var e=t.Bundle.createObject();e.newMessage(t.messages.Baseapp_importClientEntityDef),e.send(t.app),t.Event.fire("Baseapp_importClientEntityDef")}},e.prototype.createDataTypeFromStreams=function(e,n){var r=e.readUint16();for(t.INFO_MSG("KBEngineApp::createDataTypeFromStreams: importAlias(size="+r+")!");r>0;)r--,t.app.createDataTypeFromStream(e,n);for(var a in t.datatypes)void 0!=t.datatypes[a]&&t.datatypes[a].bind()},e.prototype.createDataTypeFromStream=function(e,n){var r,a=e.readUint16(),i=e.readString(),o=e.readString();if(0==o.length&&(r="Null_"+a),n&&t.INFO_MSG("KBEngineApp::Client_onImportClientEntityDef: importAlias("+i+":"+o+")!"),"FIXED_DICT"==i){var p=new t.DATATYPE_FIXED_DICT,s=e.readUint8();for(p.implementedBy=e.readString();s>0;){s--;var l=e.readString(),c=e.readUint16();p.dicttype[l]=c}t.datatypes[o]=p}else if("ARRAY"==i){var d=e.readUint16(),p=new t.DATATYPE_ARRAY;p.type=d,t.datatypes[o]=p}else t.datatypes[o]=t.datatypes[i];t.datatypes[a]=t.datatypes[o],t.datatype2id[o]=a},e.prototype.Client_onImportClientEntityDef=function(e){for(t.app.createDataTypeFromStreams(e,!0);e.length()>0;){var n=e.readString(),r=e.readUint16(),a=e.readUint16(),i=e.readUint16(),o=e.readUint16(),p=e.readUint16();t.INFO_MSG("KBEngineApp::Client_onImportClientEntityDef: import("+n+"), propertys("+a+"), clientMethods("+i+"), baseMethods("+o+"), cellMethods("+p+")!"),t.moduledefs[n]={};var s=t.moduledefs[n];s.name=n,s.propertys={},s.methods={},s.base_methods={},s.cell_methods={},t.moduledefs[r]=s;for(var l=s.propertys,c=s.methods,d=s.base_methods,u=s.cell_methods,y=t.Entities[n];a>0;){a--;var _=e.readUint16(),f=e.readUint32(),h=e.readInt16(),E=e.readString(),g=e.readString(),m=t.datatypes[e.readUint16()],v=null;void 0!=y&&(v=y.prototype["set_"+E],void 0==v&&(v=null));var T=[_,h,E,g,m,v,f];l[E]=T,-1!=h?(l[h]=T,s.usePropertyDescrAlias=!0):(l[_]=T,s.usePropertyDescrAlias=!1),t.INFO_MSG("KBEngineApp::Client_onImportClientEntityDef: add("+n+"), property("+E+"/"+_+").")}for(;i>0;){i--;for(var S=e.readUint16(),h=e.readInt16(),A=e.readString(),I=e.readUint8(),D=[];I>0;)I--,D.push(t.datatypes[e.readUint16()]);var T=[S,h,A,D];c[A]=T,-1!=h?(c[h]=T,s.useMethodDescrAlias=!0):(c[S]=T,s.useMethodDescrAlias=!1),t.INFO_MSG("KBEngineApp::Client_onImportClientEntityDef: add("+n+"), method("+A+").")}for(;o>0;){o--;for(var S=e.readUint16(),h=e.readInt16(),M=e.readString(),I=e.readUint8(),D=[];I>0;)I--,D.push(t.datatypes[e.readUint16()]);d[M]=[S,h,M,D],t.INFO_MSG("KBEngineApp::Client_onImportClientEntityDef: add("+n+"), base_method("+M+").")}for(;p>0;){p--;for(var S=e.readUint16(),h=e.readInt16(),w=e.readString(),I=e.readUint8(),D=[];I>0;)I--,D.push(t.datatypes[e.readUint16()]);u[w]=[S,h,w,D],t.INFO_MSG("KBEngineApp::Client_onImportClientEntityDef: add("+n+"), cell_method("+w+").")}var F=void 0;try{F=t.Entities[n]}catch(C){t.ERROR_MSG("KBEngineApp::Client_onImportClientEntityDef: module("+n+") not found!"),F=void 0}for(var B in s.propertys){var L=s.propertys[B],_=L[0],h=L[1],R=L[2],g=L[3],m=L[4];void 0!=F&&m&&(F.prototype[R]=m.parseDefaultValStr(g))}for(var b in s.methods){var L=s.methods[b],_=L[0],h=L[1],R=L[2],D=L[3];void 0!=F&&void 0==F.prototype[R]&&t.WARNING_MSG(n+":: method("+R+") no implement!")}}t.app.onImportEntityDefCompleted()},e.prototype.Client_onVersionNotMatch=function(e){t.app.serverVersion=e.readString(),t.ERROR_MSG("Client_onVersionNotMatch: verInfo="+t.app.clientVersion+" not match(server: "+t.app.serverVersion+")"),t.Event.fire(t.EventTypes.onVersionNotMatch,t.app.clientVersion,t.app.serverVersion)},e.prototype.Client_onScriptVersionNotMatch=function(e){t.app.serverScriptVersion=e.readString(),t.ERROR_MSG("Client_onScriptVersionNotMatch: verInfo="+t.app.clientScriptVersion+" not match(server: "+t.app.serverScriptVersion+")"),t.Event.fire(t.EventTypes.onScriptVersionNotMatch,t.app.clientScriptVersion,t.app.serverScriptVersion)},e.prototype.onImportEntityDefCompleted=function(){t.INFO_MSG("KBEngineApp::onImportEntityDefCompleted: successfully!"),t.app.entitydefImported=!0,t.app.login_baseapp(!1)},e.prototype.importClientMessages=function(e){for(;t.app.currMsgCount>0;){t.app.currMsgCount--;for(var n=e.readUint16(),r=e.readInt16(),a=e.readString(),i=e.readInt8(),o=e.readUint8(),p=new Array(o),s=0;o>s;s++)p[s]=e.readUint8();var l=null,c=a.indexOf("Client_")>=0;c&&(l=t.app[a],null==l||void 0==l?(t.WARNING_MSG("KBEngineApp::onImportClientMessages["+t.app.currserver+"]: interface("+a+"/"+n+") no implement!"),l=null):t.INFO_MSG("KBEngineApp::onImportClientMessages: import("+a+") successfully!")),a.length>0?(t.messages[a]=new t.Message(n,a,r,i,p,l),c?t.clientmessages[n]=t.messages[a]:t.messages[t.app.currserver][n]=t.messages[a]):t.messages[t.app.currserver][n]=new t.Message(n,a,r,i,p,l)}t.app.onImportClientMessagesCompleted(),t.app.currMsgID=0,t.app.currMsgLen=0,t.app.currMsgCount=0,t.app.fragmentStream=null},e.prototype.Client_onImportClientMessages=function(e){var n=new t.MemoryStream(e.data);n.wpos=e.data.byteLength,0==t.app.currMsgID&&(t.app.currMsgID=n.readUint16()),t.app.currMsgID==t.messages.onImportClientMessages.id?(0==t.app.currMsgLen&&(t.app.currMsgLen=n.readUint16(),t.app.currMsgCount=n.readUint16()),n.length()+2=t.app.currMsgLen&&t.app.importClientMessages(t.app.fragmentStream)):t.app.importClientMessages(n)):t.ERROR_MSG("KBEngineApp::onmessage: not found msg("+t.app.currMsgID+")!")},e.prototype.createAccount=function(e,n,r){t.app.reset(),t.app.username=e,t.app.password=n,t.app.clientdatas=r,t.app.createAccount_loginapp(!0)},e.prototype.createAccount_loginapp=function(e){if(e)t.INFO_MSG("KBEngineApp::createAccount_loginapp: start connect to ws://"+t.app.args.ip+":"+t.app.args.port+"!"),t.app.currconnect="loginapp",t.app.connect(t.app.args.ip,t.app.args.port),t.app.socket.onopen=t.app.onOpenLoginapp_createAccount;else{var n=t.Bundle.createObject();n.newMessage(t.messages.Loginapp_reqCreateAccount),n.writeString(t.app.username),n.writeString(t.app.password),n.writeBlob(t.app.clientdatas),n.send(t.app)}},e.prototype.bindAccountEmail=function(e){var n=t.Bundle.createObject();n.newMessage(t.messages.Baseapp_reqAccountBindEmail),n.writeInt32(t.app.entity_id),n.writeString(t.app.password),n.writeString(e),n.send(t.app)},e.prototype.newPassword=function(e,n){var r=t.Bundle.createObject();r.newMessage(t.messages.Baseapp_reqAccountNewPassword),r.writeInt32(t.app.entity_id),r.writeString(e),r.writeString(n),r.send(t.app)},e.prototype.logout=function(){var e=new t.Bundle;e.newMessage(t.messages.Baseapp_logoutBaseapp),e.writeUint64(t.app.entity_uuid),e.writeInt32(t.app.entity_id),e.send(t.app)},e.prototype.login=function(e,n,r){t.app.reset(),t.app.username=e,t.app.password=n,t.app.clientdatas=r,t.app.login_loginapp(!0)},e.prototype.login_loginapp=function(e){if(e)t.INFO_MSG("KBEngineApp::login_loginapp: start connect to ws://"+t.app.args.ip+":"+t.app.args.port+"!"),t.app.currconnect="loginapp",t.app.connect(t.app.args.ip,t.app.args.port),t.app.socket.onopen=t.app.onOpenLoginapp_login;else{var n=t.Bundle.createObject();n.newMessage(t.messages.Loginapp_login),n.writeInt8(t.app.args.clientType),n.writeBlob(t.app.clientdatas),n.writeString(t.app.username),n.writeString(t.app.password),n.send(t.app)}},e.prototype.onOpenLoginapp_resetpassword=function(){if(t.INFO_MSG("KBEngineApp::onOpenLoginapp_resetpassword: successfully!"),t.app.currserver="loginapp",t.app.currstate="resetpassword",t.app.loginappMessageImported)t.app.onImportClientMessagesCompleted();else{var e=t.Bundle.createObject();e.newMessage(t.messages.Loginapp_importClientMessages),e.send(t.app),t.app.socket.onmessage=t.app.Client_onImportClientMessages,t.INFO_MSG("KBEngineApp::onOpenLoginapp_resetpassword: start importClientMessages ...")}},e.prototype.reset_password=function(e){t.app.reset(),t.app.username=e,t.app.resetpassword_loginapp(!0)},e.prototype.resetpassword_loginapp=function(e){if(e)t.INFO_MSG("KBEngineApp::createAccount_loginapp: start connect to ws://"+t.app.args.ip+":"+t.app.args.port+"!"),t.app.currconnect="loginapp",t.app.connect(t.app.args.ip,t.app.args.port),t.app.socket.onopen=t.app.onOpenLoginapp_resetpassword;else{var n=t.Bundle.createObject();n.newMessage(t.messages.Loginapp_reqAccountResetPassword),n.writeString(t.app.username),n.send(t.app)}},e.prototype.onOpenBaseapp=function(){if(t.INFO_MSG("KBEngineApp::onOpenBaseapp: successfully!"),t.app.currserver="baseapp",t.app.baseappMessageImported)t.app.onImportClientMessagesCompleted();else{var e=t.Bundle.createObject();e.newMessage(t.messages.Baseapp_importClientMessages),e.send(t.app),t.app.socket.onmessage=t.app.Client_onImportClientMessages,t.Event.fire("Baseapp_importClientMessages")}},e.prototype.login_baseapp=function(e){if(e)t.Event.fire("onLoginBaseapp"),t.INFO_MSG("KBEngineApp::login_baseapp: start connect to ws://"+t.app.baseappIp+":"+t.app.baseappPort+"!"),t.app.currconnect="baseapp",t.app.connect(t.app.baseappIp,t.app.baseappPort),void 0!=t.app.socket&&null!=t.app.socket&&(t.app.socket.onopen=t.app.onOpenBaseapp);else{var n=t.Bundle.createObject();n.newMessage(t.messages.Baseapp_loginBaseapp),n.writeString(t.app.username),n.writeString(t.app.password),n.send(t.app)}},e.prototype.reloginBaseapp=function(){t.app.lastTickCBTime=t.app.lastTickTime=Date.now(),(void 0==t.app.socket||null==t.app.socket)&&(t.app.resetSocket(),t.Event.fire(t.EventTypes.onReloginBaseapp),t.INFO_MSG("KBEngineApp::reloginBaseapp: start connect to ws://"+t.app.baseappIp+":"+t.app.baseappPort+"!"),t.app.currconnect="baseapp",t.app.connect(t.app.baseappIp,t.app.baseappPort),void 0!=t.app.socket&&null!=t.app.socket&&(t.app.socket.onopen=t.app.onReOpenBaseapp))},e.prototype.onReOpenBaseapp=function(){t.INFO_MSG("KBEngineApp::onReOpenBaseapp: successfully!"),t.app.currserver="baseapp";var e=t.Bundle.createObject();e.newMessage(t.messages.Baseapp_reloginBaseapp),e.writeString(t.app.username),e.writeString(t.app.password),e.writeUint64(t.app.entity_uuid),e.writeInt32(t.app.entity_id),e.send(t.app);var n=new Date;t.app.lastTickCBTime=n.getTime()},e.prototype.Client_onHelloCB=function(e){t.app.serverVersion=e.readString(),t.app.serverScriptVersion=e.readString(),t.app.serverProtocolMD5=e.readString(),t.app.serverEntityDefMD5=e.readString();var n=e.readInt32();t.INFO_MSG("KBEngineApp::Client_onHelloCB: verInfo("+t.app.serverVersion+"), scriptVerInfo("+t.app.serverScriptVersion+"), serverProtocolMD5("+t.app.serverProtocolMD5+"), serverEntityDefMD5("+t.app.serverEntityDefMD5+"), ctype("+n+")!");var r=new Date;t.app.lastTickCBTime=r.getTime()},e.prototype.Client_onLoginFailed=function(e){var n=e.readUint16(); +t.app.serverdatas=e.readBlob(),t.ERROR_MSG("KBEngineApp::Client_onLoginFailed: failedcode("+t.app.serverErrs[n].name+"), datas("+t.app.serverdatas.length+")!"),t.Event.fire("onLoginFailed",n)},e.prototype.Client_onLoginSuccessfully=function(e){var n=e.readString();t.app.username=n,t.app.baseappIp=e.readString(),t.app.baseappPort=e.readUint16(),t.app.baseappUdpPort=e.readUint16(),t.app.serverdatas=e.readBlob(),t.INFO_MSG("KBEngineApp::Client_onLoginSuccessfully: accountName("+n+"), addr("+t.app.baseappIp+":"+t.app.baseappPort+"), datas("+t.app.serverdatas.length+")!"),t.app.disconnect(),t.app.login_baseapp(!0)},e.prototype.Client_onLoginBaseappFailed=function(e){t.ERROR_MSG("KBEngineApp::Client_onLoginBaseappFailed: failedcode("+t.app.serverErrs[e].name+")!"),t.Event.fire(t.EventTypes.onLoginBaseappFailed,e)},e.prototype.Client_onReloginBaseappFailed=function(e){t.ERROR_MSG("KBEngineApp::Client_onReloginBaseappFailed: failedcode("+t.app.serverErrs[e].name+")!"),t.Event.fire(t.EventTypes.onReloginBaseappFailed,e)},e.prototype.Client_onReloginBaseappSuccessfully=function(e){t.app.entity_uuid=e.readUint64(),t.DEBUG_MSG("KBEngineApp::Client_onReloginBaseappSuccessfully: "+t.app.username),t.Event.fire(t.EventTypes.onReloginBaseappSuccessfully)},e.prototype.getentityclass=function(e){var n=t.Entities[e];return void 0==n?(t.ERROR_MSG("KBEngineApp::getentityclass: entityType("+e+") is error!"),n):n},e.prototype.Client_onCreatedProxies=function(e,n,r){t.INFO_MSG("KBEngineApp::Client_onCreatedProxies: eid("+n+"), entityType("+r+")!");var a=t.app.entities[n];if(t.app.entity_uuid=e,t.app.entity_id=n,void 0==a){var i=t.app.getentityclass(r);if(void 0==i)return;var o=new i;o.id=n,o.className=r,o.base=new t.EntityCall,o.base.id=n,o.base.className=r,o.base.type=t.ENTITYCALL_TYPE_BASE,t.app.entities[n]=o;var p=t.bufferedCreateEntityMessages[n];void 0!=p&&(t.app.Client_onUpdatePropertys(p),delete t.bufferedCreateEntityMessages[n]),o.__init__(),o.attachComponents(),o.inited=!0,t.app.args.isOnInitCallPropertysSetMethods&&o.callPropertysSetMethods()}else{var p=t.bufferedCreateEntityMessages[n];void 0!=p&&(t.app.Client_onUpdatePropertys(p),delete t.bufferedCreateEntityMessages[n])}},e.prototype.getViewEntityIDFromStream=function(e){var n=0;if(t.app.entityIDAliasIDList.length>255)n=e.readInt32();else{var r=e.readUint8();if(t.app.entityIDAliasIDList.length<=r)return 0;n=t.app.entityIDAliasIDList[r]}return n},e.prototype.onUpdatePropertys_=function(e,n){var r=t.app.entities[e];if(void 0==r){var a=t.bufferedCreateEntityMessages[e];if(void 0!=a)return void t.ERROR_MSG("KBEngineApp::Client_onUpdEntityComponentatePropertys: entity("+e+") not found!");var i=new t.MemoryStream(n.buffer);return i.wpos=n.wpos,i.rpos=n.rpos-4,void(t.bufferedCreateEntityMessages[e]=i)}r.onUpdatePropertys(n)},e.prototype.Client_onUpdatePropertysOptimized=function(e){var n=t.app.getViewEntityIDFromStream(e);t.app.onUpdatePropertys_(n,e)},e.prototype.Client_onUpdatePropertys=function(e){var n=e.readInt32();t.app.onUpdatePropertys_(n,e)},e.prototype.onRemoteMethodCall_=function(e,n){var r=t.app.entities[e];return void 0==r?void t.ERROR_MSG("KBEngineApp::Client_onRemoteMethodCall: entity("+e+") not found!"):void r.onRemoteMethodCall(n)},e.prototype.Client_onRemoteMethodCallOptimized=function(e){var n=t.app.getViewEntityIDFromStream(e);t.app.onRemoteMethodCall_(n,e)},e.prototype.Client_onRemoteMethodCall=function(e){var n=e.readInt32();t.app.onRemoteMethodCall_(n,e)},e.prototype.Client_onEntityEnterWorld=function(e){var n=e.readInt32();t.app.entity_id>0&&n!=t.app.entity_id&&t.app.entityIDAliasIDList.push(n);var r;r=t.moduledefs.Length>255?e.readUint16():e.readUint8();var a=!0;e.length()>0&&(a=e.readInt8()),r=t.moduledefs[r].name,t.INFO_MSG("KBEngineApp::Client_onEntityEnterWorld: "+r+"("+n+"), spaceID("+t.app.spaceID+"), isOnGround("+a+")!");var i=t.app.entities[n];if(void 0==i){var o=t.bufferedCreateEntityMessages[n];if(void 0==o)return void t.ERROR_MSG("KBEngineApp::Client_onEntityEnterWorld: entity("+n+") not found!");var p=t.app.getentityclass(r);if(void 0==p)return;var s=new p;s.id=n,s.className=r,s.cell=new t.EntityCall,s.cell.id=n,s.cell.className=r,s.cell.type=t.ENTITYCALL_TYPE_CELL,t.app.entities[n]=s,t.app.Client_onUpdatePropertys(o),delete t.bufferedCreateEntityMessages[n],s.isOnGround=a,s.__init__(),s.attachComponents(),s.inited=!0,s.inWorld=!0,s.enterWorld(),t.app.args.isOnInitCallPropertysSetMethods&&s.callPropertysSetMethods(),s.set_direction(s.direction),s.set_position(s.position)}else i.inWorld||(i.cell=new t.EntityCall,i.cell.id=n,i.cell.className=r,i.cell.type=t.ENTITYCALL_TYPE_CELL,t.app.entityIDAliasIDList=[],t.app.entities={},t.app.entities[i.id]=i,i.set_direction(i.direction),i.set_position(i.position),t.app.entityServerPos.x=i.position.x,t.app.entityServerPos.y=i.position.y,t.app.entityServerPos.z=i.position.z,i.isOnGround=a,i.inWorld=!0,i.enterWorld(),t.app.args.isOnInitCallPropertysSetMethods&&i.callPropertysSetMethods())},e.prototype.Client_onEntityLeaveWorldOptimized=function(e){var n=t.app.getViewEntityIDFromStream(e);t.app.Client_onEntityLeaveWorld(n)},e.prototype.Client_onEntityLeaveWorld=function(e){var n=t.app.entities[e];if(void 0==n)return void t.ERROR_MSG("KBEngineApp::Client_onEntityLeaveWorld: entity("+e+") not found!");if(n.inWorld&&n.leaveWorld(),t.app.entity_id>0&&e!=t.app.entity_id){for(var r=[],a=0;a0&&(r=e.readInt8());var a=t.app.entities[n];return void 0==a?void t.ERROR_MSG("KBEngineApp::Client_onEntityEnterSpace: entity("+n+") not found!"):(a.isOnGround=r,t.app.entityServerPos.x=a.position.x,t.app.entityServerPos.y=a.position.y,t.app.entityServerPos.z=a.position.z,void a.enterSpace())},e.prototype.Client_onEntityLeaveSpace=function(e){var n=t.app.entities[e];return void 0==n?void t.ERROR_MSG("KBEngineApp::Client_onEntityLeaveSpace: entity("+e+") not found!"):(t.app.clearSpace(!1),void n.leaveSpace())},e.prototype.Client_onKicked=function(e){t.ERROR_MSG("KBEngineApp::Client_onKicked: failedcode("+t.app.serverErrs[e].name+")!"),t.Event.fire(t.EventTypes.onKicked,e)},e.prototype.Client_onCreateAccountResult=function(e){var n=e.readUint16(),r=e.readBlob();return t.Event.fire("onCreateAccountResult",n,r),0!=n?void t.ERROR_MSG("KBEngineApp::Client_onCreateAccountResult: "+t.app.username+" create is failed! code="+t.app.serverErrs[n].name+"!"):void t.INFO_MSG("KBEngineApp::Client_onCreateAccountResult: "+t.app.username+" create is successfully!")},e.prototype.Client_onControlEntity=function(e,n){var r=t.app.entities[e];if(void 0==r)return void t.ERROR_MSG("KBEngineApp::Client_onControlEntity: entity("+e+") not found!");var a=0!=n;if(a)t.app.player().id!=r.id&&t.app.controlledEntities.push(r);else{for(var i=[],o=0;o.001||e.entityLastLocalDir.distance(e.direction)>.001){e.entityLastLocalPos.x=e.position.x,e.entityLastLocalPos.y=e.position.y,e.entityLastLocalPos.z=e.position.z,e.entityLastLocalDir.x=e.direction.x,e.entityLastLocalDir.y=e.direction.y,e.entityLastLocalDir.z=e.direction.z;var n=t.Bundle.createObject();n.newMessage(t.messages.Baseapp_onUpdateDataFromClient),n.writeFloat(e.position.x),n.writeFloat(e.position.y),n.writeFloat(e.position.z),n.writeFloat(e.direction.x),n.writeFloat(e.direction.y),n.writeFloat(e.direction.z),n.writeUint8(e.isOnGround),n.writeUint32(t.app.spaceID),n.send(t.app)}for(var r in t.app.controlledEntities){var a=t.app.controlledEntities[r],i=a.position,o=a.direction,p=a.entityLastLocalPos.distance(i)>.001,s=a.entityLastLocalDir.distance(o)>.001;if(p||s){a.entityLastLocalPos=i,a.entityLastLocalDir=o;var n=t.Bundle.createObject();n.newMessage(t.messages.Baseapp_onUpdateDataFromClientForControlledEntity),n.writeInt32(a.id),n.writeFloat(i.x),n.writeFloat(i.y),n.writeFloat(i.z),n.writeFloat(o.x),n.writeFloat(o.y),n.writeFloat(o.z),n.writeUint8(a.isOnGround),n.writeUint32(t.app.spaceID),n.send(t.app)}}}},e.prototype.addSpaceGeometryMapping=function(e,n){t.INFO_MSG("KBEngineApp::addSpaceGeometryMapping: spaceID("+e+"), respath("+n+")!"),t.app.spaceID=e,t.app.spaceResPath=n,t.Event.fire(t.EventTypes.addSpaceGeometryMapping,n)},e.prototype.clearSpace=function(e){t.app.entityIDAliasIDList=[],t.app.spacedata={},t.app.clearEntities(e),t.app.isLoadedGeometry=!1,t.app.spaceID=0},e.prototype.clearEntities=function(e){if(t.app.controlledEntities=[],e){for(var n in t.app.entities)t.app.entities[n].inWorld&&t.app.entities[n].leaveWorld(),t.app.entities[n].onDestroy();t.app.entities={}}else{var r=t.app.player();for(var n in t.app.entities)n!=r.id&&(t.app.entities[n].inWorld&&t.app.entities[n].leaveWorld(),t.app.entities[n].onDestroy());t.app.entities={},t.app.entities[r.id]=r}},e.prototype.Client_initSpaceData=function(e){for(t.app.clearSpace(!1),t.app.spaceID=e.readInt32();e.length()>0;){var n=e.readString(),r=e.readString();t.app.Client_setSpaceData(t.app.spaceID,n,r)}t.INFO_MSG("KBEngineApp::Client_initSpaceData: spaceID("+t.app.spaceID+"), datas("+t.app.spacedata+")!")},e.prototype.Client_setSpaceData=function(e,n,r){t.INFO_MSG("KBEngineApp::Client_setSpaceData: spaceID("+e+"), key("+n+"), value("+r+")!"),t.app.spacedata[n]=r,"_mapping"==n&&t.app.addSpaceGeometryMapping(e,r),t.Event.fire("onSetSpaceData",e,n,r)},e.prototype.Client_delSpaceData=function(e,n){t.INFO_MSG("KBEngineApp::Client_delSpaceData: spaceID("+e+"), key("+n+")!"),delete t.app.spacedata[n],t.Event.fire("onDelSpaceData",e,n)},e.prototype.Client_getSpaceData=function(e,n){return t.app.spacedata[n]},e.prototype.Client_onUpdateBasePos=function(e,n,r){t.app.entityServerPos.x=e,t.app.entityServerPos.y=n,t.app.entityServerPos.z=r},e.prototype.Client_onUpdateBasePosXZ=function(e,n){t.app.entityServerPos.x=e,t.app.entityServerPos.z=n},e.prototype.Client_onUpdateData=function(e){var n=t.app.getViewEntityIDFromStream(e),r=t.app.entities[n];return void 0==r?void t.ERROR_MSG("KBEngineApp::Client_onUpdateData: entity("+n+") not found!"):void 0},e.prototype.Client_onSetEntityPosAndDir=function(e){var n=e.readInt32(),r=t.app.entities[n];return void 0==r?void t.ERROR_MSG("KBEngineApp::Client_onSetEntityPosAndDir: entity("+n+") not found!"):(r.position.x=e.readFloat(),r.position.y=e.readFloat(),r.position.z=e.readFloat(),r.direction.x=e.readFloat(),r.direction.y=e.readFloat(),r.direction.z=e.readFloat(),r.entityLastLocalPos.x=r.position.x,r.entityLastLocalPos.y=r.position.y,r.entityLastLocalPos.z=r.position.z,r.entityLastLocalDir.x=r.direction.x,r.entityLastLocalDir.y=r.direction.y,r.entityLastLocalDir.z=r.direction.z,r.set_direction(r.direction),void r.set_position(r.position))},e.prototype.Client_onUpdateData_ypr=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat(),i=e.readFloat();t.app._updateVolatileData(n,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,r,a,i,-1)},e.prototype.Client_onUpdateData_yp=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat();t.app._updateVolatileData(n,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,r,a,t.KBE_FLT_MAX,-1)},e.prototype.Client_onUpdateData_yr=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat();t.app._updateVolatileData(n,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,r,t.KBE_FLT_MAX,a,-1)},e.prototype.Client_onUpdateData_pr=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat();t.app._updateVolatileData(n,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,r,a,-1)},e.prototype.Client_onUpdateData_y=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat();t.app._updateVolatileData(n,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,r,t.KBE_FLT_MAX,t.KBE_FLT_MAX,-1)},e.prototype.Client_onUpdateData_p=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat();t.app._updateVolatileData(n,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,r,t.KBE_FLT_MAX,-1)},e.prototype.Client_onUpdateData_r=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat();t.app._updateVolatileData(n,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,r,-1)},e.prototype.Client_onUpdateData_xz=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat();t.app._updateVolatileData(n,r,t.KBE_FLT_MAX,a,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,1)},e.prototype.Client_onUpdateData_xz_ypr=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat(),i=e.readFloat(),o=e.readFloat(),p=e.readFloat();t.app._updateVolatileData(n,r,t.KBE_FLT_MAX,a,i,o,p,1)},e.prototype.Client_onUpdateData_xz_yp=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat(),i=e.readFloat(),o=e.readFloat();t.app._updateVolatileData(n,r,t.KBE_FLT_MAX,a,i,o,t.KBE_FLT_MAX,1)},e.prototype.Client_onUpdateData_xz_yr=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat(),i=e.readFloat(),o=e.readFloat();t.app._updateVolatileData(n,r,t.KBE_FLT_MAX,a,i,t.KBE_FLT_MAX,o,1)},e.prototype.Client_onUpdateData_xz_pr=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat(),i=e.readFloat(),o=e.readFloat();t.app._updateVolatileData(n,r,t.KBE_FLT_MAX,a,t.KBE_FLT_MAX,i,o,1)},e.prototype.Client_onUpdateData_xz_y=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat(),i=e.readFloat();t.app._updateVolatileData(n,r,t.KBE_FLT_MAX,a,i,t.KBE_FLT_MAX,t.KBE_FLT_MAX,1)},e.prototype.Client_onUpdateData_xz_p=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat(),i=e.readInt8();t.app._updateVolatileData(n,r,t.KBE_FLT_MAX,a,t.KBE_FLT_MAX,i,t.KBE_FLT_MAX,1)},e.prototype.Client_onUpdateData_xz_r=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat(),i=e.readInt8();t.app._updateVolatileData(n,r,t.KBE_FLT_MAX,a,t.KBE_FLT_MAX,t.KBE_FLT_MAX,i,1)},e.prototype.Client_onUpdateData_xyz=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat(),i=e.readFloat();t.app._updateVolatileData(n,r,a,i,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,0)},e.prototype.Client_onUpdateData_xyz_ypr=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat(),i=e.readFloat(),o=e.readFloat(),p=e.readFloat(),s=e.readFloat();t.app._updateVolatileData(n,r,a,i,o,p,s,0)},e.prototype.Client_onUpdateData_xyz_yp=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat(),i=e.readFloat(),o=e.readFloat(),p=e.readFloat();t.app._updateVolatileData(n,r,i,a,o,p,t.KBE_FLT_MAX,0)},e.prototype.Client_onUpdateData_xyz_yr=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat(),i=e.readFloat(),o=e.readFloat(),p=e.readFloat();t.app._updateVolatileData(n,r,i,a,o,t.KBE_FLT_MAX,p,0)},e.prototype.Client_onUpdateData_xyz_pr=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat(),i=e.readFloat(),o=e.readFloat(),p=e.readFloat();t.app._updateVolatileData(n,r,i,a,t.KBE_FLT_MAX,o,p,0)},e.prototype.Client_onUpdateData_xyz_y=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat(),i=e.readFloat(),o=e.readFloat();t.app._updateVolatileData(n,r,i,a,o,t.KBE_FLT_MAX,t.KBE_FLT_MAX,0)},e.prototype.Client_onUpdateData_xyz_p=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat(),i=e.readFloat(),o=e.readFloat();t.app._updateVolatileData(n,r,i,a,t.KBE_FLT_MAX,o,t.KBE_FLT_MAX,0)},e.prototype.Client_onUpdateData_xyz_r=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readFloat(),a=e.readFloat(),i=e.readFloat(),o=e.readFloat();t.app._updateVolatileData(n,r,i,a,o,t.KBE_FLT_MAX,t.KBE_FLT_MAX,0)},e.prototype.Client_onUpdateData_ypr_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readInt8(),a=e.readInt8(),i=e.readInt8();t.app._updateVolatileData(n,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,r,a,i,-1,!0)},e.prototype.Client_onUpdateData_yp_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readInt8(),a=e.readInt8();t.app._updateVolatileData(n,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,r,a,t.KBE_FLT_MAX,-1,!0)},e.prototype.Client_onUpdateData_yr_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readInt8(),a=e.readInt8();t.app._updateVolatileData(n,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,r,t.KBE_FLT_MAX,a,-1,!0)},e.prototype.Client_onUpdateData_pr_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readInt8(),a=e.readInt8();t.app._updateVolatileData(n,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,r,a,-1,!0)},e.prototype.Client_onUpdateData_y_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readInt8();t.app._updateVolatileData(n,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,r,t.KBE_FLT_MAX,t.KBE_FLT_MAX,-1,!0)},e.prototype.Client_onUpdateData_p_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readInt8();t.app._updateVolatileData(n,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,r,t.KBE_FLT_MAX,-1,!0)},e.prototype.Client_onUpdateData_r_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readInt8();t.app._updateVolatileData(n,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,r,-1,!0)},e.prototype.Client_onUpdateData_xz_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readPackXZ();t.app._updateVolatileData(n,r[0],t.KBE_FLT_MAX,r[1],t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,1,!0)},e.prototype.Client_onUpdateData_xz_ypr_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readPackXZ(),a=e.readInt8(),i=e.readInt8(),o=e.readInt8();t.app._updateVolatileData(n,r[0],t.KBE_FLT_MAX,r[1],a,i,o,1,!0)},e.prototype.Client_onUpdateData_xz_yp_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readPackXZ(),a=e.readInt8(),i=e.readInt8();t.app._updateVolatileData(n,r[0],t.KBE_FLT_MAX,r[1],a,i,t.KBE_FLT_MAX,1,!0)},e.prototype.Client_onUpdateData_xz_yr_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readPackXZ(),a=e.readInt8(),i=e.readInt8();t.app._updateVolatileData(n,r[0],t.KBE_FLT_MAX,r[1],a,t.KBE_FLT_MAX,i,1,!0)},e.prototype.Client_onUpdateData_xz_pr_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readPackXZ(),a=e.readInt8(),i=e.readInt8();t.app._updateVolatileData(n,r[0],t.KBE_FLT_MAX,r[1],t.KBE_FLT_MAX,a,i,1,!0)},e.prototype.Client_onUpdateData_xz_y_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readPackXZ(),a=e.readInt8();t.app._updateVolatileData(n,r[0],t.KBE_FLT_MAX,r[1],a,t.KBE_FLT_MAX,t.KBE_FLT_MAX,1,!0)},e.prototype.Client_onUpdateData_xz_p_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readPackXZ(),a=e.readInt8();t.app._updateVolatileData(n,r[0],t.KBE_FLT_MAX,r[1],t.KBE_FLT_MAX,a,t.KBE_FLT_MAX,1,!0)},e.prototype.Client_onUpdateData_xz_r_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readPackXZ(),a=e.readInt8();t.app._updateVolatileData(n,r[0],t.KBE_FLT_MAX,r[1],t.KBE_FLT_MAX,t.KBE_FLT_MAX,a,1,!0)},e.prototype.Client_onUpdateData_xyz_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readPackXZ(),a=e.readPackY();t.app._updateVolatileData(n,r[0],a,r[1],t.KBE_FLT_MAX,t.KBE_FLT_MAX,t.KBE_FLT_MAX,0,!0)},e.prototype.Client_onUpdateData_xyz_ypr_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readPackXZ(),a=e.readPackY(),i=e.readInt8(),o=e.readInt8(),p=e.readInt8();t.app._updateVolatileData(n,r[0],a,r[1],i,o,p,0,!0)},e.prototype.Client_onUpdateData_xyz_yp_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readPackXZ(),a=e.readPackY(),i=e.readInt8(),o=e.readInt8();t.app._updateVolatileData(n,r[0],a,r[1],i,o,t.KBE_FLT_MAX,0,!0)},e.prototype.Client_onUpdateData_xyz_yr_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readPackXZ(),a=e.readPackY(),i=e.readInt8(),o=e.readInt8();t.app._updateVolatileData(n,r[0],a,r[1],i,t.KBE_FLT_MAX,o,0,!0)},e.prototype.Client_onUpdateData_xyz_pr_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readPackXZ(),a=e.readPackY(),i=e.readInt8(),o=e.readInt8();t.app._updateVolatileData(n,r[0],a,r[1],t.KBE_FLT_MAX,i,o,0,!0)},e.prototype.Client_onUpdateData_xyz_y_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readPackXZ(),a=e.readPackY(),i=e.readInt8();t.app._updateVolatileData(n,r[0],a,r[1],i,t.KBE_FLT_MAX,t.KBE_FLT_MAX,0,!0)},e.prototype.Client_onUpdateData_xyz_p_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readPackXZ(),a=e.readPackY(),i=e.readInt8();t.app._updateVolatileData(n,r[0],a,r[1],t.KBE_FLT_MAX,i,t.KBE_FLT_MAX,0,!0)},e.prototype.Client_onUpdateData_xyz_r_optimized=function(e){var n=t.app.getViewEntityIDFromStream(e),r=e.readPackXZ(),a=e.readPackY(),i=e.readInt8();t.app._updateVolatileData(n,r[0],a,r[1],i,t.KBE_FLT_MAX,t.KBE_FLT_MAX,0,!0)},e.prototype._updateVolatileData=function(e,n,r,a,i,o,p,s,l){void 0===l&&(l=!1);var c=t.app.entities[e];if(void 0==c)return void t.ERROR_MSG("KBEngineApp::_updateVolatileData: entity("+e+") not found!");s>=0&&(c.isOnGround=s>0);var d=!1;p!=t.KBE_FLT_MAX&&(d=!0,c.direction.x=t.int82angle(p,!1)),o!=t.KBE_FLT_MAX&&(d=!0,c.direction.y=t.int82angle(o,!1)),i!=t.KBE_FLT_MAX&&(d=!0,c.direction.z=t.int82angle(i,!1));var u=!1;1==d&&(t.Event.fire("set_direction",c),u=!0);var y=!1;(n!=t.KBE_FLT_MAX||r!=t.KBE_FLT_MAX||a!=t.KBE_FLT_MAX)&&(y=!0),n==t.KBE_FLT_MAX&&(n=0),r==t.KBE_FLT_MAX&&(r=0),a==t.KBE_FLT_MAX&&(a=0),y&&(l?(c.position.x=n+t.app.entityServerPos.x,c.position.y=r+t.app.entityServerPos.y,c.position.z=a+t.app.entityServerPos.z):(c.position.x=n,c.position.y=r,c.position.z=a),u=!0,t.Event.fire("updatePosition",c)),u&&c.onUpdateVolatileData()},e.prototype.Client_onStreamDataStarted=function(e,n,r){t.Event.fire(t.EventTypes.onStreamDataStarted,e,n,r)},e.prototype.Client_onStreamDataRecv=function(e){var n=e.readUint16(),r=e.readBlob();t.Event.fire(t.EventTypes.onStreamDataRecv,n,r)},e.prototype.Client_onStreamDataCompleted=function(e){t.Event.fire(t.EventTypes.onStreamDataCompleted,e)},e.prototype.Client_onReqAccountResetPasswordCB=function(e){return 0!=e?void t.ERROR_MSG("KBEngineApp::Client_onReqAccountResetPasswordCB: "+t.app.username+" is failed! code="+t.app.serverErrs[e].name+"!"):void t.INFO_MSG("KBEngineApp::Client_onReqAccountResetPasswordCB: "+t.app.username+" is successfully!")},e.prototype.Client_onReqAccountBindEmailCB=function(e){return 0!=e?void t.ERROR_MSG("KBEngineApp::Client_onReqAccountBindEmailCB: "+t.app.username+" is failed! code="+t.app.serverErrs[e].name+"!"):void t.INFO_MSG("KBEngineApp::Client_onReqAccountBindEmailCB: "+t.app.username+" is successfully!")},e.prototype.Client_onReqAccountNewPasswordCB=function(e){return 0!=e?void t.ERROR_MSG("KBEngineApp::Client_onReqAccountNewPasswordCB: "+t.app.username+" is failed! code="+t.app.serverErrs[e].name+"!"):void t.INFO_MSG("KBEngineApp::Client_onReqAccountNewPasswordCB: "+t.app.username+" is successfully!")},e}();t.KBEngineApp=r,__reflect(r.prototype,"KBEngine.KBEngineApp");var a=function(){function t(){this.name="",this.descr="",this.id=0}return t}();t.ServerErr=a,__reflect(a.prototype,"KBEngine.ServerErr"),t.FragmentDataTypes={FRAGMENT_DATA_UNKNOW:0,FRAGMENT_DATA_MESSAGE_ID:1,FRAGMENT_DATA_MESSAGE_LENGTH:2,FRAGMENT_DATA_MESSAGE_LENGTH1:3,FRAGMENT_DATA_MESSAGE_BODY:4};var i;t.create=e,t.destroy=n}(KBEngine||(KBEngine={})); \ No newline at end of file diff --git a/kbengine_ts/package.json b/kbengine_ts/package.json new file mode 100644 index 0000000..d09e17c --- /dev/null +++ b/kbengine_ts/package.json @@ -0,0 +1,4 @@ +{ + "name": "kbengine_ts", + "compilerVersion": "5.2.18" +} \ No newline at end of file diff --git a/kbengine_ts/src/KBEngine.ts b/kbengine_ts/src/KBEngine.ts new file mode 100644 index 0000000..64a5ac5 --- /dev/null +++ b/kbengine_ts/src/KBEngine.ts @@ -0,0 +1,4760 @@ +/** + * KBEngine的html5客户端扩展ts版 2.x版本 + * cocos creator 环境下使用方法 + * + * 注：（下面的是重点） + * 1、实体声明的命名空间为KBEngine.Entities,与官方的KBEngine不同 + * 2、 @KBEngine.registerEntity() /// TODO: <---组件使用@KBEngine.registerComponent() + export default class Account extends KBEngine.Entity { /// TODO: 组件继承自KBEngine.EntityComponent,类名等于服务器(实体/组件)名 + __comps__ = {组件名:组件类型} ///TODO: 因为组件类型不会从服务器同步，只能获取到EntityComponent，无法获取具体类型，所以需要在实体里进行手动设置，需要代码提示可以手动声明一下 + __init__() { + console.log('创建account') + } + } + //这里加入声明用于vscode代码提示 + declare global { + namespace KBEngine { + interface IEntities{ + Account:new ()=>Account + } + } + } + + * 3、cocos creator编辑器下会出现KBEngine未找到的问题，不影响运行，如果想去掉，将允许编辑器加载勾选 + 4、因为下班了，组件的basecall和cellcall还未测试，改天再继续 + */ + +/*----------------------------------------------------------------------------------------- + global +-----------------------------------------------------------------------------------------*/ +namespace KBEngine { + export const CLIENT_VERSION = '2.5.0'; + export const CLIENT_SCRIPT_VERSION = '0.1.0'; + + export const PACKET_MAX_SIZE = 1500; + export const PACKET_MAX_SIZE_TCP = 1460; + export const PACKET_MAX_SIZE_UDP = 1472; + + export const MESSAGE_ID_LENGTH = 2; + export const MESSAGE_LENGTH_LENGTH = 2; + export const MESSAGE_LENGTH1_LENGTH = 4; + export const MESSAGE_MAX_SIZE = 65535; + + export const CLIENT_NO_FLOAT = 0; + export const KBE_FLT_MAX = 3.402823466e+38; +} +/** + * 加上声明避免cocos creator编辑器报错 + */ +window['KBEngine'] = KBEngine; + +if (!ArrayBuffer['transfer']) { + ArrayBuffer['transfer'] = function (source: ArrayBuffer, length: number): ArrayBuffer { + let dest = new ArrayBuffer(length); + + if (!(source instanceof ArrayBuffer) || !(dest instanceof ArrayBuffer)) { + throw new TypeError("ArrayBuffer.transfer, error: Source and destination must be ArrayBuffer instances"); + } + + if (dest.byteLength >= source.byteLength) { + let buf = new Uint8Array(dest); + buf.set(new Uint8Array(source), 0); + } + else { + throw new RangeError("ArrayBuffer.transfer, error: destination has not enough space"); + } + + return dest; + }; +}; +/*----------------------------------------------------------------------------------------- + number64bits +-----------------------------------------------------------------------------------------*/ +namespace KBEngine { + export class INT64 { + constructor(lo, hi) { + this.lo = lo; + this.hi = hi; + + if (hi >= 2147483648) { + this.sign = -1; + if (this.lo > 0) { + this.lo = (4294967296 - this.lo) & 0xffffffff; + this.hi = 4294967295 - this.hi; + } + else { + this.lo = (4294967296 - this.lo) & 0xffffffff; + this.hi = 4294967296 - this.hi; + } + } + } + lo: number; + hi: number; + sign: number = 1; + toString() { + let result = ""; + + if (this.sign < 0) { + result += "-" + } + + let low = this.lo.toString(16); + let high = this.hi.toString(16); + + if (this.hi > 0) { + result += high; + for (let i = 8 - low.length; i > 0; --i) { + result += "0"; + } + } + result += low; + + return result; + } + } + export class UINT64 { + constructor(lo, hi) { + this.lo = lo; + this.hi = hi; + } + lo: number; + hi: number; + toString() { + let low = this.lo.toString(16); + let high = this.hi.toString(16); + + let result = ""; + if (this.hi > 0) { + result += high; + for (let i = 8 - low.length; i > 0; --i) { + result += "0"; + } + } + result += low; + return result; + } + } +} +namespace KBEngine { + export function getQualifiedClassName(value) { + let type = typeof value; + if (!value || (type != "object" && !value.prototype)) { + return type; + } + let prototype = value.prototype ? value.prototype : Object.getPrototypeOf(value); + if (prototype.hasOwnProperty("__class__")) { + return prototype["__class__"]; + } + let constructorString = prototype.constructor.toString().trim(); + let index = constructorString.indexOf("("); + let className = constructorString.substring(9, index); + let c = className.split('.') + Object.defineProperty(prototype, "__class__", { + value: c[c.length - 1], + enumerable: false, + writable: true + }); + return c[c.length - 1]; + } +} +/*----------------------------------------------------------------------------------------- + debug +-----------------------------------------------------------------------------------------*/ +namespace KBEngine { + /** todo 调试输出模块，这里需要根据使用的引擎不同在这里加入判断条件 */ + export function INFO_MSG(...args: any[]) { + console.info.apply(console, args); + } + export function DEBUG_MSG(...args: any[]) { + console.debug.apply(console, args); + } + export function ERROR_MSG(...args: any[]) { + console.error.apply(console, args); + } + export function WARNING_MSG(...args: any[]) { + console.warn.apply(console, args); + } +} +/*----------------------------------------------------------------------------------------- + string +-----------------------------------------------------------------------------------------*/ +namespace KBEngine { + export function utf8ArrayToString(array: Array) { + let out, i, len, c; + let char2, char3; + + out = ""; + len = array.length; + i = 0; + + while (i < len) { + c = array[i++]; + + switch (c >> 4) { + case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: + // 0xxxxxxx + out += String.fromCharCode(c); + break; + case 12: case 13: + // 110x xxxx 10xx xxxx + char2 = array[i++]; + out += String.fromCharCode(((c & 0x1F) << 6) | (char2 & 0x3F)); + break; + case 14: + // 1110 xxxx 10xx xxxx 10xx xxxx + char2 = array[i++]; + char3 = array[i++]; + out += String.fromCharCode(((c & 0x0F) << 12) | + ((char2 & 0x3F) << 6) | + ((char3 & 0x3F) << 0)); + break; + } + } + + return out; + } + export function stringToUTF8Bytes(str: string) { + let utf8 = []; + for (let i = 0; i < str.length; i++) { + let charcode = str.charCodeAt(i); + if (charcode < 0x80) utf8.push(charcode); + else if (charcode < 0x800) { + utf8.push(0xc0 | (charcode >> 6), + 0x80 | (charcode & 0x3f)); + } + else if (charcode < 0xd800 || charcode >= 0xe000) { + utf8.push(0xe0 | (charcode >> 12), + 0x80 | ((charcode >> 6) & 0x3f), + 0x80 | (charcode & 0x3f)); + } + // surrogate pair + else { + i++; + // UTF-16 encodes 0x10000-0x10FFFF by + // subtracting 0x10000 and splitting the + // 20 bits of 0x0-0xFFFFF into two halves + charcode = 0x10000 + (((charcode & 0x3ff) << 10) + | (str.charCodeAt(i) & 0x3ff)) + utf8.push(0xf0 | (charcode >> 18), + 0x80 | ((charcode >> 12) & 0x3f), + 0x80 | ((charcode >> 6) & 0x3f), + 0x80 | (charcode & 0x3f)); + } + } + return utf8; + } +} + +/*----------------------------------------------------------------------------------------- + event +-----------------------------------------------------------------------------------------*/ +namespace KBEngine { + export class EventInfo { + constructor(public classinst, public callbackfn) { + } + } + export class FiredEvent { + constructor(public evtName, public evtInfo, public ars) { } + } + export interface IEvents { + [evtName: string]: EventInfo[]; + } + export class Events { + constructor() { + + } + _events: IEvents = {}; + _isPause = false; + _firedEvents: FiredEvent[] = [] + register(evtName: string, classinst, strCallback: string) { + let callbackfn = classinst[strCallback]; + if (callbackfn == undefined) { + ERROR_MSG('export class Event::fire: not found strCallback(' + classinst + ")!" + strCallback); + return; + } + + let evtlst = this._events[evtName]; + if (evtlst == undefined) { + evtlst = []; + this._events[evtName] = evtlst; + } + + let info = new EventInfo(classinst, callbackfn); + evtlst.push(info); + } + deregisterAll(classinst) { + for (let itemkey in this._events) { + this.deregister(itemkey, classinst) + } + } + deregister(evtName: string, classinst) { + let evtlst = this._events[evtName]; + if (!evtlst) return; + for (let i = evtlst.length - 1; i >= 0; i--) { + let info = evtlst[i]; + if (info.classinst == classinst) { + evtlst.splice(i, 1); + } + } + } + removeAllFiredEvent(classinst) { + this.removeFiredEvent("", classinst); + } + removeFiredEvent(evtName: string, classinst) { + let firedEvents = this._firedEvents; + for (let i = firedEvents.length - 1; i >= 0; i--) { + let evt = firedEvents[i]; + if ((evtName == "" || evt.evtName == evtName) && evt.evtInfo.classinst == classinst) { + firedEvents.splice(i, 1); + } + } + } + fire(evtName: string, ...args: any[]) { + if (!evtName) { + ERROR_MSG('export class Event::fire: not found eventName!'); + return; + } + + let evtlst = this._events[evtName]; + + if (evtlst == undefined) { + return; + } + + // let ars = []; + // for (let i = 0; i < args.length; i++) + // ars.push(args[i]); + + for (let i = 0; i < evtlst.length; i++) { + let info = evtlst[i]; + if (!this._isPause) { + info.callbackfn.apply(info.classinst, args || []); + } else { + let eobj = new FiredEvent(evtName, info, args || []); + this._firedEvents.push(eobj); + } + // if (args.length < 1) { + // info.callbackfn.apply(info.classinst); + // } + // else { + // info.callbackfn.apply(info.classinst, args); + // } + } + } + pasue() { + this._isPause = true; + } + resume() { + this._isPause = false; + + let firedEvents = this._firedEvents; + while (firedEvents.length > 0) { + let evt = firedEvents.shift(); + let info = evt.evtInfo; + let ars = evt.ars; + + if (ars.length < 1) { + info.callbackfn.apply(info.classinst); + } + else { + info.callbackfn.apply(info.classinst, ars); + } + } + } + clear() { + this._events = {}; + this._firedEvents.splice(0, this._firedEvents.length); + } + } + export const Event = new Events(); +} +/*----------------------------------------------------------------------------------------- + memorystream +-----------------------------------------------------------------------------------------*/ +namespace KBEngine { + export class PackFloatXType { + _unionData = new ArrayBuffer(4); + fv = new Float32Array(this._unionData, 0, 1); + uv = new Uint32Array(this._unionData, 0, 1); + iv = new Int32Array(this._unionData, 0, 1); + } + + export const _xPackData = new PackFloatXType(); + export const _yPackData = new PackFloatXType(); + export const _zPackData = new PackFloatXType(); + + export class MemoryStream { + constructor(size_or_buffer: number | ArrayBuffer) { + if (size_or_buffer instanceof ArrayBuffer) { + this.buffer = size_or_buffer; + } + else { + this.buffer = new ArrayBuffer(size_or_buffer); + } + + this.rpos = 0; + this.wpos = 0; + } + + buffer: ArrayBuffer; + rpos: number = 0; + wpos: number = 0; + //--------------------------------------------------------------------------------- + readInt8() { + let buf = new Int8Array(this.buffer, this.rpos, 1); + this.rpos += 1; + return buf[0]; + } + + readInt16() { + let v = this.readUint16(); + if (v >= 32768) + v -= 65536; + return v; + } + + readInt32() { + let v = this.readUint32(); + if (v >= 2147483648) + v -= 4294967296; + return v; + } + + readInt64() { + let lo = this.readUint32() + let hi = this.readUint32() + return new INT64(lo, hi); + } + + readUint8() { + let buf = new Uint8Array(this.buffer, this.rpos, 1); + this.rpos += 1; + return buf[0]; + } + + readUint16() { + let buf = new Uint8Array(this.buffer, this.rpos); + this.rpos += 2; + return ((buf[1] & 0xff) << 8) + (buf[0] & 0xff); + } + + readUint32() { + let buf = new Uint8Array(this.buffer, this.rpos); + this.rpos += 4; + return (buf[3] << 24) + (buf[2] << 16) + (buf[1] << 8) + buf[0]; + } + + readUint64() { + let lo = this.readUint32() + let hi = this.readUint32() + return new UINT64(lo, hi); + } + + readFloat() { + let buf; + try { + buf = new Float32Array(this.buffer, this.rpos, 1); + } + catch (e) { + buf = new Float32Array(this.buffer.slice(this.rpos, this.rpos + 4)); + } + + this.rpos += 4; + return buf[0]; + } + + readDouble() { + let buf; + try { + buf = new Float64Array(this.buffer, this.rpos, 1); + } + catch (e) { + buf = new Float64Array(this.buffer.slice(this.rpos, this.rpos + 8), 0, 1); + } + + this.rpos += 8; + return buf[0]; + } + + readString() { + let buf = new Uint8Array(this.buffer, this.rpos); + let i = 0; + let s = ""; + + while (true) { + if (buf[i] != 0) { + s += String.fromCharCode(buf[i]); + } + else { + i++; + break; + } + + i++; + + if (this.rpos + i >= this.buffer.byteLength) + throw (new Error("export class MemoryStream::readString: rpos(" + (this.rpos + i) + ")>=" + + this.buffer.byteLength + " overflow!")); + } + + this.rpos += i; + return s; + } + + readBlob() { + let size = this.readUint32(); + let buf = new Uint8Array(this.buffer, this.rpos, size); + this.rpos += size; + return buf; + } + + readStream() { + let buf = new Uint8Array(this.buffer, this.rpos, this.buffer.byteLength - this.rpos); + this.rpos = this.buffer.byteLength; + return new MemoryStream(buf); + } + + readPackXZ() { + let xPackData = _xPackData; + let zPackData = _zPackData; + + xPackData.fv[0] = 0.0; + zPackData.fv[0] = 0.0; + + xPackData.uv[0] = 0x40000000; + zPackData.uv[0] = 0x40000000; + + let v1 = this.readUint8(); + let v2 = this.readUint8(); + let v3 = this.readUint8(); + + let data = 0; + data |= (v1 << 16); + data |= (v2 << 8); + data |= v3; + + xPackData.uv[0] |= (data & 0x7ff000) << 3; + zPackData.uv[0] |= (data & 0x0007ff) << 15; + + xPackData.fv[0] -= 2.0; + zPackData.fv[0] -= 2.0; + + xPackData.uv[0] |= (data & 0x800000) << 8; + zPackData.uv[0] |= (data & 0x000800) << 20; + + let d = new Array(2); + d[0] = xPackData.fv[0]; + d[1] = zPackData.fv[0]; + return d; + } + + readPackY() { + let v = this.readUint16(); + + let yPackData = _yPackData; + yPackData.uv[0] = 0x40000000; + yPackData.uv[0] |= (v & 0x7fff) << 12; + yPackData.fv[0] -= 2.0; + yPackData.uv[0] |= (v & 0x8000) << 16; + return yPackData.fv[0]; + } + + //--------------------------------------------------------------------------------- + writeInt8(v) { + let buf = new Int8Array(this.buffer, this.wpos, 1); + buf[0] = v; + this.wpos += 1; + } + + writeInt16(v) { + this.writeInt8(v & 0xff); + this.writeInt8(v >> 8 & 0xff); + } + + writeInt32(v) { + for (let i = 0; i < 4; i++) + this.writeInt8(v >> i * 8 & 0xff); + } + + writeInt64(v) { + this.writeInt32(v.lo); + this.writeInt32(v.hi); + } + + writeUint8(v) { + let buf = new Uint8Array(this.buffer, this.wpos, 1); + buf[0] = v; + this.wpos += 1; + } + + writeUint16(v) { + this.writeUint8(v & 0xff); + this.writeUint8(v >> 8 & 0xff); + } + + writeUint32(v) { + for (let i = 0; i < 4; i++) + this.writeUint8(v >> i * 8 & 0xff); + } + + writeUint64(v: UINT64) { + this.writeUint32(v.lo); + this.writeUint32(v.hi); + } + + writeFloat(v) { + try { + let buf = new Float32Array(this.buffer, this.wpos, 1); + buf[0] = v; + } + catch (e) { + let buf = new Float32Array(1); + buf[0] = v; + let buf1 = new Uint8Array(this.buffer); + let buf2 = new Uint8Array(buf.buffer); + buf1.set(buf2, this.wpos); + } + + this.wpos += 4; + } + + writeDouble(v) { + try { + let buf = new Float64Array(this.buffer, this.wpos, 1); + buf[0] = v; + } + catch (e) { + let buf = new Float64Array(1); + buf[0] = v; + let buf1 = new Uint8Array(this.buffer); + let buf2 = new Uint8Array(buf.buffer); + buf1.set(buf2, this.wpos); + } + + this.wpos += 8; + } + + writeBlob(v) { + let size = v.length; + if (size + 4 > this.space()) { + ERROR_MSG("memorystream::writeBlob: no free!"); + return; + } + + this.writeUint32(size); + let buf = new Uint8Array(this.buffer, this.wpos, size); + + if (typeof (v) == "string") { + for (let i = 0; i < size; i++) { + buf[i] = v.charCodeAt(i); + } + } + else { + for (let i = 0; i < size; i++) { + buf[i] = v[i]; + } + } + + this.wpos += size; + } + + writeString(v) { + if (v.length > this.space()) { + ERROR_MSG("memorystream::writeString: no free!"); + return; + } + + let buf = new Uint8Array(this.buffer, this.wpos); + let i = 0; + for (let idx = 0; idx < v.length; idx++) { + buf[i++] = v.charCodeAt(idx); + } + + buf[i++] = 0; + this.wpos += i; + } + append(stream: MemoryStream, offset: number, size: number) { + if (size > this.space()) { + this.buffer = ArrayBuffer['transfer'](this.buffer, this.buffer.byteLength + size * 2); + } + + let buf = new Uint8Array(this.buffer, this.wpos, size); + buf.set(new Uint8Array(stream.buffer, offset, size), 0); + this.wpos += size; + } + + //--------------------------------------------------------------------------------- + readSkip(v) { + this.rpos += v; + } + + //--------------------------------------------------------------------------------- + space() { + return this.buffer.byteLength - this.wpos; + } + + //--------------------------------------------------------------------------------- + length() { + return this.wpos - this.rpos; + } + + //--------------------------------------------------------------------------------- + readEOF() { + return this.buffer.byteLength - this.rpos <= 0; + } + + //--------------------------------------------------------------------------------- + done() { + this.rpos = this.wpos; + } + + //--------------------------------------------------------------------------------- + getbuffer() { + return this.buffer.slice(this.rpos, this.wpos); + } + setbuffer(buffer: ArrayBuffer) { + this.clear(); + this.buffer = buffer; + } + size() { + return this.buffer.byteLength; + } + clear() { + this.rpos = this.wpos = 0; + if (this.buffer.byteLength > PACKET_MAX_SIZE) { + this.buffer = new ArrayBuffer(PACKET_MAX_SIZE) + } + } + reclaimObject() { + this.clear() + if (MemoryStream._objects != undefined) { + MemoryStream._objects.push(this) + } + } + } + export module MemoryStream { + export const _objects: MemoryStream[] = [] + export function createObject() { + return MemoryStream._objects.length > 0 ? MemoryStream._objects.pop() : new MemoryStream(PACKET_MAX_SIZE_TCP); + } + } +} +/*----------------------------------------------------------------------------------------- + bundle +-----------------------------------------------------------------------------------------*/ +namespace KBEngine { + export class Bundle { + static _objects: Bundle[] = [] + static createObject() { + return Bundle._objects.length > 0 ? Bundle._objects.pop() : new Bundle(); + } + constructor() { + this.stream = MemoryStream.createObject(); + } + memorystreams: Array = new Array(); + stream: MemoryStream; + numMessage: number = 0; + messageLengthBuffer: Uint8Array = null; + msgtype = null; + messageLength: number = 0; + //--------------------------------------------------------------------------------- + newMessage(msgtype) { + this.fini(false); + + this.msgtype = msgtype; + this.numMessage += 1; + + if (this.msgtype.length == -1) { + this.messageLengthBuffer = new Uint8Array(this.stream.buffer, this.stream.wpos + MESSAGE_ID_LENGTH, 2); + } + + this.writeUint16(msgtype.id); + + if (this.messageLengthBuffer) { + this.writeUint16(0); + this.messageLengthBuffer[0] = 0; + this.messageLengthBuffer[1] = 0; + this.messageLength = 0; + } + } + + //--------------------------------------------------------------------------------- + writeMsgLength(v) { + if (this.messageLengthBuffer) { + this.messageLengthBuffer[0] = v & 0xff; + this.messageLengthBuffer[1] = v >> 8 & 0xff; + } + } + + //--------------------------------------------------------------------------------- + fini(issend) { + if (this.numMessage > 0) { + this.writeMsgLength(this.messageLength); + if (this.stream) + this.memorystreams.push(this.stream); + + this.stream = MemoryStream.createObject(); + } + + if (issend) { + this.messageLengthBuffer = null; + this.numMessage = 0; + this.msgtype = null; + } + } + + //--------------------------------------------------------------------------------- + send(network) { + this.fini(true); + + for (let i = 0; i < this.memorystreams.length; i++) { + let tmpStream = this.memorystreams[i]; + network.send(tmpStream.getbuffer()); + } + + this.reclaimObject(); + } + + //--------------------------------------------------------------------------------- + checkStream(v) { + if (v > this.stream.space()) { + this.memorystreams.push(this.stream); + this.stream = MemoryStream.createObject(); + } + + this.messageLength += v; + } + + //--------------------------------------------------------------------------------- + writeInt8(v) { + this.checkStream(1); + this.stream.writeInt8(v); + } + + writeInt16(v) { + this.checkStream(2); + this.stream.writeInt16(v); + } + + writeInt32(v) { + this.checkStream(4); + this.stream.writeInt32(v); + } + + writeInt64(v) { + this.checkStream(8); + this.stream.writeInt64(v); + } + + writeUint8(v) { + this.checkStream(1); + this.stream.writeUint8(v); + } + + writeUint16(v) { + this.checkStream(2); + this.stream.writeUint16(v); + } + + writeUint32(v) { + this.checkStream(4); + this.stream.writeUint32(v); + } + + writeUint64(v) { + this.checkStream(8); + this.stream.writeUint64(v); + } + + writeFloat(v) { + this.checkStream(4); + this.stream.writeFloat(v); + } + + writeDouble(v) { + this.checkStream(8); + this.stream.writeDouble(v); + } + + writeString(v) { + this.checkStream(v.length + 1); + this.stream.writeString(v); + } + + writeBlob(v) { + this.checkStream(v.length + 4); + this.stream.writeBlob(v); + } + clear() { + for (let i = 0; i < this.memorystreams.length; i++) { + if (this.stream != this.memorystreams[i]) + this.memorystreams[i].reclaimObject(); + } + + if (this.stream) + this.stream.clear(); + else + this.stream = MemoryStream.createObject(); + + this.memorystreams = new Array(); + this.numMessage = 0; + this.messageLengthBuffer = null; + this.messageLength = 0; + this.msgtype = null; + } + reclaimObject() { + this.clear(); + + if (Bundle._objects != undefined) + Bundle._objects.push(this); + } + } + export const reader = new MemoryStream(0); + export interface IDataType2Id { + [type: string]: number; + } + export let datatype2id: IDataType2Id = {}; + + export function mappingDataType() { + datatype2id = {}; + datatype2id["STRING"] = 1; + datatype2id["STD::STRING"] = 1; + + datatype2id["UINT8"] = 2; + datatype2id["BOOL"] = 2; + datatype2id["DATATYPE"] = 2; + datatype2id["CHAR"] = 2; + datatype2id["DETAIL_TYPE"] = 2; + datatype2id["ENTITYCALL_CALL_TYPE"] = 2; + + datatype2id["UINT16"] = 3; + datatype2id["UNSIGNED SHORT"] = 3; + datatype2id["SERVER_ERROR_CODE"] = 3; + datatype2id["ENTITY_TYPE"] = 3; + datatype2id["ENTITY_PROPERTY_UID"] = 3; + datatype2id["ENTITY_METHOD_UID"] = 3; + datatype2id["ENTITY_SCRIPT_UID"] = 3; + datatype2id["DATATYPE_UID"] = 3; + + datatype2id["UINT32"] = 4; + datatype2id["UINT"] = 4; + datatype2id["UNSIGNED INT"] = 4; + datatype2id["ARRAYSIZE"] = 4; + datatype2id["SPACE_ID"] = 4; + datatype2id["GAME_TIME"] = 4; + datatype2id["TIMER_ID"] = 4; + + datatype2id["UINT64"] = 5; + datatype2id["DBID"] = 5; + datatype2id["COMPONENT_ID"] = 5; + + datatype2id["INT8"] = 6; + datatype2id["COMPONENT_ORDER"] = 6; + + datatype2id["INT16"] = 7; + datatype2id["SHORT"] = 7; + + datatype2id["INT32"] = 8; + datatype2id["INT"] = 8; + datatype2id["ENTITY_ID"] = 8; + datatype2id["CALLBACK_ID"] = 8; + datatype2id["COMPONENT_TYPE"] = 8; + + datatype2id["INT64"] = 9; + + datatype2id["PYTHON"] = 10; + datatype2id["PY_DICT"] = 10; + datatype2id["PY_TUPLE"] = 10; + datatype2id["PY_LIST"] = 10; + datatype2id["ENTITYCALL"] = 10; + + datatype2id["BLOB"] = 11; + + datatype2id["UNICODE"] = 12; + + datatype2id["FLOAT"] = 13; + + datatype2id["DOUBLE"] = 14; + + datatype2id["VECTOR2"] = 15; + + datatype2id["VECTOR3"] = 16; + + datatype2id["VECTOR4"] = 17; + + datatype2id["FIXED_DICT"] = 18; + + datatype2id["ARRAY"] = 19; + + datatype2id["ENTITYCALL"] = 20; + } + mappingDataType(); + + export function bindWriter(writer, argType: number) { + switch (argType) { + case datatype2id["UINT8"]: return writer.writeUint8; + case datatype2id["UINT16"]: return writer.writeUint16; + case datatype2id["UINT32"]: return writer.writeUint32; + case datatype2id["UINT64"]: return writer.writeUint64; + case datatype2id["INT8"]: return writer.writeInt8; + case datatype2id["INT16"]: return writer.writeInt16; + case datatype2id["INT32"]: return writer.writeInt32; + case datatype2id["INT64"]: return writer.writeInt64; + case datatype2id["FLOAT"]: return writer.writeFloat; + case datatype2id["DOUBLE"]: return writer.writeDouble; + case datatype2id["STRING"]: return writer.writeString; + case datatype2id["FIXED_DICT"]: return writer.writeStream; + case datatype2id["ARRAY"]: return writer.writeStream; + default: return writer.writeStream; + } + } + export function bindReader(argType: number) { + switch (argType) { + case datatype2id["UINT8"]: return reader.readUint8; + case datatype2id["UINT16"]: return reader.readUint16; + case datatype2id["UINT32"]: return reader.readUint32; + case datatype2id["UINT64"]: return reader.readUint64; + case datatype2id["INT8"]: return reader.readInt8; + case datatype2id["INT16"]: return reader.readInt16; + case datatype2id["INT32"]: return reader.readInt32; + case datatype2id["INT64"]: return reader.readInt64; + case datatype2id["FLOAT"]: return reader.readFloat; + case datatype2id["DOUBLE"]: return reader.readDouble; + case datatype2id["STRING"]: return reader.readString; + case datatype2id["FIXED_DICT"]: return reader.readStream; + case datatype2id["ARRAY"]: return reader.readStream; + default: return reader.readStream; + } + } + export class Message { + constructor(public id, public name, public length, public argsType, public args, public handler) { + for (let i = 0; i < args.length; i++) { + args[i] = bindReader(args[i]); + } + } + createFromStream(msgstream) { + if (this.args.length <= 0) + return msgstream; + + let result = new Array(this.args.length); + for (let i = 0; i < this.args.length; i++) { + result[i] = this.args[i].call(msgstream); + } + + return result; + } + + handleMessage(msgstream) { + if (this.handler == null) { + ERROR_MSG("Message::handleMessage: interface(" + this.name + "/" + this.id + ") no implement!"); + return; + } + + if (this.args.length <= 0) { + if (this.argsType < 0) + this.handler(msgstream); + else + this.handler(); + } + else { + this.handler.apply(app, this.createFromStream(msgstream)); + } + } + } + + export module messages { + export const loginapp = {}; + export const baseapp = {}; + export const Loginapp_importClientMessages = new Message(5, "importClientMessages", 0, 0, new Array(), null); + export const Baseapp_importClientMessages = new Message(207, "importClientMessages", 0, 0, new Array(), null); + export const Baseapp_importClientEntityDef = new Message(208, "importClientEntityDef", 0, 0, new Array(), null); + export const onImportClientMessages = new Message(518, "onImportClientMessages", -1, -1, new Array(), null); + } + export let clientmessages = {}; + export let bufferedCreateEntityMessages = {}; +} +/*----------------------------------------------------------------------------------------- + math +-----------------------------------------------------------------------------------------*/ +namespace KBEngine { + export class Vector2 { + constructor(public x: number, public y: number) { + } + distance(pos: Vector2) { + let x = pos.x - this.x; + let y = pos.y - this.y; + return Math.sqrt(x * x + y * y); + } + add(vec2: Vector2) { + this.x += vec2.x; + this.y += vec2.y; + return this; + } + + sub(vec2: Vector2) { + this.x -= vec2.x; + this.y -= vec2.y; + return this; + } + + mul(num: number) { + this.x *= num; + this.y *= num; + return this; + } + + div(num: number) { + this.x /= num; + this.y /= num; + return this; + } + + neg() { + this.x = -this.x; + this.y = -this.y; + return this; + } + } + export class Vector3 { + constructor(public x: number, public y: number, public z: number) { + this.x = x; + this.y = y; + this.z = z; + } + distance(pos: Vector3) { + let x = pos.x - this.x; + let y = pos.y - this.y; + let z = pos.z - this.z; + return Math.sqrt(x * x + y * y + z * z); + } + + //向量加法 + add(vec3: Vector3) { + this.x += vec3.x; + this.y += vec3.y; + this.z += vec3.z; + return this; + } + + //向量减法 + sub(vec3: Vector3) { + this.x -= vec3.x; + this.y -= vec3.y; + this.z -= vec3.z; + return this; + } + + //向量乘法 + mul(num: number) { + this.x *= num; + this.y *= num; + this.z *= num; + return this; + } + + //向量除法 + div(num: number) { + this.x /= num; + this.y /= num; + this.z /= num; + return this; + } + + // 向量取反 + neg() { + this.x = -this.x; + this.y = -this.y; + this.z = -this.z; + return this; + } + } + export class Vector4 { + constructor(public x: number, public y: number, public z: number, public w: number) { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } + distance(pos: Vector4) { + let x = pos.x - this.x; + let y = pos.y - this.y; + let z = pos.z - this.z; + let w = pos.w - this.w; + return Math.sqrt(x * x + y * y + z * z + w * w); + } + + add(vec4: Vector4) { + this.x += vec4.x; + this.y += vec4.y; + this.z += vec4.z; + this.w += vec4.w; + return this; + } + + sub(vec4: Vector4) { + this.x -= vec4.x; + this.y -= vec4.y; + this.z -= vec4.z; + this.w -= vec4.w; + return this; + } + + mul(num: number) { + this.x *= num; + this.y *= num; + this.z *= num; + this.w *= num; + return this; + } + div(num: number) { + this.x /= num; + this.y /= num; + this.z /= num; + this.w /= num; + return this; + } + + neg() { + this.x = -this.x; + this.y = -this.y; + this.z = -this.z; + this.w = -this.w; + return this; + } + } + export function clampf(value, min_inclusive, max_inclusive) { + if (min_inclusive > max_inclusive) { + let temp = min_inclusive; + min_inclusive = max_inclusive; + max_inclusive = temp; + } + return value < min_inclusive ? min_inclusive : value < max_inclusive ? value : max_inclusive; + } + export function int82angle(angle: number, half: boolean) { + return angle * (Math.PI / (half ? 254.0 : 128.0)); + } + export function angle2int8(v: number, half: boolean) { + let angle = 0; + if (!half) { + //todo 原来写的float(Math.PI)，因为js没有float这个方法所以去掉了 + angle = Math.floor((v * 128.0) / Math.PI + 0.5); + } + else { + angle = clampf(Math.floor((v * 254.0) / Math.PI + 0.5), -128.0, 127.0); + } + + return angle; + } +} +/*----------------------------------------------------------------------------------------- + entity +-----------------------------------------------------------------------------------------*/ + +namespace KBEngine { + export interface IEntities { } + export const Entities: IEntities = {} + + export class Entity { + constructor() { + for (let i in this.__comps__) { + this[i] = new this.__comps__[i]() + } + } + protected __comps__: { [compName: string]: new () => EntityComponent } = {} + id: number = 0; + className: string = ""; + position: Vector3 = new Vector3(0, 0, 0); + direction: Vector3 = new Vector3(0, 0, 0); + velocity: number = 0; + + cell = null; + base = null; + + // enterworld之后设置为true + inWorld = false; + + // __init__调用之后设置为true + inited = false; + + // 是否被控制 + isControlled = false; + + entityLastLocalPos = new Vector3(0.0, 0.0, 0.0); + entityLastLocalDir = new Vector3(0.0, 0.0, 0.0); + + // 玩家是否在地面上 + isOnGround = false; + + __init__() { + + } + attachComponents() { + for (let i in this.__comps__) { + this[i].onAttached(this) + } + } + getComponents(compName: string, all: boolean = false) { + let res = [] + for (let i in this.__comps__) { + if (getQualifiedClassName(this.__comps__[i]) === compName) { + if (!all) { + return this[i]; + } + res.push(this[i]) + } + } + return res; + } + detachComponents() { + for (let i in this.__comps__) { + this[i].onDetached(this) + } + } + callPropertysSetMethods() { + let currModule = moduledefs[this.className]; + for (let name in currModule.propertys) { + let propertydata = currModule.propertys[name]; + let properUtype = propertydata[0]; + name = propertydata[2]; + let setmethod = propertydata[5]; + let flags = propertydata[6]; + let oldval = this[name]; + + if (setmethod != null) { + // base类属性或者进入世界后cell类属性会触发set_*方法 + // ED_FLAG_BASE_AND_CLIENT、ED_FLAG_BASE + if (flags == 0x00000020 || flags == 0x00000040) { + if (this.inited && !this.inWorld) + setmethod.call(this, oldval); + } + else { + if (this.inWorld) { + if (flags == 0x00000008 || flags == 0x00000010) { + if (!this.isPlayer()) + continue; + } + + setmethod.call(this, oldval); + } + } + } + }; + } + onDestroy() { + this.detachComponents() + } + onControlled(bIsControlled) { + + } + isPlayer() { + return this.id == app.entity_id; + } + baseCall(type: string, ...params: any[]) { + // if (params.length < 1) { + // ERROR_MSG('Entity::baseCall: not fount interfaceName!'); + // return; + // } + + if (this.base == undefined) { + ERROR_MSG('Entity::baseCall: base is None!'); + return; + } + + let method = moduledefs[this.className].base_methods[type]; + + if (method == undefined) { + ERROR_MSG("Entity::baseCall: The server did not find the def_method(" + this.className + "." + type + ")!"); + return; + } + + let methodID = method[0]; + let args = method[3]; + + if (params.length != args.length) { + ERROR_MSG("Entity::baseCall: args(" + (params.length - 1) + "!= " + args.length + ") size is error!"); + return; + } + + this.base.newCall(); + this.base.bundle.writeUint16(0); + this.base.bundle.writeUint16(methodID); + + try { + for (let i = 0; i < params.length; i++) { + if (args[i].isSameType(params[i])) { + args[i].addToStream(this.base.bundle, params[i]); + } + else { + throw new Error("Entity::baseCall: arg[" + i + "] is error!"); + } + } + } + catch (e) { + ERROR_MSG(e.toString()); + ERROR_MSG('Entity::baseCall: args is error!'); + this.base.bundle = null; + return; + } + + this.base.sendCall(); + } + cellCall(type: string, ...params: any[]) { + // if (params.length < 1) { + // ERROR_MSG('Entity::cellCall: not fount interfaceName!'); + // return; + // } + + if (this.cell == undefined) { + ERROR_MSG('Entity::cellCall: cell is None!'); + return; + } + + let method = moduledefs[this.className].cell_methods[type]; + + if (method == undefined) { + ERROR_MSG("Entity::cellCall: The server did not find the def_method(" + this.className + "." + type + ")!"); + return; + } + + let methodID = method[0]; + let args = method[3]; + + if (params.length != args.length) { + ERROR_MSG("Entity::cellCall: args(" + (params.length) + "!= " + args.length + ") size is error!"); + return; + } + + this.cell.newCall() + this.cell.bundle.writeUint16(0); + this.cell.bundle.writeUint16(methodID); + + try { + for (let i = 0; i < args.length; i++) { + if (args[i].isSameType(params[i])) { + args[i].addToStream(this.cell.bundle, params[i]); + } + else { + throw new Error("Entity::cellCall: arg[" + i + "] is error!"); + } + } + } + catch (e) { + ERROR_MSG(e.toString()); + ERROR_MSG('Entity::cellCall: args is error!'); + this.cell.bundle = null; + return; + } + + this.cell.sendCall(); + } + enterWorld() { + INFO_MSG(this.className + '::enterWorld: ' + this.id); + this.inWorld = true; + this.onEnterWorld(); + this.onComponentsEnterworld(); + Event.fire("onEnterWorld", this); + } + onComponentsEnterworld() { + for (let i in this.__comps__) { + this[i].onEnterWorld() + } + } + onComponentsLeaveworld() { + for (let i in this.__comps__) { + this[i].onLeaveWorld() + } + } + onEnterWorld() { + + } + leaveWorld() { + INFO_MSG(this.className + '::leaveWorld: ' + this.id); + this.inWorld = false; + this.onLeaveWorld(); + this.onComponentsLeaveworld() + Event.fire("onLeaveWorld", this); + } + onLeaveWorld() { + + } + enterSpace() { + INFO_MSG(this.className + '::enterSpace: ' + this.id); + this.onEnterSpace(); + Event.fire("onEnterSpace", this); + + // 要立即刷新表现层对象的位置 + Event.fire("set_position", this); + Event.fire("set_direction", this); + } + onEnterSpace() { + + } + leaveSpace() { + INFO_MSG(this.className + '::leaveSpace: ' + this.id); + this.onLeaveSpace(); + Event.fire("onLeaveSpace", this); + } + onLeaveSpace() { + + } + set_position() { + DEBUG_MSG(this.className + "::set_position: " + this.position); + if (this.isPlayer()) { + app.entityServerPos.x = this.position.x; + app.entityServerPos.y = this.position.y; + app.entityServerPos.z = this.position.z; + } + + Event.fire("set_position", this); + } + onUpdateVolatileData() { + + } + onUpdatePropertys(stream: MemoryStream) { + let currModule = moduledefs[getQualifiedClassName(this)]; + let pdatas = currModule.propertys; + while (stream.length() > 0) { + let utype = 0, cId = 0; + if (currModule.usePropertyDescrAlias) { + cId = stream.readUint8() + utype = stream.readUint8() + } else { + cId = stream.readUint16() + utype = stream.readUint16() + } + if (cId !== 0) { + let comp = pdatas[cId]; + if (this[comp[2]]) { + this[comp[2]].onUpdatePropertys(utype, stream, -1) + } + continue; + } + let propertydata = pdatas[utype]; + let setmethod = propertydata[5]; + let flags = propertydata[6]; + if (!propertydata[4]) { + if (this[propertydata[2]] && typeof this[propertydata[2]].createFromStream === 'function') + this[propertydata[2]].createFromStream(stream, propertydata[0]) + continue; + } + let val = propertydata[4].createFromStream(stream); + let oldval = this[propertydata[2]]; + KBEngine.INFO_MSG("KBEngineApp::Client_onUpdatePropertys: " + this.className + "(id=" + this.id + " " + propertydata[2] + ", val=" + val + ")!"); + this[propertydata[2]] = val; + if (setmethod != null) { + // base类属性或者进入世界后cell类属性会触发set_*方法 + if (flags == 0x00000020 || flags == 0x00000040) { + if (this.inited) + setmethod.call(this, oldval); + } + else { + if (this.inWorld) + setmethod.call(this, oldval); + } + } + } + } + set_direction(old) { + DEBUG_MSG(this.className + "::set_direction: " + this.direction); + Event.fire("set_direction", this); + } + onRemoteMethodCall(stream: MemoryStream) { + let sm = moduledefs[this.className] + let ComponentID = sm.usePropertyDescrAlias ? stream.readUint8() : stream.readUint16(); + let methodUtype = sm.useMethodDescrAlias ? stream.readUint8() : stream.readUint16(); + if (ComponentID !== 0) { + let comp = this[sm.propertys[ComponentID][2]]; + if (comp) comp.onRemoteMethodCall(methodUtype, stream) + return; + } + + let methoddata = moduledefs[this.className].methods[methodUtype]; + let args = []; + let argsdata = methoddata[3]; + for (let i = 0; i < argsdata.length; i++) { + args.push(argsdata[i].createFromStream(stream)); + } + + if (this[methoddata[2]] != undefined) { + this[methoddata[2]].apply(this, args); + } + else { + ERROR_MSG("KBEngineApp::Client_onRemoteMethodCall: entity(" + this.id + ") not found method(" + methoddata[2] + ")!"); + } + } + } + export function registerEntity() { + return (ctor: new () => Entity) => { + let name = getQualifiedClassName(ctor); + // KBEngine['Entities'] = KBEngine['Entities'] || {} + KBEngine['Entities'][name] = ctor; + } + } +} +namespace KBEngine { + export class EntityComponent { + id = 0 + entityComponentPropertyID = 0; + componentType = 0; + ownerID = 0; + owner: Entity = null; + className = ''; + + base: EntityComponentCall = null; + cell: EntityComponentCall = null; + + protected onAttached(owner: Entity) { } + protected onDetached(owner: Entity) { } + protected onEnterWorld() { } + protected onLeaveWorld() { } + + baseCall(type: string, ...params: any[]) { + let className = this.className + if (this.base == undefined) { + ERROR_MSG('Entity::baseCall: base is None!'); + return; + } + + let method = moduledefs[className].base_methods[type]; + + if (method == undefined) { + ERROR_MSG("Entity::baseCall: The server did not find the def_method(" + className + "." + type + ")!"); + return; + } + + let methodID = method[0]; + let args = method[3]; + + if (params.length != args.length) { + ERROR_MSG("Entity::baseCall: args(" + (params.length - 1) + "!= " + args.length + ") size is error!"); + return; + } + + this.base.newCall(); + this.base.bundle.writeUint16(this.entityComponentPropertyID); + this.base.bundle.writeUint16(methodID); + + try { + for (let i = 0; i < params.length; i++) { + if (args[i].isSameType(params[i])) { + args[i].addToStream(this.base.bundle, params[i]); + } + else { + throw new Error("Entity::baseCall: arg[" + i + "] is error!"); + } + } + } + catch (e) { + ERROR_MSG(e.toString()); + ERROR_MSG('Entity::baseCall: args is error!'); + this.base.bundle = null; + return; + } + + this.base.sendCall(); + } + cellCall(type: string, ...params: any[]) { + + let className = this.className + + if (this.cell == undefined) { + ERROR_MSG('Entity::cellCall: cell is None!'); + return; + } + + let method = moduledefs[className].cell_methods[type]; + + if (method == undefined) { + ERROR_MSG("Entity::cellCall: The server did not find the def_method(" + className + "." + type + ")!"); + return; + } + + let methodID = method[0]; + let args = method[3]; + + if (params.length != args.length) { + ERROR_MSG("Entity::cellCall: args(" + (params.length) + "!= " + args.length + ") size is error!"); + return; + } + + this.cell.newCall() + this.cell.bundle.writeUint16(this.entityComponentPropertyID); + this.cell.bundle.writeUint16(methodID); + + try { + for (let i = 0; i < args.length; i++) { + if (args[i].isSameType(params[i])) { + args[i].addToStream(this.cell.bundle, params[i]); + } + else { + throw new Error("Entity::cellCall: arg[" + i + "] is error!"); + } + } + } + catch (e) { + ERROR_MSG(e.toString()); + ERROR_MSG('Entity::cellCall: args is error!'); + this.cell.bundle = null; + return; + } + + this.cell.sendCall(); + } + onUpdatePropertys(propUtype: number, stream: MemoryStream, maxCount: number) { + let className = getQualifiedClassName(this) + let currModule = moduledefs[className]; + let pdatas = currModule.propertys; + while (stream.length() > 0 && maxCount-- != 0) { + let utype = propUtype, cId = 0; + if (utype === 0) { + if (currModule.usePropertyDescrAlias) { + cId = stream.readUint8() + utype = stream.readUint8() + } else { + cId = stream.readUint16() + utype = stream.readUint16() + } + } + let propertydata = pdatas[utype]; + let setmethod = propertydata[5]; + let flags = propertydata[6]; + let val = propertydata[4].createFromStream(stream); + let oldval = this[propertydata[2]]; + KBEngine.INFO_MSG("KBEngineApp::Client_onUpdatePropertys: " + className + "(id=" + this.id + " " + propertydata[2] + ", val=" + val + ")!"); + this[propertydata[2]] = val; + if (setmethod != null) { + // base类属性或者进入世界后cell类属性会触发set_*方法 + if (flags == 0x00000020 || flags == 0x00000040) { + if (this.owner.inited) + setmethod.call(this, oldval); + } + else { + if (this.owner.inWorld) + setmethod.call(this, oldval); + } + } + } + } + onRemoteMethodCall(propUtype: number, stream: MemoryStream) { + let sm = moduledefs[this.className].methods[propUtype]; + + let args = []; + let argsdata = sm[3]; + for (let i = 0; i < argsdata.length; i++) { + args.push(argsdata[i].createFromStream(stream)); + } + typeof this[sm[2]] === 'function' && this[sm[2]].apply(this, args) + } + createFromStream(stream: MemoryStream, ecpId: number) { + this.entityComponentPropertyID = ecpId; + this.componentType = stream.readInt32(); + this.ownerID = stream.readInt32() + this.owner = app.entities[this.ownerID]; + + //UInt16 ComponentDescrsType; + stream.readUint16(); + let count = stream.readUint16() + if (count > 0) { + this.onUpdatePropertys(0, stream, count) + } + this.className = getQualifiedClassName(this) + this.base = new EntityComponentCall(this.entityComponentPropertyID, this.ownerID, this.className) + this.base.type = ENTITYCALL_TYPE_BASE + this.cell = new EntityComponentCall(this.entityComponentPropertyID, this.ownerID, this.className) + this.cell.type = ENTITYCALL_TYPE_CELL + } + } + export function registerComponent() { + return (ctor: new () => EntityComponent) => { + let name = getQualifiedClassName(ctor); + // KBEngine['Entities'] = KBEngine['Entities'] || {} + KBEngine['Entities'][name] = ctor; + } + } +} +/*----------------------------------------------------------------------------------------- + EntityCall +-----------------------------------------------------------------------------------------*/ +namespace KBEngine { + export const ENTITYCALL_TYPE_CELL = 0; + export const ENTITYCALL_TYPE_BASE = 1; + + export class EntityCall { + constructor() { + + } + id: number = 0; + className = ''; + type: number = ENTITYCALL_TYPE_CELL; + networkInterface = app; + bundle = null; + + isBase() { + return this.type == ENTITYCALL_TYPE_BASE; + } + isCell() { + return this.type == ENTITYCALL_TYPE_CELL; + } + newCall() { + if (this.bundle == null) + this.bundle = Bundle.createObject(); + + if (this.type == ENTITYCALL_TYPE_CELL) + this.bundle.newMessage(messages['Baseapp_onRemoteCallCellMethodFromClient']); + else + this.bundle.newMessage(messages['Entity_onRemoteMethodCall']); + + this.bundle.writeInt32(this.id); + + return this.bundle; + } + sendCall(bundle?: Bundle) { + if (bundle == undefined) + bundle = this.bundle; + + bundle.send(this.networkInterface); + + if (this.bundle == bundle) + this.bundle = null; + } + } + export class EntityComponentCall extends EntityCall { + entityComponentPropertyID = 0 + constructor(ecpId: number, eid: number, className: string) { + super() + this.entityComponentPropertyID = ecpId; + this.id = eid; + this.className = className + } + } + + export class DATATYPE_UINT8 { + bind() { + } + + createFromStream(stream) { + return reader.readUint8.call(stream); + } + + addToStream(stream, v) { + stream.writeUint8(v); + } + + parseDefaultValStr(v) { + return parseInt(v); + } + + isSameType(v) { + if (typeof (v) != "number") { + return false; + } + + if (v < 0 || v > 0xff) { + return false; + } + + return true; + } + } + export class DATATYPE_UINT16 { + bind() { + } + + createFromStream(stream) { + return reader.readUint16.call(stream); + } + + addToStream(stream, v) { + stream.writeUint16(v); + } + + parseDefaultValStr(v) { + return parseInt(v); + } + + isSameType(v) { + if (typeof (v) != "number") { + return false; + } + + if (v < 0 || v > 0xffff) { + return false; + } + + return true; + } + } + export class DATATYPE_UINT32 { + bind() { + } + createFromStream(stream) { + return reader.readUint32.call(stream); + } + + addToStream(stream, v) { + stream.writeUint32(v); + } + + parseDefaultValStr(v) { + return parseInt(v); + } + + isSameType(v) { + if (typeof (v) != "number") { + return false; + } + + if (v < 0 || v > 0xffffffff) { + return false; + } + + return true; + } + } + export class DATATYPE_UINT64 { + bind() { + } + + createFromStream(stream) { + return reader.readUint64.call(stream); + } + + addToStream(stream, v) { + stream.writeUint64(v); + } + + parseDefaultValStr(v) { + return parseInt(v); + } + + isSameType(v) { + return v instanceof UINT64; + } + } + export class DATATYPE_INT8 { + bind() { + } + + createFromStream(stream) { + return reader.readInt8.call(stream); + } + + addToStream(stream, v) { + stream.writeInt8(v); + } + + parseDefaultValStr(v) { + return parseInt(v); + } + + isSameType(v) { + if (typeof (v) != "number") { + return false; + } + + if (v < -0x80 || v > 0x7f) { + return false; + } + + return true; + } + } + export class DATATYPE_INT16 { + bind() { + } + + createFromStream(stream) { + return reader.readInt16.call(stream); + } + + addToStream(stream, v) { + stream.writeInt16(v); + } + + parseDefaultValStr(v) { + return parseInt(v); + } + + isSameType(v) { + if (typeof (v) != "number") { + return false; + } + + if (v < -0x8000 || v > 0x7fff) { + return false; + } + + return true; + } + } + export class DATATYPE_INT32 { + bind() { + } + + createFromStream(stream) { + return reader.readInt32.call(stream); + } + + addToStream(stream, v) { + stream.writeInt32(v); + } + + parseDefaultValStr(v) { + return parseInt(v); + } + + isSameType(v) { + if (typeof (v) != "number") { + return false; + } + + if (v < -0x80000000 || v > 0x7fffffff) { + return false; + } + + return true; + } + } + export class DATATYPE_INT64 { + bind() { + } + + createFromStream(stream) { + return reader.readInt64.call(stream); + } + + addToStream(stream, v) { + stream.writeInt64(v); + } + + parseDefaultValStr(v) { + return parseInt(v); + } + + isSameType(v) { + return v instanceof INT64; + } + } + export class DATATYPE_FLOAT { + bind() { + } + + createFromStream(stream) { + return reader.readFloat.call(stream); + } + + addToStream(stream, v) { + stream.writeFloat(v); + } + + parseDefaultValStr(v) { + return parseFloat(v); + } + + isSameType(v) { + return typeof (v) == "number"; + } + } + export class DATATYPE_DOUBLE extends DATATYPE_FLOAT { + createFromStream(stream) { + return reader.readDouble.call(stream); + } + + addToStream(stream, v) { + stream.writeDouble(v); + } + } + export class DATATYPE_STRING { + bind() { + } + + createFromStream(stream) { + return reader.readString.call(stream); + } + + addToStream(stream, v) { + stream.writeString(v); + } + + parseDefaultValStr(v) { + if (typeof (v) == "string") + return v; + + return ""; + } + + isSameType(v) { + return typeof (v) == "string"; + } + } + export class DATATYPE_VECTOR2 { + bind() { + } + + createFromStream(stream) { + if (CLIENT_NO_FLOAT) { + let x = reader.readInt32.call(stream) + let y = reader.readInt32.call(stream) + return new Vector2(x, y); + } + else { + let x = reader.readFloat.call(stream) + let y = reader.readFloat.call(stream) + return new Vector2(x, y); + } + } + + addToStream(stream, v) { + if (CLIENT_NO_FLOAT) { + stream.writeInt32(v.x); + stream.writeInt32(v.y); + } + else { + stream.writeFloat(v.x); + stream.writeFloat(v.y); + } + } + + parseDefaultValStr(v) { + return new Vector2(0.0, 0.0);; + } + + isSameType(v) { + if (!(v instanceof Vector2)) { + return false; + } + + return true; + } + } + export class DATATYPE_VECTOR3 { + bind() { + } + + createFromStream(stream) { + if (CLIENT_NO_FLOAT) { + return new Vector3(reader.readInt32.call(stream), + reader.readInt32.call(stream), reader.readInt32.call(stream)); + } + else { + return new Vector3(reader.readFloat.call(stream), + reader.readFloat.call(stream), reader.readFloat.call(stream)); + } + } + + addToStream(stream, v) { + if (CLIENT_NO_FLOAT) { + stream.writeInt32(v.x); + stream.writeInt32(v.y); + stream.writeInt32(v.z); + } + else { + stream.writeFloat(v.x); + stream.writeFloat(v.y); + stream.writeFloat(v.z); + } + } + + parseDefaultValStr(v) { + return new Vector3(0.0, 0.0, 0.0); + } + + isSameType(v) { + if (!(v instanceof Vector3)) { + return false; + } + + return true; + } + } + export class DATATYPE_VECTOR4 { + bind() { + } + + createFromStream(stream) { + if (CLIENT_NO_FLOAT) { + return new Vector4(reader.readInt32.call(stream), + reader.readInt32.call(stream), + reader.readInt32.call(stream), + reader.readInt32.call(stream)); + } + else { + return new Vector4(reader.readFloat.call(stream), + reader.readFloat.call(stream), + reader.readFloat.call(stream), + reader.readFloat.call(stream)); + } + } + + addToStream(stream, v) { + if (CLIENT_NO_FLOAT) { + stream.writeInt32(v.x); + stream.writeInt32(v.y); + stream.writeInt32(v.z); + stream.writeInt32(v.w); + } + else { + stream.writeFloat(v.x); + stream.writeFloat(v.y); + stream.writeFloat(v.z); + stream.writeFloat(v.w); + } + } + + parseDefaultValStr(v) { + return new Vector4(0.0, 0.0, 0.0, 0.0); + } + + isSameType(v) { + if (!(v instanceof Vector4)) { + return false; + } + + return true; + } + } + export class DATATYPE_PYTHON { + bind() { + } + + createFromStream(stream) { + return stream.readBlob(); + } + + addToStream(stream, v) { + stream.writeBlob(v); + } + + parseDefaultValStr(v) { + return new Uint8Array(0); + } + + isSameType(v) { + return false; + } + } + export class DATATYPE_UNICODE { + bind() { + } + + createFromStream(stream) { + return utf8ArrayToString(reader.readBlob.call(stream)); + } + + addToStream(stream, v) { + stream.writeBlob(stringToUTF8Bytes(v)); + } + + parseDefaultValStr(v) { + if (typeof (v) == "string") + return v; + + return ""; + } + + isSameType(v) { + return typeof (v) == "string"; + } + } + + export class DATATYPE_ENTITYCALL { + bind() { + } + + createFromStream(stream) { + } + + addToStream(stream, v) { + } + + parseDefaultValStr(v) { + return new Uint8Array(0);; + } + + isSameType(v) { + return false; + } + } + export class DATATYPE_BLOB { + bind() { + } + + createFromStream(stream) { + let size = reader.readUint32.call(stream); + let buf = new Uint8Array(stream.buffer, stream.rpos, size); + stream.rpos += size; + return buf; + } + + addToStream(stream, v) { + stream.writeBlob(v); + } + + parseDefaultValStr(v) { + return new Uint8Array(0); + } + + isSameType(v) { + return true; + } + } + export class DATATYPE_ARRAY { + type = null; + + bind() { + if (typeof (this.type) == "number") + this.type = datatypes[this.type]; + } + + createFromStream(stream) { + let size = stream.readUint32(); + let datas = []; + + while (size > 0) { + size--; + datas.push(this.type.createFromStream(stream)); + }; + + return datas; + } + + addToStream(stream, v) { + stream.writeUint32(v.length); + for (let i = 0; i < v.length; i++) { + this.type.addToStream(stream, v[i]); + } + } + + parseDefaultValStr(v) { + return []; + } + + isSameType(v) { + for (let i = 0; i < v.length; i++) { + if (!this.type.isSameType(v[i])) { + return false; + } + } + + return true; + } + } + export class DATATYPE_FIXED_DICT { + dicttype = {}; + implementedBy = null; + + bind() { + for (let itemkey in this.dicttype) { + let utype = this.dicttype[itemkey]; + + if (typeof (this.dicttype[itemkey]) == "number") + this.dicttype[itemkey] = datatypes[utype]; + } + } + + createFromStream(stream) { + let datas = {}; + for (let itemkey in this.dicttype) { + datas[itemkey] = this.dicttype[itemkey].createFromStream(stream); + } + + return datas; + } + + addToStream(stream, v) { + for (let itemkey in this.dicttype) { + this.dicttype[itemkey].addToStream(stream, v[itemkey]); + } + } + + parseDefaultValStr(v) { + return {}; + } + + isSameType(v) { + for (let itemkey in this.dicttype) { + if (!this.dicttype[itemkey].isSameType(v[itemkey])) { + return false; + } + } + + return true; + } + } + + export module datatypes { + export const UINT8 = new DATATYPE_UINT8(); + export const UINT16 = new DATATYPE_UINT16(); + export const UINT32 = new DATATYPE_UINT32(); + export const UINT64 = new DATATYPE_UINT64(); + + export const INT8 = new DATATYPE_INT8(); + export const INT16 = new DATATYPE_INT16(); + export const INT32 = new DATATYPE_INT32(); + export const INT64 = new DATATYPE_INT64(); + + export const FLOAT = new DATATYPE_FLOAT(); + export const DOUBLE = new DATATYPE_DOUBLE(); + + export const STRING = new DATATYPE_STRING(); + export const VECTOR2 = new DATATYPE_VECTOR2(); + export const VECTOR3 = new DATATYPE_VECTOR3(); + export const VECTOR4 = new DATATYPE_VECTOR4(); + export const PYTHON = new DATATYPE_PYTHON(); + // export const PY_DICT = new DATATYPE_PYTHON(); + // export const PY_LIST = new DATATYPE_PYTHON(); + export const UNICODE = new DATATYPE_UNICODE(); + export const ENTITYCALL = new DATATYPE_ENTITYCALL(); + export const BLOB = new DATATYPE_BLOB(); + }; +} +/*----------------------------------------------------------------------------------------- + KBEngine args +-----------------------------------------------------------------------------------------*/ +namespace KBEngine { + export class KBEngineArgs { + ip = '127.0.0.1'; + port = 20013; + updateHZ = 100; + serverHeartbeatTick = 15; + + isWss: boolean = false; + //TODO wss需要参数，因为服务器不支持wss，需要使用Nginx转发一次，在这里设置强制修改baseapp连接端口到Nginx端口 + get protocol(): string { return this.isWss ? "wss://" : "ws://" } + forceBasePort: number = 0; + + // Reference: http://github.io/docs/programming/clientsdkprogramming.html, client types + clientType = 5; + + // 在Entity初始化时是否触发属性的set_*事件(callPropertysSetMethods) + isOnInitCallPropertysSetMethods = true; + } + export const EventTypes = { + // Create new account. + // param1(string): accountName + // param2(string): password + // param3(bytes): datas // Datas by user defined. Data will be recorded into the KBE account database, you can access the datas through the script layer. If you use third-party account system, datas will be submitted to the third-party system. + createAccount: "createAccount", + + // Login to server. + // param1(string): accountName + // param2(string): password + // param3(bytes): datas // Datas by user defined. Data will be recorded into the KBE account database, you can access the datas through the script layer. If you use third-party account system, datas will be submitted to the third-party system. + login: "login", + + // Logout to baseapp, called when exiting the client. + logout: "logout", + + // Relogin to baseapp. + reloginBaseapp: "reloginBaseapp", + + // Request server binding account Email. + // param1(string): emailAddress + bindAccountEmail: "bindAccountEmail", + + // Request to set up a new password for the account. Note: account must be online. + // param1(string): old_password + // param2(string): new_password + newPassword: "newPassword", + + // ------------------------------------连接相关------------------------------------ + + // Kicked of the current server. + // param1(uint16): retcode. // server_errors + onKicked: "onKicked", + + // Disconnected from the server. + onDisconnected: "onDisconnected", + + // Status of connection server. + // param1(bool): success or fail + onConnectionState: "onConnectionState", + + // ------------------------------------logon相关------------------------------------ + + // Create account feedback results. + // param1(uint16): retcode. // server_errors + // param2(bytes): datas. // If you use third-party account system, the system may fill some of the third-party additional datas. + onCreateAccountResult: "onCreateAccountResult", + + // Engine version mismatch. + // param1(string): clientVersion + // param2(string): serverVersion + onVersionNotMatch: "onVersionNotMatch", + + // script version mismatch. + // param1(string): clientScriptVersion + // param2(string): serverScriptVersion + onScriptVersionNotMatch: "onScriptVersionNotMatch", + + // Login failed. + // param1(uint16): retcode. // server_errors + onLoginFailed: "onLoginFailed", + + // Login to baseapp. + onLoginBaseapp: "onLoginBaseapp", + + // Login baseapp failed. + // param1(uint16): retcode. // server_errors + onLoginBaseappFailed: "onLoginBaseappFailed", + + // Relogin to baseapp. + onReloginBaseapp: "onReloginBaseapp", + + // Relogin baseapp success. + onReloginBaseappSuccessfully: "onReloginBaseappSuccessfully", + + // Relogin baseapp failed. + // param1(uint16): retcode. // server_errors + onReloginBaseappFailed: "onReloginBaseappFailed", + + // ------------------------------------实体cell相关事件------------------------------------ + + // Entity enter the client-world. + // param1: Entity + onEnterWorld: "onEnterWorld", + + // Entity leave the client-world. + // param1: Entity + onLeaveWorld: "onLeaveWorld", + + // Player enter the new space. + // param1: Entity + onEnterSpace: "onEnterSpace", + + // Player leave the space. + // param1: Entity + onLeaveSpace: "onLeaveSpace", + + // Sets the current position of the entity. + // param1: Entity + set_position: "set_position", + + // Sets the current direction of the entity. + // param1: Entity + set_direction: "set_direction", + + // The entity position is updated, you can smooth the moving entity to new location. + // param1: Entity + updatePosition: "updatePosition", + + // The current space is specified by the geometry mapping. + // Popular said is to load the specified Map Resources. + // param1(string): resPath + addSpaceGeometryMapping: "addSpaceGeometryMapping", + + // Server spaceData set data. + // param1(int32): spaceID + // param2(string): key + // param3(string): value + onSetSpaceData: "onSetSpaceData", + + // Start downloading data. + // param1(int32): rspaceID + // param2(string): key + onDelSpaceData: "onDelSpaceData", + + // Triggered when the entity is controlled or out of control. + // param1: Entity + // param2(bool): isControlled + onControlled: "onControlled", + + // Lose controlled entity. + // param1: Entity + onLoseControlledEntity: "onLoseControlledEntity", + + // ------------------------------------数据下载相关------------------------------------ + + // Start downloading data. + // param1(uint16): resouce id + // param2(uint32): data size + // param3(string): description + onStreamDataStarted: "onStreamDataStarted", + + // Receive data. + // param1(uint16): resouce id + // param2(bytes): datas + onStreamDataRecv: "onStreamDataRecv", + + // The downloaded data is completed. + // param1(uint16): resouce id + onStreamDataCompleted: "onStreamDataCompleted", + } +} +/*----------------------------------------------------------------------------------------- + KBEngine app +-----------------------------------------------------------------------------------------*/ +namespace KBEngine { + export const moduledefs = {}; + export class KBEngineApp { + constructor(public args: KBEngineArgs) { + // console.assert(app == null || app == undefined, "Assertion of app not is null"); + app = this; + } + baseappIp: string; + username = "testhtml51"; + password = "123456"; + clientdatas = ""; + encryptedKey = ""; + + loginappMessageImported = false; + baseappMessageImported = false; + serverErrorsDescrImported = false; + entitydefImported = false; + + // 这个参数的选择必须与kbengine_defs.xml::cellapp/aliasEntityID的参数保持一致 + useAliasEntityID = true; + serverErrs: { [err: string]: ServerErr } = {}; + + // // 登录loginapp的地址 + // ip: string; + // port: number; + + // 服务端分配的baseapp地址 + baseappIP = ''; + baseappPort = 0; + baseappUdpPort = 0; + + currMsgID = 0; + currMsgCount = 0; + currMsgLen = 0; + + fragmentStream = null; + fragmentDatasFlag = FragmentDataTypes.FRAGMENT_DATA_UNKNOW; + fragmentDatasRemain = 0; + + socket; + currserver: string; + currstate = "create"; + currconnect = 'loginapp'; + + // 扩展数据 + serverdatas = ""; + + // 版本信息 + serverVersion = ""; + serverScriptVersion = ""; + serverProtocolMD5 = ""; + serverEntityDefMD5 = ""; + clientVersion = CLIENT_VERSION; + clientScriptVersion = CLIENT_SCRIPT_VERSION; + + // player的相关信息 + entity_uuid = null; + entity_id = 0; + entity_type = ""; + + // 当前玩家最后一次同步到服务端的位置与朝向与服务端最后一次同步过来的位置 + entityServerPos = new Vector3(0.0, 0.0, 0.0); + + // 客户端所有的实体 + entities = {}; + entityIDAliasIDList = []; + controlledEntities = []; + + // 空间的信息 + spacedata = {}; + spaceID = 0; + spaceResPath = ""; + isLoadedGeometry = false; + + lastTickTime = Date.now(); + lastTickCBTime = Date.now(); + component; + msgStream = new MemoryStream(PACKET_MAX_SIZE_TCP); + + resetSocket() { + try { + if (app.socket != undefined && app.socket != null) { + let sock = app.socket; + + sock.onopen = undefined; + sock.onerror = undefined; + sock.onmessage = undefined; + sock.onclose = undefined; + app.socket = null; + sock.close(); + } + } + catch (e) { + } + } + reset() { + if (app.entities != undefined && app.entities != null) { + app.clearEntities(true); + } + + app.resetSocket(); + + app.currserver = "loginapp"; + app.currstate = "create"; + app.currconnect = 'loginapp' + + // 扩展数据 + app.serverdatas = ""; + + // 版本信息 + app.serverVersion = ""; + app.serverScriptVersion = ""; + app.serverProtocolMD5 = ""; + app.serverEntityDefMD5 = ""; + // app.clientVersion = "1.1.5"; + // app.clientScriptVersion = "0.1.0"; + + // player的相关信息 + app.entity_uuid = null; + app.entity_id = 0; + app.entity_type = ""; + + // 当前玩家最后一次同步到服务端的位置与朝向与服务端最后一次同步过来的位置 + app.entityServerPos = new Vector3(0.0, 0.0, 0.0); + + // 客户端所有的实体 + app.entities = {}; + app.entityIDAliasIDList = []; + app.controlledEntities = []; + + // 空间的信息 + app.spacedata = {}; + app.spaceID = 0; + app.spaceResPath = ""; + app.isLoadedGeometry = false; + + let dateObject = new Date(); + app.lastTickTime = dateObject.getTime(); + app.lastTickCBTime = dateObject.getTime(); + + mappingDataType(); + + // 当前组件类别， 配套服务端体系 + app.component = "client"; + } + installEvents() { + Event.register(EventTypes.createAccount, app, "createAccount"); + Event.register(EventTypes.login, app, "login"); + Event.register(EventTypes.logout, app, 'logout') + Event.register(EventTypes.reloginBaseapp, app, "reloginBaseapp"); + Event.register(EventTypes.bindAccountEmail, app, "bindAccountEmail"); + Event.register(EventTypes.newPassword, app, "newPassword"); + } + uninstallEvents() { + Event.deregister(EventTypes.createAccount, app); + Event.deregister(EventTypes.login, app); + Event.deregister(EventTypes.logout, app) + Event.deregister(EventTypes.reloginBaseapp, app); + Event.deregister(EventTypes.bindAccountEmail, app); + Event.deregister(EventTypes.newPassword, app); + } + hello() { + let bundle = Bundle.createObject(); + + if (app.currserver == "loginapp") + bundle.newMessage(messages['Loginapp_hello']); + else + bundle.newMessage(messages['Baseapp_hello']); + + bundle.writeString(app.clientVersion); + bundle.writeString(app.clientScriptVersion); + bundle.writeBlob(app.encryptedKey); + bundle.send(app); + } + player() { + return app.entities[app.entity_id]; + } + findEntity(entityID) { + return app.entities[entityID]; + } + connect(host, port) { + // console.assert(app.socket == null, "Assertion of socket not is null"); + try { + let addr = app.args.protocol + host + ':' + port + //todo 应该是在这里设置wss + app.socket = new WebSocket(addr); + } + catch (e) { + ERROR_MSG('WebSocket init error!'); + Event.fire(EventTypes.onConnectionState, false); + return; + } + + app.socket.binaryType = "arraybuffer"; + app.socket.onopen = app.onopen; + app.socket.onerror = app.onerror_before_onopen; + app.socket.onmessage = app.onmessage; + app.socket.onclose = app.onclose; + } + disconnect() { + app.resetSocket(); + } + onopen() { + INFO_MSG('connect success!'); + app.socket.onerror = app.onerror_after_onopen; + Event.fire(EventTypes.onConnectionState, true); + } + onerror_before_onopen(evt) { + ERROR_MSG('connect error:' + evt.data); + app.resetSocket(); + Event.fire(EventTypes.onConnectionState, false); + } + onerror_after_onopen(evt) { + ERROR_MSG('connect error:' + evt.data); + app.resetSocket(); + Event.fire(EventTypes.onDisconnected); + } + onmessage(msg) { + let stream = app.msgStream; + stream.setbuffer(msg.data); + stream.wpos = msg.data.byteLength; + + while (stream.length() > 0 || app.fragmentStream != null) { + if (app.fragmentDatasFlag == FragmentDataTypes.FRAGMENT_DATA_UNKNOW) { + if (app.currMsgID == 0) { + if (MESSAGE_ID_LENGTH > 1 && stream.length() < MESSAGE_ID_LENGTH) { + app.writeFragmentMessage(FragmentDataTypes.FRAGMENT_DATA_MESSAGE_ID, stream, MESSAGE_ID_LENGTH); + break; + } + + app.currMsgID = stream.readUint16(); + } + + let msgHandler = clientmessages[app.currMsgID]; + + if (!msgHandler) { + app.currMsgID = 0; + app.currMsgLen = 0; + ERROR_MSG("KBEngineApp::onmessage[" + app.currserver + "]: not found msg(" + app.currMsgID + ")!"); + break; + } + + let msglen = msgHandler.length; + if (app.currMsgLen == 0) { + if (msglen == -1) { + if (stream.length() < MESSAGE_LENGTH_LENGTH) { + app.writeFragmentMessage(FragmentDataTypes.FRAGMENT_DATA_MESSAGE_LENGTH, stream, MESSAGE_LENGTH_LENGTH); + break; + } + else { + msglen = stream.readUint16(); + app.currMsgLen = msglen; + + // 扩展长度 + if (msglen == MESSAGE_MAX_SIZE) { + if (stream.length() < MESSAGE_LENGTH1_LENGTH) { + app.writeFragmentMessage(FragmentDataTypes.FRAGMENT_DATA_MESSAGE_LENGTH1, stream, MESSAGE_LENGTH1_LENGTH); + break; + } + + app.currMsgLen = stream.readUint32(); + } + } + } + else { + app.currMsgLen = msglen; + } + } + + if (app.fragmentStream != null && app.fragmentStream.length() >= app.currMsgLen) { + msgHandler.handleMessage(app.fragmentStream); + app.fragmentStream = null; + } + else if (stream.length() < app.currMsgLen && stream.length() > 0) { + app.writeFragmentMessage(FragmentDataTypes.FRAGMENT_DATA_MESSAGE_BODY, stream, app.currMsgLen); + break; + } + else { + let wpos = stream.wpos; + let rpos = stream.rpos + msglen; + stream.wpos = rpos; + msgHandler.handleMessage(stream); + stream.wpos = wpos; + stream.rpos = rpos; + } + + app.currMsgID = 0; + app.currMsgLen = 0; + app.fragmentStream = null; + } + else { + if (app.mergeFragmentMessage(stream)) + break; + } + } + } + writeFragmentMessage(FragmentDataType, stream: MemoryStream, datasize) { + let opsize = stream.length(); + + app.fragmentDatasRemain = datasize - opsize; + app.fragmentDatasFlag = FragmentDataType; + app.fragmentStream = stream; + } + + mergeFragmentMessage(stream: MemoryStream) { + let opsize = stream.length(); + if (opsize == 0) + return 0; + + let fragmentStream = app.fragmentStream; + // console.assert(fragmentStream != null); + + if (opsize >= app.fragmentDatasRemain) { + fragmentStream.append(stream, stream.rpos, app.fragmentDatasRemain); + + switch (app.fragmentDatasFlag) { + case FragmentDataTypes.FRAGMENT_DATA_MESSAGE_ID: + app.currMsgID = fragmentStream.readUint16(); + app.fragmentStream = null; + break; + + case FragmentDataTypes.FRAGMENT_DATA_MESSAGE_LENGTH: + app.currMsgLen = fragmentStream.readUint16(); + app.fragmentStream = null; + break; + + case FragmentDataTypes.FRAGMENT_DATA_MESSAGE_LENGTH1: + app.currMsgLen = fragmentStream.readUint32(); + app.fragmentStream = null; + break; + + case FragmentDataTypes.FRAGMENT_DATA_MESSAGE_BODY: + default: + break; + } + + stream.rpos += app.fragmentDatasRemain; + app.fragmentDatasFlag = FragmentDataTypes.FRAGMENT_DATA_UNKNOW; + app.fragmentDatasRemain = 0; + return false; + } + else { + fragmentStream.append(stream, stream.rpos, opsize); + app.fragmentDatasRemain -= opsize; + stream.done(); + return true; + } + } + onclose() { + INFO_MSG('connect close:' + app.currserver); + + if (app.currconnect != app.currstate) return; + + app.resetSocket(); + Event.fire(EventTypes.onDisconnected); + //if(app.currserver != "loginapp") + // app.reset(); + } + send(msg) { + app.socket.send(msg); + } + close() { + INFO_MSG('KBEngine::close()'); + app.socket.close(); + app.reset(); + } + update() { + if (app.socket == null) + return; + + let dateObject = new Date(); + if ((dateObject.getTime() - app.lastTickTime) / 1000 > app.args.serverHeartbeatTick / 2) { + // 如果心跳回调接收时间小于心跳发送时间，说明没有收到回调 + // 此时应该通知客户端掉线了 + if (app.lastTickCBTime < app.lastTickTime) { + ERROR_MSG("sendTick: Receive appTick timeout!"); + app.socket.close(); + } + + if (app.currserver == "loginapp") { + if (messages['Loginapp_onClientActiveTick'] != undefined) { + let bundle = Bundle.createObject(); + bundle.newMessage(messages['Loginapp_onClientActiveTick']); + bundle.send(app); + } + } + else { + if (messages['Baseapp_onClientActiveTick'] != undefined) { + let bundle = Bundle.createObject(); + bundle.newMessage(messages['Baseapp_onClientActiveTick']); + bundle.send(app); + } + } + + app.lastTickTime = dateObject.getTime(); + } + + app.updatePlayerToServer(); + } + Client_onAppActiveTickCB() { + // let dateObject = new Date(); + app.lastTickCBTime = Date.now() //dateObject.getTime(); + } + serverErr(id) { + let e = app.serverErrs[id]; + + if (e == undefined) { + return ""; + } + + return e.name + " [" + e.descr + "]"; + } + + Client_onImportServerErrorsDescr(stream) { + let size = stream.readUint16(); + while (size > 0) { + size -= 1; + + let e = new ServerErr(); + e.id = stream.readUint16(); + e.name = utf8ArrayToString(stream.readBlob()); + e.descr = utf8ArrayToString(stream.readBlob()); + + app.serverErrs[e.id] = e; + + INFO_MSG("Client_onImportServerErrorsDescr: id=" + e.id + ", name=" + e.name + ", descr=" + e.descr); + } + } + Client_onImportClientSdk(stream: MemoryStream) { + let remainingFiles = stream.readInt32(); + let fileName = stream.readString(); + let fileSize = stream.readInt32(); + let fileDatas = stream.readBlob() + Event.fire("onImportClientSDK", remainingFiles, fileName, fileSize, fileDatas); + } + onOpenLoginapp_login() { + INFO_MSG("KBEngineApp::onOpenLoginapp_login: successfully!"); + Event.fire(EventTypes.onConnectionState, true); + + app.currserver = "loginapp"; + app.currstate = "login"; + + if (!app.loginappMessageImported) { + let bundle = Bundle.createObject(); + bundle.newMessage(messages.Loginapp_importClientMessages); + bundle.send(app); + app.socket.onmessage = app.Client_onImportClientMessages; + INFO_MSG("KBEngineApp::onOpenLoginapp_login: start importClientMessages ..."); + Event.fire("Loginapp_importClientMessages"); + } + else { + app.onImportClientMessagesCompleted(); + } + } + + onOpenLoginapp_createAccount() { + Event.fire("onConnectionState", true); + INFO_MSG("KBEngineApp::onOpenLoginapp_createAccount: successfully!"); + app.currserver = "loginapp"; + app.currstate = "createAccount"; + + if (!app.loginappMessageImported) { + let bundle = Bundle.createObject(); + bundle.newMessage(messages.Loginapp_importClientMessages); + bundle.send(app); + app.socket.onmessage = app.Client_onImportClientMessages; + INFO_MSG("KBEngineApp::onOpenLoginapp_createAccount: start importClientMessages ..."); + Event.fire("Loginapp_importClientMessages"); + } + else { + app.onImportClientMessagesCompleted(); + } + } + onImportClientMessagesCompleted() { + INFO_MSG("KBEngineApp::onImportClientMessagesCompleted: successfully!"); + app.socket.onmessage = app.onmessage; + app.hello(); + + if (app.currserver == "loginapp") { + if (!app.serverErrorsDescrImported) { + INFO_MSG("KBEngine::onImportClientMessagesCompleted(): send importServerErrorsDescr!"); + app.serverErrorsDescrImported = true; + let bundle = Bundle.createObject(); + bundle.newMessage(messages['Loginapp_importServerErrorsDescr']); + bundle.send(app); + } + + if (app.currstate == "login") + app.login_loginapp(false); + else if (app.currstate == "resetpassword") + app.resetpassword_loginapp(false); + else + app.createAccount_loginapp(false); + + app.loginappMessageImported = true; + } + else { + app.baseappMessageImported = true; + + if (!app.entitydefImported) { + INFO_MSG("KBEngineApp::onImportClientMessagesCompleted: start importEntityDef ..."); + let bundle = Bundle.createObject(); + bundle.newMessage(messages.Baseapp_importClientEntityDef); + bundle.send(app); + Event.fire("Baseapp_importClientEntityDef"); + } + else { + app.onImportEntityDefCompleted(); + } + } + } + createDataTypeFromStreams(stream, canprint) { + let aliassize = stream.readUint16(); + INFO_MSG("KBEngineApp::createDataTypeFromStreams: importAlias(size=" + aliassize + ")!"); + + while (aliassize > 0) { + aliassize--; + app.createDataTypeFromStream(stream, canprint); + }; + + for (let datatype in datatypes) { + if (datatypes[datatype] != undefined) { + datatypes[datatype].bind(); + } + } + } + createDataTypeFromStream(stream, canprint) { + let utype = stream.readUint16(); + let name = stream.readString(); + let valname = stream.readString(); + let length: string; + /* 有一些匿名类型，我们需要提供一个唯一名称放到datatypes中 + 如： + + ARRAY INT8 + + */ + if (valname.length == 0) + length = "Null_" + utype; + + if (canprint) + INFO_MSG("KBEngineApp::Client_onImportClientEntityDef: importAlias(" + name + ":" + valname + ")!"); + + if (name == "FIXED_DICT") { + let datatype = new DATATYPE_FIXED_DICT(); + let keysize = stream.readUint8(); + datatype.implementedBy = stream.readString(); + + while (keysize > 0) { + keysize--; + + let keyname = stream.readString(); + let keyutype = stream.readUint16(); + datatype.dicttype[keyname] = keyutype; + }; + + datatypes[valname] = datatype; + } + else if (name == "ARRAY") { + let uitemtype = stream.readUint16(); + let datatype = new DATATYPE_ARRAY(); + datatype.type = uitemtype; + datatypes[valname] = datatype; + } + else { + datatypes[valname] = datatypes[name]; + } + + datatypes[utype] = datatypes[valname]; + + // 将用户自定义的类型补充到映射表中 + datatype2id[valname] = utype; + } + Client_onImportClientEntityDef(stream) { + app.createDataTypeFromStreams(stream, true); + + while (stream.length() > 0) { + let scriptmodule_name = stream.readString(); + let scriptUtype = stream.readUint16(); + let propertysize = stream.readUint16(); + let methodsize = stream.readUint16(); + let base_methodsize = stream.readUint16(); + let cell_methodsize = stream.readUint16(); + + INFO_MSG("KBEngineApp::Client_onImportClientEntityDef: import(" + scriptmodule_name + "), propertys(" + propertysize + "), " + + "clientMethods(" + methodsize + "), baseMethods(" + base_methodsize + "), cellMethods(" + cell_methodsize + ")!"); + + moduledefs[scriptmodule_name] = {}; + let currModuleDefs = moduledefs[scriptmodule_name]; + currModuleDefs["name"] = scriptmodule_name; + currModuleDefs["propertys"] = {}; + currModuleDefs["methods"] = {}; + currModuleDefs["base_methods"] = {}; + currModuleDefs["cell_methods"] = {}; + moduledefs[scriptUtype] = currModuleDefs; + + let self_propertys = currModuleDefs["propertys"]; + let self_methods = currModuleDefs["methods"]; + let self_base_methods = currModuleDefs["base_methods"]; + let self_cell_methods = currModuleDefs["cell_methods"]; + + let Class = KBEngine['Entities'][scriptmodule_name]; + + while (propertysize > 0) { + propertysize--; + + let properUtype = stream.readUint16(); + let properFlags = stream.readUint32(); + let aliasID = stream.readInt16(); + let name = stream.readString(); + let defaultValStr = stream.readString(); + let utype = datatypes[stream.readUint16()]; + let setmethod = null; + + if (Class != undefined) { + setmethod = Class.prototype["set_" + name]; + if (setmethod == undefined) + setmethod = null; + } + + let savedata = [properUtype, aliasID, name, defaultValStr, utype, setmethod, properFlags]; + self_propertys[name] = savedata; + + if (aliasID != -1) { + self_propertys[aliasID] = savedata; + currModuleDefs["usePropertyDescrAlias"] = true; + } + else { + self_propertys[properUtype] = savedata; + currModuleDefs["usePropertyDescrAlias"] = false; + } + + INFO_MSG("KBEngineApp::Client_onImportClientEntityDef: add(" + scriptmodule_name + "), property(" + name + "/" + properUtype + ")."); + }; + + while (methodsize > 0) { + methodsize--; + + let methodUtype = stream.readUint16(); + let aliasID = stream.readInt16(); + let name = stream.readString(); + let argssize = stream.readUint8(); + let args = []; + + while (argssize > 0) { + argssize--; + args.push(datatypes[stream.readUint16()]); + }; + + let savedata = [methodUtype, aliasID, name, args]; + self_methods[name] = savedata; + + if (aliasID != -1) { + self_methods[aliasID] = savedata; + currModuleDefs["useMethodDescrAlias"] = true; + } + else { + self_methods[methodUtype] = savedata; + currModuleDefs["useMethodDescrAlias"] = false; + } + + INFO_MSG("KBEngineApp::Client_onImportClientEntityDef: add(" + scriptmodule_name + "), method(" + name + ")."); + }; + + while (base_methodsize > 0) { + base_methodsize--; + + let methodUtype = stream.readUint16(); + let aliasID = stream.readInt16(); + let name = stream.readString(); + let argssize = stream.readUint8(); + let args = []; + + while (argssize > 0) { + argssize--; + args.push(datatypes[stream.readUint16()]); + }; + + self_base_methods[name] = [methodUtype, aliasID, name, args]; + INFO_MSG("KBEngineApp::Client_onImportClientEntityDef: add(" + scriptmodule_name + "), base_method(" + name + ")."); + }; + + while (cell_methodsize > 0) { + cell_methodsize--; + + let methodUtype = stream.readUint16(); + let aliasID = stream.readInt16(); + let name = stream.readString(); + let argssize = stream.readUint8(); + let args = []; + + while (argssize > 0) { + argssize--; + args.push(datatypes[stream.readUint16()]); + }; + + self_cell_methods[name] = [methodUtype, aliasID, name, args]; + INFO_MSG("KBEngineApp::Client_onImportClientEntityDef: add(" + scriptmodule_name + "), cell_method(" + name + ")."); + }; + let defmethod + try { + defmethod = KBEngine['Entities'][scriptmodule_name]; + } + catch (e) { + ERROR_MSG("KBEngineApp::Client_onImportClientEntityDef: module(" + scriptmodule_name + ") not found!"); + defmethod = undefined; + } + + for (let name in currModuleDefs.propertys) { + let infos = currModuleDefs.propertys[name]; + let properUtype = infos[0]; + let aliasID = infos[1]; + let n = infos[2]; + let defaultValStr = infos[3]; + let utype = infos[4]; + + if (defmethod != undefined && utype) + defmethod.prototype[n] = utype.parseDefaultValStr(defaultValStr); + }; + + for (let name in currModuleDefs.methods) { + let infos = currModuleDefs.methods[name]; + let properUtype = infos[0]; + let aliasID = infos[1]; + let n = infos[2]; + let args = infos[3]; + + if (defmethod != undefined && defmethod.prototype[n] == undefined) { + WARNING_MSG(scriptmodule_name + ":: method(" + n + ") no implement!"); + } + }; + } + + app.onImportEntityDefCompleted(); + } + Client_onVersionNotMatch(stream) { + app.serverVersion = stream.readString(); + ERROR_MSG("Client_onVersionNotMatch: verInfo=" + app.clientVersion + " not match(server: " + app.serverVersion + ")"); + Event.fire(EventTypes.onVersionNotMatch, app.clientVersion, app.serverVersion); + } + Client_onScriptVersionNotMatch(stream) { + app.serverScriptVersion = stream.readString(); + ERROR_MSG("Client_onScriptVersionNotMatch: verInfo=" + app.clientScriptVersion + " not match(server: " + app.serverScriptVersion + ")"); + Event.fire(EventTypes.onScriptVersionNotMatch, app.clientScriptVersion, app.serverScriptVersion); + } + onImportEntityDefCompleted() { + INFO_MSG("KBEngineApp::onImportEntityDefCompleted: successfully!"); + app.entitydefImported = true; + app.login_baseapp(false); + } + importClientMessages(stream) { + while (app.currMsgCount > 0) { + app.currMsgCount--; + + let msgid = stream.readUint16(); + let msglen = stream.readInt16(); + let msgname = stream.readString(); + let argtype = stream.readInt8(); + let argsize = stream.readUint8(); + let argstypes = new Array(argsize); + + for (let i = 0; i < argsize; i++) { + argstypes[i] = stream.readUint8(); + } + + let handler = null; + let isClientMethod = msgname.indexOf("Client_") >= 0; + if (isClientMethod) { + handler = app[msgname]; + if (handler == null || handler == undefined) { + WARNING_MSG("KBEngineApp::onImportClientMessages[" + app.currserver + "]: interface(" + msgname + "/" + msgid + ") no implement!"); + handler = null; + } + else { + INFO_MSG("KBEngineApp::onImportClientMessages: import(" + msgname + ") successfully!"); + } + } + + if (msgname.length > 0) { + messages[msgname] = new Message(msgid, msgname, msglen, argtype, argstypes, handler); + + if (isClientMethod) + clientmessages[msgid] = messages[msgname]; + else + messages[app.currserver][msgid] = messages[msgname]; + } + else { + messages[app.currserver][msgid] = new Message(msgid, msgname, msglen, argtype, argstypes, handler); + } + }; + + app.onImportClientMessagesCompleted(); + app.currMsgID = 0; + app.currMsgLen = 0; + app.currMsgCount = 0; + app.fragmentStream = null; + } + + Client_onImportClientMessages(msg) { + let stream = new MemoryStream(msg.data); + stream.wpos = msg.data.byteLength; + + if (app.currMsgID == 0) { + app.currMsgID = stream.readUint16(); + } + + if (app.currMsgID == messages.onImportClientMessages.id) { + if (app.currMsgLen == 0) { + app.currMsgLen = stream.readUint16(); + app.currMsgCount = stream.readUint16(); + } + + if (stream.length() + 2 < app.currMsgLen && app.fragmentStream == null) { + app.writeFragmentMessage(FragmentDataTypes.FRAGMENT_DATA_MESSAGE_BODY, stream, app.currMsgLen - 2); + } + else if (app.fragmentStream != null) { + app.mergeFragmentMessage(stream); + + if (app.fragmentStream.length() + 2 >= app.currMsgLen) { + app.importClientMessages(app.fragmentStream); + } + } + else { + app.importClientMessages(stream); + } + } + else { + ERROR_MSG("KBEngineApp::onmessage: not found msg(" + app.currMsgID + ")!"); + } + } + createAccount(username, password, datas) { + app.reset(); + app.username = username; + app.password = password; + app.clientdatas = datas; + + app.createAccount_loginapp(true); + } + createAccount_loginapp(noconnect) { + if (noconnect) { + INFO_MSG("KBEngineApp::createAccount_loginapp: start connect to ws://" + app.args.ip + ":" + app.args.port + "!"); + app.currconnect = "loginapp"; + app.connect(app.args.ip, app.args.port); + app.socket.onopen = app.onOpenLoginapp_createAccount; + } + else { + let bundle = Bundle.createObject(); + bundle.newMessage(messages['Loginapp_reqCreateAccount']); + bundle.writeString(app.username); + bundle.writeString(app.password); + bundle.writeBlob(app.clientdatas); + bundle.send(app); + } + } + bindAccountEmail(emailAddress) { + let bundle = Bundle.createObject(); + bundle.newMessage(messages['Baseapp_reqAccountBindEmail']); + bundle.writeInt32(app.entity_id); + bundle.writeString(app.password); + bundle.writeString(emailAddress); + bundle.send(app); + } + newPassword(old_password, new_password) { + let bundle = Bundle.createObject(); + bundle.newMessage(messages['Baseapp_reqAccountNewPassword']); + bundle.writeInt32(app.entity_id); + bundle.writeString(old_password); + bundle.writeString(new_password); + bundle.send(app); + } + logout() { + let bundle = new Bundle(); + bundle.newMessage(messages['Baseapp_logoutBaseapp']); + bundle.writeUint64(app.entity_uuid); + bundle.writeInt32(app.entity_id); + bundle.send(app); + } + login(username, password, datas) { + app.reset(); + app.username = username; + app.password = password; + app.clientdatas = datas; + + app.login_loginapp(true); + } + login_loginapp(noconnect) { + if (noconnect) { + INFO_MSG("KBEngineApp::login_loginapp: start connect to ws://" + app.args.ip + ":" + app.args.port + "!"); + app.currconnect = "loginapp"; + app.connect(app.args.ip, app.args.port); + app.socket.onopen = app.onOpenLoginapp_login; + } + else { + let bundle = Bundle.createObject(); + bundle.newMessage(messages['Loginapp_login']); + bundle.writeInt8(app.args.clientType); // clientType + bundle.writeBlob(app.clientdatas); + bundle.writeString(app.username); + bundle.writeString(app.password); + bundle.send(app); + } + } + onOpenLoginapp_resetpassword() { + INFO_MSG("KBEngineApp::onOpenLoginapp_resetpassword: successfully!"); + app.currserver = "loginapp"; + app.currstate = "resetpassword"; + + if (!app.loginappMessageImported) { + let bundle = Bundle.createObject(); + bundle.newMessage(messages.Loginapp_importClientMessages); + bundle.send(app); + app.socket.onmessage = app.Client_onImportClientMessages; + INFO_MSG("KBEngineApp::onOpenLoginapp_resetpassword: start importClientMessages ..."); + } + else { + app.onImportClientMessagesCompleted(); + } + } + reset_password(username) { + app.reset(); + app.username = username; + app.resetpassword_loginapp(true); + } + resetpassword_loginapp(noconnect) { + if (noconnect) { + INFO_MSG("KBEngineApp::createAccount_loginapp: start connect to ws://" + app.args.ip + ":" + app.args.port + "!"); + app.currconnect = "loginapp"; + app.connect(app.args.ip, app.args.port); + app.socket.onopen = app.onOpenLoginapp_resetpassword; + } + else { + let bundle = Bundle.createObject(); + bundle.newMessage(messages['Loginapp_reqAccountResetPassword']); + bundle.writeString(app.username); + bundle.send(app); + } + } + onOpenBaseapp() { + INFO_MSG("KBEngineApp::onOpenBaseapp: successfully!"); + app.currserver = "baseapp"; + + if (!app.baseappMessageImported) { + let bundle = Bundle.createObject(); + bundle.newMessage(messages.Baseapp_importClientMessages); + bundle.send(app); + app.socket.onmessage = app.Client_onImportClientMessages; + Event.fire("Baseapp_importClientMessages"); + } + else { + app.onImportClientMessagesCompleted(); + } + } + + login_baseapp(noconnect) { + if (noconnect) { + Event.fire("onLoginBaseapp"); + INFO_MSG("KBEngineApp::login_baseapp: start connect to ws://" + app.baseappIp + ":" + app.baseappPort + "!"); + app.currconnect = "baseapp"; + app.connect(app.baseappIp, app.baseappPort); + + if (app.socket != undefined && app.socket != null) + app.socket.onopen = app.onOpenBaseapp; + } + else { + let bundle = Bundle.createObject(); + bundle.newMessage(messages['Baseapp_loginBaseapp']); + bundle.writeString(app.username); + bundle.writeString(app.password); + bundle.send(app); + } + } + reloginBaseapp() { + app.lastTickCBTime = app.lastTickTime = Date.now(); + + if (app.socket != undefined && app.socket != null) + return; + + app.resetSocket(); + Event.fire(EventTypes.onReloginBaseapp); + + INFO_MSG("KBEngineApp::reloginBaseapp: start connect to ws://" + app.baseappIp + ":" + app.baseappPort + "!"); + app.currconnect = "baseapp"; + app.connect(app.baseappIp, app.baseappPort); + + if (app.socket != undefined && app.socket != null) + app.socket.onopen = app.onReOpenBaseapp; + } + onReOpenBaseapp() { + INFO_MSG("KBEngineApp::onReOpenBaseapp: successfully!"); + app.currserver = "baseapp"; + + let bundle = Bundle.createObject(); + bundle.newMessage(messages['Baseapp_reloginBaseapp']); + bundle.writeString(app.username); + bundle.writeString(app.password); + bundle.writeUint64(app.entity_uuid); + bundle.writeInt32(app.entity_id); + bundle.send(app); + + let dateObject = new Date(); + app.lastTickCBTime = dateObject.getTime(); + } + Client_onHelloCB(args) { + app.serverVersion = args.readString(); + app.serverScriptVersion = args.readString(); + app.serverProtocolMD5 = args.readString(); + app.serverEntityDefMD5 = args.readString(); + + let ctype = args.readInt32(); + + INFO_MSG("KBEngineApp::Client_onHelloCB: verInfo(" + app.serverVersion + "), scriptVerInfo(" + + app.serverScriptVersion + "), serverProtocolMD5(" + app.serverProtocolMD5 + "), serverEntityDefMD5(" + + app.serverEntityDefMD5 + "), ctype(" + ctype + ")!"); + + let dateObject = new Date(); + app.lastTickCBTime = dateObject.getTime(); + } + Client_onLoginFailed(args) { + let failedcode = args.readUint16(); + app.serverdatas = args.readBlob(); + ERROR_MSG("KBEngineApp::Client_onLoginFailed: failedcode(" + app.serverErrs[failedcode].name + "), datas(" + app.serverdatas.length + ")!"); + Event.fire("onLoginFailed", failedcode); + } + Client_onLoginSuccessfully(args) { + let accountName = args.readString(); + app.username = accountName; + app.baseappIp = args.readString(); + app.baseappPort = args.readUint16(); + app.baseappUdpPort = args.readUint16(); + app.serverdatas = args.readBlob(); + + INFO_MSG("KBEngineApp::Client_onLoginSuccessfully: accountName(" + accountName + "), addr(" + + app.baseappIp + ":" + app.baseappPort + "), datas(" + app.serverdatas.length + ")!"); + + app.disconnect(); + app.login_baseapp(true); + } + Client_onLoginBaseappFailed(failedcode) { + ERROR_MSG("KBEngineApp::Client_onLoginBaseappFailed: failedcode(" + app.serverErrs[failedcode].name + ")!"); + Event.fire(EventTypes.onLoginBaseappFailed, failedcode); + } + Client_onReloginBaseappFailed(failedcode) { + ERROR_MSG("KBEngineApp::Client_onReloginBaseappFailed: failedcode(" + app.serverErrs[failedcode].name + ")!"); + Event.fire(EventTypes.onReloginBaseappFailed, failedcode); + } + Client_onReloginBaseappSuccessfully(stream) { + app.entity_uuid = stream.readUint64(); + DEBUG_MSG("KBEngineApp::Client_onReloginBaseappSuccessfully: " + app.username); + Event.fire(EventTypes.onReloginBaseappSuccessfully); + } + entityclass = {}; + getentityclass(entityType) { + let runclass = KBEngine['Entities'][entityType]; + if (runclass == undefined) { + ERROR_MSG("KBEngineApp::getentityclass: entityType(" + entityType + ") is error!"); + return runclass; + } + + return runclass; + } + Client_onCreatedProxies(rndUUID, eid, entityType) { + INFO_MSG("KBEngineApp::Client_onCreatedProxies: eid(" + eid + "), entityType(" + entityType + ")!"); + + let entity = app.entities[eid]; + + app.entity_uuid = rndUUID; + app.entity_id = eid; + + if (entity == undefined) { + let runclass = app.getentityclass(entityType); + if (runclass == undefined) + return; + + let entity = new runclass(); + entity.id = eid; + entity.className = entityType; + + entity.base = new EntityCall(); + entity.base.id = eid; + entity.base.className = entityType; + entity.base.type = ENTITYCALL_TYPE_BASE; + + app.entities[eid] = entity; + + let entityMessage = bufferedCreateEntityMessages[eid]; + if (entityMessage != undefined) { + app.Client_onUpdatePropertys(entityMessage); + delete bufferedCreateEntityMessages[eid]; + } + + entity.__init__(); + entity.attachComponents(); + entity.inited = true; + + if (app.args.isOnInitCallPropertysSetMethods) + entity.callPropertysSetMethods(); + } + else { + let entityMessage = bufferedCreateEntityMessages[eid]; + if (entityMessage != undefined) { + app.Client_onUpdatePropertys(entityMessage); + delete bufferedCreateEntityMessages[eid]; + } + } + } + getViewEntityIDFromStream(stream) { + let id = 0; + if (app.entityIDAliasIDList.length > 255) { + id = stream.readInt32(); + } + else { + let aliasID = stream.readUint8(); + + // 如果为0且客户端上一步是重登陆或者重连操作并且服务端entity在断线期间一直处于在线状态 + // 则可以忽略这个错误, 因为cellapp可能一直在向baseapp发送同步消息， 当客户端重连上时未等 + // 服务端初始化步骤开始则收到同步信息, 此时这里就会出错。 + if (app.entityIDAliasIDList.length <= aliasID) + return 0; + + id = app.entityIDAliasIDList[aliasID]; + } + + return id; + } + onUpdatePropertys_(eid, stream) { + let entity = app.entities[eid]; + + if (entity == undefined) { + let entityMessage = bufferedCreateEntityMessages[eid]; + if (entityMessage != undefined) { + ERROR_MSG("KBEngineApp::Client_onUpdEntityComponentatePropertys: entity(" + eid + ") not found!"); + return; + } + + let stream1 = new MemoryStream(stream.buffer); + stream1.wpos = stream.wpos; + stream1.rpos = stream.rpos - 4; + bufferedCreateEntityMessages[eid] = stream1; + return; + } + entity.onUpdatePropertys(stream) + } + Client_onUpdatePropertysOptimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + app.onUpdatePropertys_(eid, stream); + } + Client_onUpdatePropertys(stream) { + let eid = stream.readInt32(); + app.onUpdatePropertys_(eid, stream); + } + onRemoteMethodCall_(eid, stream) { + let entity = app.entities[eid]; + + if (entity == undefined) { + ERROR_MSG("KBEngineApp::Client_onRemoteMethodCall: entity(" + eid + ") not found!"); + return; + } + entity.onRemoteMethodCall(stream) + } + Client_onRemoteMethodCallOptimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + app.onRemoteMethodCall_(eid, stream); + } + Client_onRemoteMethodCall(stream) { + let eid = stream.readInt32(); + app.onRemoteMethodCall_(eid, stream); + } + Client_onEntityEnterWorld(stream) { + let eid = stream.readInt32(); + if (app.entity_id > 0 && eid != app.entity_id) + app.entityIDAliasIDList.push(eid) + + let entityType; + if (moduledefs['Length'] > 255) + entityType = stream.readUint16(); + else + entityType = stream.readUint8(); + + let isOnGround = true; + + if (stream.length() > 0) + isOnGround = stream.readInt8(); + + entityType = moduledefs[entityType].name; + INFO_MSG("KBEngineApp::Client_onEntityEnterWorld: " + entityType + "(" + eid + "), spaceID(" + app.spaceID + "), isOnGround(" + isOnGround + ")!"); + + let entity = app.entities[eid]; + if (entity == undefined) { + let entityMessage = bufferedCreateEntityMessages[eid]; + if (entityMessage == undefined) { + ERROR_MSG("KBEngineApp::Client_onEntityEnterWorld: entity(" + eid + ") not found!"); + return; + } + + let runclass = app.getentityclass(entityType); + if (runclass == undefined) + return; + + let entity = new runclass(); + entity.id = eid; + entity.className = entityType; + + entity.cell = new EntityCall(); + entity.cell.id = eid; + entity.cell.className = entityType; + entity.cell.type = ENTITYCALL_TYPE_CELL; + + app.entities[eid] = entity; + + app.Client_onUpdatePropertys(entityMessage); + delete bufferedCreateEntityMessages[eid]; + + // entity.isOnGround = isOnGround > 0; + entity.isOnGround = isOnGround; + entity.__init__(); + entity.attachComponents(); + entity.inited = true; + entity.inWorld = true; + entity.enterWorld(); + + if (app.args.isOnInitCallPropertysSetMethods) + entity.callPropertysSetMethods(); + + entity.set_direction(entity.direction); + entity.set_position(entity.position); + } + else { + if (!entity.inWorld) { + entity.cell = new EntityCall(); + entity.cell.id = eid; + entity.cell.className = entityType; + entity.cell.type = ENTITYCALL_TYPE_CELL; + + // 安全起见， 这里清空一下 + // 如果服务端上使用giveClientTo切换控制权 + // 之前的实体已经进入世界， 切换后的实体也进入世界， 这里可能会残留之前那个实体进入世界的信息 + app.entityIDAliasIDList = []; + app.entities = {} + app.entities[entity.id] = entity; + + entity.set_direction(entity.direction); + entity.set_position(entity.position); + + app.entityServerPos.x = entity.position.x; + app.entityServerPos.y = entity.position.y; + app.entityServerPos.z = entity.position.z; + + entity.isOnGround = isOnGround; + // entity.isOnGround = isOnGround > 0; + + entity.inWorld = true; + entity.enterWorld(); + + if (app.args.isOnInitCallPropertysSetMethods) + entity.callPropertysSetMethods(); + } + } + } + Client_onEntityLeaveWorldOptimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + app.Client_onEntityLeaveWorld(eid); + } + Client_onEntityLeaveWorld(eid) { + let entity = app.entities[eid]; + if (entity == undefined) { + ERROR_MSG("KBEngineApp::Client_onEntityLeaveWorld: entity(" + eid + ") not found!"); + return; + } + + if (entity.inWorld) + entity.leaveWorld(); + + if (app.entity_id > 0 && eid != app.entity_id) { + let newArray0 = []; + + for (let i = 0; i < app.controlledEntities.length; i++) { + if (app.controlledEntities[i] != eid) { + newArray0.push(app.controlledEntities[i]); + } + else { + Event.fire("onLoseControlledEntity"); + } + } + + app.controlledEntities = newArray0 + + delete app.entities[eid]; + + let newArray = []; + for (let i = 0; i < app.entityIDAliasIDList.length; i++) { + if (app.entityIDAliasIDList[i] != eid) { + newArray.push(app.entityIDAliasIDList[i]); + } + } + + app.entityIDAliasIDList = newArray + } + else { + app.clearSpace(false); + entity.cell = null; + } + } + Client_onEntityDestroyed(eid) { + INFO_MSG("KBEngineApp::Client_onEntityDestroyed: entity(" + eid + ")!"); + + let entity = app.entities[eid]; + if (entity == undefined) { + ERROR_MSG("KBEngineApp::Client_onEntityDestroyed: entity(" + eid + ") not found!"); + return; + } + + if (entity.inWorld) { + if (app.entity_id == eid) + app.clearSpace(false); + + entity.leaveWorld(); + } + + delete app.entities[eid]; + } + Client_onEntityEnterSpace(stream) { + let eid = stream.readInt32(); + app.spaceID = stream.readUint32(); + let isOnGround = true; + + if (stream.length() > 0) + isOnGround = stream.readInt8(); + + let entity = app.entities[eid]; + if (entity == undefined) { + ERROR_MSG("KBEngineApp::Client_onEntityEnterSpace: entity(" + eid + ") not found!"); + return; + } + + entity.isOnGround = isOnGround; + app.entityServerPos.x = entity.position.x; + app.entityServerPos.y = entity.position.y; + app.entityServerPos.z = entity.position.z; + entity.enterSpace(); + } + Client_onEntityLeaveSpace(eid) { + let entity = app.entities[eid]; + if (entity == undefined) { + ERROR_MSG("KBEngineApp::Client_onEntityLeaveSpace: entity(" + eid + ") not found!"); + return; + } + + app.clearSpace(false); + entity.leaveSpace(); + } + Client_onKicked(failedcode) { + ERROR_MSG("KBEngineApp::Client_onKicked: failedcode(" + app.serverErrs[failedcode].name + ")!"); + Event.fire(EventTypes.onKicked, failedcode); + } + Client_onCreateAccountResult(stream) { + let retcode = stream.readUint16(); + let datas = stream.readBlob(); + + Event.fire("onCreateAccountResult", retcode, datas); + + if (retcode != 0) { + ERROR_MSG("KBEngineApp::Client_onCreateAccountResult: " + app.username + " create is failed! code=" + app.serverErrs[retcode].name + "!"); + return; + } + + INFO_MSG("KBEngineApp::Client_onCreateAccountResult: " + app.username + " create is successfully!"); + } + Client_onControlEntity(eid, isControlled) { + // eid = stream.readInt32(); + let entity = app.entities[eid]; + if (entity == undefined) { + ERROR_MSG("KBEngineApp::Client_onControlEntity: entity(" + eid + ") not found!"); + return; + } + + let isCont = isControlled != 0; + if (isCont) { + // 如果被控制者是玩家自己，那表示玩家自己被其它人控制了 + // 所以玩家自己不应该进入这个被控制列表 + if (app.player().id != entity.id) { + app.controlledEntities.push(entity) + } + } + else { + let newArray = []; + + for (let i = 0; i < app.controlledEntities.length; i++) + if (app.controlledEntities[i] != entity.id) + newArray.push(app.controlledEntities[i]); + + app.controlledEntities = newArray + } + + entity.isControlled = isCont; + + try { + entity.onControlled(isCont); + Event.fire(EventTypes.onControlled, entity, isCont); + } + catch (e) { + ERROR_MSG("KBEngine::Client_onControlEntity: entity id = '" + eid + "', is controlled = '" + isCont + "', error = '" + e + "'"); + } + } + updatePlayerToServer() { + let player = app.player(); + if (player == undefined || player.inWorld == false || app.spaceID == 0 || player.isControlled) + return; + + if (player.entityLastLocalPos.distance(player.position) > 0.001 || player.entityLastLocalDir.distance(player.direction) > 0.001) { + // 记录玩家最后一次上报位置时自身当前的位置 + player.entityLastLocalPos.x = player.position.x; + player.entityLastLocalPos.y = player.position.y; + player.entityLastLocalPos.z = player.position.z; + player.entityLastLocalDir.x = player.direction.x; + player.entityLastLocalDir.y = player.direction.y; + player.entityLastLocalDir.z = player.direction.z; + + let bundle = Bundle.createObject(); + bundle.newMessage(messages['Baseapp_onUpdateDataFromClient']); + bundle.writeFloat(player.position.x); + bundle.writeFloat(player.position.y); + bundle.writeFloat(player.position.z); + bundle.writeFloat(player.direction.x); + bundle.writeFloat(player.direction.y); + bundle.writeFloat(player.direction.z); + bundle.writeUint8(player.isOnGround); + bundle.writeUint32(app.spaceID); + bundle.send(app); + } + + // 开始同步所有被控制了的entity的位置 + for (let i in app.controlledEntities) { + let entity = app.controlledEntities[i]; + let position = entity.position; + let direction = entity.direction; + + let posHasChanged = entity.entityLastLocalPos.distance(position) > 0.001; + let dirHasChanged = entity.entityLastLocalDir.distance(direction) > 0.001; + + if (posHasChanged || dirHasChanged) { + entity.entityLastLocalPos = position; + entity.entityLastLocalDir = direction; + + let bundle = Bundle.createObject(); + bundle.newMessage(messages['Baseapp_onUpdateDataFromClientForControlledEntity']); + bundle.writeInt32(entity.id); + bundle.writeFloat(position.x); + bundle.writeFloat(position.y); + bundle.writeFloat(position.z); + + bundle.writeFloat(direction.x); + bundle.writeFloat(direction.y); + bundle.writeFloat(direction.z); + bundle.writeUint8(entity.isOnGround); + bundle.writeUint32(app.spaceID); + bundle.send(app); + } + } + } + addSpaceGeometryMapping(spaceID, respath) { + INFO_MSG("KBEngineApp::addSpaceGeometryMapping: spaceID(" + spaceID + "), respath(" + respath + ")!"); + + app.spaceID = spaceID; + app.spaceResPath = respath; + Event.fire(EventTypes.addSpaceGeometryMapping, respath); + } + clearSpace(isAll) { + app.entityIDAliasIDList = []; + app.spacedata = {}; + app.clearEntities(isAll); + app.isLoadedGeometry = false; + app.spaceID = 0; + } + clearEntities(isAll) { + app.controlledEntities = [] + + if (!isAll) { + let entity = app.player(); + + for (let eid in app.entities) { + if (eid == entity.id) + continue; + + if (app.entities[eid].inWorld) { + app.entities[eid].leaveWorld(); + } + + app.entities[eid].onDestroy(); + } + + app.entities = {} + app.entities[entity.id] = entity; + } + else { + for (let eid in app.entities) { + if (app.entities[eid].inWorld) { + app.entities[eid].leaveWorld(); + } + + app.entities[eid].onDestroy(); + } + + app.entities = {} + } + } + Client_initSpaceData(stream) { + app.clearSpace(false); + + app.spaceID = stream.readInt32(); + while (stream.length() > 0) { + let key = stream.readString(); + let value = stream.readString(); + app.Client_setSpaceData(app.spaceID, key, value); + } + + INFO_MSG("KBEngineApp::Client_initSpaceData: spaceID(" + app.spaceID + "), datas(" + app.spacedata + ")!"); + } + Client_setSpaceData(spaceID, key, value) { + INFO_MSG("KBEngineApp::Client_setSpaceData: spaceID(" + spaceID + "), key(" + key + "), value(" + value + ")!"); + + app.spacedata[key] = value; + + if (key == "_mapping") + app.addSpaceGeometryMapping(spaceID, value); + + Event.fire("onSetSpaceData", spaceID, key, value); + } + Client_delSpaceData(spaceID, key) { + INFO_MSG("KBEngineApp::Client_delSpaceData: spaceID(" + spaceID + "), key(" + key + ")!"); + + delete app.spacedata[key]; + Event.fire("onDelSpaceData", spaceID, key); + } + Client_getSpaceData(spaceID, key) { + return app.spacedata[key]; + } + Client_onUpdateBasePos(x, y, z) { + app.entityServerPos.x = x; + app.entityServerPos.y = y; + app.entityServerPos.z = z; + } + Client_onUpdateBasePosXZ(x, z) { + app.entityServerPos.x = x; + app.entityServerPos.z = z; + } + Client_onUpdateData(stream) { + let eid = app.getViewEntityIDFromStream(stream); + let entity = app.entities[eid]; + if (entity == undefined) { + ERROR_MSG("KBEngineApp::Client_onUpdateData: entity(" + eid + ") not found!"); + return; + } + } + Client_onSetEntityPosAndDir(stream) { + let eid = stream.readInt32(); + let entity = app.entities[eid]; + if (entity == undefined) { + ERROR_MSG("KBEngineApp::Client_onSetEntityPosAndDir: entity(" + eid + ") not found!"); + return; + } + + entity.position.x = stream.readFloat(); + entity.position.y = stream.readFloat(); + entity.position.z = stream.readFloat(); + entity.direction.x = stream.readFloat(); + entity.direction.y = stream.readFloat(); + entity.direction.z = stream.readFloat(); + + // 记录玩家最后一次上报位置时自身当前的位置 + entity.entityLastLocalPos.x = entity.position.x; + entity.entityLastLocalPos.y = entity.position.y; + entity.entityLastLocalPos.z = entity.position.z; + entity.entityLastLocalDir.x = entity.direction.x; + entity.entityLastLocalDir.y = entity.direction.y; + entity.entityLastLocalDir.z = entity.direction.z; + + entity.set_direction(entity.direction); + entity.set_position(entity.position); + } + Client_onUpdateData_ypr(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let y = stream.readFloat(); + let p = stream.readFloat(); + let r = stream.readFloat(); + + app._updateVolatileData(eid, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, y, p, r, -1); + } + Client_onUpdateData_yp(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let y = stream.readFloat(); + let p = stream.readFloat(); + + app._updateVolatileData(eid, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, y, p, KBE_FLT_MAX, -1); + } + Client_onUpdateData_yr(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let y = stream.readFloat(); + let r = stream.readFloat(); + + app._updateVolatileData(eid, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, y, KBE_FLT_MAX, r, -1); + } + Client_onUpdateData_pr(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let p = stream.readFloat(); + let r = stream.readFloat(); + + app._updateVolatileData(eid, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, p, r, -1); + } + Client_onUpdateData_y(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let y = stream.readFloat(); + + app._updateVolatileData(eid, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, y, KBE_FLT_MAX, KBE_FLT_MAX, -1); + } + Client_onUpdateData_p(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let p = stream.readFloat(); + + app._updateVolatileData(eid, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, p, KBE_FLT_MAX, -1); + } + Client_onUpdateData_r(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let r = stream.readFloat(); + + app._updateVolatileData(eid, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, r, -1); + } + Client_onUpdateData_xz(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + // let x = stream.readFloat(); let z = stream.readFloat(); + let x = stream.readFloat(); + let z = stream.readFloat(); + + app._updateVolatileData(eid, x, KBE_FLT_MAX, z, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, 1); + } + Client_onUpdateData_xz_ypr(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let x = stream.readFloat(); + let z = stream.readFloat(); + + let y = stream.readFloat(); + let p = stream.readFloat(); + let r = stream.readFloat(); + + app._updateVolatileData(eid, x, KBE_FLT_MAX, z, y, p, r, 1); + } + Client_onUpdateData_xz_yp(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let x = stream.readFloat(); + let z = stream.readFloat(); + + let y = stream.readFloat(); + let p = stream.readFloat(); + + app._updateVolatileData(eid, x, KBE_FLT_MAX, z, y, p, KBE_FLT_MAX, 1); + } + Client_onUpdateData_xz_yr(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let x = stream.readFloat(); + let z = stream.readFloat(); + + let y = stream.readFloat(); + let r = stream.readFloat(); + + app._updateVolatileData(eid, x, KBE_FLT_MAX, z, y, KBE_FLT_MAX, r, 1); + } + Client_onUpdateData_xz_pr(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let x = stream.readFloat(); + let z = stream.readFloat(); + + let p = stream.readFloat(); + let r = stream.readFloat(); + + app._updateVolatileData(eid, x, KBE_FLT_MAX, z, KBE_FLT_MAX, p, r, 1); + } + Client_onUpdateData_xz_y(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let x = stream.readFloat(); + let z = stream.readFloat(); + let y = stream.readFloat(); + + app._updateVolatileData(eid, x, KBE_FLT_MAX, z, y, KBE_FLT_MAX, KBE_FLT_MAX, 1); + } + Client_onUpdateData_xz_p(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let x = stream.readFloat(); + let z = stream.readFloat(); + let p = stream.readInt8(); + + app._updateVolatileData(eid, x, KBE_FLT_MAX, z, KBE_FLT_MAX, p, KBE_FLT_MAX, 1); + } + Client_onUpdateData_xz_r(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let x = stream.readFloat(); + let z = stream.readFloat(); + + let r = stream.readInt8(); + + app._updateVolatileData(eid, x, KBE_FLT_MAX, z, KBE_FLT_MAX, KBE_FLT_MAX, r, 1); + } + Client_onUpdateData_xyz(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let x = stream.readFloat(); + let y = stream.readFloat(); + let z = stream.readFloat(); + + app._updateVolatileData(eid, x, y, z, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, 0); + } + Client_onUpdateData_xyz_ypr(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let x = stream.readFloat(); + let y = stream.readFloat(); + let z = stream.readFloat(); + + let yaw = stream.readFloat(); + let p = stream.readFloat(); + let r = stream.readFloat(); + + app._updateVolatileData(eid, x, y, z, yaw, p, r, 0); + } + Client_onUpdateData_xyz_yp(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let x = stream.readFloat(); let z = stream.readFloat(); + let y = stream.readFloat(); + + let yaw = stream.readFloat(); + let p = stream.readFloat(); + + app._updateVolatileData(eid, x, y, z, yaw, p, KBE_FLT_MAX, 0); + } + Client_onUpdateData_xyz_yr(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let x = stream.readFloat(); let z = stream.readFloat(); + let y = stream.readFloat(); + + let yaw = stream.readFloat(); + let r = stream.readFloat(); + + app._updateVolatileData(eid, x, y, z, yaw, KBE_FLT_MAX, r, 0); + } + Client_onUpdateData_xyz_pr(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let x = stream.readFloat(); let z = stream.readFloat(); + let y = stream.readFloat(); + + let p = stream.readFloat(); + let r = stream.readFloat(); + + app._updateVolatileData(eid, x, y, z, KBE_FLT_MAX, p, r, 0); + } + Client_onUpdateData_xyz_y(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let x = stream.readFloat(); let z = stream.readFloat(); + let y = stream.readFloat(); + + let yaw = stream.readFloat(); + + app._updateVolatileData(eid, x, y, z, yaw, KBE_FLT_MAX, KBE_FLT_MAX, 0); + } + Client_onUpdateData_xyz_p(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let x = stream.readFloat(); let z = stream.readFloat(); + let y = stream.readFloat(); + + let p = stream.readFloat(); + + app._updateVolatileData(eid, x, y, z, KBE_FLT_MAX, p, KBE_FLT_MAX, 0); + } + Client_onUpdateData_xyz_r(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let x = stream.readFloat(); let z = stream.readFloat(); + let y = stream.readFloat(); + //todo 这个是自己加的，如果错误再修改 + let r = stream.readFloat(); + + // let p = stream.readFloat(); + + app._updateVolatileData(eid, x, y, z, r, KBE_FLT_MAX, KBE_FLT_MAX, 0); + } + Client_onUpdateData_ypr_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let y = stream.readInt8(); + let p = stream.readInt8(); + let r = stream.readInt8(); + + app._updateVolatileData(eid, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, y, p, r, -1, true); + } + + Client_onUpdateData_yp_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let y = stream.readInt8(); + let p = stream.readInt8(); + + app._updateVolatileData(eid, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, y, p, KBE_FLT_MAX, -1, true); + } + + Client_onUpdateData_yr_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let y = stream.readInt8(); + let r = stream.readInt8(); + + app._updateVolatileData(eid, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, y, KBE_FLT_MAX, r, -1, true); + } + + Client_onUpdateData_pr_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let p = stream.readInt8(); + let r = stream.readInt8(); + + app._updateVolatileData(eid, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, p, r, -1, true); + } + + Client_onUpdateData_y_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let y = stream.readInt8(); + + app._updateVolatileData(eid, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, y, KBE_FLT_MAX, KBE_FLT_MAX, -1, true); + } + + Client_onUpdateData_p_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let p = stream.readInt8(); + + app._updateVolatileData(eid, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, p, KBE_FLT_MAX, -1, true); + } + + Client_onUpdateData_r_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let r = stream.readInt8(); + + app._updateVolatileData(eid, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, r, -1, true); + } + + Client_onUpdateData_xz_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let xz = stream.readPackXZ(); + + app._updateVolatileData(eid, xz[0], KBE_FLT_MAX, xz[1], KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, 1, true); + } + + Client_onUpdateData_xz_ypr_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let xz = stream.readPackXZ(); + + let y = stream.readInt8(); + let p = stream.readInt8(); + let r = stream.readInt8(); + + app._updateVolatileData(eid, xz[0], KBE_FLT_MAX, xz[1], y, p, r, 1, true); + } + + Client_onUpdateData_xz_yp_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let xz = stream.readPackXZ(); + + let y = stream.readInt8(); + let p = stream.readInt8(); + + app._updateVolatileData(eid, xz[0], KBE_FLT_MAX, xz[1], y, p, KBE_FLT_MAX, 1, true); + } + + Client_onUpdateData_xz_yr_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let xz = stream.readPackXZ(); + + let y = stream.readInt8(); + let r = stream.readInt8(); + + app._updateVolatileData(eid, xz[0], KBE_FLT_MAX, xz[1], y, KBE_FLT_MAX, r, 1, true); + } + + Client_onUpdateData_xz_pr_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let xz = stream.readPackXZ(); + + let p = stream.readInt8(); + let r = stream.readInt8(); + + app._updateVolatileData(eid, xz[0], KBE_FLT_MAX, xz[1], KBE_FLT_MAX, p, r, 1, true); + } + + Client_onUpdateData_xz_y_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let xz = stream.readPackXZ(); + + let y = stream.readInt8(); + + app._updateVolatileData(eid, xz[0], KBE_FLT_MAX, xz[1], y, KBE_FLT_MAX, KBE_FLT_MAX, 1, true); + } + + Client_onUpdateData_xz_p_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let xz = stream.readPackXZ(); + + let p = stream.readInt8(); + + app._updateVolatileData(eid, xz[0], KBE_FLT_MAX, xz[1], KBE_FLT_MAX, p, KBE_FLT_MAX, 1, true); + } + + Client_onUpdateData_xz_r_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let xz = stream.readPackXZ(); + + let r = stream.readInt8(); + + app._updateVolatileData(eid, xz[0], KBE_FLT_MAX, xz[1], KBE_FLT_MAX, KBE_FLT_MAX, r, 1, true); + } + + Client_onUpdateData_xyz_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let xz = stream.readPackXZ(); + let y = stream.readPackY(); + + app._updateVolatileData(eid, xz[0], y, xz[1], KBE_FLT_MAX, KBE_FLT_MAX, KBE_FLT_MAX, 0, true); + } + + Client_onUpdateData_xyz_ypr_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let xz = stream.readPackXZ(); + let y = stream.readPackY(); + + let yaw = stream.readInt8(); + let p = stream.readInt8(); + let r = stream.readInt8(); + + app._updateVolatileData(eid, xz[0], y, xz[1], yaw, p, r, 0, true); + } + + Client_onUpdateData_xyz_yp_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let xz = stream.readPackXZ(); + let y = stream.readPackY(); + + let yaw = stream.readInt8(); + let p = stream.readInt8(); + + app._updateVolatileData(eid, xz[0], y, xz[1], yaw, p, KBE_FLT_MAX, 0, true); + } + + Client_onUpdateData_xyz_yr_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let xz = stream.readPackXZ(); + let y = stream.readPackY(); + + let yaw = stream.readInt8(); + let r = stream.readInt8(); + + app._updateVolatileData(eid, xz[0], y, xz[1], yaw, KBE_FLT_MAX, r, 0, true); + } + + Client_onUpdateData_xyz_pr_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let xz = stream.readPackXZ(); + let y = stream.readPackY(); + + let p = stream.readInt8(); + let r = stream.readInt8(); + + app._updateVolatileData(eid, xz[0], y, xz[1], KBE_FLT_MAX, p, r, 0, true); + } + + Client_onUpdateData_xyz_y_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let xz = stream.readPackXZ(); + let y = stream.readPackY(); + + let yaw = stream.readInt8(); + + app._updateVolatileData(eid, xz[0], y, xz[1], yaw, KBE_FLT_MAX, KBE_FLT_MAX, 0, true); + } + + Client_onUpdateData_xyz_p_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let xz = stream.readPackXZ(); + let y = stream.readPackY(); + + let p = stream.readInt8(); + + app._updateVolatileData(eid, xz[0], y, xz[1], KBE_FLT_MAX, p, KBE_FLT_MAX, 0, true); + } + + Client_onUpdateData_xyz_r_optimized(stream) { + let eid = app.getViewEntityIDFromStream(stream); + + let xz = stream.readPackXZ(); + let y = stream.readPackY(); + + let r = stream.readInt8(); + + app._updateVolatileData(eid, xz[0], y, xz[1], r, KBE_FLT_MAX, KBE_FLT_MAX, 0, true); + } + _updateVolatileData(entityID, x, y, z, yaw, pitch, roll, isOnGround, isOptimized: boolean = false) { + let entity = app.entities[entityID]; + if (entity == undefined) { + // 如果为0且客户端上一步是重登陆或者重连操作并且服务端entity在断线期间一直处于在线状态 + // 则可以忽略这个错误, 因为cellapp可能一直在向baseapp发送同步消息， 当客户端重连上时未等 + // 服务端初始化步骤开始则收到同步信息, 此时这里就会出错。 + ERROR_MSG("KBEngineApp::_updateVolatileData: entity(" + entityID + ") not found!"); + return; + } + + // 小于0不设置 + if (isOnGround >= 0) { + entity.isOnGround = (isOnGround > 0); + } + + let changeDirection = false; + + if (roll != KBE_FLT_MAX) { + changeDirection = true; + entity.direction.x = int82angle(roll, false); + } + + if (pitch != KBE_FLT_MAX) { + changeDirection = true; + entity.direction.y = int82angle(pitch, false); + } + + if (yaw != KBE_FLT_MAX) { + changeDirection = true; + entity.direction.z = int82angle(yaw, false); + } + + let done = false; + if (changeDirection == true) { + Event.fire("set_direction", entity); + done = true; + } + + let positionChanged = false; + if (x != KBE_FLT_MAX || y != KBE_FLT_MAX || z != KBE_FLT_MAX) + positionChanged = true; + + if (x == KBE_FLT_MAX) x = 0.0; + if (y == KBE_FLT_MAX) y = 0.0; + if (z == KBE_FLT_MAX) z = 0.0; + + if (positionChanged) { + if (isOptimized) { + entity.position.x = x + KBEngine.app.entityServerPos.x; + entity.position.y = y + KBEngine.app.entityServerPos.y; + entity.position.z = z + KBEngine.app.entityServerPos.z; + } + else { + entity.position.x = x; + entity.position.y = y; + entity.position.z = z; + } + done = true; + Event.fire("updatePosition", entity); + } + + if (done) + entity.onUpdateVolatileData(); + } + Client_onStreamDataStarted(id, datasize, descr) { + Event.fire(EventTypes.onStreamDataStarted, id, datasize, descr); + } + Client_onStreamDataRecv(stream) { + let id = stream.readUint16(); + let data = stream.readBlob(); + Event.fire(EventTypes.onStreamDataRecv, id, data); + } + Client_onStreamDataCompleted(id) { + Event.fire(EventTypes.onStreamDataCompleted, id); + } + Client_onReqAccountResetPasswordCB(failedcode) { + if (failedcode != 0) { + ERROR_MSG("KBEngineApp::Client_onReqAccountResetPasswordCB: " + app.username + " is failed! code=" + app.serverErrs[failedcode].name + "!"); + return; + } + + INFO_MSG("KBEngineApp::Client_onReqAccountResetPasswordCB: " + app.username + " is successfully!"); + } + Client_onReqAccountBindEmailCB(failedcode) { + if (failedcode != 0) { + ERROR_MSG("KBEngineApp::Client_onReqAccountBindEmailCB: " + app.username + " is failed! code=" + app.serverErrs[failedcode].name + "!"); + return; + } + + INFO_MSG("KBEngineApp::Client_onReqAccountBindEmailCB: " + app.username + " is successfully!"); + } + Client_onReqAccountNewPasswordCB(failedcode) { + if (failedcode != 0) { + ERROR_MSG("KBEngineApp::Client_onReqAccountNewPasswordCB: " + app.username + " is failed! code=" + app.serverErrs[failedcode].name + "!"); + return; + } + + INFO_MSG("KBEngineApp::Client_onReqAccountNewPasswordCB: " + app.username + " is successfully!"); + } + } + // 描述服务端返回的错误信息 + export class ServerErr { + name = ""; + descr = ""; + id = 0; + } + export const FragmentDataTypes = { + FRAGMENT_DATA_UNKNOW: 0, + FRAGMENT_DATA_MESSAGE_ID: 1, + FRAGMENT_DATA_MESSAGE_LENGTH: 2, + FRAGMENT_DATA_MESSAGE_LENGTH1: 3, + FRAGMENT_DATA_MESSAGE_BODY: 4 + }; + export let app: KBEngineApp; + let idInterval; + export function create(args: KBEngineArgs) { + if (app != undefined) + return; + + new KBEngineApp(args); + + app.reset(); + app.installEvents(); + idInterval = setInterval(app.update, args.updateHZ); + } + export function destroy() { + if (idInterval != undefined) + clearInterval(idInterval); + + if (app == undefined) + return; + + app.uninstallEvents(); + app.reset(); + app = undefined; + Event.clear(); + } +} diff --git a/kbengine_ts/tsconfig.json b/kbengine_ts/tsconfig.json new file mode 100644 index 0000000..b2ccbcd --- /dev/null +++ b/kbengine_ts/tsconfig.json @@ -0,0 +1,17 @@ +{ + "compilerOptions": { + "target": "es5", + "noImplicitAny": false, + "sourceMap": false, + "declaration": true, + "experimentalDecorators": true, + "outFile": "kbengine/kbengine.js" + }, + "include": [ + "libs", + "src" + ], + "exclude": [ + "kbengine" + ] +} \ No newline at end of file