Beispiel #1
0
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                switch (num)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 8u:
                    CompanionDefId = input.ReadInt32();
                    break;

                case 18u:
                    if (coords_ == null)
                    {
                        coords_ = new CellCoord();
                    }
                    input.ReadMessage(coords_);
                    break;
                }
            }
        }
Beispiel #2
0
                public void MergeFrom(CodedInputStream input)
                {
                    uint num;

                    while ((num = input.ReadTag()) != 0)
                    {
                        switch (num)
                        {
                        default:
                            _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                            break;

                        case 10u:
                            Name = input.ReadString();
                            break;

                        case 16u:
                            Level = input.ReadInt32();
                            break;

                        case 26u:
                        {
                            int?num2 = _single_weaponId_codec.Read(input);
                            if (!weaponId_.HasValue || num2 != 0)
                            {
                                WeaponId = num2;
                            }
                            break;
                        }
                        }
                    }
                }
                public void MergeFrom(CodedInputStream input)
                {
                    uint num;

                    while ((num = input.ReadTag()) != 0)
                    {
                        switch (num)
                        {
                        default:
                            _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                            break;

                        case 8u:
                            PlayerId = input.ReadInt32();
                            break;

                        case 16u:
                            FightId = input.ReadInt32();
                            break;

                        case 26u:
                            stats_.AddEntriesFrom(input, _map_stats_codec);
                            break;

                        case 32u:
                        case 34u:
                            titles_.AddEntriesFrom(input, _repeated_titles_codec);
                            break;
                        }
                    }
                }
Beispiel #4
0
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                switch (num)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10u:
                    Nickname = input.ReadString();
                    break;

                case 16u:
                    God = input.ReadInt32();
                    break;

                case 24u:
                    WeaponId = input.ReadInt32();
                    break;

                case 32u:
                    Skin = input.ReadInt32();
                    break;
                }
            }
        }
Beispiel #5
0
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                switch (num)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10u:
                    selectedDecks_.AddEntriesFrom(input, _repeated_selectedDecks_codec);
                    break;

                case 18u:
                {
                    int?num2 = _single_selectedWeapon_codec.Read(input);
                    if (!selectedWeapon_.HasValue || num2 != 0)
                    {
                        SelectedWeapon = num2;
                    }
                    break;
                }
                }
            }
        }
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                switch (num)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10u:
                    fightsSnapshots_.AddEntriesFrom(input, _repeated_fightsSnapshots_codec);
                    break;

                case 16u:
                    OwnFightId = input.ReadInt32();
                    break;

                case 24u:
                    OwnPlayerId = input.ReadInt32();
                    break;

                case 34u:
                    ownSpellsIds_.AddEntriesFrom(input, _repeated_ownSpellsIds_codec);
                    break;
                }
            }
        }
Beispiel #7
0
        public void MergeFrom(CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 26: {
                    VerificationKeyVersion = input.ReadString();
                    break;
                }

                case 34: {
                    VerificationKeyId = input.ReadString();
                    break;
                }

                case 42: {
                    SignatureAlgorithm = input.ReadString();
                    break;
                }
                }
            }
        }
Beispiel #8
0
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                switch (num)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 8u:
                    WeaponId = input.ReadInt32();
                    break;

                case 18u:
                {
                    int?num2 = _single_deckId_codec.Read(input);
                    if (!deckId_.HasValue || num2 != 0)
                    {
                        DeckId = num2;
                    }
                    break;
                }
                }
            }
        }
Beispiel #9
0
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                switch (num)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10u:
                {
                    CellCoord cellCoord = new CellCoord();
                    if (valueCase_ == ValueOneofCase.Cell)
                    {
                        cellCoord.MergeFrom(Cell);
                    }
                    input.ReadMessage(cellCoord);
                    Cell = cellCoord;
                    break;
                }

                case 16u:
                    EntityId = input.ReadInt32();
                    break;
                }
            }
        }
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                switch (num)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 8u:
                    CompanionDefId = input.ReadInt32();
                    break;

                case 16u:
                    TargetFightId = input.ReadInt32();
                    break;

                case 24u:
                    TargetPlayerId = input.ReadInt32();
                    break;
                }
            }
        }
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                switch (num)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 8u:
                    Id = input.ReadInt32();
                    break;

                case 16u:
                    Success = input.ReadBool();
                    break;

                case 26u:
                    Result = input.ReadString();
                    break;
                }
            }
        }
