Пример #1
0
        public override void WriteTo(pb::CodedOutputStream output)
        {
            int size = SerializedSize;

            if (recipes_.Count > 0)
            {
                foreach (int element in recipes_)
                {
                    output.WriteSFixed32(1, element);
                }
            }
            if (availableEnchants_.Count > 0)
            {
                foreach (int element in availableEnchants_)
                {
                    output.WriteSFixed32(2, element);
                }
            }
            if (HasLevel)
            {
                output.WriteInt32(3, Level);
            }
            if (HasCooldownEnd)
            {
                output.WriteSFixed64(4, CooldownEnd);
            }
            UnknownFields.WriteTo(output);
        }
Пример #2
0
 public void WriteTo(pb::CodedOutputStream output)
 {
     if (Id != 0)
     {
         output.WriteRawTag(13);
         output.WriteSFixed32(Id);
     }
     if (Category.Length != 0)
     {
         output.WriteRawTag(18);
         output.WriteBytes(Category);
     }
     if (Rawname.Length != 0)
     {
         output.WriteRawTag(26);
         output.WriteBytes(Rawname);
     }
     if (Name.Length != 0)
     {
         output.WriteRawTag(34);
         output.WriteBytes(Name);
     }
     if (Crowdness.Length != 0)
     {
         output.WriteRawTag(42);
         output.WriteBytes(Crowdness);
     }
     if (Open.Length != 0)
     {
         output.WriteRawTag(50);
         output.WriteBytes(Open);
     }
     if (Ip != 0)
     {
         output.WriteRawTag(61);
         output.WriteSFixed32(Ip);
     }
     if (Port != 0)
     {
         output.WriteRawTag(69);
         output.WriteSFixed32(Port);
     }
     if (Lang != 0)
     {
         output.WriteRawTag(77);
         output.WriteSFixed32(Lang);
     }
     if (Popup.Length != 0)
     {
         output.WriteRawTag(82);
         output.WriteBytes(Popup);
     }
     if (_unknownFields != null)
     {
         _unknownFields.WriteTo(output);
     }
 }
Пример #3
0
        public void WriteTo(pb::CodedOutputStream output)
        {
            servers_.WriteTo(output, _repeated_servers_codec);
            output.WriteRawTag(21);
            output.WriteSFixed32(LastPlayedId);
            output.WriteRawTag(29);
            output.WriteSFixed32(Unknwn);

            if (_unknownFields != null)
            {
                _unknownFields.WriteTo(output);
            }
        }
Пример #4
0
 public void WriteTo(pb::CodedOutputStream output)
 {
     if (HirelingClass != 0)
     {
         output.WriteRawTag(8);
         output.WriteSInt32(HirelingClass);
     }
     if (GbidName != 0)
     {
         output.WriteRawTag(21);
         output.WriteSFixed32(GbidName);
     }
     if (LevelDeprecated != 0)
     {
         output.WriteRawTag(24);
         output.WriteSInt32(LevelDeprecated);
     }
     if (AttributeExperienceNextDeprecated != 0)
     {
         output.WriteRawTag(32);
         output.WriteUInt32(AttributeExperienceNextDeprecated);
     }
     powerKeyParams_.WriteTo(output, _repeated_powerKeyParams_codec);
     if (Dead != false)
     {
         output.WriteRawTag(48);
         output.WriteBool(Dead);
     }
     if (_unknownFields != null)
     {
         _unknownFields.WriteTo(output);
     }
 }
Пример #5
0
        public override void WriteTo(pb::CodedOutputStream output)
        {
            int size = SerializedSize;

            if (HasHirelingClass)
            {
                output.WriteSInt32(1, HirelingClass);
            }
            if (HasGbidName)
            {
                output.WriteSFixed32(2, GbidName);
            }
            if (HasLevel)
            {
                output.WriteSInt32(3, Level);
            }
            if (HasAttributeExperienceNext)
            {
                output.WriteUInt32(4, AttributeExperienceNext);
            }
            if (powerKeyParams_.Count > 0)
            {
                foreach (int element in powerKeyParams_)
                {
                    output.WriteSInt32(11, element);
                }
            }
            if (HasDead)
            {
                output.WriteBool(12, Dead);
            }
            UnknownFields.WriteTo(output);
        }
Пример #6
0
 public void WriteTo(pb::CodedOutputStream output)
 {
     if (ServerTimestamp != 0)
     {
         output.WriteRawTag(13);
         output.WriteSFixed32(ServerTimestamp);
     }
     if (ClientIp != 0)
     {
         output.WriteRawTag(21);
         output.WriteFixed32(ClientIp);
     }
     if (RedirectIp != 0)
     {
         output.WriteRawTag(29);
         output.WriteFixed32(RedirectIp);
     }
     if (RedirectPort != 0)
     {
         output.WriteRawTag(32);
         output.WriteUInt32(RedirectPort);
     }
     if (_unknownFields != null)
     {
         _unknownFields.WriteTo(output);
     }
 }
