示例#1
0
 private bool IsNumberType(KSDType ksdType)
 {
     if (ksdType == KSDType.kstUInt8 ||
         ksdType == KSDType.kstUInt16 ||
         ksdType == KSDType.kstUInt32 ||
         ksdType == KSDType.kstInt8 ||
         ksdType == KSDType.kstInt16 ||
         ksdType == KSDType.kstInt32 ||
         ksdType == KSDType.kstFloat ||
         ksdType == KSDType.kstDouble)
     {
         return(true);
     }
     else
     {
         return(false);
     }
 }
示例#2
0
        private ushort UnPackTable(MemoryStream stream, BinaryReader read, ArrayList retArray, ushort tabSize = 0)
        {
            if (tabSize == 0)
            {
                tabSize = read.ReadUInt16();
            }

            uint        tabEnd = (uint)(stream.Position) + tabSize;
            RemoteTable luaTab = new RemoteTable();

            while (stream.Position < tabEnd)
            {
                ArrayList tabKV = new ArrayList();

                KSDType keyType   = UnPackUp(stream, read, tabKV);
                KSDType valueType = UnPackUp(stream, read, tabKV);

                if (IsNumberType(keyType))
                {
                    int nIndex = Convert.ToInt32(tabKV[0]);
                    switch (valueType)
                    {
                    case KSDType.kstBool:
                        luaTab[nIndex] = RemoteBool.GetItem((bool)tabKV[1]);
                        break;

                    case KSDType.kstInt8:
                        luaTab[nIndex] = RemoteInt8.GetItem((sbyte)tabKV[1]);
                        break;

                    case KSDType.kstInt16:
                        luaTab[nIndex] = RemoteInt16.GetItem((short)tabKV[1]);
                        break;

                    case KSDType.kstInt32:
                        luaTab[nIndex] = RemoteInt32.GetItem((int)tabKV[1]);
                        break;

                    case KSDType.kstUInt8:
                        luaTab[nIndex] = RemoteUInt8.GetItem((byte)tabKV[1]);
                        break;

                    case KSDType.kstUInt16:
                        luaTab[nIndex] = RemoteUInt16.GetItem((ushort)tabKV[1]);
                        break;

                    case KSDType.kstUInt32:
                        luaTab[nIndex] = RemoteUInt32.GetItem((uint)tabKV[1]);
                        break;

                    case KSDType.kstFloat:
                        luaTab[nIndex] = RemoteFloat.GetItem((float)tabKV[1]);
                        break;

                    case KSDType.kstDouble:
                        luaTab[nIndex] = RemoteDouble.GetItem((double)tabKV[1]);
                        break;

                    case KSDType.kstString:
                        luaTab[nIndex] = RemoteString.GetItem((string)tabKV[1]);
                        break;

                    case KSDType.kstBigString:
                        luaTab[nIndex] = RemoteString.GetItem((string)tabKV[1]);
                        break;

                    case KSDType.kstUInt64:
                        luaTab[nIndex] = RemoteUInt64.GetItem((ulong)tabKV[1]);
                        break;

                    case KSDType.kstDataStream:
                        luaTab[nIndex] = tabKV[1] as RemoteTable;
                        break;

                    case KSDType.kstNull:
                        luaTab[nIndex] = null;
                        break;

                    default:
                        Debug.LogError("UnKnow ValueType");
                        break;
                    }
                }
                else if (keyType == KSDType.kstString)
                {
                    string name = tabKV[0] as string;
                    switch (valueType)
                    {
                    case KSDType.kstBool:
                        luaTab[name] = RemoteBool.GetItem((bool)tabKV[1]);
                        break;

                    case KSDType.kstInt8:
                        luaTab[name] = RemoteInt8.GetItem((sbyte)tabKV[1]);
                        break;

                    case KSDType.kstInt16:
                        luaTab[name] = RemoteInt16.GetItem((short)tabKV[1]);
                        break;

                    case KSDType.kstInt32:
                        luaTab[name] = RemoteInt32.GetItem((int)tabKV[1]);
                        break;

                    case KSDType.kstUInt8:
                        luaTab[name] = RemoteUInt8.GetItem((byte)tabKV[1]);
                        break;

                    case KSDType.kstUInt16:
                        luaTab[name] = RemoteUInt16.GetItem((ushort)tabKV[1]);
                        break;

                    case KSDType.kstUInt32:
                        luaTab[name] = RemoteUInt32.GetItem((uint)tabKV[1]);
                        break;

                    case KSDType.kstFloat:
                        luaTab[name] = RemoteFloat.GetItem((float)tabKV[1]);
                        break;

                    case KSDType.kstDouble:
                        luaTab[name] = RemoteDouble.GetItem((double)tabKV[1]);
                        break;

                    case KSDType.kstString:
                        luaTab[name] = RemoteString.GetItem((string)tabKV[1]);
                        break;

                    case KSDType.kstBigString:
                        luaTab[name] = RemoteString.GetItem((string)tabKV[1]);
                        break;

                    case KSDType.kstUInt64:
                        luaTab[name] = RemoteUInt64.GetItem((ulong)tabKV[1]);
                        break;

                    case KSDType.kstDataStream:
                        luaTab[name] = tabKV[1] as RemoteTable;
                        break;

                    case KSDType.kstNull:
                        luaTab[name] = null;
                        break;

                    default:
                        Debug.LogError("UnKnow ValueType");
                        break;
                    }
                }
                else
                {
                    Debug.LogError("RemoteCall UnPackTable error, key type error");
                    throw new NotImplementedException();
                }
            }
            retArray.Add(luaTab);
            return(tabSize);
        }
示例#3
0
        private KSDType UnPackUp(MemoryStream stream, BinaryReader reader, ArrayList retArray)
        {
            KSDType eRet = (KSDType)stream.ReadByte();

            switch (eRet)
            {
            case KSDType.kstBool:
                UnPackupBoolean(stream, reader, retArray);
                break;

            case KSDType.kstUInt8:
                UnPackupUInt8(stream, reader, retArray);
                break;

            case KSDType.kstUInt16:
                UnPackupUInt16(stream, reader, retArray);
                break;

            case KSDType.kstUInt32:
                UnPackupUInt32(stream, reader, retArray);
                break;

            case KSDType.kstInt8:
                UnPackupInt8(stream, reader, retArray);
                break;

            case KSDType.kstInt16:
                UnPackupInt16(stream, reader, retArray);
                break;

            case KSDType.kstInt32:
                UnPackupInt32(stream, reader, retArray);
                break;

            case KSDType.kstFloat:
                UnPackupFloat(stream, reader, retArray);
                break;

            case KSDType.kstDouble:
                UnPackupDouble(stream, reader, retArray);
                break;

            case KSDType.kstString:
                UnPackupString(stream, reader, retArray);
                break;

            case KSDType.kstBigString:
                UnPackupBigString(stream, reader, retArray);
                break;

            case KSDType.kstUInt64:
                UnPackupUInt64(stream, reader, retArray);
                break;

            case KSDType.kstDataStream:
                UnPackTable(stream, reader, retArray);
                break;

            case KSDType.kstNull:
                UnPackupNull(stream, reader, retArray);
                break;

            default:
                Debug.LogError("RemoteCall UnPackUp Error, type  unsupported, type:" + eRet);
                eRet = KSDType.kstInvalid;
                break;
            }
            return(eRet);
        }