Beispiel #1
0
        // CStage 実装

        public override void OnActivate()
        {
            int nGraphUsePart = CDTXMania.ConfigIni.bGraph有効.Guitar ? 1 : 2;

            this.ct登場用           = new CCounter(0, 12, 16, CDTXMania.Timer);
            dtLastQueueOperation = DateTime.MinValue;
            if (CDTXMania.bCompactMode)
            {
                var score = new CScore();
                CDTXMania.SongManager.tReadScoreIniAndSetScoreInformation(CDTXMania.strCompactModeFile + ".score.ini", ref score);
                this.actGraph.dbGraphValue_Goal = score.SongInformation.HighSkill[nGraphUsePart];
            }
            else
            {
                this.actGraph.dbGraphValue_Goal         = CDTXMania.stageSongSelection.rChosenScore.SongInformation.HighSkill[nGraphUsePart];           // #24074 2011.01.23 add ikanick
                this.actGraph.dbGraphValue_PersonalBest = CDTXMania.stageSongSelection.rChosenScore.SongInformation.HighSkill[nGraphUsePart];

                // #35411 2015.08.21 chnmr0 add
                // ゴースト利用可のなとき、0で初期化
                if (CDTXMania.ConfigIni.eTargetGhost[nGraphUsePart] != ETargetGhostData.NONE)
                {
                    if (CDTXMania.listTargetGhsotLag[nGraphUsePart] != null)
                    {
                        this.actGraph.dbGraphValue_Goal = 0;
                    }
                }
            }
            base.OnActivate();
        }
Beispiel #2
0
        public void t選択曲が変更された()
        {
            CScore cスコア = CDTXMania.stageSongSelection.rSelectedScore;

            if ((cスコア != null) && !CDTXMania.stageSongSelection.bScrolling)
            {
                try
                {
                    Bitmap   image    = new Bitmap(800, 0xc3);
                    Graphics graphics = Graphics.FromImage(image);
                    graphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
                    for (int i = 0; i < 5; i++)
                    {
                        if ((cスコア.SongInformation.PerformanceHistory[i] != null) && (cスコア.SongInformation.PerformanceHistory[i].Length > 0))
                        {
                            graphics.DrawString(cスコア.SongInformation.PerformanceHistory[i], this.ft表示用フォント, Brushes.Yellow, (float)0f, (float)(i * 36f));
                        }
                    }
                    graphics.Dispose();
                    if (this.tx文字列パネル != null)
                    {
                        this.tx文字列パネル.Dispose();
                    }
                    this.tx文字列パネル = new CTexture(CDTXMania.app.Device, image, CDTXMania.TextureFormat);
                    this.tx文字列パネル.vcScaleRatio = new Vector3(0.5f, 0.5f, 1f);
                    image.Dispose();
                }
                catch (CTextureCreateFailedException)
                {
                    Trace.TraceError("演奏履歴文字列テクスチャの作成に失敗しました。");
                    this.tx文字列パネル = null;
                }
            }
        }
Beispiel #3
0
        private void tプレビューサウンドの作成()
        {
            CScore cスコア = CDTXMania.stageSongSelection.rSelectedScore;

            if ((cスコア != null) && !string.IsNullOrEmpty(cスコア.SongInformation.Presound))
            {
                string strPreviewFilename = cスコア.FileInformation.AbsoluteFolderPath + cスコア.SongInformation.Presound;
                try
                {
                    this.sound         = CDTXMania.SoundManager.tGenerateSound(strPreviewFilename);
                    this.sound.nVolume = 80;                            // CDTXMania.ConfigIni.n自動再生音量;			// #25217 changed preview volume from AutoVolume
                    this.sound.tStartPlaying(true);
                    this.str現在のファイル名 = strPreviewFilename;
                    this.tBGMフェードアウト開始();
                    Trace.TraceInformation("プレビューサウンドを生成しました。({0})", strPreviewFilename);
                }
                catch
                {
                    Trace.TraceError("プレビューサウンドの生成に失敗しました。({0})", strPreviewFilename);
                    if (this.sound != null)
                    {
                        this.sound.Dispose();
                    }
                    this.sound = null;
                }
            }
        }
        private bool tプレビュー画像の指定があれば構築する()
        {
            CScore cスコア = CDTXMania.stageSongSelection.rSelectedScore;

            if ((cスコア == null) || string.IsNullOrEmpty(cスコア.SongInformation.Preimage))
            {
                return(false);
            }
            string str = cスコア.FileInformation.AbsoluteFolderPath + cスコア.SongInformation.Preimage;

            if (!str.Equals(this.str現在のファイル名))
            {
                CDTXMania.tReleaseTexture(ref this.txプレビュー画像);
                this.str現在のファイル名 = str;
                if (!File.Exists(this.str現在のファイル名))
                {
                    Trace.TraceWarning("ファイルが存在しません。({0})", new object[] { this.str現在のファイル名 });
                    return(false);
                }
                this.txプレビュー画像 = CDTXMania.tGenerateTexture(this.str現在のファイル名, false);
                if (this.txプレビュー画像 != null)
                {
                    this.r表示するプレビュー画像 = this.txプレビュー画像;
                }
                else
                {
                    this.r表示するプレビュー画像 = this.txプレビュー画像がないときの画像;
                }
            }
            return(true);
        }
Beispiel #5
0
        public void t選択曲が変更された()
        {
            CScore cスコア = CDTXMania.stageSongSelection.rSelectedScore;

            if ((cスコア != null) && ((!(cスコア.FileInformation.AbsoluteFolderPath + cスコア.SongInformation.Presound).Equals(this.str現在のファイル名) || (this.sound == null)) || !this.sound.b再生中))
            {
                this.tサウンド停止();
                this.tBGMフェードイン開始();
                if ((cスコア.SongInformation.Presound != null) && (cスコア.SongInformation.Presound.Length > 0))
                {
                    this.ct再生待ちウェイト = new CCounter(0, CDTXMania.ConfigIni.n曲が選択されてからプレビュー音が鳴るまでのウェイトms, 1, CDTXMania.Timer);
                }
            }
        }