Пример #7
0
     public void WriteTo(pb::CodedOutputStream output)
     {
 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
         output.WriteRawMessage(this);
 #else
         if (ServerTimestamp != 0)
         {
             output.WriteRawTag(13);
             output.WriteSFixed32(ServerTimestamp);
         }
         if (ClientIp != 0)
         {
             output.WriteRawTag(21);
             output.WriteFixed32(ClientIp);
         }
         if (RedirectIp != 0)
         {
             output.WriteRawTag(29);
             output.WriteFixed32(RedirectIp);
         }
         if (RedirectPort != 0)
         {
             output.WriteRawTag(32);
             output.WriteUInt32(RedirectPort);
         }
         if (_unknownFields != null)
         {
             _unknownFields.WriteTo(output);
         }
 #endif
     }
Пример #8
0
        public override void WriteTo(pb::CodedOutputStream output)
        {
            int size = SerializedSize;

            if (HasGameBalanceType)
            {
                output.WriteSInt32(1, GameBalanceType);
            }
            if (HasGbid)
            {
                output.WriteSFixed32(2, Gbid);
            }
            UnknownFields.WriteTo(output);
        }
Пример #9
0
 public void WriteTo(pb::CodedOutputStream output)
 {
     if (Id != 0)
     {
         output.WriteRawTag(13);
         output.WriteSFixed32(Id);
     }
     if (Name.Length != 0)
     {
         output.WriteRawTag(18);
         output.WriteString(Name);
     }
     if (_unknownFields != null)
     {
         _unknownFields.WriteTo(output);
     }
 }
Пример #10
0
 public void WriteTo(pb::CodedOutputStream output)
 {
     if (Units != 0L)
     {
         output.WriteRawTag(8);
         output.WriteInt64(Units);
     }
     if (Nanos != 0)
     {
         output.WriteRawTag(21);
         output.WriteSFixed32(Nanos);
     }
     if (_unknownFields != null)
     {
         _unknownFields.WriteTo(output);
     }
 }
Пример #11
0
 public void WriteTo(pb::CodedOutputStream output)
 {
     if (GameBalanceType != 0)
     {
         output.WriteRawTag(8);
         output.WriteSInt32(GameBalanceType);
     }
     if (Gbid != 0)
     {
         output.WriteRawTag(21);
         output.WriteSFixed32(Gbid);
     }
     if (_unknownFields != null)
     {
         _unknownFields.WriteTo(output);
     }
 }
Пример #12
0
 public void WriteTo(pb::CodedOutputStream output)
 {
     if (Gbid != 0)
     {
         output.WriteRawTag(13);
         output.WriteSFixed32(Gbid);
     }
     if (ExpirationTime != 0L)
     {
         output.WriteRawTag(16);
         output.WriteInt64(ExpirationTime);
     }
     if (_unknownFields != null)
     {
         _unknownFields.WriteTo(output);
     }
 }