Beispiel #12
0
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                switch (num)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10u:
                    if (fightInfo_ == null)
                    {
                        fightInfo_ = new FightInfo();
                    }
                    input.ReadMessage(fightInfo_);
                    break;

                case 16u:
                    FightDefId = input.ReadInt32();
                    break;

                case 24u:
                    FightType = input.ReadInt32();
                    break;
                }
            }
        }
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                switch (num)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 8u:
                    EntityId = input.ReadInt32();
                    break;

                case 18u:
                    path_.AddEntriesFrom(input, _repeated_path_codec);
                    break;

                case 26u:
                {
                    int?num2 = _single_entityToAttackId_codec.Read(input);
                    if (!entityToAttackId_.HasValue || num2 != 0)
                    {
                        EntityToAttackId = num2;
                    }
                    break;
                }
                }
            }
        }
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            }
        }
Beispiel #15
0
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                switch (num)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10u:
                {
                    int?num2 = _single_id_codec.Read(input);
                    if (!id_.HasValue || num2 != 0)
                    {
                        Id = num2;
                    }
                    break;
                }

                case 18u:
                    Name = input.ReadString();
                    break;

                case 24u:
                    God = input.ReadInt32();
                    break;

                case 32u:
                    Weapon = input.ReadInt32();
                    break;

                case 40u:
                case 42u:
                    companions_.AddEntriesFrom(input, _repeated_companions_codec);
                    break;

                case 48u:
                case 50u:
                    spells_.AddEntriesFrom(input, _repeated_spells_codec);
                    break;

                case 56u:
                case 58u:
                    summonings_.AddEntriesFrom(input, _repeated_summonings_codec);
                    break;
                }
            }
        }
        public void MergeFrom(CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10:
                {
                    KeyData = input.ReadBytes();
                    break;
                }

                case 16:
                {
                    TransmissionRiskLevel = input.ReadInt32();
                    break;
                }

                case 24:
                {
                    RollingStartIntervalNumber = input.ReadInt32();
                    break;
                }

                case 32:
                {
                    RollingPeriod = input.ReadInt32();
                    break;
                }

                case 40:
                {
                    ReportType = (Types.ReportType)input.ReadEnum();
                    break;
                }

                case 48:
                {
                    DaysSinceOnsetOfSymptoms = input.ReadSInt32();
                    break;
                }
                }
            }
        }
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                if (num != 8)
                {
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                }
                else
                {
                    result_ = (CmdResult)input.ReadEnum();
                }
            }
        }
Beispiel #18
0
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                if (num != 8)
                {
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                }
                else
                {
                    TurnIndex = input.ReadInt32();
                }
            }
        }
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                if (num != 10)
                {
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                }
                else
                {
                    playerStats_.AddEntriesFrom(input, _repeated_playerStats_codec);
                }
            }
        }
        public void MergeFrom(CodedInputStream input) {
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
      input.ReadRawMessage(this);
#else
            uint tag;
            while ((tag = input.ReadTag()) != 0) {
                switch(tag) {
                    default:
                        _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                        break;
                    case 10: {
                        KeyData = input.ReadBytes();
                        break;
                    }
                    case 16: {
                        RollingStartIntervalNumber = input.ReadUInt32();
                        break;
                    }
                    case 24: {
                        RollingPeriod = input.ReadUInt32();
                        break;
                    }
                    case 32: {
                        TransmissionRiskLevel = input.ReadInt32();
                        break;
                    }
                    case 42: {
                        visitedCountries_.AddEntriesFrom(input, _repeated_visitedCountries_codec);
                        break;
                    }
                    case 50: {
                        Origin = input.ReadString();
                        break;
                    }
                    case 56: {
                        ReportType = (global::Iks.Protobuf.EfgsReportType) input.ReadEnum();
                        break;
                    }
                    case 64: {
                        DaysSinceOnsetOfSymptoms = input.ReadSInt32();
                        break;
                    }
                }
            }
#endif
        }