Beispiel #6
0
        private void tCreateBestProgressBarRecordTexture(CScore cScore)
        {
            if (cScore != null)
            {
                for (EInstrumentPart ePart = EInstrumentPart.DRUMS; ePart <= EInstrumentPart.BASS; ePart++)
                {
                    //Need to check for guitar/bass swap because Hi-Scores, Hi-Skills records are never swapped during Performance
                    CTexture currTexture = null;
                    txGenerateProgressBarLine(ref currTexture,
                                              cScore.SongInformation.progress[(int)CDTXMania.ConfigIni.GetFlipInst(ePart)]
                                              );

                    txBestProgressBarRecord[(int)ePart] = currTexture;
                }
            }
        }
Beispiel #7
0
        public void t選択曲が変更された()
        {
            if (base.bNotActivated)
            {
                return;
            }
            for (EInstrumentPart ePart = EInstrumentPart.DRUMS; ePart <= EInstrumentPart.BASS; ePart++)
            {
                for (int i = 0; i < nSectionIntervalCount; i++)
                {
                    CProgressSection c区間 = listProgressSection[(int)ePart][i];
                    c区間.nChipCount             = 0;
                    c区間.nHitCount              = 0;
                    c区間.rectDrawingFrame.Width = 0;
                }
            }
            CScore r現在選択中のスコア = CDTXMania.stageSongSelection.rSelectedScore;

            if (r現在選択中のスコア != null)
            {
                //Use config.ini Drums / Guitar enabled to decide
                epartプレイ楽器 = EInstrumentPart.UNKNOWN;
                if (CDTXMania.ConfigIni.bDrumsEnabled)
                {
                    epartプレイ楽器 = EInstrumentPart.DRUMS;
                }
                else
                {
                    epartプレイ楽器 = EInstrumentPart.GUITAR;
                    if (CDTXMania.ConfigIni.bIsSwappedGuitarBass)
                    {
                        epartプレイ楽器 = EInstrumentPart.BASS;
                    }
                }
                //epartプレイ楽器 = CDTXMania.stageSongSelection.tオートを参考にこれからプレイするであろうパートを推測する();
                //epartプレイ楽器 = CDTXMania.ConfigIni.GetFlipInst(epartプレイ楽器);
                if (epartプレイ楽器 >= EInstrumentPart.DRUMS && epartプレイ楽器 <= EInstrumentPart.BASS && r現在選択中のスコア.SongInformation.progress[(int)epartプレイ楽器] != null)
                {
                    char[] arrプログレス = r現在選択中のスコア.SongInformation.progress[(int)epartプレイ楽器].ToCharArray();
                    tプログレス配列から区間情報を設定する(arrプログレス);
                }
            }
        }
        private bool tプレビュー動画の指定があれば構築する()
        {
            CScore cスコア = CDTXMania.stageSongSelection.rSelectedScore;

            if ((CDTXMania.ConfigIni.bAVIEnabled && (cスコア != null)) && !string.IsNullOrEmpty(cスコア.SongInformation.Premovie))
            {
                string filename = cスコア.FileInformation.AbsoluteFolderPath + cスコア.SongInformation.Premovie;
                if (filename.Equals(this.str現在のファイル名))
                {
                    return(true);
                }
                if (this.rAVI != null)
                {
                    this.rAVI.Dispose();
                    this.rAVI = null;
                }
                this.str現在のファイル名 = filename;
                if (!File.Exists(this.str現在のファイル名))
                {
                    Trace.TraceWarning("ファイルが存在しません。({0})", new object[] { this.str現在のファイル名 });
                    return(false);
                }
                try
                {
                    CDTX.CAVI cAVI = new CDTX.CAVI(0, filename, "", (int)CDTXMania.ConfigIni.nPlaySpeed);
                    cAVI.OnDeviceCreated();

                    this.rAVI          = cAVI;
                    this.nAVI再生開始時刻    = CDTXMania.Timer.nCurrentTime;
                    this.n前回描画したフレーム番号 = -1;
                    this.b動画フレームを作成した  = false;
                    this.tサーフェイスをクリアする(this.sfAVI画像);
                    Trace.TraceInformation("動画を生成しました。({0})", new object[] { filename });
                }
                catch
                {
                    Trace.TraceError("動画の生成に失敗しました。({0})", new object[] { filename });
                    this.rAVI       = null;
                    this.nAVI再生開始時刻 = -1;
                }
            }
            return(false);
        }
