diff --git a/AxibugEmuOnline.Client/Assets/AlienUICore.meta b/AxibugEmuOnline.Client/Assets/AlienUICore.meta new file mode 100644 index 0000000..ee7ad88 --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/AlienUICore.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 3b3f84ffc19016f4dbc28b308894bb4a +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay.meta b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay.meta new file mode 100644 index 0000000..edf2ec0 --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 86a02c697fd26264cb5ee552b582449b +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/AxiReplay.asmdef b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/AxiReplay.asmdef new file mode 100644 index 0000000..5cf0cb6 --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/AxiReplay.asmdef @@ -0,0 +1,3 @@ +{ + "name": "AxiReplay" +} diff --git a/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/AxiReplay.asmdef.meta b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/AxiReplay.asmdef.meta new file mode 100644 index 0000000..285d952 --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/AxiReplay.asmdef.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 0a45db2096af23647aaafe5b70ccb4d7 +AssemblyDefinitionImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/IReplayReader.cs b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/IReplayReader.cs new file mode 100644 index 0000000..c0761a5 --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/IReplayReader.cs @@ -0,0 +1,11 @@ +using System; + +namespace AxiReplay +{ + internal interface IReplayReader : IDisposable + { + bool NextFrame(out ReplayStep data); + bool TakeFrame(int addFrame, out ReplayStep data); + bool NextFramebyFrameIdx(int FrameID, out ReplayStep data); + } +} diff --git a/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/IReplayReader.cs.meta b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/IReplayReader.cs.meta new file mode 100644 index 0000000..86101ce --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/IReplayReader.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 896ff07370157db46b612575616020ed +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/IReplayWriter.cs b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/IReplayWriter.cs new file mode 100644 index 0000000..8f11a28 --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/IReplayWriter.cs @@ -0,0 +1,12 @@ +using System; + +namespace AxiReplay +{ + internal interface IReplayWriter : IDisposable + { + void NextFrame(UInt64 frameInput); + void NextFramebyFrameIdx(int FrameID, UInt64 frameInput); + void TakeFrame(int addFrame, UInt64 frameInput); + void SaveData(string path, bool bNeedDump = false, string dumpFilePath = null); + } +} diff --git a/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/IReplayWriter.cs.meta b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/IReplayWriter.cs.meta new file mode 100644 index 0000000..c1eb6a6 --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/IReplayWriter.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6a8fcda365e5a7f428f88bc130eb913b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/NetReplay.cs b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/NetReplay.cs new file mode 100644 index 0000000..ec67432 --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/NetReplay.cs @@ -0,0 +1,74 @@ +using System.Collections.Generic; + +namespace AxiReplay +{ + public class NetReplay + { + int MaxInFrame = 0; + int mCurrPlayFrame = -1; + Queue mQueueReplay; + ReplayStep mNextReplay; + ReplayStep mCurrReplay; + int byFrameIdx = 0; + public NetReplay() + { + mQueueReplay = new Queue(); + } + public void InData(ReplayStep inputData) + { + mQueueReplay.Enqueue(inputData); + MaxInFrame = inputData.FrameStartID; + } + public bool NextFrame(out ReplayStep data, out int FrameDiff) + { + return TakeFrame(0, out data, out FrameDiff); + } + /// + /// 往前推进帧的,指定帧下标 + /// + public bool NextFramebyFrameIdx(int FrameID, out ReplayStep data, out int FrameDiff) + { + bool res = TakeFrame(FrameID - byFrameIdx, out data, out FrameDiff); + byFrameIdx = FrameID; + return res; + } + public bool TakeFrame(int addFrame, out ReplayStep data, out int FrameDiff) + { + bool Changed = false; + mCurrPlayFrame += addFrame; + if (mCurrPlayFrame >= mNextReplay.FrameStartID) + { + Changed = mCurrReplay.InPut != mNextReplay.InPut; + mCurrReplay = mNextReplay; + data = mCurrReplay; + UpdateNextFrame(mCurrPlayFrame, out FrameDiff); + } + else + { + data = mCurrReplay; + FrameDiff = MaxInFrame - mCurrPlayFrame; + } + return Changed; + } + void UpdateNextFrame(int targetFrame,out int FrameDiff) + { + FrameDiff = MaxInFrame - targetFrame; + //如果已经超过 + while (targetFrame > mNextReplay.FrameStartID) + { + if (mNextReplay.FrameStartID >= MaxInFrame) + { + //TODO + //bEnd = true; + break; + } + + if (mQueueReplay.Count > 0) + { + mNextReplay = mQueueReplay.Dequeue(); + } + targetFrame++; + } + } + } +} diff --git a/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/NetReplay.cs.meta b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/NetReplay.cs.meta new file mode 100644 index 0000000..d8228d2 --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/NetReplay.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 452b58ff73a0853449845fd9e1134cc2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/ReplayData.cs b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/ReplayData.cs new file mode 100644 index 0000000..ab3dd58 --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/ReplayData.cs @@ -0,0 +1,101 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; + +namespace AxiReplay +{ + [StructLayout(LayoutKind.Explicit,Size = 44)] + public struct ReplayHandler + { + [FieldOffset(0)] + public int Format; + [FieldOffset(sizeof(int) * 1)] + public int RomID; + [FieldOffset(sizeof(int) * 2)] + public int RomType; + [FieldOffset(sizeof(int) * 3)] + public int DataOffset; + [FieldOffset(sizeof(int) * 4)] + public int TitleOffset; + [FieldOffset(sizeof(int) * 5)] + public int NoteOffset; + [FieldOffset(sizeof(int) * 6)] + public int AllFrame; + [FieldOffset(sizeof(int) * 7)] + public int AllTime; + [FieldOffset(sizeof(int) * 8)] + public int SingleLenght; + [FieldOffset(sizeof(int) * 9)] + public long CreateTime; + } + + [StructLayout(LayoutKind.Explicit)] + public struct ReplayStep + { + [FieldOffset(0)] + public UInt64 All64Data; + [FieldOffset(0)] + public Int32 FrameStartID; + [FieldOffset(4)] + public UInt64 InPut; + } + + public static class ReplayData + { + public static int HandlerLenght = sizeof(int) * 9 + sizeof(long); + public enum ReplayFormat : byte + { + None = 0, + FM32IPBYTE, + FM32IP16, + FM32IP32, + FM32IP64, + } + public static void GetStringByteData(string str,out byte[] data,out int lenghtWithEnd,Encoding encoding) + { + data = encoding.GetBytes(str); + lenghtWithEnd = data.Length + 1; + } + + public static byte[] GetHandlerData(ReplayHandler replayhandler) + { + int size = Marshal.SizeOf(typeof(ReplayHandler)); + byte[] arr = new byte[size]; + + IntPtr ptr = Marshal.AllocHGlobal(size); + try + { + Marshal.StructureToPtr(replayhandler, ptr, false); + Marshal.Copy(ptr, arr, 0, size); + } + finally + { + Marshal.FreeHGlobal(ptr); + } + + return arr; + } + + public static ReplayHandler GetReplayHandlerFromData(byte[] data) + { + if (data == null || data.Length < ReplayData.HandlerLenght) + { + throw new ArgumentException("Invalid data length or null data."); + } + + IntPtr ptr = Marshal.AllocHGlobal(ReplayData.HandlerLenght); + try + { + // 将byte数组的内容复制到非托管内存中 + Marshal.Copy(data, 0, ptr, ReplayData.HandlerLenght); + // 从非托管内存将内容转换回ReplayHandler结构体 + return (ReplayHandler)Marshal.PtrToStructure(ptr, typeof(ReplayHandler)); + } + finally + { + // 释放非托管内存 + Marshal.FreeHGlobal(ptr); + } + } + } +} diff --git a/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/ReplayData.cs.meta b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/ReplayData.cs.meta new file mode 100644 index 0000000..6aa2fce --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/ReplayData.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 42df5a138f4f4ae488815f35d8e748da +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/ReplayReader.cs b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/ReplayReader.cs new file mode 100644 index 0000000..28677e4 --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/ReplayReader.cs @@ -0,0 +1,174 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; +using static AxiReplay.ReplayData; + +namespace AxiReplay +{ + public class ReplayReader : IReplayReader + { + public ReplayData.ReplayFormat mFormat { get; private set; } + public Encoding TexEncoding { get; private set; } + ReplayHandler handler; + string mTitle; + string mNote; + int mAllFrame; + int mAllTime; + long mData; + int mSingleInputLenght; + int mSingleDataLenght; + FileStream mStream; + BinaryReader mBinaryReader; + + int mCurrFrame = -1; + byte[] mNextOutbytes; + public ReplayStep currStep; + public ReplayStep nextStep; + bool bEnd; + + List dbgList = new List(); + bool bdbg = false; + string dumpPath; + + public ReplayReader(string path, bool bWithDump = false, string dumppath = null) + { + dbgList.Clear(); + bdbg = bWithDump; + dumpPath = dumppath; + mStream = new FileStream(path, FileMode.Open, FileAccess.Read); + mBinaryReader = new BinaryReader(mStream); + byte[] Outbytes; + Outbytes = mBinaryReader.ReadBytes(ReplayData.HandlerLenght); + handler = ReplayData.GetReplayHandlerFromData(Outbytes); + mFormat = (ReplayFormat)handler.Format; + switch (mFormat) + { + case ReplayData.ReplayFormat.FM32IP64: mSingleInputLenght = sizeof(UInt64); break; + case ReplayData.ReplayFormat.FM32IP32: mSingleInputLenght = sizeof(UInt32); break; + case ReplayData.ReplayFormat.FM32IP16: mSingleInputLenght = sizeof(UInt16); break; + case ReplayData.ReplayFormat.FM32IPBYTE: mSingleInputLenght = sizeof(byte); break; + } + //Frame+Lenght + mSingleDataLenght = (sizeof(UInt32)) + mSingleInputLenght; + nextStep = new ReplayStep(); + nextStep.FrameStartID = -1; + bEnd = false; + + dbgList.Add($"Format => {handler.Format}"); + dbgList.Add($"DataOffset => {handler.DataOffset}"); + dbgList.Add($"CreateTime => {handler.CreateTime}"); + dbgList.Add($"AllFrame => {handler.AllFrame}"); + dbgList.Add($"SingleLenght => {handler.SingleLenght}"); + + + mNextOutbytes = new byte[mSingleDataLenght]; + + if (bWithDump) + { + int TestFrameIdx = -1; + while (!bEnd) + { + UpdateNextFrame(TestFrameIdx++); + } + File.WriteAllLines(dumppath, dbgList); + } + else + { + UpdateNextFrame(0); + } + } + + + void UpdateNextFrame(int targetFrame) + { + //如果已经超过 + while (targetFrame >= nextStep.FrameStartID) + { + if (nextStep.FrameStartID >= handler.AllFrame) + { + bEnd = true; + break; + } + mBinaryReader.Read(mNextOutbytes, 0, mSingleDataLenght); + switch (mFormat) + { + case ReplayFormat.FM32IP64: + { + nextStep.FrameStartID = BitConverter.ToInt32(mNextOutbytes, 0); + nextStep.InPut = BitConverter.ToUInt64(mNextOutbytes, sizeof(UInt32)); + } + break; + case ReplayFormat.FM32IP32: + { + nextStep.All64Data = BitConverter.ToUInt64(mNextOutbytes, 0); + } + break; + case ReplayFormat.FM32IP16: + { + nextStep.All64Data = BitConverter.ToUInt64(mNextOutbytes, 0); + } + break; + case ReplayFormat.FM32IPBYTE: + { + nextStep.All64Data = BitConverter.ToUInt64(mNextOutbytes, 0); + } + break; + } + dbgList.Add($"{nextStep.FrameStartID} | {nextStep.InPut}"); + + targetFrame++; + } + } + + int byFrameIdx = 0; + + /// + /// 往前推进1帧的Input(返回是否变化） + /// + public bool NextFrame(out ReplayStep data) + { + return TakeFrame(1,out data); + } + + /// + /// 往前推进指定帧数量的Input (返回是否变化） + /// + /// + public bool TakeFrame(int addFrame,out ReplayStep data) + { + bool Changed = false; + mCurrFrame += addFrame; + if (mCurrFrame >= nextStep.FrameStartID) + { + Changed = currStep.InPut != nextStep.InPut; + currStep = nextStep; + data = currStep; + UpdateNextFrame(mCurrFrame); + } + else + { + data = currStep; + } + return Changed; + } + + /// + /// 往前推进帧的,指定帧下标 + /// + public bool NextFramebyFrameIdx(int FrameID, out ReplayStep data) + { + bool res = TakeFrame(FrameID - byFrameIdx, out data); + byFrameIdx = FrameID; + return res; + } + + public void Dispose() + { + mStream.Dispose(); + mBinaryReader.Dispose(); + //TODO + } + + } +} diff --git a/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/ReplayReader.cs.meta b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/ReplayReader.cs.meta new file mode 100644 index 0000000..7a9cfa2 --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/ReplayReader.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 66e0e18d1f5981745a3078e8460cb0e6 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/ReplayWriter.cs b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/ReplayWriter.cs new file mode 100644 index 0000000..a4a0f9e --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/ReplayWriter.cs @@ -0,0 +1,156 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; + +namespace AxiReplay +{ + public class ReplayWriter : IReplayWriter + { + public ReplayData.ReplayFormat mFormat { get; private set; } + public Encoding TexEncoding { get; private set; } + ReplayHandler handler; + string mTitle; + string mNote; + int mAllFrame; + int mAllTime; + long mData; + int mSingleInputLenght; + int mSingleDataLenght; + MemoryStream mStream; + BinaryWriter mBinaryWriter; + + int mCurrFrame; + UInt64 mCurrInput; + ReplayStep wirteStep; + + List dbgList = new List(); + + public ReplayWriter(string Title, string Note, ReplayData.ReplayFormat format, Encoding encoding) + { + mTitle = Title; + mNote = Note; + TexEncoding = encoding; + mFormat = format; + switch (mFormat) + { + case ReplayData.ReplayFormat.FM32IP64: mSingleInputLenght = sizeof(UInt64); break; + case ReplayData.ReplayFormat.FM32IP32: mSingleInputLenght = sizeof(UInt32); break; + case ReplayData.ReplayFormat.FM32IP16: mSingleInputLenght = sizeof(UInt16); break; + case ReplayData.ReplayFormat.FM32IPBYTE: mSingleInputLenght = sizeof(byte); break; + } + mSingleDataLenght = (sizeof(UInt32)) + mSingleInputLenght; + + mStream = new MemoryStream(); + mBinaryWriter = new BinaryWriter(mStream); + + mCurrFrame = -1; + mCurrInput = int.MaxValue; + wirteStep = new ReplayStep(); + + dbgList.Clear(); + + } + + int byFrameIdx = 0; + /// + /// 往前推进帧的,指定帧下标 + /// + /// + public void NextFramebyFrameIdx(int FrameID,UInt64 frameInput) + { + TakeFrame(FrameID - byFrameIdx, frameInput); + byFrameIdx = FrameID; + } + + /// + /// 往前推进1帧的Input + /// + /// + public void NextFrame(UInt64 frameInput) + { + TakeFrame(1, frameInput); + } + + /// + /// 往前推进指定帧数量的Input + /// + /// + public void TakeFrame(int addFrame, UInt64 frameInput) + { + if (addFrame < 0) + { + + } + mCurrFrame += addFrame; + if (mCurrInput == frameInput) + return; + mCurrInput = frameInput; + + wirteStep.FrameStartID = mCurrFrame; + wirteStep.InPut = mCurrInput; + dbgList.Add($"{mCurrFrame} | {mCurrInput}"); + + switch (mFormat) + { + case ReplayData.ReplayFormat.FM32IP64: + mBinaryWriter.Write(wirteStep.FrameStartID); + mBinaryWriter.Write(wirteStep.InPut); + break; + case ReplayData.ReplayFormat.FM32IP32: + mBinaryWriter.Write(BitConverter.GetBytes(wirteStep.All64Data), 0, 4 + 4); + break; + case ReplayData.ReplayFormat.FM32IP16: + mBinaryWriter.Write(BitConverter.GetBytes(wirteStep.All64Data), 0, 4 + 2); + break; + case ReplayData.ReplayFormat.FM32IPBYTE: + mBinaryWriter.Write(BitConverter.GetBytes(wirteStep.All64Data), 0, 4 + 1); + break; + } + } + + public void SaveData(string path, bool bWithDump = false, string dumppath = null) + { + ReplayData.GetStringByteData(mTitle, out byte[] titleData, out int titleLenghtWithEnd, TexEncoding); + ReplayData.GetStringByteData(mNote, out byte[] noteData, out int noteLenghtWithEnd, TexEncoding); + + ReplayHandler handler = new ReplayHandler(); + handler.Format = (int)this.mFormat; + handler.DataOffset = ReplayData.HandlerLenght; + handler.CreateTime = DateTimeOffset.UtcNow.ToUnixTimeSeconds(); + handler.AllFrame = wirteStep.FrameStartID; + handler.SingleLenght = mSingleDataLenght; + + using (FileStream fs = new FileStream(path, FileMode.Create)) + { + using (BinaryWriter bw = new BinaryWriter(fs)) + { + //写入Handler + bw.Write(ReplayData.GetHandlerData(handler)); + //写入Data + bw.Write(mStream.ToArray()); + } + } + + if (bWithDump) + { + List temp = new List(); + temp.Add($"Format => {handler.Format}"); + temp.Add($"DataOffset => {handler.DataOffset}"); + temp.Add($"CreateTime => {handler.CreateTime}"); + temp.Add($"AllFrame => {handler.AllFrame}"); + temp.Add($"SingleLenght => {handler.SingleLenght}"); + dbgList.InsertRange(0,temp); + File.WriteAllLines(dumppath, dbgList); + } + } + + public void Dispose() + { + mStream.Dispose(); + mBinaryWriter.Dispose(); + //TODO + } + + } +} diff --git a/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/ReplayWriter.cs.meta b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/ReplayWriter.cs.meta new file mode 100644 index 0000000..51245f7 --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Plugins/AxiReplay/ReplayWriter.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: dc53a3d9a3e1749438b6ad1cef7b39bc +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/AxibugEmuOnline.Client/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.dll.meta b/AxibugEmuOnline.Client/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.dll.meta deleted file mode 100644 index 53590f3..0000000 --- a/AxibugEmuOnline.Client/Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.dll.meta +++ /dev/null @@ -1,22 +0,0 @@ -fileFormatVersion: 2 -guid: 45d5034162d6cf04dbe46da84fc7d074 -PluginImporter: - serializedVersion: 1 - iconMap: {} - executionOrder: {} - isPreloaded: 0 - platformData: - Any: - enabled: 0 - settings: {} - Editor: - enabled: 1 - settings: - DefaultValueInitialized: true - WindowsStoreApps: - enabled: 0 - settings: - CPU: AnyCPU - userData: - assetBundleName: - assetBundleVariant: diff --git a/AxibugEmuOnline.Client/Assets/Plugins/MyNes.Standard2.dll b/AxibugEmuOnline.Client/Assets/Plugins/MyNes.Standard2.dll new file mode 100644 index 0000000..1d06e30 Binary files /dev/null and b/AxibugEmuOnline.Client/Assets/Plugins/MyNes.Standard2.dll differ diff --git a/AxibugEmuOnline.Client/Assets/Plugins/MyNes.Standard2.dll.meta b/AxibugEmuOnline.Client/Assets/Plugins/MyNes.Standard2.dll.meta new file mode 100644 index 0000000..0753ee5 --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Plugins/MyNes.Standard2.dll.meta @@ -0,0 +1,86 @@ +fileFormatVersion: 2 +guid: 1818bd4d6ed568f4f98c1750b011c967 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + : Any + second: + enabled: 0 + settings: + Exclude Android: 0 + Exclude Editor: 0 + Exclude Linux64: 0 + Exclude OSXUniversal: 0 + Exclude Win: 0 + Exclude Win64: 0 + Exclude iOS: 0 + - first: + Android: Android + second: + enabled: 1 + settings: + CPU: ARMv7 + - first: + Any: + second: + enabled: 1 + settings: {} + - first: + Editor: Editor + second: + enabled: 1 + settings: + CPU: AnyCPU + DefaultValueInitialized: true + OS: AnyOS + - first: + Standalone: Linux64 + second: + enabled: 1 + settings: + CPU: None + - first: + Standalone: OSXUniversal + second: + enabled: 1 + settings: + CPU: None + - first: + Standalone: Win + second: + enabled: 1 + settings: + CPU: x86 + - first: + Standalone: Win64 + second: + enabled: 1 + settings: + CPU: x86_64 + - first: + Windows Store Apps: WindowsStoreApps + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + iPhone: iOS + second: + enabled: 1 + settings: + AddToEmbeddedBinaries: false + CPU: AnyCPU + CompileFlags: + FrameworkDependencies: + userData: + assetBundleName: + assetBundleVariant: diff --git a/AxibugEmuOnline.Client/Assets/Resources/BillingMode.json b/AxibugEmuOnline.Client/Assets/Resources/BillingMode.json new file mode 100644 index 0000000..6f4bfb7 --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Resources/BillingMode.json @@ -0,0 +1 @@ +{"androidStore":"GooglePlay"} \ No newline at end of file diff --git a/AxibugEmuOnline.Client/Assets/Resources/BillingMode.json.meta b/AxibugEmuOnline.Client/Assets/Resources/BillingMode.json.meta new file mode 100644 index 0000000..d427ca7 --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Resources/BillingMode.json.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: e4ccda23241d6af42ae6d1dc84bf75cd +TextScriptImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/AxibugEmuOnline.Client/Assets/Resources/Roms.meta b/AxibugEmuOnline.Client/Assets/Resources/Roms.meta new file mode 100644 index 0000000..d77a3a1 --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Resources/Roms.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: d830a09fe661cf84cacc42badaf2b40a +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/AxibugEmuOnline.Client/Assets/Resources/Roms/tstd2.nes.bytes b/AxibugEmuOnline.Client/Assets/Resources/Roms/tstd2.nes.bytes new file mode 100644 index 0000000..f9f8eff Binary files /dev/null and b/AxibugEmuOnline.Client/Assets/Resources/Roms/tstd2.nes.bytes differ diff --git a/AxibugEmuOnline.Client/Assets/Resources/Roms/tstd2.nes.bytes.meta b/AxibugEmuOnline.Client/Assets/Resources/Roms/tstd2.nes.bytes.meta new file mode 100644 index 0000000..63dae0e --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Resources/Roms/tstd2.nes.bytes.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 8699750fbb17aca46835f0748d2344d0 +TextScriptImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/AxibugEmuOnline.Client/Assets/Script/AppAxibugEmuOnline.cs b/AxibugEmuOnline.Client/Assets/Script/AppAxibugEmuOnline.cs index 94a1308..9534791 100644 --- a/AxibugEmuOnline.Client/Assets/Script/AppAxibugEmuOnline.cs +++ b/AxibugEmuOnline.Client/Assets/Script/AppAxibugEmuOnline.cs @@ -9,7 +9,6 @@ namespace AxibugEmuOnline.Client.ClientCore public static class AppAxibugEmuOnline { public static string TokenStr; - public static long RID = -1; public static string IP; public static int Port; public static LogManager log; diff --git a/AxibugEmuOnline.Client/Assets/Script/AxibugEmuOnline.Client.asmdef b/AxibugEmuOnline.Client/Assets/Script/AxibugEmuOnline.Client.asmdef index d86155f..410a9f7 100644 --- a/AxibugEmuOnline.Client/Assets/Script/AxibugEmuOnline.Client.asmdef +++ b/AxibugEmuOnline.Client/Assets/Script/AxibugEmuOnline.Client.asmdef @@ -3,7 +3,8 @@ "rootNamespace": "AxibugEmuOnline.Client", "references": [ "GUID:390a2c4058e5c304a87e8be70c84d80b", - "GUID:085dc26d74e6f994a924d401ea41a5a8" + "GUID:085dc26d74e6f994a924d401ea41a5a8", + "GUID:0a45db2096af23647aaafe5b70ccb4d7" ], "includePlatforms": [], "excludePlatforms": [], diff --git a/AxibugEmuOnline.Client/Assets/Script/Common/Helper.cs b/AxibugEmuOnline.Client/Assets/Script/Common/Helper.cs index f6dfde4..9e9b8d2 100644 --- a/AxibugEmuOnline.Client/Assets/Script/Common/Helper.cs +++ b/AxibugEmuOnline.Client/Assets/Script/Common/Helper.cs @@ -1,4 +1,6 @@ using System; +using System.IO; +using System.IO.Compression; namespace AxibugEmuOnline.Client.Common { @@ -18,5 +20,27 @@ namespace AxibugEmuOnline.Client.Common TimeSpan ts = dt - new DateTime(1970, 1, 1, 0, 0, 0, 0); return Convert.ToInt64(ts.TotalSeconds); } + + public static byte[] CompressByteArray(byte[] bytesToCompress) + { + using (var compressedMemoryStream = new MemoryStream()) + using (var gzipStream = new GZipStream(compressedMemoryStream, CompressionMode.Compress)) + { + gzipStream.Write(bytesToCompress, 0, bytesToCompress.Length); + gzipStream.Close(); + return compressedMemoryStream.ToArray(); + } + } + + public static byte[] DecompressByteArray(byte[] compressedBytes) + { + using (var compressedMemoryStream = new MemoryStream(compressedBytes)) + using (var gzipStream = new GZipStream(compressedMemoryStream, CompressionMode.Decompress)) + using (var resultMemoryStream = new MemoryStream()) + { + gzipStream.CopyTo(resultMemoryStream); + return resultMemoryStream.ToArray(); + } + } } } diff --git a/AxibugEmuOnline.Client/Assets/Script/Event/EEvent.cs b/AxibugEmuOnline.Client/Assets/Script/Event/EEvent.cs index 3896d91..16185db 100644 --- a/AxibugEmuOnline.Client/Assets/Script/Event/EEvent.cs +++ b/AxibugEmuOnline.Client/Assets/Script/Event/EEvent.cs @@ -3,6 +3,39 @@ public enum EEvent { // 添加你自己需要的事件类型 - OnChatMsg + OnChatMsg, + + + OnRoomListAllUpdate,//房间列表全量刷新 + OnRoomListSingleUpdate,//房间列表中单个更新 + + /// + /// 我进入房间 + /// + OnMineJoinRoom, + /// + /// 我离开房间 + /// + OnMineLeavnRoom, + + /// + /// 其他人进入房间 + /// + OnOtherPlayerJoinRoom, + + /// + /// 其他人离开房间 + /// + OnOtherPlayerLeavnRoom, + + /// + /// 服务器等待Step更新 + /// + OnRoomWaitStepChange, + + /// + /// 要求加载即时存档 + /// + OnRoomNeedLoadRawData, } } diff --git a/AxibugEmuOnline.Client/Assets/Script/Manager/AppNetGame.cs b/AxibugEmuOnline.Client/Assets/Script/Manager/AppNetGame.cs index a576bc8..5824079 100644 --- a/AxibugEmuOnline.Client/Assets/Script/Manager/AppNetGame.cs +++ b/AxibugEmuOnline.Client/Assets/Script/Manager/AppNetGame.cs @@ -3,8 +3,6 @@ using AxibugEmuOnline.Client.Common; using AxibugEmuOnline.Client.Network; using AxibugProtobuf; using Google.Protobuf; -using System.IO; -using System.IO.Compression; using System.Linq; namespace AxibugEmuOnline.Client.Manager @@ -23,7 +21,7 @@ namespace AxibugEmuOnline.Client.Manager public void SendScreen(byte[] RenderBuffer) { - byte[] comData = CompressByteArray(RenderBuffer); + byte[] comData = Helper.CompressByteArray(RenderBuffer); _Protobuf_Screnn_Frame.FrameID = 0; _Protobuf_Screnn_Frame.RawBitmap = ByteString.CopyFrom(comData); AppAxibugEmuOnline.networkHelper.SendToServer((int)CommandID.CmdScreen, ProtoBufHelper.Serizlize(_Protobuf_Screnn_Frame)); @@ -34,7 +32,7 @@ namespace AxibugEmuOnline.Client.Manager Protobuf_Screnn_Frame msg = ProtoBufHelper.DeSerizlize(reqData); lock (_renderbuffer) { - byte[] data = DecompressByteArray(msg.RawBitmap.ToArray()); + byte[] data = Helper.DecompressByteArray(msg.RawBitmap.ToArray()); for (int i = 0; i < data.Length; i++) { _renderbuffer[i] = _palette[data[i]]; @@ -42,26 +40,6 @@ namespace AxibugEmuOnline.Client.Manager } } - public static byte[] CompressByteArray(byte[] bytesToCompress) - { - using (var compressedMemoryStream = new MemoryStream()) - using (var gzipStream = new GZipStream(compressedMemoryStream, CompressionMode.Compress)) - { - gzipStream.Write(bytesToCompress, 0, bytesToCompress.Length); - gzipStream.Close(); - return compressedMemoryStream.ToArray(); - } - } - - public static byte[] DecompressByteArray(byte[] compressedBytes) - { - using (var compressedMemoryStream = new MemoryStream(compressedBytes)) - using (var gzipStream = new GZipStream(compressedMemoryStream, CompressionMode.Decompress)) - using (var resultMemoryStream = new MemoryStream()) - { - gzipStream.CopyTo(resultMemoryStream); - return resultMemoryStream.ToArray(); - } - } + } } diff --git a/AxibugEmuOnline.Client/Assets/Script/Manager/AppRoom.cs b/AxibugEmuOnline.Client/Assets/Script/Manager/AppRoom.cs new file mode 100644 index 0000000..5610c67 --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Script/Manager/AppRoom.cs @@ -0,0 +1,326 @@ +using AxibugEmuOnline.Client.ClientCore; +using AxibugEmuOnline.Client.Common; +using AxibugEmuOnline.Client.Event; +using AxibugEmuOnline.Client.Network; +using AxibugProtobuf; +using AxiReplay; +using Google.Protobuf; +using System.Collections.Generic; +using UnityEngine; + +namespace AxibugEmuOnline.Client.Manager +{ + public class AppRoom + { + public Protobuf_Room_MiniInfo mineRoomMiniInfo { get; private set; } = null; + public bool InRoom => mineRoomMiniInfo != null; + public bool IsHost => mineRoomMiniInfo?.HostPlayerUID == AppAxibugEmuOnline.user.userdata.UID; + public RoomGameState RoomState => mineRoomMiniInfo.GameState; + public int MinePlayerIdx => GetMinePlayerIndex(); + public int WaitStep { get; private set; } = -1; + public byte[] RawData { get; private set; } = null; + public NetReplay netReplay { get; private set; } + + + Dictionary dictRoomListID2Info = new Dictionary(); + static Protobuf_Room_List _Protobuf_Room_List = new Protobuf_Room_List(); + static Protobuf_Room_Create _Protobuf_Room_Create = new Protobuf_Room_Create(); + static Protobuf_Room_Join _Protobuf_Room_Join = new Protobuf_Room_Join(); + static Protobuf_Room_Leave _Protobuf_Room_Leave = new Protobuf_Room_Leave(); + static Protobuf_Room_Player_Ready _Protobuf_Room_Player_Ready = new Protobuf_Room_Player_Ready(); + static Protobuf_Room_SinglePlayerInputData _Protobuf_Room_SinglePlayerInputData = new Protobuf_Room_SinglePlayerInputData(); + public AppRoom() + { + NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdRoomList, RecvGetRoomList); + NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdRoomListUpdate, RecvGetRoomListUpdate); + NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdRoomCreate, RecvCreateRoom); + NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdRoomJoin, RecvJoinRoom); + NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdRoomLeave, RecvLeavnRoom); + NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdRoomMyRoomStateChanged, RecvRoomMyRoomStateChange); + NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdRoomWaitStep, RecvRoom_WaitStep); + NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdRoomHostPlayerUpdateStateRaw, RecvHostPlayer_UpdateStateRaw); + NetMsg.Instance.RegNetMsgEvent((int)CommandID.CmdRoomSynPlayerInput, RecvHostSyn_RoomFrameAllInputData); + } + + #region 房间列表管理 + void AddOrUpdateRoomList(Protobuf_Room_MiniInfo roomInfo) + { + dictRoomListID2Info[roomInfo.RoomID] = roomInfo; + } + bool RemoveRoomList(int roomId) + { + if (dictRoomListID2Info.ContainsKey(roomId)) + { + dictRoomListID2Info.Remove(roomId); + return true; + } + return false; + } + /// + /// 获取单个房间MiniInfo + /// + /// + /// + /// + public bool GetRoomListMiniInfo(int roomId, out Protobuf_Room_MiniInfo MiniInfo) + { + if (dictRoomListID2Info.ContainsKey(roomId)) + { + MiniInfo = dictRoomListID2Info[roomId]; + return true; + } + MiniInfo = null; + return false; + } + public List GetRoomList() + { + List result = new List(); + foreach (var item in dictRoomListID2Info) + { + result.Add(new Protobuf_Room_MiniInfo()); + } + return result; + } + #endregion + + #region Replay + public void InitRePlay() + { + netReplay = new NetReplay(); + } + public void ReleaseRePlay() + { + + } + #endregion + + #region 房间管理 + int GetMinePlayerIndex() + { + if (mineRoomMiniInfo == null) + return -1; + + if (mineRoomMiniInfo.Player1UID == AppAxibugEmuOnline.user.userdata.UID) + return 0; + if (mineRoomMiniInfo.Player2UID == AppAxibugEmuOnline.user.userdata.UID) + return 1; + return -1; + } + + long[] GetRoom4Player() + { + if (mineRoomMiniInfo == null) + return null; + long[] result = new long[4]; + + if (mineRoomMiniInfo.Player1UID > 0) + result[0] = mineRoomMiniInfo.Player1UID; + if (mineRoomMiniInfo.Player2UID == AppAxibugEmuOnline.user.userdata.UID) + result[1] = mineRoomMiniInfo.Player2UID; + + return result; + } + + #endregion + + /// + /// 获取所有房间列表 + /// + /// + public void SendGetRoomList() + { + AppAxibugEmuOnline.log.Info("拉取房间列表"); + AppAxibugEmuOnline.networkHelper.SendToServer((int)CommandID.CmdRoomList, ProtoBufHelper.Serizlize(_Protobuf_Room_List)); + } + + /// + /// 获取所有房间列表 + /// + /// + void RecvGetRoomList(byte[] reqData) + { + AppAxibugEmuOnline.log.Info("取得完整房间列表"); + Protobuf_Room_List_RESP msg = ProtoBufHelper.DeSerizlize(reqData); + for (int i = 0; i < msg.RoomMiniInfoList.Count; i++) + AddOrUpdateRoomList(msg.RoomMiniInfoList[i]); + EventSystem.Instance.PostEvent(EEvent.OnRoomListAllUpdate); + } + + /// + /// 获取单个列表更新 + /// + /// + void RecvGetRoomListUpdate(byte[] reqData) + { + AppAxibugEmuOnline.log.Debug("单个房间状态更新"); + Protobuf_Room_Update_RESP msg = ProtoBufHelper.DeSerizlize(reqData); + AddOrUpdateRoomList(msg.RoomMiniInfo); + EventSystem.Instance.PostEvent(EEvent.OnRoomListSingleUpdate, msg.RoomMiniInfo.GameRomID); + } + + /// + /// 创建房间 + /// + /// + /// + /// + public void SendCreateRoom(int GameRomID, int JoinPlayerIdx, string GameRomHash = null) + { + _Protobuf_Room_Create.JoinPlayerIdx = JoinPlayerIdx; + _Protobuf_Room_Create.GameRomID = GameRomID; + _Protobuf_Room_Create.GameRomHash = GameRomHash; + AppAxibugEmuOnline.log.Info($"创建房间"); + AppAxibugEmuOnline.networkHelper.SendToServer((int)CommandID.CmdRoomCreate, ProtoBufHelper.Serizlize(_Protobuf_Room_Create)); + } + + /// + /// 创建房间成功 + /// + /// + void RecvCreateRoom(byte[] reqData) + { + AppAxibugEmuOnline.log.Debug("创建房间成功"); + Protobuf_Room_Create_RESP msg = ProtoBufHelper.DeSerizlize(reqData); + mineRoomMiniInfo = msg.RoomMiniInfo; + } + + /// + /// 创建房间 + /// + /// + /// + /// + public void SendJoinRoom(int RoomID, int JoinPlayerIdx) + { + _Protobuf_Room_Join.RoomID = RoomID; + _Protobuf_Room_Join.PlayerNum = JoinPlayerIdx; + AppAxibugEmuOnline.log.Info($"创建房间"); + AppAxibugEmuOnline.networkHelper.SendToServer((int)CommandID.CmdRoomJoin, ProtoBufHelper.Serizlize(_Protobuf_Room_Join)); + } + + /// + /// 加入房间成功 + /// + /// + void RecvJoinRoom(byte[] reqData) + { + AppAxibugEmuOnline.log.Debug("加入房间成功"); + Protobuf_Room_Join_RESP msg = ProtoBufHelper.DeSerizlize(reqData); + mineRoomMiniInfo = msg.RoomMiniInfo; + InitRePlay(); + EventSystem.Instance.PostEvent(EEvent.OnMineJoinRoom); + } + + /// + /// 离开房间 + /// + /// + public void SendLeavnRoom(int RoomID) + { + _Protobuf_Room_Leave.RoomID = RoomID; + AppAxibugEmuOnline.log.Info($"创建房间"); + AppAxibugEmuOnline.networkHelper.SendToServer((int)CommandID.CmdRoomLeave, ProtoBufHelper.Serizlize(_Protobuf_Room_Leave)); + } + + /// + /// 离开房间成功 + /// + /// + void RecvLeavnRoom(byte[] reqData) + { + AppAxibugEmuOnline.log.Debug("加入房间成功"); + Protobuf_Room_Leave_RESP msg = ProtoBufHelper.DeSerizlize(reqData); + ReleaseRePlay(); + mineRoomMiniInfo = null; + EventSystem.Instance.PostEvent(EEvent.OnMineLeavnRoom); + } + + void RecvRoomMyRoomStateChange(byte[] reqData) + { + Protobuf_Room_MyRoom_State_Change msg = ProtoBufHelper.DeSerizlize(reqData); + long[] oldRoomPlayer = GetRoom4Player(); + mineRoomMiniInfo = msg.RoomMiniInfo; + long[] newRoomPlayer = GetRoom4Player(); + for (int i = 0; i < 4; i++) + { + long OldPlayer = oldRoomPlayer[i]; + long NewPlayer = newRoomPlayer[i]; + if (OldPlayer == NewPlayer) + continue; + //位置之前有人，但是离开了 + if (OldPlayer > 0) + { + EventSystem.Instance.PostEvent(EEvent.OnOtherPlayerLeavnRoom, i, OldPlayer); + if (NewPlayer > 0)//而且害换了一个玩家 + EventSystem.Instance.PostEvent(EEvent.OnOtherPlayerJoinRoom, i, NewPlayer); + } + else //之前没人 + EventSystem.Instance.PostEvent(EEvent.OnOtherPlayerJoinRoom, i, NewPlayer); + } + } + + /// + /// 上报即时存档 + /// + /// + public void SendLeavnRoom(byte[] RawData) + { + //压缩 + byte[] compressRawData = Helper.CompressByteArray(RawData); + Protobuf_Room_HostPlayer_UpdateStateRaw msg = new Protobuf_Room_HostPlayer_UpdateStateRaw() + { + LoadStateRaw = Google.Protobuf.ByteString.CopyFrom(compressRawData) + }; + AppAxibugEmuOnline.log.Info($"上报即时存档数据 原数据大小:{RawData.Length},压缩后;{compressRawData.Length}"); + AppAxibugEmuOnline.networkHelper.SendToServer((int)CommandID.CmdRoomHostPlayerUpdateStateRaw, ProtoBufHelper.Serizlize(msg)); + } + + void RecvRoom_WaitStep(byte[] reqData) + { + Protobuf_Room_WaitStep_RESP msg = ProtoBufHelper.DeSerizlize(reqData); + if (WaitStep != msg.WaitStep) + { + WaitStep = msg.WaitStep; + EventSystem.Instance.PostEvent(EEvent.OnRoomWaitStepChange, WaitStep); + if (WaitStep == 1) + { + byte[] decompressRawData = Helper.DecompressByteArray(msg.LoadStateRaw.ToByteArray()); + AppAxibugEmuOnline.log.Info($"收到即时存档数据 解压后;{decompressRawData.Length}"); + RawData = decompressRawData; + } + } + } + + void RecvHostPlayer_UpdateStateRaw(byte[] reqData) + { + Protobuf_Room_HostPlayer_UpdateStateRaw_RESP msg = ProtoBufHelper.DeSerizlize(reqData); + AppAxibugEmuOnline.log.Info($"鸡翅孙当上报成功"); + } + + /// + /// 即时存档加载完毕 + /// + public void SendRoomPlayerReady() + { + AppAxibugEmuOnline.log.Debug("上报准备完毕"); + AppAxibugEmuOnline.networkHelper.SendToServer((int)CommandID.CmdRoomPlayerReady, ProtoBufHelper.Serizlize(_Protobuf_Room_Player_Ready)); + } + + /// + /// 同步上行 + /// + public void SendRoomSingelPlayerInput(uint FrameID,uint InputData) + { + _Protobuf_Room_SinglePlayerInputData.FrameID = FrameID; + _Protobuf_Room_SinglePlayerInputData.InputData = InputData; + AppAxibugEmuOnline.networkHelper.SendToServer((int)CommandID.CmdRoomSingelPlayerInput, ProtoBufHelper.Serizlize(_Protobuf_Room_SinglePlayerInputData)); + } + + + void RecvHostSyn_RoomFrameAllInputData(byte[] reqData) + { + Protobuf_Room_Syn_RoomFrameAllInputData msg = ProtoBufHelper.DeSerizlize(reqData); + netReplay.InData(new ReplayStep() { FrameStartID = (int)msg.FrameID, InPut = msg.InputData }); + } + } +} \ No newline at end of file diff --git a/AxibugEmuOnline.Client/Assets/Script/Manager/AppRoom.cs.meta b/AxibugEmuOnline.Client/Assets/Script/Manager/AppRoom.cs.meta new file mode 100644 index 0000000..09c0f66 --- /dev/null +++ b/AxibugEmuOnline.Client/Assets/Script/Manager/AppRoom.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 32566452eb52f484d92619b539b1d70f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/AxibugEmuOnline.Client/Assets/Script/Protobuf/ProtobufAxibugEmuOnline.cs b/AxibugEmuOnline.Client/Assets/Script/Protobuf/ProtobufAxibugEmuOnline.cs index b23e13b..777de64 100644 --- a/AxibugEmuOnline.Client/Assets/Script/Protobuf/ProtobufAxibugEmuOnline.cs +++ b/AxibugEmuOnline.Client/Assets/Script/Protobuf/ProtobufAxibugEmuOnline.cs @@ -27,30 +27,94 @@ namespace AxibugProtobuf { "Ch5wcm90b2J1Zl9BeGlidWdFbXVPbmxpbmUucHJvdG8SDkF4aWJ1Z1Byb3Rv", "YnVmIiMKEFByb3RvYnVmX0NoYXRNc2cSDwoHQ2hhdE1zZxgBIAEoCSJIChVQ", "cm90b2J1Zl9DaGF0TXNnX1JFU1ASEAoITmlja05hbWUYASABKAkSDwoHQ2hh", - "dE1zZxgCIAEoCRIMCgREYXRlGAMgASgDIpEBCg5Qcm90b2J1Zl9Mb2dpbhIs", - "Cglsb2dpblR5cGUYASABKA4yGS5BeGlidWdQcm90b2J1Zi5Mb2dpblR5cGUS", - "LgoKZGV2aWNlVHlwZRgCIAEoDjIaLkF4aWJ1Z1Byb3RvYnVmLkRldmljZVR5", - "cGUSDwoHQWNjb3VudBgDIAEoCRIQCghQYXNzd29yZBgEIAEoCSKMAQoTUHJv", - "dG9idWZfTG9naW5fUkVTUBINCgVUb2tlbhgBIAEoCRIVCg1MYXN0TG9naW5E", - "YXRlGAIgASgJEg8KB1JlZ0RhdGUYAyABKAkSMQoGU3RhdHVzGAQgASgOMiEu", - "QXhpYnVnUHJvdG9idWYuTG9naW5SZXN1bHRTdGF0dXMSCwoDVUlEGAUgASgD", - "IjsKFVByb3RvYnVmX1NjcmVubl9GcmFtZRIPCgdGcmFtZUlEGAEgASgFEhEK", - "CVJhd0JpdG1hcBgCIAEoDCpOCglDb21tYW5kSUQSDgoKQ01EX0RFRkFVTBAA", - "Eg4KCUNNRF9MT0dJThDRDxIQCgtDTURfQ0hBVE1TRxChHxIPCgpDTURfU2Ny", - "ZWVuEIknKisKCUVycm9yQ29kZRIQCgxFUlJPUl9ERUZBVUwQABIMCghFUlJP", - "Ul9PSxABKhwKCUxvZ2luVHlwZRIPCgtCYXNlRGVmYXVsdBAAKksKCkRldmlj", - "ZVR5cGUSFgoSRGV2aWNlVHlwZV9EZWZhdWx0EAASBgoCUEMQARILCgdBbmRy", - "b2lkEAISBwoDSU9TEAMSBwoDUFNWEAQqTgoRTG9naW5SZXN1bHRTdGF0dXMS", - "IQodTG9naW5SZXN1bHRTdGF0dXNfQmFzZURlZmF1bHQQABIGCgJPSxABEg4K", - "CkFjY291bnRFcnIQAkICSAFiBnByb3RvMw==")); + "dE1zZxgCIAEoCRIMCgREYXRlGAMgASgDIh0KDVByb3RvYnVmX1BpbmcSDAoE", + "U2VlZBgBIAEoBSIdCg1Qcm90b2J1Zl9Qb25nEgwKBFNlZWQYASABKAUikQEK", + "DlByb3RvYnVmX0xvZ2luEiwKCWxvZ2luVHlwZRgBIAEoDjIZLkF4aWJ1Z1By", + "b3RvYnVmLkxvZ2luVHlwZRIuCgpkZXZpY2VUeXBlGAIgASgOMhouQXhpYnVn", + "UHJvdG9idWYuRGV2aWNlVHlwZRIPCgdBY2NvdW50GAMgASgJEhAKCFBhc3N3", + "b3JkGAQgASgJIqABChNQcm90b2J1Zl9Mb2dpbl9SRVNQEhIKCkRldmljZVVV", + "SUQYASABKAkSDQoFVG9rZW4YAiABKAkSFQoNTGFzdExvZ2luRGF0ZRgDIAEo", + "CRIPCgdSZWdEYXRlGAQgASgJEjEKBlN0YXR1cxgFIAEoDjIhLkF4aWJ1Z1By", + "b3RvYnVmLkxvZ2luUmVzdWx0U3RhdHVzEgsKA1VJRBgGIAEoAyIUChJQcm90", + "b2J1Zl9Sb29tX0xpc3QiWwoXUHJvdG9idWZfUm9vbV9MaXN0X1JFU1ASQAoQ", + "Um9vbU1pbmlJbmZvTGlzdBgBIAMoCzImLkF4aWJ1Z1Byb3RvYnVmLlByb3Rv", + "YnVmX1Jvb21fTWluaUluZm8ijQIKFlByb3RvYnVmX1Jvb21fTWluaUluZm8S", + "DgoGUm9vbUlEGAEgASgFEhEKCUdhbWVSb21JRBgCIAEoBRITCgtHYW1lUm9t", + "SGFzaBgDIAEoCRIwCglHYW1lU3RhdGUYBSABKA4yHS5BeGlidWdQcm90b2J1", + "Zi5Sb29tR2FtZVN0YXRlEhUKDUhvc3RQbGF5ZXJVSUQYBiABKAUSFAoMT2Jz", + "VXNlckNvdW50GAcgASgFEhMKC1BsYXllcjFfVUlEGAggASgDEhgKEFBsYXll", + "cjFfTmlja05hbWUYCSABKAkSEwoLUGxheWVyMl9VSUQYCiABKAMSGAoQUGxh", + "eWVyMl9OaWNrTmFtZRgLIAEoCSJtChlQcm90b2J1Zl9Sb29tX1VwZGF0ZV9S", + "RVNQEhIKClVwZGF0ZVR5cGUYASABKAUSPAoMUm9vbU1pbmlJbmZvGAIgASgL", + "MiYuQXhpYnVnUHJvdG9idWYuUHJvdG9idWZfUm9vbV9NaW5pSW5mbyJLChVQ", + "cm90b2J1Zl9TY3Jlbm5fRnJhbWUSDgoGUm9vbUlEGAEgASgFEg8KB0ZyYW1l", + "SUQYAiABKAUSEQoJUmF3Qml0bWFwGAMgASgMIkkKI1Byb3RvYnVmX1Jvb21f", + "U2luZ2xlUGxheWVySW5wdXREYXRhEg8KB0ZyYW1lSUQYASABKA0SEQoJSW5w", + "dXREYXRhGAIgASgNIk0KJ1Byb3RvYnVmX1Jvb21fU3luX1Jvb21GcmFtZUFs", + "bElucHV0RGF0YRIPCgdGcmFtZUlEGAEgASgNEhEKCUlucHV0RGF0YRgCIAEo", + "BCJVChRQcm90b2J1Zl9Sb29tX0NyZWF0ZRIRCglHYW1lUm9tSUQYASABKAUS", + "EwoLR2FtZVJvbUhhc2gYAiABKAkSFQoNSm9pblBsYXllcklkeBgDIAEoBSJZ", + "ChlQcm90b2J1Zl9Sb29tX0NyZWF0ZV9SRVNQEjwKDFJvb21NaW5pSW5mbxgB", + "IAEoCzImLkF4aWJ1Z1Byb3RvYnVmLlByb3RvYnVmX1Jvb21fTWluaUluZm8i", + "NwoSUHJvdG9idWZfUm9vbV9Kb2luEg4KBlJvb21JRBgBIAEoBRIRCglQbGF5", + "ZXJOdW0YAiABKAUiVwoXUHJvdG9idWZfUm9vbV9Kb2luX1JFU1ASPAoMUm9v", + "bU1pbmlJbmZvGAEgASgLMiYuQXhpYnVnUHJvdG9idWYuUHJvdG9idWZfUm9v", + "bV9NaW5pSW5mbyIlChNQcm90b2J1Zl9Sb29tX0xlYXZlEg4KBlJvb21JRBgB", + "IAEoBSIqChhQcm90b2J1Zl9Sb29tX0xlYXZlX1JFU1ASDgoGUm9vbUlEGAEg", + "ASgFImEKIVByb3RvYnVmX1Jvb21fTXlSb29tX1N0YXRlX0NoYW5nZRI8CgxS", + "b29tTWluaUluZm8YASABKAsyJi5BeGlidWdQcm90b2J1Zi5Qcm90b2J1Zl9S", + "b29tX01pbmlJbmZvIkUKG1Byb3RvYnVmX1Jvb21fV2FpdFN0ZXBfUkVTUBIQ", + "CghXYWl0U3RlcBgBIAEoBRIUCgxMb2FkU3RhdGVSYXcYAiABKAwiPwonUHJv", + "dG9idWZfUm9vbV9Ib3N0UGxheWVyX1VwZGF0ZVN0YXRlUmF3EhQKDExvYWRT", + "dGF0ZVJhdxgBIAEoDCIuCixQcm90b2J1Zl9Sb29tX0hvc3RQbGF5ZXJfVXBk", + "YXRlU3RhdGVSYXdfUkVTUCIcChpQcm90b2J1Zl9Sb29tX1BsYXllcl9SZWFk", + "eSqaAwoJQ29tbWFuZElEEg4KCkNNRF9ERUZBVUwQABIMCghDTURfUElORxAB", + "EgwKCENNRF9QT05HEAISDgoJQ01EX0xPR0lOENEPEhAKC0NNRF9DSEFUTVNH", + "EKEfEhIKDUNNRF9Sb29tX0xpc3QQiScSGQoUQ01EX1Jvb21fTGlzdF9VcGRh", + "dGUQiicSFAoPQ01EX1Jvb21fQ3JlYXRlEO0nEhIKDUNNRF9Sb29tX0pvaW4Q", + "8ScSEwoOQ01EX1Jvb21fTGVhdmUQ8icSIgodQ01EX1Jvb21fTXlSb29tX1N0", + "YXRlX0NoYW5nZWQQ9icSFgoRQ01EX1Jvb21fV2FpdFN0ZXAQ0SgSJwoiQ01E", + "X1Jvb21fSG9zdFBsYXllcl9VcGRhdGVTdGF0ZVJhdxDUKBIaChVDTURfUm9v", + "bV9QbGF5ZXJfUmVhZHkQ2CgSIAobQ01EX1Jvb21fU2luZ2VsX1BsYXllcklu", + "cHV0EPouEh0KGENNRF9ST09NX1NZTl9QbGF5ZXJJbnB1dBD/LhIPCgpDTURf", + "U2NyZWVuENk2Ko8BCglFcnJvckNvZGUSEAoMRVJST1JfREVGQVVMEAASDAoI", + "RVJST1JfT0sQARIYChRFUlJPUl9ST09NX05PVF9GT1VORBAKEiUKIUVSUk9S", + "X1JPT01fU0xPVF9SRUFETFlfSEFEX1BMQVlFUhALEiEKHUVSUk9SX1JPT01f", + "Q0FOVF9ET19DVVJSX1NUQVRFEDIqHAoJTG9naW5UeXBlEg8KC0Jhc2VEZWZh", + "dWx0EAAqSwoKRGV2aWNlVHlwZRIWChJEZXZpY2VUeXBlX0RlZmF1bHQQABIG", + "CgJQQxABEgsKB0FuZHJvaWQQAhIHCgNJT1MQAxIHCgNQU1YQBCpwCg1Sb29t", + "R2FtZVN0YXRlEhIKDk5vbmVfR2FtZVN0YXRlEAASDAoIT25seUhvc3QQARIR", + "Cg1XYWl0UmF3VXBkYXRlEAISDQoJV2FpdFJlYWR5EAMSCQoFUGF1c2UQBBIQ", + "CgxJbk9ubGluZUdhbWUQBSpOChFMb2dpblJlc3VsdFN0YXR1cxIhCh1Mb2dp", + "blJlc3VsdFN0YXR1c19CYXNlRGVmYXVsdBAAEgYKAk9LEAESDgoKQWNjb3Vu", + "dEVychACQgJIAWIGcHJvdG8z")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { }, - new pbr::GeneratedClrTypeInfo(new[] {typeof(global::AxibugProtobuf.CommandID), typeof(global::AxibugProtobuf.ErrorCode), typeof(global::AxibugProtobuf.LoginType), typeof(global::AxibugProtobuf.DeviceType), typeof(global::AxibugProtobuf.LoginResultStatus), }, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(new[] {typeof(global::AxibugProtobuf.CommandID), typeof(global::AxibugProtobuf.ErrorCode), typeof(global::AxibugProtobuf.LoginType), typeof(global::AxibugProtobuf.DeviceType), typeof(global::AxibugProtobuf.RoomGameState), typeof(global::AxibugProtobuf.LoginResultStatus), }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_ChatMsg), global::AxibugProtobuf.Protobuf_ChatMsg.Parser, new[]{ "ChatMsg" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_ChatMsg_RESP), global::AxibugProtobuf.Protobuf_ChatMsg_RESP.Parser, new[]{ "NickName", "ChatMsg", "Date" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Ping), global::AxibugProtobuf.Protobuf_Ping.Parser, new[]{ "Seed" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Pong), global::AxibugProtobuf.Protobuf_Pong.Parser, new[]{ "Seed" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Login), global::AxibugProtobuf.Protobuf_Login.Parser, new[]{ "LoginType", "DeviceType", "Account", "Password" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Login_RESP), global::AxibugProtobuf.Protobuf_Login_RESP.Parser, new[]{ "Token", "LastLoginDate", "RegDate", "Status", "UID" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Screnn_Frame), global::AxibugProtobuf.Protobuf_Screnn_Frame.Parser, new[]{ "FrameID", "RawBitmap" }, null, null, null, null) + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Login_RESP), global::AxibugProtobuf.Protobuf_Login_RESP.Parser, new[]{ "DeviceUUID", "Token", "LastLoginDate", "RegDate", "Status", "UID" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Room_List), global::AxibugProtobuf.Protobuf_Room_List.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Room_List_RESP), global::AxibugProtobuf.Protobuf_Room_List_RESP.Parser, new[]{ "RoomMiniInfoList" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Room_MiniInfo), global::AxibugProtobuf.Protobuf_Room_MiniInfo.Parser, new[]{ "RoomID", "GameRomID", "GameRomHash", "GameState", "HostPlayerUID", "ObsUserCount", "Player1UID", "Player1NickName", "Player2UID", "Player2NickName" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Room_Update_RESP), global::AxibugProtobuf.Protobuf_Room_Update_RESP.Parser, new[]{ "UpdateType", "RoomMiniInfo" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Screnn_Frame), global::AxibugProtobuf.Protobuf_Screnn_Frame.Parser, new[]{ "RoomID", "FrameID", "RawBitmap" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Room_SinglePlayerInputData), global::AxibugProtobuf.Protobuf_Room_SinglePlayerInputData.Parser, new[]{ "FrameID", "InputData" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Room_Syn_RoomFrameAllInputData), global::AxibugProtobuf.Protobuf_Room_Syn_RoomFrameAllInputData.Parser, new[]{ "FrameID", "InputData" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Room_Create), global::AxibugProtobuf.Protobuf_Room_Create.Parser, new[]{ "GameRomID", "GameRomHash", "JoinPlayerIdx" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Room_Create_RESP), global::AxibugProtobuf.Protobuf_Room_Create_RESP.Parser, new[]{ "RoomMiniInfo" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Room_Join), global::AxibugProtobuf.Protobuf_Room_Join.Parser, new[]{ "RoomID", "PlayerNum" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Room_Join_RESP), global::AxibugProtobuf.Protobuf_Room_Join_RESP.Parser, new[]{ "RoomMiniInfo" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Room_Leave), global::AxibugProtobuf.Protobuf_Room_Leave.Parser, new[]{ "RoomID" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Room_Leave_RESP), global::AxibugProtobuf.Protobuf_Room_Leave_RESP.Parser, new[]{ "RoomID" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Room_MyRoom_State_Change), global::AxibugProtobuf.Protobuf_Room_MyRoom_State_Change.Parser, new[]{ "RoomMiniInfo" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Room_WaitStep_RESP), global::AxibugProtobuf.Protobuf_Room_WaitStep_RESP.Parser, new[]{ "WaitStep", "LoadStateRaw" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Room_HostPlayer_UpdateStateRaw), global::AxibugProtobuf.Protobuf_Room_HostPlayer_UpdateStateRaw.Parser, new[]{ "LoadStateRaw" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Room_HostPlayer_UpdateStateRaw_RESP), global::AxibugProtobuf.Protobuf_Room_HostPlayer_UpdateStateRaw_RESP.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::AxibugProtobuf.Protobuf_Room_Player_Ready), global::AxibugProtobuf.Protobuf_Room_Player_Ready.Parser, null, null, null, null, null) })); } #endregion @@ -63,17 +127,87 @@ namespace AxibugProtobuf { /// [pbr::OriginalName("CMD_DEFAUL")] CmdDefaul = 0, /// + ///服务器或客户端，均可主动ping请求，对方响应。（这里测全流程延迟，即序 列化->发送->传输过程->接收->反序列化） + /// + [pbr::OriginalName("CMD_PING")] CmdPing = 1, + /// + ///Pong | 响应 对应 Protobuf_Pong + /// + [pbr::OriginalName("CMD_PONG")] CmdPong = 2, + /// ///自动登录上行 | 下行 对应 Protobuf_Login | Protobuf_Login_RESP /// [pbr::OriginalName("CMD_LOGIN")] CmdLogin = 2001, /// - ///广播信息上行 | 下行 对应 Protobuf_ChatMsg | Protobuf_ChatMsg_RESP + ///广播聊天信息上行 | 下行 对应 Protobuf_ChatMsg | Protobuf_ChatMsg_RESP /// [pbr::OriginalName("CMD_CHATMSG")] CmdChatmsg = 4001, /// - ///画面同步 | 同步广播 对应 Protobuf_Screnn_Frame + ///房间列表相关（仅用于列表显示） /// - [pbr::OriginalName("CMD_Screen")] CmdScreen = 5001, + [pbr::OriginalName("CMD_Room_List")] CmdRoomList = 5001, + /// + ///房间单个房间信息更新 对应 Protobuf_Room_Update_RESP + /// + [pbr::OriginalName("CMD_Room_List_Update")] CmdRoomListUpdate = 5002, + /// + ///房间内相关 + /// + [pbr::OriginalName("CMD_Room_Create")] CmdRoomCreate = 5101, + /// + ///房间加入 对应 Protobuf_Room_Join | Protobuf_Room_Join_RESP //建议Join之前按照房间信息，提前下载并读取本地Rom + /// + [pbr::OriginalName("CMD_Room_Join")] CmdRoomJoin = 5105, + /// + ///房间离开 对应 Protobuf_Room_Leave | Protobuf_Room_Leave_RESP + /// + [pbr::OriginalName("CMD_Room_Leave")] CmdRoomLeave = 5106, + /// + ///我所在的房间内状态发生变化 对应 Protobuf_Room_MyRoom_State_Change + /// + [pbr::OriginalName("CMD_Room_MyRoom_State_Changed")] CmdRoomMyRoomStateChanged = 5110, + /// + ///准备和开始流程（5201 ~ 5204 ~ 5208） + /// + /// 我们采用，玩家可以随时进入的方式开发 + /// + /// 设计流程： + /// + /// Step0：服务器广播"等待-主机上报即使存档" CMD_Room_WaitStep WaitStep=[0] ---> 客户端：暂停模拟器核心：全员等待（主机玩家一人上传即时存档) + /// 主机玩家 上行 CMD_Room_HostPlayer_UpdateStateRaw消息，上传即时存档 + /// 主机玩家上传完毕之后，服务器会通知进入Step1 + /// + /// Step1：服务器广播"等待-全员加载即时存档" CMD_Room_WaitStep WaitStep=[1] 附带即时存档 ---> 客户端：全员等待（主机玩家一人上传) + /// 所有玩家确保加载ROM和即时存档，并保持模拟器暂停，准备完毕后 发送 CMD_Room_Player_Ready + /// 所有玩家Ready之后，服务器会根据所有玩家延迟提前跑若干Frame，通知进入Step2 + /// + /// Step2：服务器广播"开始" CMD_Room_WaitStep WaitStep=[2] ---> 客户端：立即开始 + /// + /// PS：[联机过程中加载即时存档] 房间在游玩过程中，单个玩家发送CMD_Room_HostPlayer_UpdateStateRaw 上报即时存档 + /// 重新从Step1走流程 + /// + /// + [pbr::OriginalName("CMD_Room_WaitStep")] CmdRoomWaitStep = 5201, + /// + ///主机玩家上传即时存档 上行 | 下行 对应 Protobuf_Room_HostPlayer_UpdateStateRaw | Protobuf_Room_HostPlayer_UpdateStateRaw_RESP + /// + [pbr::OriginalName("CMD_Room_HostPlayer_UpdateStateRaw")] CmdRoomHostPlayerUpdateStateRaw = 5204, + /// + ///玩家准备完毕 上行 Protobuf_Room_Player_Ready + /// + [pbr::OriginalName("CMD_Room_Player_Ready")] CmdRoomPlayerReady = 5208, + /// + ///游戏同步 + /// + [pbr::OriginalName("CMD_Room_Singel_PlayerInput")] CmdRoomSingelPlayerInput = 6010, + /// + ///单个玩家操作同步下行 对应 Protobuf_Room_Syn_RoomFrameAllInputData + /// + [pbr::OriginalName("CMD_ROOM_SYN_PlayerInput")] CmdRoomSynPlayerInput = 6015, + /// + ///画面采集 + /// + [pbr::OriginalName("CMD_Screen")] CmdScreen = 7001, } public enum ErrorCode { @@ -85,6 +219,18 @@ namespace AxibugProtobuf { ///成功 /// [pbr::OriginalName("ERROR_OK")] ErrorOk = 1, + /// + ///房间不存在 + /// + [pbr::OriginalName("ERROR_ROOM_NOT_FOUND")] ErrorRoomNotFound = 10, + /// + ///加入目标位置已经有人 + /// + [pbr::OriginalName("ERROR_ROOM_SLOT_READLY_HAD_PLAYER")] ErrorRoomSlotReadlyHadPlayer = 11, + /// + ///当前房间状态不允许本操作 + /// + [pbr::OriginalName("ERROR_ROOM_CANT_DO_CURR_STATE")] ErrorRoomCantDoCurrState = 50, } public enum LoginType { @@ -105,6 +251,33 @@ namespace AxibugProtobuf { [pbr::OriginalName("PSV")] Psv = 4, } + public enum RoomGameState { + /// + ///缺省 + /// + [pbr::OriginalName("None_GameState")] NoneGameState = 0, + /// + ///仅主机，待加入 + /// + [pbr::OriginalName("OnlyHost")] OnlyHost = 1, + /// + ///等待即时存档 + /// + [pbr::OriginalName("WaitRawUpdate")] WaitRawUpdate = 2, + /// + ///等待Ready + /// + [pbr::OriginalName("WaitReady")] WaitReady = 3, + /// + ///暂停 + /// + [pbr::OriginalName("Pause")] Pause = 4, + /// + ///联机中 + /// + [pbr::OriginalName("InOnlineGame")] InOnlineGame = 5, + } + public enum LoginResultStatus { /// ///缺省不使用 @@ -551,6 +724,356 @@ namespace AxibugProtobuf { } + public sealed partial class Protobuf_Ping : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Protobuf_Ping()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[2]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Ping() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Ping(Protobuf_Ping other) : this() { + seed_ = other.seed_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Ping Clone() { + return new Protobuf_Ping(this); + } + + /// Field number for the "Seed" field. + public const int SeedFieldNumber = 1; + private int seed_; + /// + ///随机数 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int Seed { + get { return seed_; } + set { + seed_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Protobuf_Ping); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Protobuf_Ping other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Seed != other.Seed) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Seed != 0) hash ^= Seed.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Seed != 0) { + output.WriteRawTag(8); + output.WriteInt32(Seed); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Seed != 0) { + output.WriteRawTag(8); + output.WriteInt32(Seed); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Seed != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Seed); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Protobuf_Ping other) { + if (other == null) { + return; + } + if (other.Seed != 0) { + Seed = other.Seed; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + Seed = input.ReadInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + Seed = input.ReadInt32(); + break; + } + } + } + } + #endif + + } + + public sealed partial class Protobuf_Pong : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Protobuf_Pong()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[3]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Pong() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Pong(Protobuf_Pong other) : this() { + seed_ = other.seed_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Pong Clone() { + return new Protobuf_Pong(this); + } + + /// Field number for the "Seed" field. + public const int SeedFieldNumber = 1; + private int seed_; + /// + ///原样返回随机数 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int Seed { + get { return seed_; } + set { + seed_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Protobuf_Pong); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Protobuf_Pong other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Seed != other.Seed) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Seed != 0) hash ^= Seed.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Seed != 0) { + output.WriteRawTag(8); + output.WriteInt32(Seed); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Seed != 0) { + output.WriteRawTag(8); + output.WriteInt32(Seed); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Seed != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Seed); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Protobuf_Pong other) { + if (other == null) { + return; + } + if (other.Seed != 0) { + Seed = other.Seed; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + Seed = input.ReadInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + Seed = input.ReadInt32(); + break; + } + } + } + } + #endif + + } + /// ///登录数据上行 /// @@ -566,7 +1089,7 @@ namespace AxibugProtobuf { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { - get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[2]; } + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[4]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -861,7 +1384,7 @@ namespace AxibugProtobuf { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { - get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[3]; } + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[5]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -878,6 +1401,7 @@ namespace AxibugProtobuf { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public Protobuf_Login_RESP(Protobuf_Login_RESP other) : this() { + deviceUUID_ = other.deviceUUID_; token_ = other.token_; lastLoginDate_ = other.lastLoginDate_; regDate_ = other.regDate_; @@ -891,8 +1415,22 @@ namespace AxibugProtobuf { return new Protobuf_Login_RESP(this); } + /// Field number for the "DeviceUUID" field. + public const int DeviceUUIDFieldNumber = 1; + private string deviceUUID_ = ""; + /// + ///设备唯一串 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string DeviceUUID { + get { return deviceUUID_; } + set { + deviceUUID_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Field number for the "Token" field. - public const int TokenFieldNumber = 1; + public const int TokenFieldNumber = 2; private string token_ = ""; /// ///登录凭据 （本次登录之后，所有业务请求凭据，需要存储在内存中） @@ -906,7 +1444,7 @@ namespace AxibugProtobuf { } /// Field number for the "LastLoginDate" field. - public const int LastLoginDateFieldNumber = 2; + public const int LastLoginDateFieldNumber = 3; private string lastLoginDate_ = ""; /// ///上次登录时间（只用于呈现的字符串，若界面需求需要） @@ -920,7 +1458,7 @@ namespace AxibugProtobuf { } /// Field number for the "RegDate" field. - public const int RegDateFieldNumber = 3; + public const int RegDateFieldNumber = 4; private string regDate_ = ""; /// ///注册时间（只用于呈现的字符串，若界面需求需要） @@ -934,7 +1472,7 @@ namespace AxibugProtobuf { } /// Field number for the "Status" field. - public const int StatusFieldNumber = 4; + public const int StatusFieldNumber = 5; private global::AxibugProtobuf.LoginResultStatus status_ = global::AxibugProtobuf.LoginResultStatus.BaseDefault; /// ///账号状态 （预留） [1]正常[0]被禁封 @@ -948,7 +1486,7 @@ namespace AxibugProtobuf { } /// Field number for the "UID" field. - public const int UIDFieldNumber = 5; + public const int UIDFieldNumber = 6; private long uID_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public long UID { @@ -971,6 +1509,7 @@ namespace AxibugProtobuf { if (ReferenceEquals(other, this)) { return true; } + if (DeviceUUID != other.DeviceUUID) return false; if (Token != other.Token) return false; if (LastLoginDate != other.LastLoginDate) return false; if (RegDate != other.RegDate) return false; @@ -982,6 +1521,7 @@ namespace AxibugProtobuf { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override int GetHashCode() { int hash = 1; + if (DeviceUUID.Length != 0) hash ^= DeviceUUID.GetHashCode(); if (Token.Length != 0) hash ^= Token.GetHashCode(); if (LastLoginDate.Length != 0) hash ^= LastLoginDate.GetHashCode(); if (RegDate.Length != 0) hash ^= RegDate.GetHashCode(); @@ -1003,24 +1543,28 @@ namespace AxibugProtobuf { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (Token.Length != 0) { + if (DeviceUUID.Length != 0) { output.WriteRawTag(10); + output.WriteString(DeviceUUID); + } + if (Token.Length != 0) { + output.WriteRawTag(18); output.WriteString(Token); } if (LastLoginDate.Length != 0) { - output.WriteRawTag(18); + output.WriteRawTag(26); output.WriteString(LastLoginDate); } if (RegDate.Length != 0) { - output.WriteRawTag(26); + output.WriteRawTag(34); output.WriteString(RegDate); } if (Status != global::AxibugProtobuf.LoginResultStatus.BaseDefault) { - output.WriteRawTag(32); + output.WriteRawTag(40); output.WriteEnum((int) Status); } if (UID != 0L) { - output.WriteRawTag(40); + output.WriteRawTag(48); output.WriteInt64(UID); } if (_unknownFields != null) { @@ -1032,24 +1576,28 @@ namespace AxibugProtobuf { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE [global::System.Diagnostics.DebuggerNonUserCodeAttribute] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (Token.Length != 0) { + if (DeviceUUID.Length != 0) { output.WriteRawTag(10); + output.WriteString(DeviceUUID); + } + if (Token.Length != 0) { + output.WriteRawTag(18); output.WriteString(Token); } if (LastLoginDate.Length != 0) { - output.WriteRawTag(18); + output.WriteRawTag(26); output.WriteString(LastLoginDate); } if (RegDate.Length != 0) { - output.WriteRawTag(26); + output.WriteRawTag(34); output.WriteString(RegDate); } if (Status != global::AxibugProtobuf.LoginResultStatus.BaseDefault) { - output.WriteRawTag(32); + output.WriteRawTag(40); output.WriteEnum((int) Status); } if (UID != 0L) { - output.WriteRawTag(40); + output.WriteRawTag(48); output.WriteInt64(UID); } if (_unknownFields != null) { @@ -1061,6 +1609,9 @@ namespace AxibugProtobuf { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public int CalculateSize() { int size = 0; + if (DeviceUUID.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(DeviceUUID); + } if (Token.Length != 0) { size += 1 + pb::CodedOutputStream.ComputeStringSize(Token); } @@ -1087,6 +1638,9 @@ namespace AxibugProtobuf { if (other == null) { return; } + if (other.DeviceUUID.Length != 0) { + DeviceUUID = other.DeviceUUID; + } if (other.Token.Length != 0) { Token = other.Token; } @@ -1117,22 +1671,26 @@ namespace AxibugProtobuf { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - Token = input.ReadString(); + DeviceUUID = input.ReadString(); break; } case 18: { - LastLoginDate = input.ReadString(); + Token = input.ReadString(); break; } case 26: { + LastLoginDate = input.ReadString(); + break; + } + case 34: { RegDate = input.ReadString(); break; } - case 32: { + case 40: { Status = (global::AxibugProtobuf.LoginResultStatus) input.ReadEnum(); break; } - case 40: { + case 48: { UID = input.ReadInt64(); break; } @@ -1151,22 +1709,26 @@ namespace AxibugProtobuf { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - Token = input.ReadString(); + DeviceUUID = input.ReadString(); break; } case 18: { - LastLoginDate = input.ReadString(); + Token = input.ReadString(); break; } case 26: { + LastLoginDate = input.ReadString(); + break; + } + case 34: { RegDate = input.ReadString(); break; } - case 32: { + case 40: { Status = (global::AxibugProtobuf.LoginResultStatus) input.ReadEnum(); break; } - case 40: { + case 48: { UID = input.ReadInt64(); break; } @@ -1177,6 +1739,1052 @@ namespace AxibugProtobuf { } + public sealed partial class Protobuf_Room_List : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Protobuf_Room_List()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[6]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_List() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_List(Protobuf_Room_List other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_List Clone() { + return new Protobuf_Room_List(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Protobuf_Room_List); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Protobuf_Room_List other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Protobuf_Room_List other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + public sealed partial class Protobuf_Room_List_RESP : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Protobuf_Room_List_RESP()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[7]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_List_RESP() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_List_RESP(Protobuf_Room_List_RESP other) : this() { + roomMiniInfoList_ = other.roomMiniInfoList_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_List_RESP Clone() { + return new Protobuf_Room_List_RESP(this); + } + + /// Field number for the "RoomMiniInfoList" field. + public const int RoomMiniInfoListFieldNumber = 1; + private static readonly pb::FieldCodec _repeated_roomMiniInfoList_codec + = pb::FieldCodec.ForMessage(10, global::AxibugProtobuf.Protobuf_Room_MiniInfo.Parser); + private readonly pbc::RepeatedField roomMiniInfoList_ = new pbc::RepeatedField(); + /// + ///房间列表 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField RoomMiniInfoList { + get { return roomMiniInfoList_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Protobuf_Room_List_RESP); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Protobuf_Room_List_RESP other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!roomMiniInfoList_.Equals(other.roomMiniInfoList_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + hash ^= roomMiniInfoList_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + roomMiniInfoList_.WriteTo(output, _repeated_roomMiniInfoList_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + roomMiniInfoList_.WriteTo(ref output, _repeated_roomMiniInfoList_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + size += roomMiniInfoList_.CalculateSize(_repeated_roomMiniInfoList_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Protobuf_Room_List_RESP other) { + if (other == null) { + return; + } + roomMiniInfoList_.Add(other.roomMiniInfoList_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + roomMiniInfoList_.AddEntriesFrom(input, _repeated_roomMiniInfoList_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + roomMiniInfoList_.AddEntriesFrom(ref input, _repeated_roomMiniInfoList_codec); + break; + } + } + } + } + #endif + + } + + public sealed partial class Protobuf_Room_MiniInfo : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Protobuf_Room_MiniInfo()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[8]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_MiniInfo() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_MiniInfo(Protobuf_Room_MiniInfo other) : this() { + roomID_ = other.roomID_; + gameRomID_ = other.gameRomID_; + gameRomHash_ = other.gameRomHash_; + gameState_ = other.gameState_; + hostPlayerUID_ = other.hostPlayerUID_; + obsUserCount_ = other.obsUserCount_; + player1UID_ = other.player1UID_; + player1NickName_ = other.player1NickName_; + player2UID_ = other.player2UID_; + player2NickName_ = other.player2NickName_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_MiniInfo Clone() { + return new Protobuf_Room_MiniInfo(this); + } + + /// Field number for the "RoomID" field. + public const int RoomIDFieldNumber = 1; + private int roomID_; + /// + ///房间ID + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int RoomID { + get { return roomID_; } + set { + roomID_ = value; + } + } + + /// Field number for the "GameRomID" field. + public const int GameRomIDFieldNumber = 2; + private int gameRomID_; + /// + ///游戏ID + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int GameRomID { + get { return gameRomID_; } + set { + gameRomID_ = value; + } + } + + /// Field number for the "GameRomHash" field. + public const int GameRomHashFieldNumber = 3; + private string gameRomHash_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string GameRomHash { + get { return gameRomHash_; } + set { + gameRomHash_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "GameState" field. + public const int GameStateFieldNumber = 5; + private global::AxibugProtobuf.RoomGameState gameState_ = global::AxibugProtobuf.RoomGameState.NoneGameState; + /// + ///游戏状态 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::AxibugProtobuf.RoomGameState GameState { + get { return gameState_; } + set { + gameState_ = value; + } + } + + /// Field number for the "HostPlayerUID" field. + public const int HostPlayerUIDFieldNumber = 6; + private int hostPlayerUID_; + /// + ///主机玩家ID + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int HostPlayerUID { + get { return hostPlayerUID_; } + set { + hostPlayerUID_ = value; + } + } + + /// Field number for the "ObsUserCount" field. + public const int ObsUserCountFieldNumber = 7; + private int obsUserCount_; + /// + ///观战用户数量 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int ObsUserCount { + get { return obsUserCount_; } + set { + obsUserCount_ = value; + } + } + + /// Field number for the "Player1_UID" field. + public const int Player1UIDFieldNumber = 8; + private long player1UID_; + /// + ///玩家1 UID + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public long Player1UID { + get { return player1UID_; } + set { + player1UID_ = value; + } + } + + /// Field number for the "Player1_NickName" field. + public const int Player1NickNameFieldNumber = 9; + private string player1NickName_ = ""; + /// + ///玩家1 昵称 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Player1NickName { + get { return player1NickName_; } + set { + player1NickName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "Player2_UID" field. + public const int Player2UIDFieldNumber = 10; + private long player2UID_; + /// + ///玩家2 UID + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public long Player2UID { + get { return player2UID_; } + set { + player2UID_ = value; + } + } + + /// Field number for the "Player2_NickName" field. + public const int Player2NickNameFieldNumber = 11; + private string player2NickName_ = ""; + /// + ///玩家2 昵称 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Player2NickName { + get { return player2NickName_; } + set { + player2NickName_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Protobuf_Room_MiniInfo); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Protobuf_Room_MiniInfo other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (RoomID != other.RoomID) return false; + if (GameRomID != other.GameRomID) return false; + if (GameRomHash != other.GameRomHash) return false; + if (GameState != other.GameState) return false; + if (HostPlayerUID != other.HostPlayerUID) return false; + if (ObsUserCount != other.ObsUserCount) return false; + if (Player1UID != other.Player1UID) return false; + if (Player1NickName != other.Player1NickName) return false; + if (Player2UID != other.Player2UID) return false; + if (Player2NickName != other.Player2NickName) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (RoomID != 0) hash ^= RoomID.GetHashCode(); + if (GameRomID != 0) hash ^= GameRomID.GetHashCode(); + if (GameRomHash.Length != 0) hash ^= GameRomHash.GetHashCode(); + if (GameState != global::AxibugProtobuf.RoomGameState.NoneGameState) hash ^= GameState.GetHashCode(); + if (HostPlayerUID != 0) hash ^= HostPlayerUID.GetHashCode(); + if (ObsUserCount != 0) hash ^= ObsUserCount.GetHashCode(); + if (Player1UID != 0L) hash ^= Player1UID.GetHashCode(); + if (Player1NickName.Length != 0) hash ^= Player1NickName.GetHashCode(); + if (Player2UID != 0L) hash ^= Player2UID.GetHashCode(); + if (Player2NickName.Length != 0) hash ^= Player2NickName.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (RoomID != 0) { + output.WriteRawTag(8); + output.WriteInt32(RoomID); + } + if (GameRomID != 0) { + output.WriteRawTag(16); + output.WriteInt32(GameRomID); + } + if (GameRomHash.Length != 0) { + output.WriteRawTag(26); + output.WriteString(GameRomHash); + } + if (GameState != global::AxibugProtobuf.RoomGameState.NoneGameState) { + output.WriteRawTag(40); + output.WriteEnum((int) GameState); + } + if (HostPlayerUID != 0) { + output.WriteRawTag(48); + output.WriteInt32(HostPlayerUID); + } + if (ObsUserCount != 0) { + output.WriteRawTag(56); + output.WriteInt32(ObsUserCount); + } + if (Player1UID != 0L) { + output.WriteRawTag(64); + output.WriteInt64(Player1UID); + } + if (Player1NickName.Length != 0) { + output.WriteRawTag(74); + output.WriteString(Player1NickName); + } + if (Player2UID != 0L) { + output.WriteRawTag(80); + output.WriteInt64(Player2UID); + } + if (Player2NickName.Length != 0) { + output.WriteRawTag(90); + output.WriteString(Player2NickName); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (RoomID != 0) { + output.WriteRawTag(8); + output.WriteInt32(RoomID); + } + if (GameRomID != 0) { + output.WriteRawTag(16); + output.WriteInt32(GameRomID); + } + if (GameRomHash.Length != 0) { + output.WriteRawTag(26); + output.WriteString(GameRomHash); + } + if (GameState != global::AxibugProtobuf.RoomGameState.NoneGameState) { + output.WriteRawTag(40); + output.WriteEnum((int) GameState); + } + if (HostPlayerUID != 0) { + output.WriteRawTag(48); + output.WriteInt32(HostPlayerUID); + } + if (ObsUserCount != 0) { + output.WriteRawTag(56); + output.WriteInt32(ObsUserCount); + } + if (Player1UID != 0L) { + output.WriteRawTag(64); + output.WriteInt64(Player1UID); + } + if (Player1NickName.Length != 0) { + output.WriteRawTag(74); + output.WriteString(Player1NickName); + } + if (Player2UID != 0L) { + output.WriteRawTag(80); + output.WriteInt64(Player2UID); + } + if (Player2NickName.Length != 0) { + output.WriteRawTag(90); + output.WriteString(Player2NickName); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (RoomID != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(RoomID); + } + if (GameRomID != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(GameRomID); + } + if (GameRomHash.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(GameRomHash); + } + if (GameState != global::AxibugProtobuf.RoomGameState.NoneGameState) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) GameState); + } + if (HostPlayerUID != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(HostPlayerUID); + } + if (ObsUserCount != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(ObsUserCount); + } + if (Player1UID != 0L) { + size += 1 + pb::CodedOutputStream.ComputeInt64Size(Player1UID); + } + if (Player1NickName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Player1NickName); + } + if (Player2UID != 0L) { + size += 1 + pb::CodedOutputStream.ComputeInt64Size(Player2UID); + } + if (Player2NickName.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Player2NickName); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Protobuf_Room_MiniInfo other) { + if (other == null) { + return; + } + if (other.RoomID != 0) { + RoomID = other.RoomID; + } + if (other.GameRomID != 0) { + GameRomID = other.GameRomID; + } + if (other.GameRomHash.Length != 0) { + GameRomHash = other.GameRomHash; + } + if (other.GameState != global::AxibugProtobuf.RoomGameState.NoneGameState) { + GameState = other.GameState; + } + if (other.HostPlayerUID != 0) { + HostPlayerUID = other.HostPlayerUID; + } + if (other.ObsUserCount != 0) { + ObsUserCount = other.ObsUserCount; + } + if (other.Player1UID != 0L) { + Player1UID = other.Player1UID; + } + if (other.Player1NickName.Length != 0) { + Player1NickName = other.Player1NickName; + } + if (other.Player2UID != 0L) { + Player2UID = other.Player2UID; + } + if (other.Player2NickName.Length != 0) { + Player2NickName = other.Player2NickName; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + RoomID = input.ReadInt32(); + break; + } + case 16: { + GameRomID = input.ReadInt32(); + break; + } + case 26: { + GameRomHash = input.ReadString(); + break; + } + case 40: { + GameState = (global::AxibugProtobuf.RoomGameState) input.ReadEnum(); + break; + } + case 48: { + HostPlayerUID = input.ReadInt32(); + break; + } + case 56: { + ObsUserCount = input.ReadInt32(); + break; + } + case 64: { + Player1UID = input.ReadInt64(); + break; + } + case 74: { + Player1NickName = input.ReadString(); + break; + } + case 80: { + Player2UID = input.ReadInt64(); + break; + } + case 90: { + Player2NickName = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + RoomID = input.ReadInt32(); + break; + } + case 16: { + GameRomID = input.ReadInt32(); + break; + } + case 26: { + GameRomHash = input.ReadString(); + break; + } + case 40: { + GameState = (global::AxibugProtobuf.RoomGameState) input.ReadEnum(); + break; + } + case 48: { + HostPlayerUID = input.ReadInt32(); + break; + } + case 56: { + ObsUserCount = input.ReadInt32(); + break; + } + case 64: { + Player1UID = input.ReadInt64(); + break; + } + case 74: { + Player1NickName = input.ReadString(); + break; + } + case 80: { + Player2UID = input.ReadInt64(); + break; + } + case 90: { + Player2NickName = input.ReadString(); + break; + } + } + } + } + #endif + + } + + public sealed partial class Protobuf_Room_Update_RESP : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Protobuf_Room_Update_RESP()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[9]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Update_RESP() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Update_RESP(Protobuf_Room_Update_RESP other) : this() { + updateType_ = other.updateType_; + roomMiniInfo_ = other.roomMiniInfo_ != null ? other.roomMiniInfo_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Update_RESP Clone() { + return new Protobuf_Room_Update_RESP(this); + } + + /// Field number for the "UpdateType" field. + public const int UpdateTypeFieldNumber = 1; + private int updateType_; + /// + ///[0] 更新或新增 [1] 删除 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int UpdateType { + get { return updateType_; } + set { + updateType_ = value; + } + } + + /// Field number for the "RoomMiniInfo" field. + public const int RoomMiniInfoFieldNumber = 2; + private global::AxibugProtobuf.Protobuf_Room_MiniInfo roomMiniInfo_; + /// + ///房间信息 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::AxibugProtobuf.Protobuf_Room_MiniInfo RoomMiniInfo { + get { return roomMiniInfo_; } + set { + roomMiniInfo_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Protobuf_Room_Update_RESP); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Protobuf_Room_Update_RESP other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (UpdateType != other.UpdateType) return false; + if (!object.Equals(RoomMiniInfo, other.RoomMiniInfo)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (UpdateType != 0) hash ^= UpdateType.GetHashCode(); + if (roomMiniInfo_ != null) hash ^= RoomMiniInfo.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (UpdateType != 0) { + output.WriteRawTag(8); + output.WriteInt32(UpdateType); + } + if (roomMiniInfo_ != null) { + output.WriteRawTag(18); + output.WriteMessage(RoomMiniInfo); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (UpdateType != 0) { + output.WriteRawTag(8); + output.WriteInt32(UpdateType); + } + if (roomMiniInfo_ != null) { + output.WriteRawTag(18); + output.WriteMessage(RoomMiniInfo); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (UpdateType != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(UpdateType); + } + if (roomMiniInfo_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(RoomMiniInfo); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Protobuf_Room_Update_RESP other) { + if (other == null) { + return; + } + if (other.UpdateType != 0) { + UpdateType = other.UpdateType; + } + if (other.roomMiniInfo_ != null) { + if (roomMiniInfo_ == null) { + RoomMiniInfo = new global::AxibugProtobuf.Protobuf_Room_MiniInfo(); + } + RoomMiniInfo.MergeFrom(other.RoomMiniInfo); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + UpdateType = input.ReadInt32(); + break; + } + case 18: { + if (roomMiniInfo_ == null) { + RoomMiniInfo = new global::AxibugProtobuf.Protobuf_Room_MiniInfo(); + } + input.ReadMessage(RoomMiniInfo); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + UpdateType = input.ReadInt32(); + break; + } + case 18: { + if (roomMiniInfo_ == null) { + RoomMiniInfo = new global::AxibugProtobuf.Protobuf_Room_MiniInfo(); + } + input.ReadMessage(RoomMiniInfo); + break; + } + } + } + } + #endif + + } + public sealed partial class Protobuf_Screnn_Frame : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage @@ -1189,7 +2797,7 @@ namespace AxibugProtobuf { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public static pbr::MessageDescriptor Descriptor { - get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[4]; } + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[10]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -1206,6 +2814,7 @@ namespace AxibugProtobuf { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public Protobuf_Screnn_Frame(Protobuf_Screnn_Frame other) : this() { + roomID_ = other.roomID_; frameID_ = other.frameID_; rawBitmap_ = other.rawBitmap_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); @@ -1216,8 +2825,22 @@ namespace AxibugProtobuf { return new Protobuf_Screnn_Frame(this); } + /// Field number for the "RoomID" field. + public const int RoomIDFieldNumber = 1; + private int roomID_; + /// + ///房间ID + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int RoomID { + get { return roomID_; } + set { + roomID_ = value; + } + } + /// Field number for the "FrameID" field. - public const int FrameIDFieldNumber = 1; + public const int FrameIDFieldNumber = 2; private int frameID_; /// ///帧编号 @@ -1231,7 +2854,7 @@ namespace AxibugProtobuf { } /// Field number for the "RawBitmap" field. - public const int RawBitmapFieldNumber = 2; + public const int RawBitmapFieldNumber = 3; private pb::ByteString rawBitmap_ = pb::ByteString.Empty; /// ///渲染层画面 @@ -1257,6 +2880,7 @@ namespace AxibugProtobuf { if (ReferenceEquals(other, this)) { return true; } + if (RoomID != other.RoomID) return false; if (FrameID != other.FrameID) return false; if (RawBitmap != other.RawBitmap) return false; return Equals(_unknownFields, other._unknownFields); @@ -1265,6 +2889,7 @@ namespace AxibugProtobuf { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public override int GetHashCode() { int hash = 1; + if (RoomID != 0) hash ^= RoomID.GetHashCode(); if (FrameID != 0) hash ^= FrameID.GetHashCode(); if (RawBitmap.Length != 0) hash ^= RawBitmap.GetHashCode(); if (_unknownFields != null) { @@ -1283,12 +2908,16 @@ namespace AxibugProtobuf { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (FrameID != 0) { + if (RoomID != 0) { output.WriteRawTag(8); + output.WriteInt32(RoomID); + } + if (FrameID != 0) { + output.WriteRawTag(16); output.WriteInt32(FrameID); } if (RawBitmap.Length != 0) { - output.WriteRawTag(18); + output.WriteRawTag(26); output.WriteBytes(RawBitmap); } if (_unknownFields != null) { @@ -1300,12 +2929,16 @@ namespace AxibugProtobuf { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE [global::System.Diagnostics.DebuggerNonUserCodeAttribute] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (FrameID != 0) { + if (RoomID != 0) { output.WriteRawTag(8); + output.WriteInt32(RoomID); + } + if (FrameID != 0) { + output.WriteRawTag(16); output.WriteInt32(FrameID); } if (RawBitmap.Length != 0) { - output.WriteRawTag(18); + output.WriteRawTag(26); output.WriteBytes(RawBitmap); } if (_unknownFields != null) { @@ -1317,6 +2950,9 @@ namespace AxibugProtobuf { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] public int CalculateSize() { int size = 0; + if (RoomID != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(RoomID); + } if (FrameID != 0) { size += 1 + pb::CodedOutputStream.ComputeInt32Size(FrameID); } @@ -1334,6 +2970,9 @@ namespace AxibugProtobuf { if (other == null) { return; } + if (other.RoomID != 0) { + RoomID = other.RoomID; + } if (other.FrameID != 0) { FrameID = other.FrameID; } @@ -1355,10 +2994,14 @@ namespace AxibugProtobuf { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 8: { + RoomID = input.ReadInt32(); + break; + } + case 16: { FrameID = input.ReadInt32(); break; } - case 18: { + case 26: { RawBitmap = input.ReadBytes(); break; } @@ -1377,10 +3020,14 @@ namespace AxibugProtobuf { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 8: { + RoomID = input.ReadInt32(); + break; + } + case 16: { FrameID = input.ReadInt32(); break; } - case 18: { + case 26: { RawBitmap = input.ReadBytes(); break; } @@ -1391,6 +3038,2458 @@ namespace AxibugProtobuf { } + public sealed partial class Protobuf_Room_SinglePlayerInputData : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Protobuf_Room_SinglePlayerInputData()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[11]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_SinglePlayerInputData() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_SinglePlayerInputData(Protobuf_Room_SinglePlayerInputData other) : this() { + frameID_ = other.frameID_; + inputData_ = other.inputData_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_SinglePlayerInputData Clone() { + return new Protobuf_Room_SinglePlayerInputData(this); + } + + /// Field number for the "FrameID" field. + public const int FrameIDFieldNumber = 1; + private uint frameID_; + /// + ///帧编号 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public uint FrameID { + get { return frameID_; } + set { + frameID_ = value; + } + } + + /// Field number for the "InputData" field. + public const int InputDataFieldNumber = 2; + private uint inputData_; + /// + ///单个玩家操作位运算汇总 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public uint InputData { + get { return inputData_; } + set { + inputData_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Protobuf_Room_SinglePlayerInputData); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Protobuf_Room_SinglePlayerInputData other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (FrameID != other.FrameID) return false; + if (InputData != other.InputData) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (FrameID != 0) hash ^= FrameID.GetHashCode(); + if (InputData != 0) hash ^= InputData.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (FrameID != 0) { + output.WriteRawTag(8); + output.WriteUInt32(FrameID); + } + if (InputData != 0) { + output.WriteRawTag(16); + output.WriteUInt32(InputData); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (FrameID != 0) { + output.WriteRawTag(8); + output.WriteUInt32(FrameID); + } + if (InputData != 0) { + output.WriteRawTag(16); + output.WriteUInt32(InputData); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (FrameID != 0) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(FrameID); + } + if (InputData != 0) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(InputData); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Protobuf_Room_SinglePlayerInputData other) { + if (other == null) { + return; + } + if (other.FrameID != 0) { + FrameID = other.FrameID; + } + if (other.InputData != 0) { + InputData = other.InputData; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + FrameID = input.ReadUInt32(); + break; + } + case 16: { + InputData = input.ReadUInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + FrameID = input.ReadUInt32(); + break; + } + case 16: { + InputData = input.ReadUInt32(); + break; + } + } + } + } + #endif + + } + + public sealed partial class Protobuf_Room_Syn_RoomFrameAllInputData : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Protobuf_Room_Syn_RoomFrameAllInputData()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[12]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Syn_RoomFrameAllInputData() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Syn_RoomFrameAllInputData(Protobuf_Room_Syn_RoomFrameAllInputData other) : this() { + frameID_ = other.frameID_; + inputData_ = other.inputData_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Syn_RoomFrameAllInputData Clone() { + return new Protobuf_Room_Syn_RoomFrameAllInputData(this); + } + + /// Field number for the "FrameID" field. + public const int FrameIDFieldNumber = 1; + private uint frameID_; + /// + ///帧编号 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public uint FrameID { + get { return frameID_; } + set { + frameID_ = value; + } + } + + /// Field number for the "InputData" field. + public const int InputDataFieldNumber = 2; + private ulong inputData_; + /// + ///所有玩家操作位运算汇总 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ulong InputData { + get { return inputData_; } + set { + inputData_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Protobuf_Room_Syn_RoomFrameAllInputData); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Protobuf_Room_Syn_RoomFrameAllInputData other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (FrameID != other.FrameID) return false; + if (InputData != other.InputData) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (FrameID != 0) hash ^= FrameID.GetHashCode(); + if (InputData != 0UL) hash ^= InputData.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (FrameID != 0) { + output.WriteRawTag(8); + output.WriteUInt32(FrameID); + } + if (InputData != 0UL) { + output.WriteRawTag(16); + output.WriteUInt64(InputData); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (FrameID != 0) { + output.WriteRawTag(8); + output.WriteUInt32(FrameID); + } + if (InputData != 0UL) { + output.WriteRawTag(16); + output.WriteUInt64(InputData); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (FrameID != 0) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(FrameID); + } + if (InputData != 0UL) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(InputData); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Protobuf_Room_Syn_RoomFrameAllInputData other) { + if (other == null) { + return; + } + if (other.FrameID != 0) { + FrameID = other.FrameID; + } + if (other.InputData != 0UL) { + InputData = other.InputData; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + FrameID = input.ReadUInt32(); + break; + } + case 16: { + InputData = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + FrameID = input.ReadUInt32(); + break; + } + case 16: { + InputData = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + public sealed partial class Protobuf_Room_Create : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Protobuf_Room_Create()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[13]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Create() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Create(Protobuf_Room_Create other) : this() { + gameRomID_ = other.gameRomID_; + gameRomHash_ = other.gameRomHash_; + joinPlayerIdx_ = other.joinPlayerIdx_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Create Clone() { + return new Protobuf_Room_Create(this); + } + + /// Field number for the "GameRomID" field. + public const int GameRomIDFieldNumber = 1; + private int gameRomID_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int GameRomID { + get { return gameRomID_; } + set { + gameRomID_ = value; + } + } + + /// Field number for the "GameRomHash" field. + public const int GameRomHashFieldNumber = 2; + private string gameRomHash_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string GameRomHash { + get { return gameRomHash_; } + set { + gameRomHash_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "JoinPlayerIdx" field. + public const int JoinPlayerIdxFieldNumber = 3; + private int joinPlayerIdx_; + /// + ///P1~P4[0~3] 以几号位玩家创建房间 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int JoinPlayerIdx { + get { return joinPlayerIdx_; } + set { + joinPlayerIdx_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Protobuf_Room_Create); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Protobuf_Room_Create other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (GameRomID != other.GameRomID) return false; + if (GameRomHash != other.GameRomHash) return false; + if (JoinPlayerIdx != other.JoinPlayerIdx) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (GameRomID != 0) hash ^= GameRomID.GetHashCode(); + if (GameRomHash.Length != 0) hash ^= GameRomHash.GetHashCode(); + if (JoinPlayerIdx != 0) hash ^= JoinPlayerIdx.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (GameRomID != 0) { + output.WriteRawTag(8); + output.WriteInt32(GameRomID); + } + if (GameRomHash.Length != 0) { + output.WriteRawTag(18); + output.WriteString(GameRomHash); + } + if (JoinPlayerIdx != 0) { + output.WriteRawTag(24); + output.WriteInt32(JoinPlayerIdx); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (GameRomID != 0) { + output.WriteRawTag(8); + output.WriteInt32(GameRomID); + } + if (GameRomHash.Length != 0) { + output.WriteRawTag(18); + output.WriteString(GameRomHash); + } + if (JoinPlayerIdx != 0) { + output.WriteRawTag(24); + output.WriteInt32(JoinPlayerIdx); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (GameRomID != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(GameRomID); + } + if (GameRomHash.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(GameRomHash); + } + if (JoinPlayerIdx != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(JoinPlayerIdx); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Protobuf_Room_Create other) { + if (other == null) { + return; + } + if (other.GameRomID != 0) { + GameRomID = other.GameRomID; + } + if (other.GameRomHash.Length != 0) { + GameRomHash = other.GameRomHash; + } + if (other.JoinPlayerIdx != 0) { + JoinPlayerIdx = other.JoinPlayerIdx; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + GameRomID = input.ReadInt32(); + break; + } + case 18: { + GameRomHash = input.ReadString(); + break; + } + case 24: { + JoinPlayerIdx = input.ReadInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + GameRomID = input.ReadInt32(); + break; + } + case 18: { + GameRomHash = input.ReadString(); + break; + } + case 24: { + JoinPlayerIdx = input.ReadInt32(); + break; + } + } + } + } + #endif + + } + + public sealed partial class Protobuf_Room_Create_RESP : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Protobuf_Room_Create_RESP()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[14]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Create_RESP() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Create_RESP(Protobuf_Room_Create_RESP other) : this() { + roomMiniInfo_ = other.roomMiniInfo_ != null ? other.roomMiniInfo_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Create_RESP Clone() { + return new Protobuf_Room_Create_RESP(this); + } + + /// Field number for the "RoomMiniInfo" field. + public const int RoomMiniInfoFieldNumber = 1; + private global::AxibugProtobuf.Protobuf_Room_MiniInfo roomMiniInfo_; + /// + ///房间信息 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::AxibugProtobuf.Protobuf_Room_MiniInfo RoomMiniInfo { + get { return roomMiniInfo_; } + set { + roomMiniInfo_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Protobuf_Room_Create_RESP); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Protobuf_Room_Create_RESP other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(RoomMiniInfo, other.RoomMiniInfo)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (roomMiniInfo_ != null) hash ^= RoomMiniInfo.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (roomMiniInfo_ != null) { + output.WriteRawTag(10); + output.WriteMessage(RoomMiniInfo); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (roomMiniInfo_ != null) { + output.WriteRawTag(10); + output.WriteMessage(RoomMiniInfo); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (roomMiniInfo_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(RoomMiniInfo); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Protobuf_Room_Create_RESP other) { + if (other == null) { + return; + } + if (other.roomMiniInfo_ != null) { + if (roomMiniInfo_ == null) { + RoomMiniInfo = new global::AxibugProtobuf.Protobuf_Room_MiniInfo(); + } + RoomMiniInfo.MergeFrom(other.RoomMiniInfo); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (roomMiniInfo_ == null) { + RoomMiniInfo = new global::AxibugProtobuf.Protobuf_Room_MiniInfo(); + } + input.ReadMessage(RoomMiniInfo); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (roomMiniInfo_ == null) { + RoomMiniInfo = new global::AxibugProtobuf.Protobuf_Room_MiniInfo(); + } + input.ReadMessage(RoomMiniInfo); + break; + } + } + } + } + #endif + + } + + public sealed partial class Protobuf_Room_Join : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Protobuf_Room_Join()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[15]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Join() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Join(Protobuf_Room_Join other) : this() { + roomID_ = other.roomID_; + playerNum_ = other.playerNum_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Join Clone() { + return new Protobuf_Room_Join(this); + } + + /// Field number for the "RoomID" field. + public const int RoomIDFieldNumber = 1; + private int roomID_; + /// + ///房间ID + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int RoomID { + get { return roomID_; } + set { + roomID_ = value; + } + } + + /// Field number for the "PlayerNum" field. + public const int PlayerNumFieldNumber = 2; + private int playerNum_; + /// + ///玩家编号 [0]1号玩家 [1]2号玩家 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int PlayerNum { + get { return playerNum_; } + set { + playerNum_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Protobuf_Room_Join); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Protobuf_Room_Join other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (RoomID != other.RoomID) return false; + if (PlayerNum != other.PlayerNum) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (RoomID != 0) hash ^= RoomID.GetHashCode(); + if (PlayerNum != 0) hash ^= PlayerNum.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (RoomID != 0) { + output.WriteRawTag(8); + output.WriteInt32(RoomID); + } + if (PlayerNum != 0) { + output.WriteRawTag(16); + output.WriteInt32(PlayerNum); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (RoomID != 0) { + output.WriteRawTag(8); + output.WriteInt32(RoomID); + } + if (PlayerNum != 0) { + output.WriteRawTag(16); + output.WriteInt32(PlayerNum); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (RoomID != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(RoomID); + } + if (PlayerNum != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(PlayerNum); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Protobuf_Room_Join other) { + if (other == null) { + return; + } + if (other.RoomID != 0) { + RoomID = other.RoomID; + } + if (other.PlayerNum != 0) { + PlayerNum = other.PlayerNum; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + RoomID = input.ReadInt32(); + break; + } + case 16: { + PlayerNum = input.ReadInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + RoomID = input.ReadInt32(); + break; + } + case 16: { + PlayerNum = input.ReadInt32(); + break; + } + } + } + } + #endif + + } + + public sealed partial class Protobuf_Room_Join_RESP : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Protobuf_Room_Join_RESP()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[16]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Join_RESP() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Join_RESP(Protobuf_Room_Join_RESP other) : this() { + roomMiniInfo_ = other.roomMiniInfo_ != null ? other.roomMiniInfo_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Join_RESP Clone() { + return new Protobuf_Room_Join_RESP(this); + } + + /// Field number for the "RoomMiniInfo" field. + public const int RoomMiniInfoFieldNumber = 1; + private global::AxibugProtobuf.Protobuf_Room_MiniInfo roomMiniInfo_; + /// + ///房间信息 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::AxibugProtobuf.Protobuf_Room_MiniInfo RoomMiniInfo { + get { return roomMiniInfo_; } + set { + roomMiniInfo_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Protobuf_Room_Join_RESP); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Protobuf_Room_Join_RESP other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(RoomMiniInfo, other.RoomMiniInfo)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (roomMiniInfo_ != null) hash ^= RoomMiniInfo.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (roomMiniInfo_ != null) { + output.WriteRawTag(10); + output.WriteMessage(RoomMiniInfo); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (roomMiniInfo_ != null) { + output.WriteRawTag(10); + output.WriteMessage(RoomMiniInfo); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (roomMiniInfo_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(RoomMiniInfo); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Protobuf_Room_Join_RESP other) { + if (other == null) { + return; + } + if (other.roomMiniInfo_ != null) { + if (roomMiniInfo_ == null) { + RoomMiniInfo = new global::AxibugProtobuf.Protobuf_Room_MiniInfo(); + } + RoomMiniInfo.MergeFrom(other.RoomMiniInfo); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (roomMiniInfo_ == null) { + RoomMiniInfo = new global::AxibugProtobuf.Protobuf_Room_MiniInfo(); + } + input.ReadMessage(RoomMiniInfo); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (roomMiniInfo_ == null) { + RoomMiniInfo = new global::AxibugProtobuf.Protobuf_Room_MiniInfo(); + } + input.ReadMessage(RoomMiniInfo); + break; + } + } + } + } + #endif + + } + + public sealed partial class Protobuf_Room_Leave : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Protobuf_Room_Leave()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[17]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Leave() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Leave(Protobuf_Room_Leave other) : this() { + roomID_ = other.roomID_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Leave Clone() { + return new Protobuf_Room_Leave(this); + } + + /// Field number for the "RoomID" field. + public const int RoomIDFieldNumber = 1; + private int roomID_; + /// + ///离开的房间ID + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int RoomID { + get { return roomID_; } + set { + roomID_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Protobuf_Room_Leave); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Protobuf_Room_Leave other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (RoomID != other.RoomID) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (RoomID != 0) hash ^= RoomID.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (RoomID != 0) { + output.WriteRawTag(8); + output.WriteInt32(RoomID); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (RoomID != 0) { + output.WriteRawTag(8); + output.WriteInt32(RoomID); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (RoomID != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(RoomID); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Protobuf_Room_Leave other) { + if (other == null) { + return; + } + if (other.RoomID != 0) { + RoomID = other.RoomID; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + RoomID = input.ReadInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + RoomID = input.ReadInt32(); + break; + } + } + } + } + #endif + + } + + public sealed partial class Protobuf_Room_Leave_RESP : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Protobuf_Room_Leave_RESP()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[18]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Leave_RESP() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Leave_RESP(Protobuf_Room_Leave_RESP other) : this() { + roomID_ = other.roomID_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Leave_RESP Clone() { + return new Protobuf_Room_Leave_RESP(this); + } + + /// Field number for the "RoomID" field. + public const int RoomIDFieldNumber = 1; + private int roomID_; + /// + ///离开的房间ID + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int RoomID { + get { return roomID_; } + set { + roomID_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Protobuf_Room_Leave_RESP); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Protobuf_Room_Leave_RESP other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (RoomID != other.RoomID) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (RoomID != 0) hash ^= RoomID.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (RoomID != 0) { + output.WriteRawTag(8); + output.WriteInt32(RoomID); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (RoomID != 0) { + output.WriteRawTag(8); + output.WriteInt32(RoomID); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (RoomID != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(RoomID); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Protobuf_Room_Leave_RESP other) { + if (other == null) { + return; + } + if (other.RoomID != 0) { + RoomID = other.RoomID; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + RoomID = input.ReadInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + RoomID = input.ReadInt32(); + break; + } + } + } + } + #endif + + } + + public sealed partial class Protobuf_Room_MyRoom_State_Change : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Protobuf_Room_MyRoom_State_Change()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[19]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_MyRoom_State_Change() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_MyRoom_State_Change(Protobuf_Room_MyRoom_State_Change other) : this() { + roomMiniInfo_ = other.roomMiniInfo_ != null ? other.roomMiniInfo_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_MyRoom_State_Change Clone() { + return new Protobuf_Room_MyRoom_State_Change(this); + } + + /// Field number for the "RoomMiniInfo" field. + public const int RoomMiniInfoFieldNumber = 1; + private global::AxibugProtobuf.Protobuf_Room_MiniInfo roomMiniInfo_; + /// + ///更新房间信息 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::AxibugProtobuf.Protobuf_Room_MiniInfo RoomMiniInfo { + get { return roomMiniInfo_; } + set { + roomMiniInfo_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Protobuf_Room_MyRoom_State_Change); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Protobuf_Room_MyRoom_State_Change other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(RoomMiniInfo, other.RoomMiniInfo)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (roomMiniInfo_ != null) hash ^= RoomMiniInfo.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (roomMiniInfo_ != null) { + output.WriteRawTag(10); + output.WriteMessage(RoomMiniInfo); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (roomMiniInfo_ != null) { + output.WriteRawTag(10); + output.WriteMessage(RoomMiniInfo); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (roomMiniInfo_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(RoomMiniInfo); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Protobuf_Room_MyRoom_State_Change other) { + if (other == null) { + return; + } + if (other.roomMiniInfo_ != null) { + if (roomMiniInfo_ == null) { + RoomMiniInfo = new global::AxibugProtobuf.Protobuf_Room_MiniInfo(); + } + RoomMiniInfo.MergeFrom(other.RoomMiniInfo); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (roomMiniInfo_ == null) { + RoomMiniInfo = new global::AxibugProtobuf.Protobuf_Room_MiniInfo(); + } + input.ReadMessage(RoomMiniInfo); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (roomMiniInfo_ == null) { + RoomMiniInfo = new global::AxibugProtobuf.Protobuf_Room_MiniInfo(); + } + input.ReadMessage(RoomMiniInfo); + break; + } + } + } + } + #endif + + } + + public sealed partial class Protobuf_Room_WaitStep_RESP : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Protobuf_Room_WaitStep_RESP()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[20]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_WaitStep_RESP() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_WaitStep_RESP(Protobuf_Room_WaitStep_RESP other) : this() { + waitStep_ = other.waitStep_; + loadStateRaw_ = other.loadStateRaw_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_WaitStep_RESP Clone() { + return new Protobuf_Room_WaitStep_RESP(this); + } + + /// Field number for the "WaitStep" field. + public const int WaitStepFieldNumber = 1; + private int waitStep_; + /// + ///状态 [0]等待主机上报即时存档 [1]要求客户端准备 [2]开始（收到本状态时，立即开始跑模拟器核心） + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int WaitStep { + get { return waitStep_; } + set { + waitStep_ = value; + } + } + + /// Field number for the "LoadStateRaw" field. + public const int LoadStateRawFieldNumber = 2; + private pb::ByteString loadStateRaw_ = pb::ByteString.Empty; + /// + ///如下是 WaitStep = 1 时，才有值。广播即时存档 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pb::ByteString LoadStateRaw { + get { return loadStateRaw_; } + set { + loadStateRaw_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Protobuf_Room_WaitStep_RESP); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Protobuf_Room_WaitStep_RESP other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (WaitStep != other.WaitStep) return false; + if (LoadStateRaw != other.LoadStateRaw) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (WaitStep != 0) hash ^= WaitStep.GetHashCode(); + if (LoadStateRaw.Length != 0) hash ^= LoadStateRaw.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (WaitStep != 0) { + output.WriteRawTag(8); + output.WriteInt32(WaitStep); + } + if (LoadStateRaw.Length != 0) { + output.WriteRawTag(18); + output.WriteBytes(LoadStateRaw); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (WaitStep != 0) { + output.WriteRawTag(8); + output.WriteInt32(WaitStep); + } + if (LoadStateRaw.Length != 0) { + output.WriteRawTag(18); + output.WriteBytes(LoadStateRaw); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (WaitStep != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(WaitStep); + } + if (LoadStateRaw.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeBytesSize(LoadStateRaw); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Protobuf_Room_WaitStep_RESP other) { + if (other == null) { + return; + } + if (other.WaitStep != 0) { + WaitStep = other.WaitStep; + } + if (other.LoadStateRaw.Length != 0) { + LoadStateRaw = other.LoadStateRaw; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + WaitStep = input.ReadInt32(); + break; + } + case 18: { + LoadStateRaw = input.ReadBytes(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + WaitStep = input.ReadInt32(); + break; + } + case 18: { + LoadStateRaw = input.ReadBytes(); + break; + } + } + } + } + #endif + + } + + public sealed partial class Protobuf_Room_HostPlayer_UpdateStateRaw : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Protobuf_Room_HostPlayer_UpdateStateRaw()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[21]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_HostPlayer_UpdateStateRaw() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_HostPlayer_UpdateStateRaw(Protobuf_Room_HostPlayer_UpdateStateRaw other) : this() { + loadStateRaw_ = other.loadStateRaw_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_HostPlayer_UpdateStateRaw Clone() { + return new Protobuf_Room_HostPlayer_UpdateStateRaw(this); + } + + /// Field number for the "LoadStateRaw" field. + public const int LoadStateRawFieldNumber = 1; + private pb::ByteString loadStateRaw_ = pb::ByteString.Empty; + /// + ///即时存档byte数据 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pb::ByteString LoadStateRaw { + get { return loadStateRaw_; } + set { + loadStateRaw_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Protobuf_Room_HostPlayer_UpdateStateRaw); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Protobuf_Room_HostPlayer_UpdateStateRaw other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (LoadStateRaw != other.LoadStateRaw) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (LoadStateRaw.Length != 0) hash ^= LoadStateRaw.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (LoadStateRaw.Length != 0) { + output.WriteRawTag(10); + output.WriteBytes(LoadStateRaw); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (LoadStateRaw.Length != 0) { + output.WriteRawTag(10); + output.WriteBytes(LoadStateRaw); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (LoadStateRaw.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeBytesSize(LoadStateRaw); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Protobuf_Room_HostPlayer_UpdateStateRaw other) { + if (other == null) { + return; + } + if (other.LoadStateRaw.Length != 0) { + LoadStateRaw = other.LoadStateRaw; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + LoadStateRaw = input.ReadBytes(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + LoadStateRaw = input.ReadBytes(); + break; + } + } + } + } + #endif + + } + + public sealed partial class Protobuf_Room_HostPlayer_UpdateStateRaw_RESP : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Protobuf_Room_HostPlayer_UpdateStateRaw_RESP()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[22]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_HostPlayer_UpdateStateRaw_RESP() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_HostPlayer_UpdateStateRaw_RESP(Protobuf_Room_HostPlayer_UpdateStateRaw_RESP other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_HostPlayer_UpdateStateRaw_RESP Clone() { + return new Protobuf_Room_HostPlayer_UpdateStateRaw_RESP(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Protobuf_Room_HostPlayer_UpdateStateRaw_RESP); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Protobuf_Room_HostPlayer_UpdateStateRaw_RESP other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Protobuf_Room_HostPlayer_UpdateStateRaw_RESP other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + public sealed partial class Protobuf_Room_Player_Ready : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Protobuf_Room_Player_Ready()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::AxibugProtobuf.ProtobufAxibugEmuOnlineReflection.Descriptor.MessageTypes[23]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Player_Ready() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Player_Ready(Protobuf_Room_Player_Ready other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Protobuf_Room_Player_Ready Clone() { + return new Protobuf_Room_Player_Ready(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Protobuf_Room_Player_Ready); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Protobuf_Room_Player_Ready other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Protobuf_Room_Player_Ready other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + #endregion }