public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;

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

                case 10: {
                    global::WUProtos.Data.Client.ClientEncounterStageSwish subBuilder = new global::WUProtos.Data.Client.ClientEncounterStageSwish();
                    if (typeCase_ == TypeOneofCase.Swish)
                    {
                        subBuilder.MergeFrom(Swish);
                    }
                    input.ReadMessage(subBuilder);
                    Swish = subBuilder;
                    break;
                }

                case 18: {
                    global::WUProtos.Data.Client.ClientEncounterStageCombat subBuilder = new global::WUProtos.Data.Client.ClientEncounterStageCombat();
                    if (typeCase_ == TypeOneofCase.Combat)
                    {
                        subBuilder.MergeFrom(Combat);
                    }
                    input.ReadMessage(subBuilder);
                    Combat = subBuilder;
                    break;
                }

                case 26: {
                    global::WUProtos.Data.Client.ClientEncounterStagePortkey subBuilder = new global::WUProtos.Data.Client.ClientEncounterStagePortkey();
                    if (typeCase_ == TypeOneofCase.Portkey)
                    {
                        subBuilder.MergeFrom(Portkey);
                    }
                    input.ReadMessage(subBuilder);
                    Portkey = subBuilder;
                    break;
                }

                case 34: {
                    global::WUProtos.Data.Client.ClientEncounterStagePicture subBuilder = new global::WUProtos.Data.Client.ClientEncounterStagePicture();
                    if (typeCase_ == TypeOneofCase.Picture)
                    {
                        subBuilder.MergeFrom(Picture);
                    }
                    input.ReadMessage(subBuilder);
                    Picture = subBuilder;
                    break;
                }

                case 45: {
                    DisappearDelay = input.ReadFloat();
                    break;
                }

                case 50: {
                    IntroText = input.ReadString();
                    break;
                }

                case 58: {
                    stageSetupSequence_.AddEntriesFrom(input, _repeated_stageSetupSequence_codec);
                    break;
                }

                case 66: {
                    stageCompletionSequence_.AddEntriesFrom(input, _repeated_stageCompletionSequence_codec);
                    break;
                }

                case 74: {
                    SpellAimLayout = input.ReadString();
                    break;
                }

                case 82: {
                    idleLoopTimelines_.AddEntriesFrom(input, _repeated_idleLoopTimelines_codec);
                    break;
                }

                case 90: {
                    RngIntroTimeline = input.ReadString();
                    break;
                }

                case 98: {
                    RngLoopTimeline = input.ReadString();
                    break;
                }

                case 106: {
                    SpellFailedTimeline = input.ReadString();
                    break;
                }

                case 114: {
                    combatSpellList_.AddEntriesFrom(input, _repeated_combatSpellList_codec);
                    break;
                }
                }
            }
        }
        public void MergeFrom(ClientEncounterStage other)
        {
            if (other == null)
            {
                return;
            }
            if (other.DisappearDelay != 0F)
            {
                DisappearDelay = other.DisappearDelay;
            }
            if (other.IntroText.Length != 0)
            {
                IntroText = other.IntroText;
            }
            stageSetupSequence_.Add(other.stageSetupSequence_);
            stageCompletionSequence_.Add(other.stageCompletionSequence_);
            if (other.SpellAimLayout.Length != 0)
            {
                SpellAimLayout = other.SpellAimLayout;
            }
            idleLoopTimelines_.Add(other.idleLoopTimelines_);
            if (other.RngIntroTimeline.Length != 0)
            {
                RngIntroTimeline = other.RngIntroTimeline;
            }
            if (other.RngLoopTimeline.Length != 0)
            {
                RngLoopTimeline = other.RngLoopTimeline;
            }
            if (other.SpellFailedTimeline.Length != 0)
            {
                SpellFailedTimeline = other.SpellFailedTimeline;
            }
            combatSpellList_.Add(other.combatSpellList_);
            switch (other.TypeCase)
            {
            case TypeOneofCase.Swish:
                if (Swish == null)
                {
                    Swish = new global::WUProtos.Data.Client.ClientEncounterStageSwish();
                }
                Swish.MergeFrom(other.Swish);
                break;

            case TypeOneofCase.Combat:
                if (Combat == null)
                {
                    Combat = new global::WUProtos.Data.Client.ClientEncounterStageCombat();
                }
                Combat.MergeFrom(other.Combat);
                break;

            case TypeOneofCase.Portkey:
                if (Portkey == null)
                {
                    Portkey = new global::WUProtos.Data.Client.ClientEncounterStagePortkey();
                }
                Portkey.MergeFrom(other.Portkey);
                break;

            case TypeOneofCase.Picture:
                if (Picture == null)
                {
                    Picture = new global::WUProtos.Data.Client.ClientEncounterStagePicture();
                }
                Picture.MergeFrom(other.Picture);
                break;
            }

            _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
        }