Пример #13
0
 public void WriteTo(pb::CodedOutputStream output)
 {
     if (Double10 != 0D)
     {
         output.WriteRawTag(81);
         output.WriteDouble(Double10);
     }
     if (Float11 != 0F)
     {
         output.WriteRawTag(93);
         output.WriteFloat(Float11);
     }
     if (Int3221 != 0)
     {
         output.WriteRawTag(168, 1);
         output.WriteInt32(Int3221);
     }
     if (Int6422 != 0L)
     {
         output.WriteRawTag(176, 1);
         output.WriteInt64(Int6422);
     }
     if (Uint3230 != 0)
     {
         output.WriteRawTag(240, 1);
         output.WriteUInt32(Uint3230);
     }
     if (Uint6431 != 0UL)
     {
         output.WriteRawTag(248, 1);
         output.WriteUInt64(Uint6431);
     }
     if (Sint3235 != 0)
     {
         output.WriteRawTag(152, 2);
         output.WriteSInt32(Sint3235);
     }
     if (Sint6436 != 0L)
     {
         output.WriteRawTag(160, 2);
         output.WriteSInt64(Sint6436);
     }
     if (Fixed3240 != 0)
     {
         output.WriteRawTag(197, 2);
         output.WriteFixed32(Fixed3240);
     }
     if (Fixed6441 != 0UL)
     {
         output.WriteRawTag(201, 2);
         output.WriteFixed64(Fixed6441);
     }
     if (Sfixed3245 != 0)
     {
         output.WriteRawTag(237, 2);
         output.WriteSFixed32(Sfixed3245);
     }
     if (Sfixed6446 != 0L)
     {
         output.WriteRawTag(241, 2);
         output.WriteSFixed64(Sfixed6446);
     }
     if (Bool70 != false)
     {
         output.WriteRawTag(176, 4);
         output.WriteBool(Bool70);
     }
     if (String71.Length != 0)
     {
         output.WriteRawTag(186, 4);
         output.WriteString(String71);
     }
     if (Bytes72.Length != 0)
     {
         output.WriteRawTag(194, 4);
         output.WriteBytes(Bytes72);
     }
     if (Type80 != 0)
     {
         output.WriteRawTag(128, 5);
         output.WriteEnum((int)Type80);
     }
     map100_.WriteTo(output, _map_map100_codec);
     stringList101_.WriteTo(output, _repeated_stringList101_codec);
     int32List102_.WriteTo(output, _repeated_int32List102_codec);
     map110_.WriteTo(output, _map_map110_codec);
     if (user_ != null)
     {
         output.WriteRawTag(146, 8);
         output.WriteMessage(User);
     }
     users_.WriteTo(output, _repeated_users_codec);
     map132_.WriteTo(output, _map_map132_codec);
     if (testOneofCase_ == TestOneofOneofCase.OfName300)
     {
         output.WriteRawTag(226, 18);
         output.WriteString(OfName300);
     }
     if (testOneofCase_ == TestOneofOneofCase.OfName2301)
     {
         output.WriteRawTag(234, 18);
         output.WriteString(OfName2301);
     }
     if (_unknownFields != null)
     {
         _unknownFields.WriteTo(output);
     }
 }
Пример #14
0
 public void WriteTo(pb::CodedOutputStream output)
 {
     if (ScDouble != 0D)
     {
         output.WriteRawTag(9);
         output.WriteDouble(ScDouble);
     }
     if (ScFloat != 0F)
     {
         output.WriteRawTag(21);
         output.WriteFloat(ScFloat);
     }
     if (ScInt32 != 0)
     {
         output.WriteRawTag(24);
         output.WriteInt32(ScInt32);
     }
     if (ScInt64 != 0L)
     {
         output.WriteRawTag(32);
         output.WriteInt64(ScInt64);
     }
     if (ScUint32 != 0)
     {
         output.WriteRawTag(40);
         output.WriteUInt32(ScUint32);
     }
     if (ScUint64 != 0UL)
     {
         output.WriteRawTag(48);
         output.WriteUInt64(ScUint64);
     }
     if (ScSint32 != 0)
     {
         output.WriteRawTag(56);
         output.WriteSInt32(ScSint32);
     }
     if (ScSint64 != 0L)
     {
         output.WriteRawTag(64);
         output.WriteSInt64(ScSint64);
     }
     if (ScFixed32 != 0)
     {
         output.WriteRawTag(77);
         output.WriteFixed32(ScFixed32);
     }
     if (ScFixed64 != 0UL)
     {
         output.WriteRawTag(81);
         output.WriteFixed64(ScFixed64);
     }
     if (ScSfixed32 != 0)
     {
         output.WriteRawTag(93);
         output.WriteSFixed32(ScSfixed32);
     }
     if (ScSfixed64 != 0L)
     {
         output.WriteRawTag(97);
         output.WriteSFixed64(ScSfixed64);
     }
     if (ScBool != false)
     {
         output.WriteRawTag(104);
         output.WriteBool(ScBool);
     }
     if (ScString.Length != 0)
     {
         output.WriteRawTag(114);
         output.WriteString(ScString);
     }
     if (ScBytes.Length != 0)
     {
         output.WriteRawTag(122);
         output.WriteBytes(ScBytes);
     }
     if (TEnum != 0)
     {
         output.WriteRawTag(128, 1);
         output.WriteEnum((int)TEnum);
     }
     if (TEnum2 != 0)
     {
         output.WriteRawTag(136, 1);
         output.WriteEnum((int)TEnum2);
     }
     if (tClass_ != null)
     {
         output.WriteRawTag(146, 1);
         output.WriteMessage(TClass);
     }
     if (tNestType_ != null)
     {
         output.WriteRawTag(154, 1);
         output.WriteMessage(TNestType);
     }
     repInt32_.WriteTo(output, _repeated_repInt32_codec);
     repString_.WriteTo(output, _repeated_repString_codec);
     repBytes_.WriteTo(output, _repeated_repBytes_codec);
     repEnum_.WriteTo(output, _repeated_repEnum_codec);
     repType_.WriteTo(output, _repeated_repType_codec);
 }