Beispiel #9
0
        public void t選択曲が変更された()
        {
            CScore cスコア = CDTXMania.stageSongSelection.rSelectedScore;

            if (cスコア != null)
            {
                Bitmap image = new Bitmap(1, 1);
                CDTXMania.tReleaseTexture(ref this.txArtist);
                this.strArtist = cスコア.SongInformation.ArtistName;
                if ((this.strArtist != null) && (this.strArtist.Length > 0))
                {
                    Graphics graphics = Graphics.FromImage(image);
                    graphics.PageUnit = GraphicsUnit.Pixel;
                    SizeF ef = graphics.MeasureString(this.strArtist, this.ft描画用フォント);
                    graphics.Dispose();
                    //if (ef.Width > SampleFramework.GameWindowSize.Width)
                    //{
                    //	ef.Width = SampleFramework.GameWindowSize.Width;
                    //}
                    try
                    {
                        //Fix length issue of Artist using the same method used for Song Title
                        int nLargestLengthPx  = 510;                          //510px is the available space for artist in the bar
                        int widthAfterScaling = (int)((ef.Width + 2) * 0.5f); //+2 buffer
                        if (widthAfterScaling > (CDTXMania.app.Device.Capabilities.MaxTextureWidth / 2))
                        {
                            widthAfterScaling = CDTXMania.app.Device.Capabilities.MaxTextureWidth / 2;                              // 右端断ち切れ仕方ないよね
                        }
                        //Compute horizontal scaling factor
                        float f拡大率X = (widthAfterScaling <= nLargestLengthPx) ? 0.5f : (((float)nLargestLengthPx / (float)widthAfterScaling) * 0.5f);                           // 長い文字列は横方向に圧縮。
                        //ef.Width
                        Bitmap bitmap2 = new Bitmap((int)Math.Ceiling((double)widthAfterScaling * 2), (int)Math.Ceiling((double)this.ft描画用フォント.Size));
                        graphics = Graphics.FromImage(bitmap2);
                        graphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
                        graphics.DrawString(this.strArtist, this.ft描画用フォント, Brushes.White, ( float )0f, ( float )0f);
                        graphics.Dispose();
                        this.txArtist = new CTexture(CDTXMania.app.Device, bitmap2, CDTXMania.TextureFormat);
                        this.txArtist.vcScaleRatio = new Vector3(f拡大率X, 0.5f, 1f);
                        bitmap2.Dispose();
                    }
                    catch (CTextureCreateFailedException)
                    {
                        Trace.TraceError("ARTISTテクスチャの生成に失敗しました。");
                        this.txArtist = null;
                    }
                }
                CDTXMania.tReleaseTexture(ref this.txComment);
                this.strComment = cスコア.SongInformation.Comment;
                if ((this.strComment != null) && (this.strComment.Length > 0))
                {
                    Graphics graphics2 = Graphics.FromImage(image);
                    graphics2.PageUnit = GraphicsUnit.Pixel;
                    SizeF ef2  = graphics2.MeasureString(this.strComment, this.ft描画用フォント);
                    Size  size = new Size((int)Math.Ceiling((double)ef2.Width), (int)Math.Ceiling((double)ef2.Height));
                    graphics2.Dispose();
                    this.nテクスチャの最大幅 = CDTXMania.app.Device.Capabilities.MaxTextureWidth;
                    int    maxTextureHeight = CDTXMania.app.Device.Capabilities.MaxTextureHeight;
                    Bitmap bitmap3          = new Bitmap(size.Width, (int)Math.Ceiling((double)this.ft描画用フォント.Size));
                    graphics2 = Graphics.FromImage(bitmap3);
                    graphics2.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
                    graphics2.DrawString(this.strComment, this.ft描画用フォント, Brushes.White, ( float )0f, ( float )0f);
                    graphics2.Dispose();
                    this.nComment行数    = 1;
                    this.nComment最終行の幅 = size.Width;
                    while (this.nComment最終行の幅 > this.nテクスチャの最大幅)
                    {
                        this.nComment行数++;
                        this.nComment最終行の幅 -= this.nテクスチャの最大幅;
                    }
                    while ((this.nComment行数 * ((int)Math.Ceiling((double)this.ft描画用フォント.Size))) > maxTextureHeight)
                    {
                        this.nComment行数--;
                        this.nComment最終行の幅 = this.nテクスチャの最大幅;
                    }
                    Bitmap bitmap4 = new Bitmap((this.nComment行数 > 1) ? this.nテクスチャの最大幅 : this.nComment最終行の幅, this.nComment行数 * ((int)Math.Ceiling((double)this.ft描画用フォント.Size)));
                    graphics2 = Graphics.FromImage(bitmap4);
                    Rectangle srcRect  = new Rectangle();
                    Rectangle destRect = new Rectangle();
                    for (int i = 0; i < this.nComment行数; i++)
                    {
                        srcRect.X       = i * this.nテクスチャの最大幅;
                        srcRect.Y       = 0;
                        srcRect.Width   = ((i + 1) == this.nComment行数) ? this.nComment最終行の幅 : this.nテクスチャの最大幅;
                        srcRect.Height  = bitmap3.Height;
                        destRect.X      = 0;
                        destRect.Y      = i * bitmap3.Height;
                        destRect.Width  = srcRect.Width;
                        destRect.Height = srcRect.Height;
                        graphics2.DrawImage(bitmap3, destRect, srcRect, GraphicsUnit.Pixel);
                    }
                    graphics2.Dispose();
                    try
                    {
                        this.txComment = new CTexture(CDTXMania.app.Device, bitmap4, CDTXMania.TextureFormat);
                        this.txComment.vcScaleRatio = new Vector3(0.5f, 0.5f, 1f);
                    }
                    catch (CTextureCreateFailedException)
                    {
                        Trace.TraceError("COMMENTテクスチャの生成に失敗しました。");
                        this.txComment = null;
                    }
                    bitmap4.Dispose();
                    bitmap3.Dispose();
                }
                image.Dispose();
                if (this.txComment != null)
                {
                    this.ctComment = new CCounter(-740, (int)((((this.nComment行数 - 1) * this.nテクスチャの最大幅) + this.nComment最終行の幅) * this.txComment.vcScaleRatio.X), 10, CDTXMania.Timer);
                }
            }
        }
        public void tSelectedSongChanged()
        {
            CSongListNode c曲リストノード = CDTXMania.stageSongSelection.r現在選択中の曲;
            CScore        cスコア     = CDTXMania.stageSongSelection.rSelectedScore;

            if ((c曲リストノード != null) && (cスコア != null))
            {
                this.n現在選択中の曲の難易度 = CDTXMania.stageSongSelection.nSelectedSongDifficultyLevel;
                for (int i = 0; i < 3; i++)
                {
                    if (CDTXMania.ConfigIni.nSkillMode == 0)
                    {
                        this.n現在選択中の曲の最高ランク[i] = cスコア.SongInformation.BestRank[i];
                    }
                    else if (CDTXMania.ConfigIni.nSkillMode == 1)
                    {
                        this.n現在選択中の曲の最高ランク[i] = DTXMania.CScoreIni.tCalculateRank(0, cスコア.SongInformation.HighSkill[i]);
                    }

                    this.b現在選択中の曲がフルコンボ[i]   = cスコア.SongInformation.FullCombo[i];
                    this.db現在選択中の曲の最高スキル値[i] = cスコア.SongInformation.HighSkill[i];
                    this.db現在選択中の曲の曲別スキル[i]  = cスコア.SongInformation.HighSongSkill[i];
                    this.b現在選択中の曲の譜面[i]      = cスコア.SongInformation.bScoreExists[i];
                    this.n現在選択中の曲のレベル[i]     = cスコア.SongInformation.Level[i];
                    this.n現在選択中の曲のレベル小数点[i]  = cスコア.SongInformation.LevelDec[i];
                    for (int j = 0; j < 5; j++)
                    {
                        if (c曲リストノード.arScore[j] != null)
                        {
                            this.n現在選択中の曲のレベル難易度毎DGB[j][i]    = c曲リストノード.arScore[j].SongInformation.Level[i];
                            this.n現在選択中の曲のレベル小数点難易度毎DGB[j][i] = c曲リストノード.arScore[j].SongInformation.LevelDec[i];
                            //this.n現在選択中の曲の最高ランク難易度毎[j][i] = c曲リストノード.arScore[j].SongInformation.BestRank[i];
                            if (CDTXMania.ConfigIni.nSkillMode == 0)
                            {
                                this.n現在選択中の曲の最高ランク難易度毎[j][i] = c曲リストノード.arScore[j].SongInformation.BestRank[i];
                            }
                            else if (CDTXMania.ConfigIni.nSkillMode == 1)
                            {
                                // Fix github.com/limyz/DTXmaniaXG/issues/33
                                //this.n現在選択中の曲の最高ランク難易度毎[j][i] = (DTXMania.CScoreIni.tCalculateRank(0, c曲リストノード.arScore[j].SongInformation.HighSkill[i]) == (int)DTXMania.CScoreIni.ERANK.S && DTXMania.CScoreIni.tCalculateRank(0, c曲リストノード.arScore[j].SongInformation.HighSkill[i]) >= 95 ? DTXMania.CScoreIni.tCalculateRank(0, cスコア.SongInformation.HighSkill[i]) : c曲リストノード.arScore[j].SongInformation.BestRank[i]);
                                this.n現在選択中の曲の最高ランク難易度毎[j][i] = DTXMania.CScoreIni.tCalculateRank(0, c曲リストノード.arScore[j].SongInformation.HighSkill[i]);
                            }

                            this.db現在選択中の曲の最高スキル値難易度毎[j][i] = c曲リストノード.arScore[j].SongInformation.HighSkill[i];
                            this.b現在選択中の曲がフルコンボ難易度毎[j][i]   = c曲リストノード.arScore[j].SongInformation.FullCombo[i];
                            this.b現在選択中の曲に譜面がある[j][i]       = c曲リストノード.arScore[j].SongInformation.bScoreExists[i];
                        }
                    }
                }
                for (int i = 0; i < 5; i++)
                {
                    if (c曲リストノード.arScore[i] != null)
                    {
                        int nLevel = c曲リストノード.arScore[i].SongInformation.Level.Drums;
                        if (nLevel < 0)
                        {
                            nLevel = 0;
                        }
                        if (nLevel > 999)
                        {
                            nLevel = 999;
                        }
                        this.n選択中の曲のレベル難易度毎[i] = nLevel;

                        this.db現在選択中の曲の曲別スキル値難易度毎[i] = c曲リストノード.arScore[i].SongInformation.HighSongSkill.Drums;
                    }
                    else
                    {
                        this.n選択中の曲のレベル難易度毎[i] = 0;
                    }
                    this.str難易度ラベル[i] = c曲リストノード.arDifficultyLabel[i];
                }
                if (this.r直前の曲 != c曲リストノード)
                {
                    this.n難易度開始文字位置 = 0;
                }
                this.r直前の曲 = c曲リストノード;
            }
        }
        public override int OnUpdateAndDraw()
        {
            if (!base.bNotActivated)
            {
                #region [ 初めての進行描画 ]
                //-----------------
                if (base.bJustStartedUpdate)
                {
                    this.ct登場アニメ用           = new CCounter(0, 100, 5, CDTXMania.Timer);
                    this.ct難易度スクロール用        = new CCounter(0, 20, 1, CDTXMania.Timer);
                    this.ct難易度矢印用           = new CCounter(0, 5, 80, CDTXMania.Timer);
                    base.bJustStartedUpdate = false;
                }
                //-----------------
                #endregion

                // 進行

                this.ct登場アニメ用.tUpdate();

                this.ct難易度スクロール用.tUpdate();
                if (this.ct難易度スクロール用.bReachedEndValue)
                {
                    int num = this.nCheckDifficultyLabelDisplayAndReturnScrollDirection();
                    if (num < 0)
                    {
                        this.n難易度開始文字位置--;
                    }
                    else if (num > 0)
                    {
                        this.n難易度開始文字位置++;
                    }
                    this.ct難易度スクロール用.nCurrentValue = 0;
                }

                this.ct難易度矢印用.tUpdateLoop();

                // 描画

                CScore cスコア = CDTXMania.stageSongSelection.rSelectedScore;

                #region [ 選択曲の BPM の描画 ]
                if (CDTXMania.stageSongSelection.r現在選択中の曲 != null && this.txBPM画像 != null)
                {
                    int nBPM位置X = 490;
                    int nBPM位置Y = 385;

                    if (this.txパネル本体 != null)
                    {
                        nBPM位置X = 90;
                        nBPM位置Y = 275;
                    }

                    string strBPM;
                    switch (CDTXMania.stageSongSelection.r現在選択中の曲.eNodeType)
                    {
                    case CSongListNode.ENodeType.SCORE:
                    {
                        int bpm_int = (int)Math.Round(cスコア.SongInformation.Bpm);
                        strBPM = bpm_int.ToString();
                        break;
                    }

                    default:
                    {
                        strBPM = "---";
                        break;
                    }
                    }

                    this.txBPM画像.tDraw2D(CDTXMania.app.Device, nBPM位置X, nBPM位置Y);
                    this.tDrawBPM(nBPM位置X + 17, nBPM位置Y + 25, string.Format("{0,3:###}", strBPM));
                    //CDTXMania.act文字コンソール.tPrint(50, 570, CCharacterConsole.Eフォント種別.白, string.Format("BPM:{0:####0}", this.n現在選択中の曲のBPM));
                }
                #endregion

                //-----------------

                int[] nPart = { 0, CDTXMania.ConfigIni.bIsSwappedGuitarBass ? 2 : 1, CDTXMania.ConfigIni.bIsSwappedGuitarBass ? 1 : 2 };

                int nBaseX = 30;
                int nBaseY = 350;//350

                int n難易度文字X = 70;
                int n難易度文字Y = 75;

                if (this.txパネル本体 != null)
                {
                    n難易度文字X = nBaseX + 10;
                    n難易度文字Y = nBaseY + 2;
                }

                #region [ ステータスパネルの描画 ]
                //-----------------
                if (this.txパネル本体 != null)
                {
                    this.txパネル本体.tDraw2D(CDTXMania.app.Device, nBaseX, nBaseY);

                    for (int j = 0; j < 3; j++)
                    {
                        int nPanelW = 187;
                        int nPanelH = 60;

                        if (this.tx難易度パネル != null)
                        {
                            nPanelW = this.tx難易度パネル.szImageSize.Width / 3;
                            nPanelH = this.tx難易度パネル.szImageSize.Height * 2 / 11;
                        }

                        int nPanelX = nBaseX + this.txパネル本体.szImageSize.Width + (nPanelW * (nPart[j] - 3));
                        int nPanelY = nBaseY + this.txパネル本体.szImageSize.Height - (nPanelH * 11 / 2) - 5; // Note: Effectively not in use

                        int nRankW;

                        int    flag = 0;
                        int    n変数;
                        double db変数;

                        if (this.tx難易度パネル != null)
                        {
                            this.tx難易度パネル.tDraw2D(CDTXMania.app.Device, nPanelX, nPanelY, new Rectangle(nPanelW * j, 0, nPanelW, this.tx難易度パネル.szImageSize.Height));
                        }

                        int[] n難易度整数 = new int[5];
                        int[] n難易度小数 = new int[5];
                        for (int i = 0; i < 5; i++)
                        {
                            if (this.str難易度ラベル[i] != null || CDTXMania.stageSongSelection.r現在選択中の曲.eNodeType == CSongListNode.ENodeType.RANDOM)
                            {
                                int nBoxX = nPanelX;
                                int nBoxY = (391 + ((4 - i) * 60)) - 2;      // Note: does not use nPanelY

                                if (this.n現在選択中の曲の難易度 == i && this.tx難易度枠 != null)
                                {
                                    if ((CDTXMania.ConfigIni.bDrumsEnabled && j == 0) || (CDTXMania.ConfigIni.bGuitarEnabled && j != 0))
                                    {
                                        this.tx難易度枠.tDraw2D(CDTXMania.app.Device, nBoxX, nBoxY);
                                    }
                                }

                                #region [ 選択曲の Lv の描画 ]
                                if ((cスコア != null) && (this.txDifficultyNumber != null))
                                {
                                    if (n選択中の曲のレベル難易度毎[i] > 100)
                                    {
                                        n難易度整数[i] = (int)this.n現在選択中の曲のレベル難易度毎DGB[i][j] / 100;
                                        n難易度小数[i] = (n選択中の曲のレベル難易度毎[i] - (n難易度整数[i] * 100));
                                    }
                                    else
                                    {
                                        n難易度整数[i]  = (int)this.n現在選択中の曲のレベル難易度毎DGB[i][j] / 10;
                                        n難易度小数[i]  = (this.n現在選択中の曲のレベル難易度毎DGB[i][j] - (n難易度整数[i] * 10)) * 10;
                                        n難易度小数[i] += this.n現在選択中の曲のレベル小数点難易度毎DGB[i][j];
                                    }

                                    if (this.str難易度ラベル[i] != null && this.b現在選択中の曲に譜面がある[i][j])
                                    {
                                        this.tDrawDifficulty(nBoxX + nPanelW - 77, nBoxY + nPanelH - 35, string.Format("{0,4:0.00}", ((double)n難易度整数[i]) + (((double)n難易度小数[i]) / 100)));
                                    }
                                    else if ((this.str難易度ラベル[i] != null && !this.b現在選択中の曲に譜面がある[i][j]) || CDTXMania.stageSongSelection.r現在選択中の曲.eNodeType == CSongListNode.ENodeType.RANDOM)
                                    {
                                        this.tDrawDifficulty(nBoxX + nPanelW - 77, nBoxY + nPanelH - 35, ("-.--"));
                                    }
                                }
                                #endregion
                                db変数 = this.db現在選択中の曲の最高スキル値難易度毎[i][j];

                                if (db変数 < 0)
                                {
                                    db変数 = 0;
                                }

                                if (db変数 > 100)
                                {
                                    db変数 = 100;
                                }

                                if (db変数 != 0.00)
                                {
                                    if (this.txランク != null)
                                    {
                                        nRankW = this.txランク.szImageSize.Width / 9;

                                        #region [ 選択曲の FullCombo Excellent の 描画 ]
                                        if (this.db現在選択中の曲の最高スキル値難易度毎[i][j] == 100)
                                        {
                                            this.txランク.tDraw2D(CDTXMania.app.Device, nBoxX + 42, nBoxY + 5, new Rectangle(nRankW * 8, 0, nRankW, this.txランク.szImageSize.Height));
                                        }
                                        else if (this.b現在選択中の曲がフルコンボ難易度毎[i][j])
                                        {
                                            this.txランク.tDraw2D(CDTXMania.app.Device, nBoxX + 42, nBoxY + 5, new Rectangle(nRankW * 7, 0, nRankW, this.txランク.szImageSize.Height));
                                        }
                                        #endregion
                                        #region [ 選択曲の 最高ランクの描画 ]
                                        n変数 = this.n現在選択中の曲の最高ランク難易度毎[i][j];

                                        if (n変数 != 99)
                                        {
                                            if (n変数 < 0)
                                            {
                                                n変数 = 0;
                                            }

                                            if (n変数 > 6)
                                            {
                                                n変数 = 6;
                                            }

                                            this.txランク.tDraw2D(CDTXMania.app.Device, nBoxX + 7, nBoxY + 5, new Rectangle(nRankW * n変数, 0, nRankW, this.txランク.szImageSize.Height));
                                        }
                                        #endregion
                                    }
                                    #region [ 選択曲の 最高スキル値ゲージ+数値の描画 ]
                                    if (this.tx達成率MAX != null && db変数 == 100)
                                    {
                                        this.tx達成率MAX.tDraw2D(CDTXMania.app.Device, nBoxX + nPanelW - 142, nBoxY + nPanelH - 27);
                                    }
                                    else
                                    {
                                        this.tDrawAchievementRate(nBoxX + nPanelW - 157, nBoxY + nPanelH - 27, string.Format("{0,6:##0.00}%", db変数));
                                    }
                                    #endregion
                                }
                            }
                            else if (CDTXMania.stageSongSelection.r現在選択中の曲.eNodeType == CSongListNode.ENodeType.SCORE)
                            {
                                flag = flag + 1;
                            }
                        }
                        if (flag == 5)
                        {
                            int nBoxX = nPanelX;
                            int nBoxY = 389;//Equal to ( 391 + ( ( 4 - i ) * 60 ) ) - 2 where i is 4

                            if (this.tx難易度枠 != null)
                            {
                                if ((CDTXMania.ConfigIni.bDrumsEnabled && j == 0) || (CDTXMania.ConfigIni.bGuitarEnabled && j != 0))
                                {
                                    this.tx難易度枠.tDraw2D(CDTXMania.app.Device, nBoxX, nBoxY);
                                }
                            }

                            #region [ 選択曲の Lv の描画 ]
                            if ((cスコア != null) && (this.txDifficultyNumber != null))
                            {
                                n難易度整数[0]  = (int)this.n現在選択中の曲のレベル[j] / 10;
                                n難易度小数[0]  = (this.n現在選択中の曲のレベル[j] - (n難易度整数[0] * 10)) * 10;
                                n難易度小数[0] += this.n現在選択中の曲のレベル小数点[j];

                                if (this.b現在選択中の曲の譜面[j] && CDTXMania.stageSongSelection.r現在選択中の曲.eNodeType == CSongListNode.ENodeType.SCORE)
                                {
                                    this.tDrawDifficulty(nBoxX + nPanelW - 77, nBoxY + nPanelH - 35, string.Format("{0,4:0.00}", ((double)n難易度整数[0]) + (((double)n難易度小数[0]) / 100)));
                                }
                                else if (!this.b現在選択中の曲の譜面[j] && CDTXMania.stageSongSelection.r現在選択中の曲.eNodeType == CSongListNode.ENodeType.SCORE)
                                {
                                    this.tDrawDifficulty(nBoxX + nPanelW - 77, nBoxY + nPanelH - 35, ("-.--"));
                                }
                            }
                            #endregion
                            db変数 = this.db現在選択中の曲の最高スキル値[j];

                            if (db変数 < 0)
                            {
                                db変数 = 0;
                            }

                            if (db変数 > 100)
                            {
                                db変数 = 100;
                            }

                            if (db変数 != 0.00)
                            {
                                if (this.txランク != null)
                                {
                                    nRankW = this.txランク.szImageSize.Width / 9;

                                    #region [ 選択曲の FullCombo Excellent の 描画 ]
                                    if (this.db現在選択中の曲の最高スキル値[j] == 100)
                                    {
                                        this.txランク.tDraw2D(CDTXMania.app.Device, nBoxX + 42, nBoxY + 5, new Rectangle(nRankW * 8, 0, nRankW, this.txランク.szImageSize.Height));
                                    }
                                    else if (this.b現在選択中の曲がフルコンボ[j])
                                    {
                                        this.txランク.tDraw2D(CDTXMania.app.Device, nBoxX + 42, nBoxY + 5, new Rectangle(nRankW * 7, 0, nRankW, this.txランク.szImageSize.Height));
                                    }
                                    #endregion
                                    #region [ 選択曲の 最高ランクの描画 ]
                                    n変数 = this.n現在選択中の曲の最高ランク[j];

                                    if (n変数 != 99)
                                    {
                                        if (n変数 < 0)
                                        {
                                            n変数 = 0;
                                        }

                                        if (n変数 > 6)
                                        {
                                            n変数 = 6;
                                        }

                                        this.txランク.tDraw2D(CDTXMania.app.Device, nBoxX + 7, nBoxY + 5, new Rectangle(nRankW * n変数, 0, nRankW, this.txランク.szImageSize.Height));
                                    }
                                    #endregion
                                }
                                #region [ 選択曲の 最高スキル値ゲージ+数値の描画 ]
                                if (this.tx達成率MAX != null && this.db現在選択中の曲の最高スキル値[j] == 100.00)
                                {
                                    this.tx達成率MAX.tDraw2D(CDTXMania.app.Device, nBoxX + nPanelW - 155, nBoxY + nPanelH - 27);
                                }
                                else
                                {
                                    this.tDrawAchievementRate(nBoxX + nPanelW - 157, nBoxY + nPanelH - 27, string.Format("{0,6:##0.00}%", db変数));
                                }
                                #endregion
                            }
                        }
                    }
                }
                #endregion
                #region [ 難易度文字列の描画 ]
                //-----------------
                for (int i = 0; i < 5; i++)
                {
                    CDTXMania.actDisplayString.tPrint(n難易度文字X + (i * 110), n難易度文字Y, (this.n現在選択中の曲の難易度 == i) ? CCharacterConsole.EFontType.Red : CCharacterConsole.EFontType.White, this.str難易度ラベル[i]);
                }
                #endregion
            }
            return(0);
        }
        private void t描画処理_ジャンル文字列()
        {
            CSongListNode c曲リストノード = CDTXMania.stageSongSelection.r現在選択中の曲;
            CScore        cスコア     = CDTXMania.stageSongSelection.rSelectedScore;

            if ((c曲リストノード != null) && (cスコア != null))
            {
                string str = "";
                switch (c曲リストノード.eNodeType)
                {
                case CSongListNode.ENodeType.SCORE:
                    if ((c曲リストノード.strジャンル == null) || (c曲リストノード.strジャンル.Length <= 0))
                    {
                        if ((cスコア.SongInformation.Genre != null) && (cスコア.SongInformation.Genre.Length > 0))
                        {
                            str = cスコア.SongInformation.Genre;
                        }
                        else
                        {
                            switch (cスコア.SongInformation.SongType)
                            {
                            case CDTX.EType.DTX:
                                str = "DTX";
                                break;

                            case CDTX.EType.GDA:
                                str = "GDA";
                                break;

                            case CDTX.EType.G2D:
                                str = "G2D";
                                break;

                            case CDTX.EType.BMS:
                                str = "BMS";
                                break;

                            case CDTX.EType.BME:
                                str = "BME";
                                break;
                            }
                            str = "Unknown";
                        }
                        break;
                    }
                    str = c曲リストノード.strジャンル;
                    break;

                case CSongListNode.ENodeType.SCORE_MIDI:
                    str = "MIDI";
                    break;

                case CSongListNode.ENodeType.BOX:
                    str = "MusicBox";
                    break;

                case CSongListNode.ENodeType.BACKBOX:
                    str = "BackBox";
                    break;

                case CSongListNode.ENodeType.RANDOM:
                    str = "Random";
                    break;

                default:
                    str = "Unknown";
                    break;
                }
                CDTXMania.actDisplayString.tPrint(this.n本体X + 0x12, this.n本体Y - 30, CCharacterConsole.EFontType.RedThin, str);
            }
        }
        private bool t背景画像があればその一部からプレビュー画像を構築する()
        {
            CScore cスコア = CDTXMania.stageSongSelection.rSelectedScore;

            if ((cスコア == null) || string.IsNullOrEmpty(cスコア.SongInformation.Backgound))
            {
                return(false);
            }
            string path = cスコア.FileInformation.AbsoluteFolderPath + cスコア.SongInformation.Backgound;

            if (!path.Equals(this.str現在のファイル名))
            {
                if (!File.Exists(path))
                {
                    Trace.TraceWarning("ファイルが存在しません。({0})", new object[] { path });
                    return(false);
                }
                CDTXMania.tReleaseTexture(ref this.txプレビュー画像);
                this.str現在のファイル名 = path;
                Bitmap image   = null;
                Bitmap bitmap2 = null;
                Bitmap bitmap3 = null;
                try
                {
                    image   = new Bitmap(this.str現在のファイル名);
                    bitmap2 = new Bitmap(SampleFramework.GameWindowSize.Width, SampleFramework.GameWindowSize.Height);
                    Graphics graphics = Graphics.FromImage(bitmap2);
                    int      x        = 0;
                    for (int i = 0; i < SampleFramework.GameWindowSize.Height; i += image.Height)
                    {
                        for (x = 0; x < SampleFramework.GameWindowSize.Width; x += image.Width)
                        {
                            graphics.DrawImage(image, x, i, image.Width, image.Height);
                        }
                    }
                    graphics.Dispose();
                    bitmap3  = new Bitmap(0xcc, 0x10d);
                    graphics = Graphics.FromImage(bitmap3);
                    graphics.DrawImage(bitmap2, 5, 5, new Rectangle(0x157, 0x6d, 204, 269), GraphicsUnit.Pixel);
                    graphics.Dispose();
                    this.txプレビュー画像    = new CTexture(CDTXMania.app.Device, bitmap3, CDTXMania.TextureFormat);
                    this.r表示するプレビュー画像 = this.txプレビュー画像;
                }
                catch
                {
                    Trace.TraceError("背景画像の読み込みに失敗しました。({0})", new object[] { this.str現在のファイル名 });
                    this.r表示するプレビュー画像 = this.txプレビュー画像がないときの画像;
                    return(false);
                }
                finally
                {
                    if (image != null)
                    {
                        image.Dispose();
                    }
                    if (bitmap2 != null)
                    {
                        bitmap2.Dispose();
                    }
                    if (bitmap3 != null)
                    {
                        bitmap3.Dispose();
                    }
                }
            }
            return(true);
        }