Beispiel #21
0
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                if (num != 10)
                {
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    continue;
                }
                if (info_ == null)
                {
                    info_ = new DeckInfo();
                }
                input.ReadMessage(info_);
            }
        }
        public void MergeFrom(CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10: {
                    KeyData = input.ReadBytes();
                    break;
                }

                case 16: {
                    TransmissionRiskLevel = input.ReadInt32();
                    break;
                }

                case 24: {
                    RollingStartIntervalNumber = input.ReadInt32();
                    break;
                }

                case 32: {
                    RollingPeriod = input.ReadInt32();
                    break;
                }

                case 40: {
                    ReportType = (global::NL.Rijksoverheid.ExposureNotification.BackEnd.GeneratedGaenFormat.TemporaryExposureKey.Types.ReportType)input.ReadEnum();
                    break;
                }

                case 48: {
                    DaysSinceOnsetOfSymptoms = input.ReadSInt32();
                    break;
                }
                }
            }
        }
Beispiel #23
0
        public void MergeFrom(CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10:
                {
                    if (signatureInfo_ == null)
                    {
                        SignatureInfo = new SignatureInfo();
                    }

                    input.ReadMessage(SignatureInfo);
                    break;
                }

                case 16:
                {
                    BatchNum = input.ReadInt32();
                    break;
                }

                case 24:
                {
                    BatchSize = input.ReadInt32();
                    break;
                }

                case 34:
                {
                    Signature = input.ReadBytes();
                    break;
                }
                }
            }
        }
        public void MergeFrom(CodedInputStream input)
        {
            uint tag;

            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10: {
                    signatures_.AddEntriesFrom(input, _repeated_signatures_codec);
                    break;
                }
                }
            }
        }
Beispiel #25
0
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                switch (num)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 8u:
                    FightDefId = input.ReadInt32();
                    break;

                case 16u:
                    FightMapId = input.ReadInt32();
                    break;

                case 24u:
                    FightType = input.ReadInt32();
                    break;

                case 32u:
                    ConcurrentFightsCount = input.ReadInt32();
                    break;

                case 40u:
                    OwnFightId = input.ReadInt32();
                    break;

                case 48u:
                    OwnTeamIndex = input.ReadInt32();
                    break;

                case 58u:
                    teams_.AddEntriesFrom(input, _repeated_teams_codec);
                    break;
                }
            }
        }
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                switch (num)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10u:
                    if (spell_ == null)
                    {
                        spell_ = new SpellInfo();
                    }
                    input.ReadMessage(spell_);
                    break;

                case 16u:
                    from_ = (SpellMovementZone)input.ReadEnum();
                    break;

                case 24u:
                    to_ = (SpellMovementZone)input.ReadEnum();
                    break;

                case 34u:
                {
                    bool?flag = _single_discardedBecauseHandWasFull_codec.Read(input);
                    if (!discardedBecauseHandWasFull_.HasValue || flag != false)
                    {
                        DiscardedBecauseHandWasFull = flag;
                    }
                    break;
                }
                }
            }
        }
Beispiel #27
0
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                switch (num)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 8u:
                    result_ = (CmdResult)input.ReadEnum();
                    break;

                case 16u:
                    DeckId = input.ReadInt32();
                    break;
                }
            }
        }
Beispiel #28
0
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                switch (num)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 8u:
                    SpellDefId = input.ReadInt32();
                    break;

                case 16u:
                    SpellInstanceId = input.ReadInt32();
                    break;
                }
            }
        }
Beispiel #29
0
        public void MergeFrom(CodedInputStream input)
        {
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
            input.ReadRawMessage(this);
#else
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 10: {
                    keys_.AddEntriesFrom(input, _repeated_keys_codec);
                    break;
                }
                }
            }
#endif
        }
Beispiel #30
0
        public void MergeFrom(CodedInputStream input)
        {
            uint num;

            while ((num = input.ReadTag()) != 0)
            {
                switch (num)
                {
                default:
                    _unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
                    break;

                case 8u:
                    FightId = input.ReadInt32();
                    break;

                case 18u:
                    events_.AddEntriesFrom(input, _repeated_events_codec);
                    break;
                }
            }
        }