Beispiel #14
0
        // CStage 実装

        public override void OnActivate()
        {
            Trace.TraceInformation("結果ステージを活性化します。");
            Trace.Indent();
            try
            {
                #region [ Initialize ]
                //---------------------
                this.eReturnValueWhenFadeOutCompleted = EReturnValue.Continue;
                this.bAnimationComplete = false;
                this.bIsCheckedWhetherResultScreenShouldSaveOrNot = false;                                              // #24609 2011.3.14 yyagi
                this.n最後に再生したHHのWAV番号   = -1;
                this.n最後に再生したHHのチャンネル番号 = 0;
                for (int i = 0; i < 3; i++)
                {
                    this.bNewRecordSkill[i] = false;
                    this.bNewRecordScore[i] = false;
                    this.bNewRecordRank[i]  = false;
                }
                //---------------------
                #endregion

                if (CDTXMania.ConfigIni.bScoreIniを出力する && !bIsTrainingMode && (CDTXMania.ConfigIni.bSaveScoreIfModifiedPlaySpeed || CDTXMania.ConfigIni.nPlaySpeed == 20))
                {
                    #region [ Calculate results ]
                    //---------------------
                    for (int i = 0; i < 3; i++)
                    {
                        this.nRankValue[i] = -1;
                        this.fPerfect率[i]  = this.fGreat率[i] = this.fGood率[i] = this.fPoor率[i] = this.fMiss率[i] = 0.0f;                         // #28500 2011.5.24 yyagi
                        if ((((i != 0) || (CDTXMania.DTX.bチップがある.Drums && !CDTXMania.ConfigIni.bGuitarRevolutionMode)) &&
                             ((i != 1) || (CDTXMania.DTX.bチップがある.Guitar && CDTXMania.ConfigIni.bGuitarRevolutionMode))) &&
                            ((i != 2) || (CDTXMania.DTX.bチップがある.Bass && CDTXMania.ConfigIni.bGuitarRevolutionMode)))
                        {
                            CScoreIni.CPerformanceEntry part = this.stPerformanceEntry[i];
                            bool bIsAutoPlay = true;
                            switch (i)
                            {
                            case 0:
                                bIsAutoPlay = CDTXMania.ConfigIni.bAllDrumsAreAutoPlay;
                                break;

                            case 1:
                                bIsAutoPlay = CDTXMania.ConfigIni.bAllGuitarsAreAutoPlay;
                                break;

                            case 2:
                                bIsAutoPlay = CDTXMania.ConfigIni.bAllBassAreAutoPlay;
                                break;
                            }

                            this.fPerfect率[i] = bIsAutoPlay ? 0f : ((100f * part.nPerfectCount) / ((float)part.nTotalChipsCount));
                            this.fGreat率[i]   = bIsAutoPlay ? 0f : ((100f * part.nGreatCount) / ((float)part.nTotalChipsCount));
                            this.fGood率[i]    = bIsAutoPlay ? 0f : ((100f * part.nGoodCount) / ((float)part.nTotalChipsCount));
                            this.fPoor率[i]    = bIsAutoPlay ? 0f : ((100f * part.nPoorCount) / ((float)part.nTotalChipsCount));
                            this.fMiss率[i]    = bIsAutoPlay ? 0f : ((100f * part.nMissCount) / ((float)part.nTotalChipsCount));
                            this.bAuto[i]     = bIsAutoPlay;                         // #23596 10.11.16 add ikanick そのパートがオートなら1
                            //        10.11.17 change (int to bool) ikanick
                            //18072020: Change first condition check to 1, XG mode is 1, not 0. Fisyher
                            if (CDTXMania.ConfigIni.nSkillMode == 1)
                            {
                                this.nRankValue[i] = CScoreIni.tCalculateRank(part);
                            }
                            else if (CDTXMania.ConfigIni.nSkillMode == 0)
                            {
                                this.nRankValue[i] = CScoreIni.tCalculateRankOld(part);
                            }

                            //Save progress bar records
                            CScore cScore = CDTXMania.stageSongSelection.rChosenScore;
                            this.strBestProgressBarRecord[i] = cScore.SongInformation.progress[i];
                            //May not need to save this...
                            this.strCurrProgressBarRecord[i] = this.stPerformanceEntry[i].strProgress;
                        }
                    }
                    this.n総合ランク値 = CScoreIni.tCalculateOverallRankValue(this.stPerformanceEntry.Drums, this.stPerformanceEntry.Guitar, this.stPerformanceEntry.Bass);
                    //---------------------
                    #endregion

                    #region [ Write .score.ini ]
                    //---------------------
                    string    str = CDTXMania.DTX.strファイル名の絶対パス + ".score.ini";
                    CScoreIni ini = new CScoreIni(str);

                    bool[] b今までにフルコンボしたことがある = new bool[] { false, false, false };
                    if (!CDTXMania.ConfigIni.bAllDrumsAreAutoPlay || !CDTXMania.ConfigIni.bAllGuitarsAreAutoPlay || !CDTXMania.ConfigIni.bAllBassAreAutoPlay)
                    {
                        for (int i = 0; i < 3; i++)
                        {
                            // フルコンボチェックならびに新記録ランクチェックは、ini.Record[] が、スコアチェックや演奏型スキルチェックの IF 内で書き直されてしまうよりも前に行う。(2010.9.10)

                            b今までにフルコンボしたことがある[i] = ini.stSection[i * 2].bIsFullCombo | ini.stSection[i * 2 + 1].bIsFullCombo;

                            #region [deleted by #24459]
                            //		if( this.nRankValue[ i ] <= CScoreIni.tCalculateRank( ini.stSection[ ( i * 2 ) + 1 ] ) )
                            //		{
                            //			this.bNewRecordRank[ i ] = true;
                            //		}
                            #endregion
                            // #24459 上記の条件だと[HiSkill.***]でのランクしかチェックしていないので、BestRankと比較するよう変更。
                            if (this.nRankValue[i] >= 0 && ini.stFile.BestRank[i] > this.nRankValue[i])                                 // #24459 2011.3.1 yyagi update BestRank
                            {
                                this.bNewRecordRank[i] = true;
                                ini.stFile.BestRank[i] = this.nRankValue[i];
                            }

                            // 新記録スコアチェック
                            if (this.stPerformanceEntry[i].nスコア > ini.stSection[i * 2].nスコア)
                            {
                                this.bNewRecordScore[i] = true;
                                ini.stSection[i * 2]    = this.stPerformanceEntry[i];
                                this.SaveGhost(i * 2);                                 // #35411 chnmr0 add
                            }

                            // 新記録スキルチェック
                            if ((this.stPerformanceEntry[i].dbPerformanceSkill > ini.stSection[(i * 2) + 1].dbPerformanceSkill) && !this.bAuto[i])
                            {
                                this.bNewRecordSkill[i]    = true;
                                ini.stSection[(i * 2) + 1] = this.stPerformanceEntry[i];
                                this.SaveGhost((i * 2) + 1);                                 // #35411 chnmr0 add
                            }

                            // ラストプレイ #23595 2011.1.9 ikanick
                            // オートじゃなければプレイ結果を書き込む
                            if (this.bAuto[i] == false)
                            {
                                ini.stSection[i + 6] = this.stPerformanceEntry[i];
                                this.SaveGhost(i + 6);                                 // #35411 chnmr0 add
                            }

                            // #23596 10.11.16 add ikanick オートじゃないならクリア回数を1増やす
                            //        11.02.05 bAuto to tGetIsUpdateNeeded use      ikanick
                            bool[] b更新が必要か否か = new bool[3];
                            CScoreIni.tGetIsUpdateNeeded(out b更新が必要か否か[0], out b更新が必要か否か[1], out b更新が必要か否か[2]);

                            if (b更新が必要か否か[i])
                            {
                                switch (i)
                                {
                                case 0:
                                    ini.stFile.ClearCountDrums++;
                                    break;

                                case 1:
                                    ini.stFile.ClearCountGuitar++;
                                    break;

                                case 2:
                                    ini.stFile.ClearCountBass++;
                                    break;

                                default:
                                    throw new Exception("クリア回数増加のk(0-2)が範囲外です。");
                                }
                            }

                            //---------------------------------------------------------------------/
                        }
                        // Already checked
                        //if (CDTXMania.ConfigIni.bScoreIniを出力する)
                        {
                            ini.tExport(str);
                        }
                    }
                    //---------------------
                    #endregion

                    #region [ Update nb of performance #24281 2011.1.30 yyagi]
                    this.nNbPerformances.Drums  = ini.stFile.PlayCountDrums;
                    this.nNbPerformances.Guitar = ini.stFile.PlayCountGuitar;
                    this.nNbPerformances.Bass   = ini.stFile.PlayCountBass;
                    #endregion
                    #region [ Update score information on Song Selection screen ]
                    //---------------------
                    if (!CDTXMania.bCompactMode)
                    {
                        CScore cScore    = CDTXMania.stageSongSelection.rChosenScore;
                        bool[] b更新が必要か否か = new bool[3];
                        CScoreIni.tGetIsUpdateNeeded(out b更新が必要か否か[0], out b更新が必要か否か[1], out b更新が必要か否か[2]);
                        for (int m = 0; m < 3; m++)
                        {
                            if (b更新が必要か否か[m])
                            {
                                // FullCombo した記録を FullCombo なしで超えた場合、FullCombo マークが消えてしまう。
                                // → FullCombo は、最新記録と関係なく、一度達成したらずっとつくようにする。(2010.9.11)
                                cScore.SongInformation.FullCombo[m] = this.stPerformanceEntry[m].bIsFullCombo | b今までにフルコンボしたことがある[m];

                                if (this.bNewRecordSkill[m])
                                {
                                    cScore.SongInformation.HighSkill[m] = this.stPerformanceEntry[m].dbPerformanceSkill;
                                    // New Song Progress for new skill record
                                    cScore.SongInformation.progress[m] = this.stPerformanceEntry[m].strProgress;
                                }

                                if (this.bNewRecordRank[m])
                                {
                                    cScore.SongInformation.BestRank[m] = this.nRankValue[m];
                                }

                                //Check if Progress record existed or not; if not, update anyway
                                if (CScoreIni.tProgressBarLength(cScore.SongInformation.progress[m]) == 0)
                                {
                                    cScore.SongInformation.progress[m] = this.stPerformanceEntry[m].strProgress;
                                }
                            }
                        }
                    }
                    //---------------------
                    #endregion
                }

                base.OnActivate();
                //this.actProgressBar.t表示レイアウトを設定する(180, 540, 20, 460);
                //this.actProgressBar.t演奏記録から区間情報を設定する(st演奏記録);
            }
            finally
            {
                Trace.TraceInformation("結果ステージの活性化を完了しました。");
                Trace.Unindent();
            }
        }