X-Git-Url: http://git.osdn.net/view?a=blobdiff_plain;f=DTXMania%E3%83%97%E3%83%AD%E3%82%B8%E3%82%A7%E3%82%AF%E3%83%88%2F%E3%82%B3%E3%83%BC%E3%83%89%2F%E3%82%B9%E3%83%86%E3%83%BC%E3%82%B8%2F07.%E6%BC%94%E5%A5%8F%2FCStage%E6%BC%94%E5%A5%8F%E7%94%BB%E9%9D%A2%E5%85%B1%E9%80%9A.cs;h=37bf777c985dcc87d35ef27f8995edac5322701d;hb=b71db1a124a8070cf03a4ba2c818211b7bb6b859;hp=54b27a5240f83cec2359d7c902185d1dcf5eb07d;hpb=a8ce3706768a79a8659161e6c609f8748bbe8af0;p=dtxmania%2Fdtxmania.git diff --git a/DTXManiaプロジェクト/コード/ステージ/07.演奏/CStage演奏画面共通.cs b/DTXManiaプロジェクト/コード/ステージ/07.演奏/CStage演奏画面共通.cs index 54b27a52..37bf777c 100644 --- a/DTXManiaプロジェクト/コード/ステージ/07.演奏/CStage演奏画面共通.cs +++ b/DTXManiaプロジェクト/コード/ステージ/07.演奏/CStage演奏画面共通.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Collections.Generic; using System.Text; using System.Runtime; @@ -17,757 +17,990 @@ namespace DTXMania /// /// 演奏画面の共通クラス (ドラム演奏画面, ギター演奏画面の継承元) /// - internal abstract class CStage演奏画面共通 : CStage + internal partial class CStage演奏画面共通 : CStage { - // プロパティ - - public bool bAUTOでないチップが１つでもバーを通過した - { - get; - protected set; - } - - // メソッド + #region [Member_Activities] + CAct演奏AVI actAVI; + CAct演奏BGA actBGA; + CAct演奏チップファイアGB actChipFireGB; + CAct演奏Combo共通 actCombo; + CAct演奏Danger共通 actDANGER; + CActFIFOBlack actFI; + CActFIFOBlack actFO; + CActFIFOWhite actFOClear; + CAct演奏ゲージ共通 actGauge; + CAct演奏判定文字列共通 actJudgeString; + CAct演奏DrumsレーンフラッシュD actLaneFlushD; + CAct演奏レーンフラッシュGB共通 actLaneFlushGB; + CActオプションパネル actOptionPanel; + CAct演奏パネル文字列 actPanel; + CAct演奏演奏情報 actPlayInfo; + CAct演奏RGB共通 actRGB; + CAct演奏スコア共通 actScore; + CAct演奏ステージ失敗 actStageFailed; + CAct演奏WailingBonus共通 actWailingBonus; + CAct演奏スクロール速度 act譜面スクロール速度; + CAct演奏DrumsチップファイアD actChipFireD; + // #24074 2011.01.23 add ikanick + CAct演奏グラフ actGraph; + CAct演奏Drumsパッド actPad; + CAct演奏Lane actLane; + #endregion - #region [ t演奏結果を格納する・ドラム() ] - public void t演奏結果を格納する・ドラム( out CScoreIni.C演奏記録 Drums ) - { - Drums = new CScoreIni.C演奏記録(); - - if ( CDTXMania.DTX.bチップがある.Drums && !CDTXMania.ConfigIni.bギタレボモード ) - { - Drums.nスコア = (long) this.actScore.Get( E楽器パート.DRUMS ); - Drums.dbゲーム型スキル値 = CScoreIni.tゲーム型スキルを計算して返す( CDTXMania.DTX.LEVEL.Drums, CDTXMania.DTX.n可視チップ数.Drums, this.nヒット数・Auto含まない.Drums.Perfect, this.actCombo.n現在のコンボ数.Drums最高値, E楽器パート.DRUMS, bIsAutoPlay ); - Drums.db演奏型スキル値 = CScoreIni.t演奏型スキルを計算して返す( CDTXMania.DTX.n可視チップ数.Drums, this.nヒット数・Auto含まない.Drums.Perfect, this.nヒット数・Auto含まない.Drums.Great, this.nヒット数・Auto含まない.Drums.Good, this.nヒット数・Auto含まない.Drums.Poor, this.nヒット数・Auto含まない.Drums.Miss, E楽器パート.DRUMS, bIsAutoPlay ); - Drums.nPerfect数 = CDTXMania.ConfigIni.bドラムが全部オートプレイである ? this.nヒット数・Auto含む.Drums.Perfect : this.nヒット数・Auto含まない.Drums.Perfect; - Drums.nGreat数 = CDTXMania.ConfigIni.bドラムが全部オートプレイである ? this.nヒット数・Auto含む.Drums.Great : this.nヒット数・Auto含まない.Drums.Great; - Drums.nGood数 = CDTXMania.ConfigIni.bドラムが全部オートプレイである ? this.nヒット数・Auto含む.Drums.Good : this.nヒット数・Auto含まない.Drums.Good; - Drums.nPoor数 = CDTXMania.ConfigIni.bドラムが全部オートプレイである ? this.nヒット数・Auto含む.Drums.Poor : this.nヒット数・Auto含まない.Drums.Poor; - Drums.nMiss数 = CDTXMania.ConfigIni.bドラムが全部オートプレイである ? this.nヒット数・Auto含む.Drums.Miss : this.nヒット数・Auto含まない.Drums.Miss; - Drums.nPerfect数・Auto含まない = this.nヒット数・Auto含まない.Drums.Perfect; - Drums.nGreat数・Auto含まない = this.nヒット数・Auto含まない.Drums.Great; - Drums.nGood数・Auto含まない = this.nヒット数・Auto含まない.Drums.Good; - Drums.nPoor数・Auto含まない = this.nヒット数・Auto含まない.Drums.Poor; - Drums.nMiss数・Auto含まない = this.nヒット数・Auto含まない.Drums.Miss; - Drums.n最大コンボ数 = this.actCombo.n現在のコンボ数.Drums最高値; - Drums.n全チップ数 = CDTXMania.DTX.n可視チップ数.Drums; - for ( int i = 0; i < (int) Eレーン.MAX; i++ ) - { - Drums.bAutoPlay[ i ] = bIsAutoPlay[ i ]; - } - Drums.bTight = CDTXMania.ConfigIni.bTight; - for ( int i = 0; i < 3; i++ ) - { - Drums.bSudden[ i ] = CDTXMania.ConfigIni.bSudden[ i ]; - Drums.bHidden[ i ] = CDTXMania.ConfigIni.bHidden[ i ]; - Drums.bReverse[ i ] = CDTXMania.ConfigIni.bReverse[ i ]; - Drums.eRandom[ i ] = CDTXMania.ConfigIni.eRandom[ i ]; - Drums.bLight[ i ] = CDTXMania.ConfigIni.bLight[ i ]; - Drums.bLeft[ i ] = CDTXMania.ConfigIni.bLeft[ i ]; - Drums.f譜面スクロール速度[ i ] = ( (float) ( CDTXMania.ConfigIni.n譜面スクロール速度[ i ] + 1 ) ) * 0.5f; - } - Drums.eDark = CDTXMania.ConfigIni.eDark; - Drums.n演奏速度分子 = CDTXMania.ConfigIni.n演奏速度; + bool bPAUSE; + STDGBSValue b演奏にMIDI入力を使った; + STDGBSValue b演奏にキーボードを使った; + STDGBSValue b演奏にジョイパッドを使った; + STDGBSValue b演奏にマウスを使った; + + CCounter ctWailingチップ模様アニメ; + STDGBSValue ctチップ模様アニメ; + + E演奏画面の戻り値 eフェードアウト完了時の戻り値; + + STDGBSValue nヒット数_Auto含まない; + STDGBSValue nヒット数_Auto含む; + // #35411 2015.08.21 chnmr0 add + STDGBSValue nヒット数_TargetGhost; + STDGBSValue nコンボ数_TargetGhost; + STDGBSValue n最大コンボ数_TargetGhost; + int n現在のトップChip = -1; + int[] n最後に再生したBGMの実WAV番号 = new int[50]; + EChannel e最後に再生したHHのチャンネル番号; + // #23921 2011.1.4 yyagi: change "int" to "List", for recording multiple wav No. + List L最後に再生したHHの実WAV番号; + // #26388 2011.11.8 yyagi: change "n最後に再生した実WAV番号.GUITAR" and "n最後に再生した実WAV番号.BASS" + STPadValue n最後に再生した実WAV番号; + // #24820 2013.1.21 yyagi まずは単純にAdd/Removeを1個のキューでまとめて管理するやり方で設計する + volatile Queue queueMixerSound; + DateTime dtLastQueueOperation; + bool bIsDirectSound; + double db再生速度; + bool bValidScore; + bool bフィルイン中; // drums only + + STDGBSValue> queWailing; + STDGBSValue r現在の歓声Chip; + STPadValue r空打ちドラムチップ = new STPadValue(); + CChip r現在の空うちギターChip; + ST空打ち r現在の空うちドラムChip; + CChip r現在の空うちベースChip; + CChip r次にくるギターChip; + CChip r次にくるベースChip; + + CTexture txWailing枠; + CTexture txチップ; + CTexture txチップGB; + CTexture txヒットバー; + CTexture txヒットバーGB; + CTexture tx背景; + + CInvisibleChip cInvisibleChip; + CWailingChip共通[] cWailingChip; + + STDGBSValue record; + + public CStage演奏画面共通() + { + base.eステージID = CStage.Eステージ.演奏; + base.eフェーズID = CStage.Eフェーズ.共通_通常状態; + base.b活性化してない = true; + base.list子Activities.Add(this.actPad = new CAct演奏Drumsパッド()); + base.list子Activities.Add(this.actChipFireD = new CAct演奏DrumsチップファイアD()); + base.list子Activities.Add(this.actChipFireGB = new CAct演奏チップファイアGB()); + base.list子Activities.Add(this.actStageFailed = new CAct演奏ステージ失敗()); + base.list子Activities.Add(this.actDANGER = new CAct演奏Danger共通()); + base.list子Activities.Add(this.actAVI = new CAct演奏AVI()); + base.list子Activities.Add(this.actBGA = new CAct演奏BGA()); + base.list子Activities.Add(this.actPanel = new CAct演奏パネル文字列()); + base.list子Activities.Add(this.act譜面スクロール速度 = new CAct演奏スクロール速度()); + base.list子Activities.Add(this.actWailingBonus = new CAct演奏WailingBonus共通()); + base.list子Activities.Add(this.actScore = new CAct演奏スコア共通()); + base.list子Activities.Add(this.actRGB = new CAct演奏RGB共通()); + base.list子Activities.Add(this.actLaneFlushD = new CAct演奏DrumsレーンフラッシュD()); + base.list子Activities.Add(this.actLaneFlushGB = new CAct演奏レーンフラッシュGB共通()); + base.list子Activities.Add(this.actJudgeString = new CAct演奏判定文字列共通()); + base.list子Activities.Add(this.actGauge = new CAct演奏ゲージ共通()); + base.list子Activities.Add(this.actGraph = new CAct演奏グラフ()); + base.list子Activities.Add(this.actCombo = new CAct演奏Combo共通()); + base.list子Activities.Add(this.actPlayInfo = new CAct演奏演奏情報()); + base.list子Activities.Add(this.actFI = new CActFIFOBlack()); + base.list子Activities.Add(this.actFO = new CActFIFOBlack()); + base.list子Activities.Add(this.actFOClear = new CActFIFOWhite()); + base.list子Activities.Add(this.actLane = new CAct演奏Lane()); + list子Activities.Add(actOptionPanel = new CActオプションパネル(EOptionPanelDirection.Vertical)); + } + + #region [ PlayRecordSave ] + private void t演奏結果を格納する_ドラム() + { + record.Drums = new CScoreIni.C演奏記録(); + CScoreIni.C演奏記録 Drums = Record.Drums; + bool allauto = CDTXMania.Instance.ConfigIni.bIsAutoPlay(EPart.Drums); + if (CDTXMania.Instance.DTX.bチップがある.Drums && CDTXMania.Instance.ConfigIni.bDrums有効) + { + Drums.nスコア = (long)this.actScore.Get(EPart.Drums); + Drums.dbゲーム型スキル値 = CScoreIni.tゲーム型スキルを計算して返す(CDTXMania.Instance.DTX.LEVEL.Drums, CDTXMania.Instance.DTX.n可視チップ数.Drums, this.nヒット数_Auto含まない.Drums.Perfect, + this.actCombo.dgbコンボ数.Drums.n最高値, + EPart.Drums); + Drums.db演奏型スキル値 = CScoreIni.t演奏型スキルを計算して返す(CDTXMania.Instance.DTX.n可視チップ数.Drums, this.nヒット数_Auto含まない.Drums.Perfect, this.nヒット数_Auto含まない.Drums.Great, this.nヒット数_Auto含まない.Drums.Good, this.nヒット数_Auto含まない.Drums.Poor, this.nヒット数_Auto含まない.Drums.Miss, EPart.Drums, true); + Drums.nPerfect数 = allauto ? this.nヒット数_Auto含む.Drums.Perfect : this.nヒット数_Auto含まない.Drums.Perfect; + Drums.nGreat数 = allauto ? this.nヒット数_Auto含む.Drums.Great : this.nヒット数_Auto含まない.Drums.Great; + Drums.nGood数 = allauto ? this.nヒット数_Auto含む.Drums.Good : this.nヒット数_Auto含まない.Drums.Good; + Drums.nPoor数 = allauto ? this.nヒット数_Auto含む.Drums.Poor : this.nヒット数_Auto含まない.Drums.Poor; + Drums.nMiss数 = allauto ? this.nヒット数_Auto含む.Drums.Miss : this.nヒット数_Auto含まない.Drums.Miss; + Drums.nPerfect数_Auto含まない = this.nヒット数_Auto含まない.Drums.Perfect; + Drums.nGreat数_Auto含まない = this.nヒット数_Auto含まない.Drums.Great; + Drums.nGood数_Auto含まない = this.nヒット数_Auto含まない.Drums.Good; + Drums.nPoor数_Auto含まない = this.nヒット数_Auto含まない.Drums.Poor; + Drums.nMiss数_Auto含まない = this.nヒット数_Auto含まない.Drums.Miss; + Drums.n最大コンボ数 = this.actCombo.dgbコンボ数.Drums.n最高値; + Drums.n全チップ数 = CDTXMania.Instance.DTX.n可視チップ数.Drums; + for (EPad i = EPad.Min; i < EPad.Max; i++) + { + Drums.bAutoPlay[i] = CDTXMania.Instance.ConfigIni.bAutoPlay[i]; + } + Drums.bTight = CDTXMania.Instance.ConfigIni.bTight; + for (EPart i = EPart.Drums; i <= EPart.Bass; i++) + { + Drums.eSudHidInv[i] = CDTXMania.Instance.ConfigIni.eSudHidInv[i]; + Drums.bReverse[i] = CDTXMania.Instance.ConfigIni.bReverse[i]; + Drums.eRandom[i] = CDTXMania.Instance.ConfigIni.eRandom[i]; + Drums.bLight[i] = CDTXMania.Instance.ConfigIni.bLight[i]; + Drums.f譜面スクロール速度[i] = ((float)(CDTXMania.Instance.ConfigIni.nScrollSpeed[i] + 1)) * 0.5f; + } + Drums.eDark = CDTXMania.Instance.ConfigIni.eDark; + Drums.n演奏速度分子 = CDTXMania.Instance.ConfigIni.nPlaySpeed; Drums.n演奏速度分母 = 20; - Drums.eHHGroup = CDTXMania.ConfigIni.eHHGroup; - Drums.eFTGroup = CDTXMania.ConfigIni.eFTGroup; - Drums.eCYGroup = CDTXMania.ConfigIni.eCYGroup; - Drums.eHitSoundPriorityHH = CDTXMania.ConfigIni.eHitSoundPriorityHH; - Drums.eHitSoundPriorityFT = CDTXMania.ConfigIni.eHitSoundPriorityFT; - Drums.eHitSoundPriorityCY = CDTXMania.ConfigIni.eHitSoundPriorityCY; - Drums.bGuitar有効 = CDTXMania.ConfigIni.bGuitar有効; - Drums.bDrums有効 = CDTXMania.ConfigIni.bDrums有効; - Drums.bSTAGEFAILED有効 = CDTXMania.ConfigIni.bSTAGEFAILED有効; - Drums.eダメージレベル = CDTXMania.ConfigIni.eダメージレベル; + Drums.eHHGroup = CDTXMania.Instance.ConfigIni.eHHGroup.Value; + Drums.eFTGroup = CDTXMania.Instance.ConfigIni.eFTGroup.Value; + Drums.eCYGroup = CDTXMania.Instance.ConfigIni.eCYGroup.Value; + Drums.eHitSoundPriorityHH = CDTXMania.Instance.ConfigIni.eHitSoundPriorityHH.Value; + Drums.eHitSoundPriorityFT = CDTXMania.Instance.ConfigIni.eHitSoundPriorityFT.Value; + Drums.eHitSoundPriorityCY = CDTXMania.Instance.ConfigIni.eHitSoundPriorityCY.Value; + Drums.bGuitar有効 = CDTXMania.Instance.ConfigIni.bGuitar有効; + Drums.bDrums有効 = CDTXMania.Instance.ConfigIni.bDrums有効; + Drums.bSTAGEFAILED有効 = CDTXMania.Instance.ConfigIni.bStageFailed; + Drums.eダメージレベル = CDTXMania.Instance.ConfigIni.eDamageLevel; + Drums.eMetronome = CDTXMania.Instance.ConfigIni.eClickType; Drums.b演奏にキーボードを使用した = this.b演奏にキーボードを使った.Drums; Drums.b演奏にMIDI入力を使用した = this.b演奏にMIDI入力を使った.Drums; Drums.b演奏にジョイパッドを使用した = this.b演奏にジョイパッドを使った.Drums; Drums.b演奏にマウスを使用した = this.b演奏にマウスを使った.Drums; - Drums.nPerfectになる範囲ms = CDTXMania.nPerfect範囲ms; - Drums.nGreatになる範囲ms = CDTXMania.nGreat範囲ms; - Drums.nGoodになる範囲ms = CDTXMania.nGood範囲ms; - Drums.nPoorになる範囲ms = CDTXMania.nPoor範囲ms; + Drums.nPerfectになる範囲ms = CDTXMania.Instance.nPerfect範囲ms; + Drums.nGreatになる範囲ms = CDTXMania.Instance.nGreat範囲ms; + Drums.nGoodになる範囲ms = CDTXMania.Instance.nGood範囲ms; + Drums.nPoorになる範囲ms = CDTXMania.Instance.nPoor範囲ms; Drums.strDTXManiaのバージョン = CDTXMania.VERSION; Drums.最終更新日時 = DateTime.Now.ToString(); - Drums.Hash = CScoreIni.t演奏セクションのMD5を求めて返す( Drums ); - } - } - #endregion - #region [ t演奏結果を格納する・ギター() ] - public void t演奏結果を格納する・ギター( out CScoreIni.C演奏記録 Guitar ) - { - Guitar = new CScoreIni.C演奏記録(); - - if ( CDTXMania.DTX.bチップがある.Guitar ) - { - Guitar.nスコア = (long) this.actScore.Get( E楽器パート.GUITAR ); - Guitar.dbゲーム型スキル値 = CScoreIni.tゲーム型スキルを計算して返す( CDTXMania.DTX.LEVEL.Guitar, CDTXMania.DTX.n可視チップ数.Guitar, this.nヒット数・Auto含まない.Guitar.Perfect, this.actCombo.n現在のコンボ数.Guitar最高値, E楽器パート.GUITAR, bIsAutoPlay ); - Guitar.db演奏型スキル値 = CScoreIni.t演奏型スキルを計算して返す( CDTXMania.DTX.n可視チップ数.Guitar, this.nヒット数・Auto含まない.Guitar.Perfect, this.nヒット数・Auto含まない.Guitar.Great, this.nヒット数・Auto含まない.Guitar.Good, this.nヒット数・Auto含まない.Guitar.Poor, this.nヒット数・Auto含まない.Guitar.Miss, E楽器パート.GUITAR, bIsAutoPlay ); - Guitar.nPerfect数 = CDTXMania.ConfigIni.bギターが全部オートプレイである ? this.nヒット数・Auto含む.Guitar.Perfect : this.nヒット数・Auto含まない.Guitar.Perfect; - Guitar.nGreat数 = CDTXMania.ConfigIni.bギターが全部オートプレイである ? this.nヒット数・Auto含む.Guitar.Great : this.nヒット数・Auto含まない.Guitar.Great; - Guitar.nGood数 = CDTXMania.ConfigIni.bギターが全部オートプレイである ? this.nヒット数・Auto含む.Guitar.Good : this.nヒット数・Auto含まない.Guitar.Good; - Guitar.nPoor数 = CDTXMania.ConfigIni.bギターが全部オートプレイである ? this.nヒット数・Auto含む.Guitar.Poor : this.nヒット数・Auto含まない.Guitar.Poor; - Guitar.nMiss数 = CDTXMania.ConfigIni.bギターが全部オートプレイである ? this.nヒット数・Auto含む.Guitar.Miss : this.nヒット数・Auto含まない.Guitar.Miss; - Guitar.nPerfect数・Auto含まない = this.nヒット数・Auto含まない.Guitar.Perfect; - Guitar.nGreat数・Auto含まない = this.nヒット数・Auto含まない.Guitar.Great; - Guitar.nGood数・Auto含まない = this.nヒット数・Auto含まない.Guitar.Good; - Guitar.nPoor数・Auto含まない = this.nヒット数・Auto含まない.Guitar.Poor; - Guitar.nMiss数・Auto含まない = this.nヒット数・Auto含まない.Guitar.Miss; - Guitar.n最大コンボ数 = this.actCombo.n現在のコンボ数.Guitar最高値; - Guitar.n全チップ数 = CDTXMania.DTX.n可視チップ数.Guitar; - for ( int i = 0; i < (int) Eレーン.MAX; i++ ) - { - Guitar.bAutoPlay[ i ] = bIsAutoPlay[ i ]; - } - Guitar.bTight = CDTXMania.ConfigIni.bTight; - for ( int i = 0; i < 3; i++ ) - { - Guitar.bSudden[ i ] = CDTXMania.ConfigIni.bSudden[ i ]; - Guitar.bHidden[ i ] = CDTXMania.ConfigIni.bHidden[ i ]; - Guitar.bReverse[ i ] = CDTXMania.ConfigIni.bReverse[ i ]; - Guitar.eRandom[ i ] = CDTXMania.ConfigIni.eRandom[ i ]; - Guitar.bLight[ i ] = CDTXMania.ConfigIni.bLight[ i ]; - Guitar.bLeft[ i ] = CDTXMania.ConfigIni.bLeft[ i ]; - Guitar.f譜面スクロール速度[ i ] = ( (float) ( CDTXMania.ConfigIni.n譜面スクロール速度[ i ] + 1 ) ) * 0.5f; - } - Guitar.eDark = CDTXMania.ConfigIni.eDark; - Guitar.n演奏速度分子 = CDTXMania.ConfigIni.n演奏速度; + // #35461 chnmr0 add + Drums.nRisky = CDTXMania.Instance.ConfigIni.nRisky; + // #35417 chnmr0 add + Drums.bギターとベースを入れ替えた = CDTXMania.Instance.ConfigIni.bIsSwappedGuitarBass; + } + } + private void t演奏結果を格納する_ギター() + { + record.Guitar = new CScoreIni.C演奏記録(); + CScoreIni.C演奏記録 Guitar = Record.Guitar; + bool allauto = CDTXMania.Instance.ConfigIni.bIsAutoPlay(EPart.Guitar); + if (CDTXMania.Instance.DTX.bチップがある.Guitar) + { + Guitar.nスコア = (long)this.actScore.Get(EPart.Guitar); + Guitar.dbゲーム型スキル値 = CScoreIni.tゲーム型スキルを計算して返す(CDTXMania.Instance.DTX.LEVEL.Guitar, CDTXMania.Instance.DTX.n可視チップ数.Guitar, this.nヒット数_Auto含まない.Guitar.Perfect, this.actCombo.dgbコンボ数.Guitar.n最高値, EPart.Guitar); + Guitar.db演奏型スキル値 = CScoreIni.t演奏型スキルを計算して返す(CDTXMania.Instance.DTX.n可視チップ数.Guitar, this.nヒット数_Auto含まない.Guitar.Perfect, this.nヒット数_Auto含まない.Guitar.Great, this.nヒット数_Auto含まない.Guitar.Good, this.nヒット数_Auto含まない.Guitar.Poor, this.nヒット数_Auto含まない.Guitar.Miss, EPart.Guitar, true); + Guitar.nPerfect数 = allauto ? this.nヒット数_Auto含む.Guitar.Perfect : this.nヒット数_Auto含まない.Guitar.Perfect; + Guitar.nGreat数 = allauto ? this.nヒット数_Auto含む.Guitar.Great : this.nヒット数_Auto含まない.Guitar.Great; + Guitar.nGood数 = allauto ? this.nヒット数_Auto含む.Guitar.Good : this.nヒット数_Auto含まない.Guitar.Good; + Guitar.nPoor数 = allauto ? this.nヒット数_Auto含む.Guitar.Poor : this.nヒット数_Auto含まない.Guitar.Poor; + Guitar.nMiss数 = allauto ? this.nヒット数_Auto含む.Guitar.Miss : this.nヒット数_Auto含まない.Guitar.Miss; + Guitar.nPerfect数_Auto含まない = this.nヒット数_Auto含まない.Guitar.Perfect; + Guitar.nGreat数_Auto含まない = this.nヒット数_Auto含まない.Guitar.Great; + Guitar.nGood数_Auto含まない = this.nヒット数_Auto含まない.Guitar.Good; + Guitar.nPoor数_Auto含まない = this.nヒット数_Auto含まない.Guitar.Poor; + Guitar.nMiss数_Auto含まない = this.nヒット数_Auto含まない.Guitar.Miss; + Guitar.n最大コンボ数 = this.actCombo.dgbコンボ数.Guitar.n最高値; + Guitar.n全チップ数 = CDTXMania.Instance.DTX.n可視チップ数.Guitar; + for (EPad i = EPad.Min; i < EPad.Max; i++) + { + Guitar.bAutoPlay[i] = CDTXMania.Instance.ConfigIni.bAutoPlay[i]; + } + Guitar.bTight = CDTXMania.Instance.ConfigIni.bTight; + for (EPart i = EPart.Drums; i <= EPart.Bass; i++) + { + Guitar.eSudHidInv[i] = CDTXMania.Instance.ConfigIni.eSudHidInv[i]; + Guitar.bReverse[i] = CDTXMania.Instance.ConfigIni.bReverse[i]; + Guitar.eRandom[i] = CDTXMania.Instance.ConfigIni.eRandom[i]; + Guitar.bLight[i] = CDTXMania.Instance.ConfigIni.bLight[i]; + Guitar.f譜面スクロール速度[i] = ((float)(CDTXMania.Instance.ConfigIni.nScrollSpeed[i] + 1)) * 0.5f; + } + Guitar.eDark = CDTXMania.Instance.ConfigIni.eDark; + Guitar.n演奏速度分子 = CDTXMania.Instance.ConfigIni.nPlaySpeed; Guitar.n演奏速度分母 = 20; - Guitar.eHHGroup = CDTXMania.ConfigIni.eHHGroup; - Guitar.eFTGroup = CDTXMania.ConfigIni.eFTGroup; - Guitar.eCYGroup = CDTXMania.ConfigIni.eCYGroup; - Guitar.eHitSoundPriorityHH = CDTXMania.ConfigIni.eHitSoundPriorityHH; - Guitar.eHitSoundPriorityFT = CDTXMania.ConfigIni.eHitSoundPriorityFT; - Guitar.eHitSoundPriorityCY = CDTXMania.ConfigIni.eHitSoundPriorityCY; - Guitar.bGuitar有効 = CDTXMania.ConfigIni.bGuitar有効; - Guitar.bDrums有効 = CDTXMania.ConfigIni.bDrums有効; - Guitar.bSTAGEFAILED有効 = CDTXMania.ConfigIni.bSTAGEFAILED有効; - Guitar.eダメージレベル = CDTXMania.ConfigIni.eダメージレベル; + Guitar.eHHGroup = CDTXMania.Instance.ConfigIni.eHHGroup; + Guitar.eFTGroup = CDTXMania.Instance.ConfigIni.eFTGroup; + Guitar.eCYGroup = CDTXMania.Instance.ConfigIni.eCYGroup; + Guitar.eHitSoundPriorityHH = CDTXMania.Instance.ConfigIni.eHitSoundPriorityHH; + Guitar.eHitSoundPriorityFT = CDTXMania.Instance.ConfigIni.eHitSoundPriorityFT; + Guitar.eHitSoundPriorityCY = CDTXMania.Instance.ConfigIni.eHitSoundPriorityCY; + Guitar.bGuitar有効 = CDTXMania.Instance.ConfigIni.bGuitar有効; + Guitar.bDrums有効 = CDTXMania.Instance.ConfigIni.bDrums有効; + Guitar.bSTAGEFAILED有効 = CDTXMania.Instance.ConfigIni.bStageFailed; + Guitar.eダメージレベル = CDTXMania.Instance.ConfigIni.eDamageLevel; + Guitar.eMetronome = CDTXMania.Instance.ConfigIni.eClickType; Guitar.b演奏にキーボードを使用した = this.b演奏にキーボードを使った.Guitar; Guitar.b演奏にMIDI入力を使用した = this.b演奏にMIDI入力を使った.Guitar; Guitar.b演奏にジョイパッドを使用した = this.b演奏にジョイパッドを使った.Guitar; Guitar.b演奏にマウスを使用した = this.b演奏にマウスを使った.Guitar; - Guitar.nPerfectになる範囲ms = CDTXMania.nPerfect範囲ms; - Guitar.nGreatになる範囲ms = CDTXMania.nGreat範囲ms; - Guitar.nGoodになる範囲ms = CDTXMania.nGood範囲ms; - Guitar.nPoorになる範囲ms = CDTXMania.nPoor範囲ms; + Guitar.nPerfectになる範囲ms = CDTXMania.Instance.nPerfect範囲ms; + Guitar.nGreatになる範囲ms = CDTXMania.Instance.nGreat範囲ms; + Guitar.nGoodになる範囲ms = CDTXMania.Instance.nGood範囲ms; + Guitar.nPoorになる範囲ms = CDTXMania.Instance.nPoor範囲ms; Guitar.strDTXManiaのバージョン = CDTXMania.VERSION; Guitar.最終更新日時 = DateTime.Now.ToString(); - Guitar.Hash = CScoreIni.t演奏セクションのMD5を求めて返す( Guitar ); - } - } - #endregion - #region [ t演奏結果を格納する・ベース() ] - public void t演奏結果を格納する・ベース( out CScoreIni.C演奏記録 Bass ) - { - Bass = new CScoreIni.C演奏記録(); - - if ( CDTXMania.DTX.bチップがある.Bass ) - { - Bass.nスコア = (long) this.actScore.Get( E楽器パート.BASS ); - Bass.dbゲーム型スキル値 = CScoreIni.tゲーム型スキルを計算して返す( CDTXMania.DTX.LEVEL.Bass, CDTXMania.DTX.n可視チップ数.Bass, this.nヒット数・Auto含まない.Bass.Perfect, this.actCombo.n現在のコンボ数.Bass最高値, E楽器パート.BASS, bIsAutoPlay ); - Bass.db演奏型スキル値 = CScoreIni.t演奏型スキルを計算して返す( CDTXMania.DTX.n可視チップ数.Bass, this.nヒット数・Auto含まない.Bass.Perfect, this.nヒット数・Auto含まない.Bass.Great, this.nヒット数・Auto含まない.Bass.Good, this.nヒット数・Auto含まない.Bass.Poor, this.nヒット数・Auto含まない.Bass.Miss, E楽器パート.BASS, bIsAutoPlay ); - Bass.nPerfect数 = CDTXMania.ConfigIni.bベースが全部オートプレイである ? this.nヒット数・Auto含む.Bass.Perfect : this.nヒット数・Auto含まない.Bass.Perfect; - Bass.nGreat数 = CDTXMania.ConfigIni.bベースが全部オートプレイである ? this.nヒット数・Auto含む.Bass.Great : this.nヒット数・Auto含まない.Bass.Great; - Bass.nGood数 = CDTXMania.ConfigIni.bベースが全部オートプレイである ? this.nヒット数・Auto含む.Bass.Good : this.nヒット数・Auto含まない.Bass.Good; - Bass.nPoor数 = CDTXMania.ConfigIni.bベースが全部オートプレイである ? this.nヒット数・Auto含む.Bass.Poor : this.nヒット数・Auto含まない.Bass.Poor; - Bass.nMiss数 = CDTXMania.ConfigIni.bベースが全部オートプレイである ? this.nヒット数・Auto含む.Bass.Miss : this.nヒット数・Auto含まない.Bass.Miss; - Bass.nPerfect数・Auto含まない = this.nヒット数・Auto含まない.Bass.Perfect; - Bass.nGreat数・Auto含まない = this.nヒット数・Auto含まない.Bass.Great; - Bass.nGood数・Auto含まない = this.nヒット数・Auto含まない.Bass.Good; - Bass.nPoor数・Auto含まない = this.nヒット数・Auto含まない.Bass.Poor; - Bass.nMiss数・Auto含まない = this.nヒット数・Auto含まない.Bass.Miss; - Bass.n最大コンボ数 = this.actCombo.n現在のコンボ数.Bass最高値; - Bass.n全チップ数 = CDTXMania.DTX.n可視チップ数.Bass; - for ( int i = 0; i < (int) Eレーン.MAX; i++ ) - { - Bass.bAutoPlay[ i ] = bIsAutoPlay[ i ]; - } - Bass.bTight = CDTXMania.ConfigIni.bTight; - for ( int i = 0; i < 3; i++ ) - { - Bass.bSudden[ i ] = CDTXMania.ConfigIni.bSudden[ i ]; - Bass.bHidden[ i ] = CDTXMania.ConfigIni.bHidden[ i ]; - Bass.bReverse[ i ] = CDTXMania.ConfigIni.bReverse[ i ]; - Bass.eRandom[ i ] = CDTXMania.ConfigIni.eRandom[ i ]; - Bass.bLight[ i ] = CDTXMania.ConfigIni.bLight[ i ]; - Bass.bLeft[ i ] = CDTXMania.ConfigIni.bLeft[ i ]; - Bass.f譜面スクロール速度[ i ] = ( (float) ( CDTXMania.ConfigIni.n譜面スクロール速度[ i ] + 1 ) ) * 0.5f; - } - Bass.eDark = CDTXMania.ConfigIni.eDark; - Bass.n演奏速度分子 = CDTXMania.ConfigIni.n演奏速度; + // #35417 chnmr0 add + Guitar.bギターとベースを入れ替えた = CDTXMania.Instance.ConfigIni.bIsSwappedGuitarBass; + } + } + private void t演奏結果を格納する_ベース() + { + record.Bass = new CScoreIni.C演奏記録(); + CScoreIni.C演奏記録 Bass = Record.Bass; + bool allauto = CDTXMania.Instance.ConfigIni.bIsAutoPlay(EPart.Bass); + if (CDTXMania.Instance.DTX.bチップがある.Bass) + { + Bass.nスコア = (long)this.actScore.Get(EPart.Bass); + Bass.dbゲーム型スキル値 = CScoreIni.tゲーム型スキルを計算して返す(CDTXMania.Instance.DTX.LEVEL.Bass, CDTXMania.Instance.DTX.n可視チップ数.Bass, this.nヒット数_Auto含まない.Bass.Perfect, this.actCombo.dgbコンボ数.Bass.n最高値, EPart.Bass); + Bass.db演奏型スキル値 = CScoreIni.t演奏型スキルを計算して返す(CDTXMania.Instance.DTX.n可視チップ数.Bass, this.nヒット数_Auto含まない.Bass.Perfect, this.nヒット数_Auto含まない.Bass.Great, this.nヒット数_Auto含まない.Bass.Good, this.nヒット数_Auto含まない.Bass.Poor, this.nヒット数_Auto含まない.Bass.Miss, EPart.Bass, true); + Bass.nPerfect数 = allauto ? this.nヒット数_Auto含む.Bass.Perfect : this.nヒット数_Auto含まない.Bass.Perfect; + Bass.nGreat数 = allauto ? this.nヒット数_Auto含む.Bass.Great : this.nヒット数_Auto含まない.Bass.Great; + Bass.nGood数 = allauto ? this.nヒット数_Auto含む.Bass.Good : this.nヒット数_Auto含まない.Bass.Good; + Bass.nPoor数 = allauto ? this.nヒット数_Auto含む.Bass.Poor : this.nヒット数_Auto含まない.Bass.Poor; + Bass.nMiss数 = allauto ? this.nヒット数_Auto含む.Bass.Miss : this.nヒット数_Auto含まない.Bass.Miss; + Bass.nPerfect数_Auto含まない = this.nヒット数_Auto含まない.Bass.Perfect; + Bass.nGreat数_Auto含まない = this.nヒット数_Auto含まない.Bass.Great; + Bass.nGood数_Auto含まない = this.nヒット数_Auto含まない.Bass.Good; + Bass.nPoor数_Auto含まない = this.nヒット数_Auto含まない.Bass.Poor; + Bass.nMiss数_Auto含まない = this.nヒット数_Auto含まない.Bass.Miss; + Bass.n最大コンボ数 = this.actCombo.dgbコンボ数.Bass.n最高値; + Bass.n全チップ数 = CDTXMania.Instance.DTX.n可視チップ数.Bass; + for (EPad i = EPad.Min; i < EPad.Max; i++) + { + Bass.bAutoPlay[i] = CDTXMania.Instance.ConfigIni.bAutoPlay[i]; + } + Bass.bTight = CDTXMania.Instance.ConfigIni.bTight; + for (EPart i = EPart.Drums; i <= EPart.Bass; i++) + { + Bass.eSudHidInv[i] = CDTXMania.Instance.ConfigIni.eSudHidInv[i]; + Bass.bReverse[i] = CDTXMania.Instance.ConfigIni.bReverse[i]; + Bass.eRandom[i] = CDTXMania.Instance.ConfigIni.eRandom[i]; + Bass.bLight[i] = CDTXMania.Instance.ConfigIni.bLight[i]; + Bass.f譜面スクロール速度[i] = ((float)(CDTXMania.Instance.ConfigIni.nScrollSpeed[i] + 1)) * 0.5f; + } + Bass.eDark = CDTXMania.Instance.ConfigIni.eDark; + Bass.n演奏速度分子 = CDTXMania.Instance.ConfigIni.nPlaySpeed; Bass.n演奏速度分母 = 20; - Bass.eHHGroup = CDTXMania.ConfigIni.eHHGroup; - Bass.eFTGroup = CDTXMania.ConfigIni.eFTGroup; - Bass.eCYGroup = CDTXMania.ConfigIni.eCYGroup; - Bass.eHitSoundPriorityHH = CDTXMania.ConfigIni.eHitSoundPriorityHH; - Bass.eHitSoundPriorityFT = CDTXMania.ConfigIni.eHitSoundPriorityFT; - Bass.eHitSoundPriorityCY = CDTXMania.ConfigIni.eHitSoundPriorityCY; - Bass.bGuitar有効 = CDTXMania.ConfigIni.bGuitar有効; - Bass.bDrums有効 = CDTXMania.ConfigIni.bDrums有効; - Bass.bSTAGEFAILED有効 = CDTXMania.ConfigIni.bSTAGEFAILED有効; - Bass.eダメージレベル = CDTXMania.ConfigIni.eダメージレベル; - Bass.b演奏にキーボードを使用した = this.b演奏にキーボードを使った.Bass; // #24280 2011.1.29 yyagi - Bass.b演奏にMIDI入力を使用した = this.b演奏にMIDI入力を使った.Bass; // - Bass.b演奏にジョイパッドを使用した = this.b演奏にジョイパッドを使った.Bass; // - Bass.b演奏にマウスを使用した = this.b演奏にマウスを使った.Bass; // - Bass.nPerfectになる範囲ms = CDTXMania.nPerfect範囲ms; - Bass.nGreatになる範囲ms = CDTXMania.nGreat範囲ms; - Bass.nGoodになる範囲ms = CDTXMania.nGood範囲ms; - Bass.nPoorになる範囲ms = CDTXMania.nPoor範囲ms; + Bass.eHHGroup = CDTXMania.Instance.ConfigIni.eHHGroup; + Bass.eFTGroup = CDTXMania.Instance.ConfigIni.eFTGroup; + Bass.eCYGroup = CDTXMania.Instance.ConfigIni.eCYGroup; + Bass.eHitSoundPriorityHH = CDTXMania.Instance.ConfigIni.eHitSoundPriorityHH; + Bass.eHitSoundPriorityFT = CDTXMania.Instance.ConfigIni.eHitSoundPriorityFT; + Bass.eHitSoundPriorityCY = CDTXMania.Instance.ConfigIni.eHitSoundPriorityCY; + Bass.bGuitar有効 = CDTXMania.Instance.ConfigIni.bGuitar有効; + Bass.bDrums有効 = CDTXMania.Instance.ConfigIni.bDrums有効; + Bass.bSTAGEFAILED有効 = CDTXMania.Instance.ConfigIni.bStageFailed; + Bass.eダメージレベル = CDTXMania.Instance.ConfigIni.eDamageLevel; + // #24280 2011.1.29 yyagi + Bass.eMetronome = CDTXMania.Instance.ConfigIni.eClickType; + Bass.b演奏にキーボードを使用した = this.b演奏にキーボードを使った.Bass; + Bass.b演奏にMIDI入力を使用した = this.b演奏にMIDI入力を使った.Bass; + Bass.b演奏にジョイパッドを使用した = this.b演奏にジョイパッドを使った.Bass; + Bass.b演奏にマウスを使用した = this.b演奏にマウスを使った.Bass; + Bass.nPerfectになる範囲ms = CDTXMania.Instance.nPerfect範囲ms; + Bass.nGreatになる範囲ms = CDTXMania.Instance.nGreat範囲ms; + Bass.nGoodになる範囲ms = CDTXMania.Instance.nGood範囲ms; + Bass.nPoorになる範囲ms = CDTXMania.Instance.nPoor範囲ms; Bass.strDTXManiaのバージョン = CDTXMania.VERSION; Bass.最終更新日時 = DateTime.Now.ToString(); - Bass.Hash = CScoreIni.t演奏セクションのMD5を求めて返す( Bass ); + // #35417 chnmr0 add + Bass.bギターとベースを入れ替えた = CDTXMania.Instance.ConfigIni.bIsSwappedGuitarBass; } } #endregion // CStage 実装 - public override void On活性化() { - listChip = CDTXMania.DTX.listChip; - listWAV = CDTXMania.DTX.listWAV; - - this.eフェードアウト完了時の戻り値 = E演奏画面の戻り値.継続; - this.n現在のトップChip = ( listChip.Count > 0 ) ? 0 : -1; - this.L最後に再生したHHの実WAV番号 = new List( 16 ); - this.n最後に再生したHHのチャンネル番号 = 0; - this.n最後に再生した実WAV番号.Guitar = -1; - this.n最後に再生した実WAV番号.Bass = -1; - for ( int i = 0; i < 50; i++ ) + if (base.b活性化してない) { - this.n最後に再生したBGMの実WAV番号[ i ] = -1; - } - this.r次にくるギターChip = null; - this.r次にくるベースChip = null; - for ( int j = 0; j < 10; j++ ) - { - this.r現在の空うちドラムChip[ j ] = null; - } - this.r現在の空うちギターChip = null; - this.r現在の空うちベースChip = null; - for ( int k = 0; k < 3; k++ ) - { - //for ( int n = 0; n < 5; n++ ) - //{ - this.nヒット数・Auto含まない[ k ] = new CHITCOUNTOFRANK(); - this.nヒット数・Auto含む[ k ] = new CHITCOUNTOFRANK(); - //} - this.queWailing[ k ] = new Queue(); - this.r現在の歓声Chip[ k ] = null; - } - for ( int i = 0; i < 3; i++ ) - { - this.b演奏にキーボードを使った[ i ] = false; - this.b演奏にジョイパッドを使った[ i ] = false; - this.b演奏にMIDI入力を使った[ i ] = false; - this.b演奏にマウスを使った[ i ] = false; - } - this.bAUTOでないチップが１つでもバーを通過した = false; - base.On活性化(); - this.tステータスパネルの選択(); - this.tパネル文字列の設定(); + this.bフィルイン中 = false; + this.dtLastQueueOperation = DateTime.MinValue; + this.eフェードアウト完了時の戻り値 = E演奏画面の戻り値.継続; + this.n現在のトップChip = (CDTXMania.Instance.DTX.listChip.Count > 0) ? 0 : -1; + n最後に再生した実WAV番号 = new STPadValue(); + this.L最後に再生したHHの実WAV番号 = new List(16); + this.e最後に再生したHHのチャンネル番号 = 0; + this.n最後に再生した実WAV番号.GtPick = -1; + this.n最後に再生した実WAV番号.BsPick = -1; + for (int i = 0; i < 50; i++) + { + this.n最後に再生したBGMの実WAV番号[i] = -1; + } + this.r次にくるギターChip = null; + this.r次にくるベースChip = null; + for (int j = 0; j < 10; j++) + { + this.r現在の空うちドラムChip[j] = null; + } + this.r現在の空うちギターChip = null; + this.r現在の空うちベースChip = null; + cInvisibleChip = new CInvisibleChip(CDTXMania.Instance.ConfigIni.nChipDisplayTimeMs, CDTXMania.Instance.ConfigIni.nChipFadeoutTimeMs); + this.n最大コンボ数_TargetGhost = new STDGBSValue(); - this.nInputAdjustTimeMs.Drums = CDTXMania.ConfigIni.nInputAdjustTimeMs.Drums; // #23580 2011.1.3 yyagi - this.nInputAdjustTimeMs.Guitar = CDTXMania.ConfigIni.nInputAdjustTimeMs.Guitar; // 2011.1.7 ikanick 修正 - this.nInputAdjustTimeMs.Bass = CDTXMania.ConfigIni.nInputAdjustTimeMs.Bass; // - this.bIsAutoPlay = CDTXMania.ConfigIni.bAutoPlay; // #24239 2011.1.23 yyagi - this.bIsAutoPlay.Guitar = CDTXMania.ConfigIni.bギターが全部オートプレイである; - this.bIsAutoPlay.Bass = CDTXMania.ConfigIni.bベースが全部オートプレイである; -// this.nRisky = CDTXMania.ConfigIni.nRisky; // #23559 2011.7.28 yyagi - actGauge.Init( CDTXMania.ConfigIni.nRisky ); // #23559 2011.7.28 yyagi - this.nPolyphonicSounds = CDTXMania.ConfigIni.nPoliphonicSounds; + for (EPart k = EPart.Drums; k <= EPart.Bass; k++) + { + this.nヒット数_Auto含まない[k] = new CHitCountOfRank(); + this.nヒット数_Auto含む[k] = new CHitCountOfRank(); + this.nヒット数_TargetGhost[k] = new CHitCountOfRank(); + this.queWailing[k] = new Queue(); + this.r現在の歓声Chip[k] = null; + if (CDTXMania.Instance.DTXVmode.Enabled) + { + CDTXMania.Instance.ConfigIni.nScrollSpeed[k] = CDTXMania.Instance.ConfigIni.nViewerScrollSpeed[k]; + } - CDTXMania.Skin.tRemoveMixerAll(); // 効果音のストリームをミキサーから解除しておく + this.b演奏にキーボードを使った[k] = false; + this.b演奏にジョイパッドを使った[k] = false; + this.b演奏にMIDI入力を使った[k] = false; + this.b演奏にマウスを使った[k] = false; + } - queueMixerSound = new Queue( 64 ); - bIsDirectSound = ( CDTXMania.Sound管理.GetCurrentSoundDeviceType() == "DirectSound" ); + cInvisibleChip.Reset(); + actGauge.Init(CDTXMania.Instance.ConfigIni.nRisky); + // 効果音のストリームをミキサーから解除しておく + CDTXMania.Instance.Skin.tRemoveMixerAll(); + queueMixerSound = new Queue(64); + bIsDirectSound = (CDTXMania.Instance.Sound管理.GetCurrentSoundDeviceType() == "DirectSound"); + this.bPAUSE = false; - #region [ 演奏開始前にmixer登録しておくべきサウンド(開幕してすぐに鳴らすことになるチップ音)を登録しておく ] - foreach ( CDTX.CChip pChip in listChip ) - { -// Debug.WriteLine( "CH=" + pChip.nチャンネル番号.ToString( "x2" ) + ", 整数値=" + pChip.n整数値 + ", time=" + pChip.n発声時刻ms ); - if ( pChip.n発声時刻ms <= 0 ) + if (CDTXMania.Instance.DTXVmode.Enabled) { - if ( pChip.nチャンネル番号 == 0xDA ) + db再生速度 = CDTXMania.Instance.DTX.dbDTXVPlaySpeed; + CDTXMania.Instance.ConfigIni.nPlaySpeed.Value = (int)(CDTXMania.Instance.DTX.dbDTXVPlaySpeed * 20 + 0.5); + } + else + { + db再生速度 = ((double)CDTXMania.Instance.ConfigIni.nPlaySpeed) / 20.0; + } + + bValidScore = (CDTXMania.Instance.DTXVmode.Enabled) ? false : true; + + cWailingChip = new CWailingChip共通[3]; + // 0:未使用, 1:Gutiar, 2:Bass + cWailingChip[1] = new CWailingChip共通(); + cWailingChip[2] = new CWailingChip共通(); + + #region [ 演奏開始前にmixer登録しておくべきサウンド(開幕してすぐに鳴らすことになるチップ音)を登録しておく ] + foreach (CChip pChip in CDTXMania.Instance.DTX.listChip) + { + // Debug.WriteLine( "CH=" + pChip.nチャンネル番号.ToString( "x2" ) + ", 整数値=" + pChip.n整数値 + ", time=" + pChip.n発声時刻ms ); + if (pChip.n発声時刻ms <= 0) { - pChip.bHit = true; -// Debug.WriteLine( "first [DA] BAR=" + pChip.n発声位置 / 384 + " ch=" + pChip.nチャンネル番号.ToString( "x2" ) + ", wav=" + pChip.n整数値 + ", time=" + pChip.n発声時刻ms ); - if ( listWAV.ContainsKey( pChip.n整数値・内部番号 ) ) // 参照が遠いので後日最適化する + if (pChip.eチャンネル番号 == EChannel.MixerAdd) { - CDTX.CWAV wc = listWAV[ pChip.n整数値・内部番号 ]; - for ( int i = 0; i < nPolyphonicSounds; i++ ) + pChip.bHit = true; + // Trace.TraceInformation( "first [DA] BAR=" + pChip.n発声位置 / 384 + " ch=" + pChip.nチャンネル番号.ToString( "x2" ) + ", wav=" + pChip.n整数値 + ", time=" + pChip.n発声時刻ms ); + if (CDTXMania.Instance.DTX.listWAV.ContainsKey(pChip.n整数値_内部番号)) { - if ( wc.rSound[ i ] != null ) + CDTX.CWAV wc = CDTXMania.Instance.DTX.listWAV[pChip.n整数値_内部番号]; + for (int i = 0; i < CDTXMania.Instance.ConfigIni.nPolyphonicSounds; i++) { - CDTXMania.Sound管理.AddMixer( wc.rSound[ i ] ); - //AddMixer( wc.rSound[ i ] ); // 最初はqueueを介さず直接ミキサー登録する + if (wc.rSound[i] != null) + { + CDTXMania.Instance.Sound管理.AddMixer(wc.rSound[i], db再生速度, pChip.b演奏終了後も再生が続くチップである); + //AddMixer( wc.rSound[ i ] ); // 最初はqueueを介さず直接ミキサー登録する + } } } } } + else + { + break; + } } - else + #endregion + + if (CDTXMania.Instance.ConfigIni.bIsSwappedGuitarBass) // #24063 2011.1.24 yyagi Gt/Bsの譜面情報入れ替え { - break; + CDTXMania.Instance.DTX.SwapGuitarBassInfos(); } - } - #endregion - if ( CDTXMania.ConfigIni.bIsSwappedGuitarBass ) // #24063 2011.1.24 yyagi Gt/Bsの譜面情報入れ替え - { - CDTXMania.DTX.SwapGuitarBassInfos(); + + for (EPart inst = EPart.Drums; inst <= EPart.Bass; ++inst) + { + // MODIFY_BEGIN #25398 2011.06.07 FROM + if (CDTXMania.Instance.bコンパクトモード) + { + var score = new Cスコア(); + CDTXMania.Instance.Songs管理.tScoreIniを読み込んで譜面情報を設定する(CDTXMania.Instance.strコンパクトモードファイル + ".score.ini", ref score); + this.actGraph.dbTarget[inst] = score.譜面情報.最大スキル[inst]; + } + else + { + if (CDTXMania.Instance.ConfigIni.b楽器有効(inst)) + { + this.actGraph.dbTarget[inst] = CDTXMania.Instance.stage選曲.r確定されたスコア.譜面情報.最大スキル[inst]; // #24074 2011.01.23 add ikanick + + // ゴースト利用可のなとき、0で初期化 + if (CDTXMania.Instance.ConfigIni.eTargetGhost[inst] != ETargetGhostData.None) + { + if (CDTXMania.Instance.DTX.listTargetGhsotLag[inst] != null) + { + this.actGraph.dbTarget[inst] = 0; + } + } + } + } + // MODIFY_END #25398 + } + + for (EPart part = EPart.Drums; part <= EPart.Bass; ++part) + { + if (CDTXMania.Instance.ConfigIni.b楽器有効(part)) + { + actOptionPanel.Pos[part] = new Coordinates.CXY(CDTXMania.Instance.ConfigIni.cdInstX[part][CDTXMania.Instance.ConfigIni.eActiveInst] + - CDTXMania.Instance.Coordinates.ImgOptionPanel.W, 0); + } + } + + base.On活性化(); + + // PANELの設定は、base.On活性化()の後に(actPanelの活性化の後)行うこと。 + // さもないと、actPanelが活性化されていないため、パネル文字列の設定が機能しなくなる。 + string strLabel = CDTXMania.Instance.stage選曲.r確定された曲.ar難易度ラベル[ CDTXMania.Instance.stage選曲.n確定された曲の難易度 ]; + string strPanel = CDTXMania.Instance.DTX.TITLE; + //string strSETDEFlabel = CDTXMania.Instance.stage選曲.r確定された曲.strタイトル; + if ( !string.IsNullOrWhiteSpace( strLabel ) && !strPanel.Contains(strLabel) + // && (strPanel == strSETDEFlabel) + ) + { + strPanel += " (" + strLabel + ")"; + } + this.actPanel.SetPanelString( strPanel ); } - this.sw = new Stopwatch(); - this.sw2 = new Stopwatch(); - this.gclatencymode = GCSettings.LatencyMode; - GCSettings.LatencyMode = GCLatencyMode.Batch; // 演奏画面中はGCを抑止する } public override void On非活性化() { - this.L最後に再生したHHの実WAV番号.Clear(); // #23921 2011.1.4 yyagi - this.L最後に再生したHHの実WAV番号 = null; // - for ( int i = 0; i < 3; i++ ) - { - this.queWailing[ i ].Clear(); - this.queWailing[ i ] = null; - } - this.ctWailingチップ模様アニメ = null; - this.ctチップ模様アニメ.Drums = null; - this.ctチップ模様アニメ.Guitar = null; - this.ctチップ模様アニメ.Bass = null; - //listWAV.Clear(); - listWAV = null; - listChip = null; - queueMixerSound.Clear(); - queueMixerSound = null; - GCSettings.LatencyMode = this.gclatencymode; - base.On非活性化(); + if (b活性化してる) + { + // #23921 2011.1.4 yyagi + L最後に再生したHHの実WAV番号.Clear(); + L最後に再生したHHの実WAV番号 = null; + for (EPart i = 0; i <= EPart.Bass; i++) + { + queWailing[i].Clear(); + queWailing[i] = null; + } + ctWailingチップ模様アニメ = null; + ctチップ模様アニメ.Drums = null; + ctチップ模様アニメ.Guitar = null; + ctチップ模様アニメ.Bass = null; + queueMixerSound.Clear(); + queueMixerSound = null; + cInvisibleChip.Dispose(); + cInvisibleChip = null; + base.On非活性化(); + } } public override void OnManagedリソースの作成() { - if ( !base.b活性化してない ) + if (b活性化してる) { - this.t背景テクスチャの生成(); - - this.txWailing枠 = CDTXMania.tテクスチャの生成( CSkin.Path( @"Graphics\ScreenPlay wailing cursor.png" ) ); - + txチップ = TextureFactory.tテクスチャの生成(CSkin.Path(@"Graphics\ScreenPlayDrums chips.png")); + txチップGB = TextureFactory.tテクスチャの生成(CSkin.Path(@"Graphics\ScreenPlayGuitar chips.png")); + txヒットバー = TextureFactory.tテクスチャの生成(CSkin.Path(@"Graphics\ScreenPlayDrums hit-bar.png")); + txヒットバーGB = TextureFactory.tテクスチャの生成(CSkin.Path(@"Graphics\ScreenPlayDrums hit-bar guitar.png")); + txWailing枠 = TextureFactory.tテクスチャの生成(CSkin.Path(@"Graphics\ScreenPlay wailing cursor.png")); + t背景テクスチャの生成(); base.OnManagedリソースの作成(); } + } public override void OnManagedリソースの解放() { - if ( !base.b活性化してない ) + if (b活性化してる) { - CDTXMania.tテクスチャの解放( ref this.tx背景 ); - - CDTXMania.tテクスチャの解放( ref this.txWailing枠 ); + TextureFactory.tテクスチャの解放(ref this.tx背景); + TextureFactory.tテクスチャの解放(ref this.txWailing枠); + TextureFactory.tテクスチャの解放(ref this.txヒットバーGB); + TextureFactory.tテクスチャの解放(ref this.txヒットバー); + TextureFactory.tテクスチャの解放(ref this.txチップGB); + TextureFactory.tテクスチャの解放(ref this.txチップ); base.OnManagedリソースの解放(); } } - - // その他 - - #region [ protected ] - //----------------- - protected class CHITCOUNTOFRANK + public override int On進行描画() { - // Fields - public int Good; - public int Great; - public int Miss; - public int Perfect; - public int Poor; - - // Properties - public int this[ int index ] + if (b活性化してる) { - get + bool bIsFinishedPlaying = false; + bool bIsFinishedFadeout = false; + + if (b初めての進行描画) { - switch ( index ) - { - case 0: - return this.Perfect; + PrepareAVITexture(); - case 1: - return this.Great; + CSound管理.rc演奏用タイマ.tリセット(); + CDTXMania.Instance.Timer.tリセット(); + if (CDTXMania.Instance.ConfigIni.bDrums有効) + { + ctチップ模様アニメ.Drums = new CCounter(0, 48, 10, CDTXMania.Instance.Timer); + } + if (CDTXMania.Instance.ConfigIni.bGuitar有効) + { + ctチップ模様アニメ.Guitar = new CCounter(0, 48, 20, CDTXMania.Instance.Timer); + ctチップ模様アニメ.Bass = new CCounter(0, 48, 20, CDTXMania.Instance.Timer); + ctWailingチップ模様アニメ = new CCounter(0, 4, 50, CDTXMania.Instance.Timer); + } - case 2: - return this.Good; + // this.actChipFireD.Start( Eレーン.HH ); // #31554 2013.6.12 yyagi + // 初チップヒット時のもたつき回避。最初にactChipFireD.Start()するときにJITが掛かって？ + // ものすごく待たされる(2回目以降と比べると2,3桁tick違う)。そこで最初の画面フェードインの間に + // 一発Start()を掛けてJITの結果を生成させておく。 - case 3: - return this.Poor; + base.eフェーズID = CStage.Eフェーズ.共通_フェードイン; + actFI.tフェードイン開始(); - case 4: - return this.Miss; + if (CDTXMania.Instance.DTXVmode.Enabled) + { + #region [ DTXV用の再生設定にする(全AUTOなど) ] + tDTXV用の設定(); + #endregion + t演奏位置の変更(CDTXMania.Instance.DTXVmode.nStartBar); } - throw new IndexOutOfRangeException(); + + CDTXMania.Instance.Sound管理.tDisableUpdateBufferAutomatically(); + b初めての進行描画 = false; } - set + + #region [ stage failed ] + if (CDTXMania.Instance.ConfigIni.bStageFailed && (base.eフェーズID == CStage.Eフェーズ.共通_通常状態)) { - switch ( index ) + if (actGauge.IsFailed) { - case 0: - this.Perfect = value; - return; - - case 1: - this.Great = value; - return; - - case 2: - this.Good = value; - return; - - case 3: - this.Poor = value; - return; - - case 4: - this.Miss = value; - return; + actStageFailed.Start(); + CDTXMania.Instance.DTX.t全チップの再生停止(); + base.eフェーズID = CStage.Eフェーズ.演奏_STAGE_FAILED; } - throw new IndexOutOfRangeException(); } - } - } + #endregion - [StructLayout( LayoutKind.Sequential )] - protected struct STKARAUCHI - { - public CDTX.CChip HH; - public CDTX.CChip SD; - public CDTX.CChip BD; - public CDTX.CChip HT; - public CDTX.CChip LT; - public CDTX.CChip FT; - public CDTX.CChip CY; - public CDTX.CChip HHO; - public CDTX.CChip RD; - public CDTX.CChip LC; - public CDTX.CChip this[ int index ] - { - get + // Background + if (CDTXMania.Instance.ConfigIni.eDark == EDark.Off) { - switch ( index ) + if (tx背景 != null) { - case 0: - return this.HH; - - case 1: - return this.SD; - - case 2: - return this.BD; - - case 3: - return this.HT; - - case 4: - return this.LT; - - case 5: - return this.FT; - - case 6: - return this.CY; - - case 7: - return this.HHO; - - case 8: - return this.RD; - - case 9: - return this.LC; + tx背景.t2D描画(CDTXMania.Instance.Device, 0, 0); } - throw new IndexOutOfRangeException(); } - set + + // AVI / BGA + if (base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED && + base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト) { - switch ( index ) + actAVI.t進行描画( + CDTXMania.Instance.ConfigIni.cdMovieX[CDTXMania.Instance.ConfigIni.eActiveInst], + CDTXMania.Instance.ConfigIni.cdMovieY[CDTXMania.Instance.ConfigIni.eActiveInst], + CDTXMania.Instance.Coordinates.Movie.W, + CDTXMania.Instance.Coordinates.Movie.H); + actBGA.On進行描画(); + #region [MIDIBGM 処理?] + if (base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED) { - case 0: - this.HH = value; - return; + CStage.Eフェーズ eフェーズid1 = base.eフェーズID; + } + #endregion + actLane.On進行描画(); + actLaneFlushGB.On進行描画(); + actPanel.On進行描画(); + actScore.On進行描画(); + actOptionPanel.On進行描画(); + actGauge.On進行描画(); + actGraph.On進行描画(); + actLaneFlushD.On進行描画(); + actDANGER.t進行描画(actGauge.IsDanger); + act譜面スクロール速度.On進行描画(); + t進行描画_判定ライン(); + actWailingBonus.On進行描画(); + + // RGB, Judge, Combo (Priority Under Chip) + if (CDTXMania.Instance.ConfigIni.eJudgePriority == EJudgeDisplayPriority.Under) + { + actRGB.On進行描画(); + actJudgeString.On進行描画(); + actCombo.On進行描画(); + } + t進行描画_チップアニメ(); + bIsFinishedPlaying = t進行描画_チップ(); + actPad.On進行描画(); - case 1: - this.SD = value; - return; + // RGB, Judge, Combo (Priority Over Chip) + if (CDTXMania.Instance.ConfigIni.eJudgePriority == EJudgeDisplayPriority.Over) + { + actRGB.On進行描画(); + actJudgeString.On進行描画(); + actCombo.On進行描画(); + } - case 2: - this.BD = value; - return; + actChipFireD.On進行描画(); + actChipFireGB.On進行描画(); + actPlayInfo.On進行描画(); - case 3: - this.HT = value; - return; + // Wailing + if ((CDTXMania.Instance.ConfigIni.eDark != EDark.Full) && + CDTXMania.Instance.ConfigIni.bGuitar有効) + { + int GtWailingFrameX = CDTXMania.Instance.ConfigIni.GetLaneX(ELane.GtW) + + (CDTXMania.Instance.ConfigIni.GetLaneW(ELane.GtW) - CDTXMania.Instance.Coordinates.ImgGtWailingFrame.W) / 2; + int BsWailingFrameX = CDTXMania.Instance.ConfigIni.GetLaneX(ELane.BsW) + + (CDTXMania.Instance.ConfigIni.GetLaneW(ELane.BsW) - CDTXMania.Instance.Coordinates.ImgGtWailingFrame.W) / 2; + int GtWailingFrameY = C演奏判定ライン座標共通.n判定ラインY座標(EPart.Guitar, true, true); + int BsWailingFrameY = C演奏判定ライン座標共通.n判定ラインY座標(EPart.Bass, true, true); + + if (txWailing枠 != null) + { + if (CDTXMania.Instance.DTX.bチップがある.Guitar) + { + txWailing枠.t2D描画(CDTXMania.Instance.Device, GtWailingFrameX, GtWailingFrameY); + } + if (CDTXMania.Instance.DTX.bチップがある.Bass) + { + txWailing枠.t2D描画(CDTXMania.Instance.Device, BsWailingFrameX, BsWailingFrameY); + } + } + } + } - case 4: - this.LT = value; - return; + // Stage Failed + if (((base.eフェーズID == CStage.Eフェーズ.演奏_STAGE_FAILED) || + (base.eフェーズID == CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト)) && + ((actStageFailed.On進行描画() != 0) && + (base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト))) + { + eフェードアウト完了時の戻り値 = E演奏画面の戻り値.ステージ失敗; + base.eフェーズID = CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト; + actFO.tフェードアウト開始(); + } - case 5: - this.FT = value; - return; + bIsFinishedFadeout = this.t進行描画_フェードイン_アウト(); + if (bIsFinishedPlaying && (base.eフェーズID == CStage.Eフェーズ.共通_通常状態)) + { + if (CDTXMania.Instance.DTXVmode.Enabled) + { + if (CDTXMania.Instance.Timer.b停止していない) + { + actPanel.Stop(); + CDTXMania.Instance.Timer.t一時停止(); + } + Thread.Sleep(5); + // DTXCからの次のメッセージを待ち続ける + } + else + { + this.eフェードアウト完了時の戻り値 = E演奏画面の戻り値.ステージクリア; + base.eフェーズID = CStage.Eフェーズ.演奏_STAGE_CLEAR_フェードアウト; + this.actFOClear.tフェードアウト開始(); + t演奏結果を格納する_ドラム(); + t演奏結果を格納する_ギター(); + t演奏結果を格納する_ベース(); + + if (CDTXMania.Instance.ConfigIni.bDrums有効) + { + for (EPad pad = EPad.DrumsPadMin; pad < EPad.DrumsPadMax; pad++) + { + r空打ちドラムチップ[pad] = r空うちChip(EPart.Drums, pad); + if (r空打ちドラムチップ[pad] == null) + { + r空打ちドラムチップ[pad] = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮( + CSound管理.rc演奏用タイマ.n現在時刻, + EnumConverter.ChannelFromPad(pad), + CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs.Drums); + } + } + } - case 6: - this.CY = value; - return; + if (CDTXMania.Instance.ConfigIni.bIsSwappedGuitarBass) // #24063 2011.1.24 yyagi Gt/Bsを入れ替えていたなら、演奏結果も入れ替える + { + CScoreIni.C演奏記録 t; + t = record.Guitar; + record.Guitar = record.Bass; + record.Bass = t; + + // 譜面情報も元に戻す + // #35417 2015.08.30 changed フラグにアクセスしている箇所が見つかったため有効化 + // #35417 2015.8.18 yyagi: AUTO系のフラグ入れ替えは削除可能!?。以後AUTOフラグに全くアクセスしておらず、意味がないため。 + // (直下でb全AUTOである にアクセスしているが、既に計算済みのクラスへのアクセスであり、ここでの交換対象ではない) + CDTXMania.Instance.DTX.SwapGuitarBassInfos(); + // #24415 2011.2.27 yyagi + // リザルト集計時のみ、Auto系のフラグも元に戻す。 + // これを戻すのは、リザルト集計後。 + // "case CStage.Eステージ.結果:"のところ。 + CDTXMania.Instance.ConfigIni.SwapGuitarBassInfos_AutoFlags(); + } + } + } + if (this.eフェードアウト完了時の戻り値 == E演奏画面の戻り値.再読込_再演奏) + { + bIsFinishedFadeout = true; + } + if (bIsFinishedFadeout) + { + return (int)this.eフェードアウト完了時の戻り値; + } - case 7: - this.HHO = value; - return; + ManageMixerQueue(); - case 8: - this.RD = value; - return; + // キー入力 - case 9: - this.LC = value; - return; - } - throw new IndexOutOfRangeException(); + if (CDTXMania.Instance.act現在入力を占有中のプラグイン == null) + { + this.tキー入力(); } } + return 0; } - protected struct stmixer + // その他 + public STPadValue GetNoChipDrums() { - internal bool bIsAdd; - internal CSound csound; - }; - - protected CAct演奏AVI actAVI; - protected CAct演奏BGA actBGA; - - protected CAct演奏チップファイアGB actChipFireGB; - protected CAct演奏Combo共通 actCombo; - protected CAct演奏Danger共通 actDANGER; - protected CActFIFOBlack actFI; - protected CActFIFOBlack actFO; - protected CActFIFOWhite actFOClear; - protected CAct演奏ゲージ共通 actGauge; - - protected CAct演奏判定文字列共通 actJudgeString; - protected CAct演奏DrumsレーンフラッシュD actLaneFlushD; - protected CAct演奏レーンフラッシュGB共通 actLaneFlushGB; - protected CAct演奏パネル文字列 actPanel; - protected CAct演奏演奏情報 actPlayInfo; - protected CAct演奏RGB共通 actRGB; - protected CAct演奏スコア共通 actScore; - protected CAct演奏ステージ失敗 actStageFailed; - protected CAct演奏ステータスパネル共通 actStatusPanels; - protected CAct演奏WailingBonus共通 actWailingBonus; - protected CAct演奏スクロール速度 act譜面スクロール速度; - protected bool bPAUSE; - protected STDGBVALUE b演奏にMIDI入力を使った; - protected STDGBVALUE b演奏にキーボードを使った; - protected STDGBVALUE b演奏にジョイパッドを使った; - protected STDGBVALUE b演奏にマウスを使った; - protected CCounter ctWailingチップ模様アニメ; - protected STDGBVALUE ctチップ模様アニメ; - - protected E演奏画面の戻り値 eフェードアウト完了時の戻り値; - protected readonly int[,] nBGAスコープチャンネルマップ = new int[ , ] { { 0xc4, 0xc7, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xe0 }, { 4, 7, 0x55, 0x56, 0x57, 0x58, 0x59, 0x60 } }; - protected readonly int[] nチャンネル0Atoパッド08 = new int[] { 1, 2, 3, 4, 5, 7, 6, 1, 8, 0 }; - protected readonly int[] nチャンネル0Atoレーン07 = new int[] { 1, 2, 3, 4, 5, 7, 6, 1, 7, 0 }; - protected readonly int[] nパッド0Atoチャンネル0A = new int[] { 0x11, 0x12, 0x13, 20, 0x15, 0x17, 0x16, 0x18, 0x19, 0x1a }; - protected readonly int[] nパッド0Atoパッド08 = new int[] { 1, 2, 3, 4, 5, 6, 7, 1, 8, 0 }; // パッド画像のヒット処理用 - protected readonly int[] nパッド0Atoレーン07 = new int[] { 1, 2, 3, 4, 5, 6, 7, 1, 7, 0 }; - protected STDGBVALUE nヒット数・Auto含まない; - protected STDGBVALUE nヒット数・Auto含む; - protected int n現在のトップChip = -1; - protected int[] n最後に再生したBGMの実WAV番号 = new int[ 50 ]; - protected int n最後に再生したHHのチャンネル番号; - protected List L最後に再生したHHの実WAV番号; // #23921 2011.1.4 yyagi: change "int" to "List", for recording multiple wav No. - protected STLANEVALUE n最後に再生した実WAV番号; // #26388 2011.11.8 yyagi: change "n最後に再生した実WAV番号.GUITAR" and "n最後に再生した実WAV番号.BASS" - // into "n最後に再生した実WAV番号"; -// protected int n最後に再生した実WAV番号.GUITAR; -// protected int n最後に再生した実WAV番号.BASS; - - protected volatile Queue queueMixerSound; // #24820 2013.1.21 yyagi まずは単純にAdd/Removeを1個のキューでまとめて管理するやり方で設計する - protected DateTime dtLastQueueOperation; // - protected bool bIsDirectSound; // - - protected STDGBVALUE> queWailing; - protected STDGBVALUE r現在の歓声Chip; - protected CDTX.CChip r現在の空うちギターChip; - protected STKARAUCHI r現在の空うちドラムChip; - protected CDTX.CChip r現在の空うちベースChip; - protected CDTX.CChip r次にくるギターChip; - protected CDTX.CChip r次にくるベースChip; - protected CTexture txWailing枠; - protected CTexture txチップ; - protected CTexture txヒットバー; - - protected CTexture tx背景; - - protected STDGBVALUE nInputAdjustTimeMs; // #23580 2011.1.3 yyagi - protected STAUTOPLAY bIsAutoPlay; // #24239 2011.1.23 yyagi -// protected int nRisky_InitialVar, nRiskyTime; // #23559 2011.7.28 yyagi → CAct演奏ゲージ共通クラスに隠蔽 - protected int nPolyphonicSounds; - protected List listChip; - protected Dictionary listWAV; - - protected Stopwatch sw; // 2011.6.13 最適化検討用のストップウォッチ - protected Stopwatch sw2; - protected GCLatencyMode gclatencymode; - - public void AddMixer( CSound cs ) + return r空打ちドラムチップ; + } + public STDGBSValue Record + { + get + { + return record; + } + } + public void AddMixer(CSound cs, bool _b演奏終了後も再生が続くチップである) { - stmixer stm = new stmixer() + STMixer stm = new STMixer() { bIsAdd = true, - csound = cs + csound = cs, + b演奏終了後も再生が続くチップである = _b演奏終了後も再生が続くチップである }; - queueMixerSound.Enqueue( stm ); -// Debug.WriteLine( "★Queue: add " + Path.GetFileName( stm.csound.strファイル名 )); + queueMixerSound.Enqueue(stm); + // Debug.WriteLine( "★Queue: add " + Path.GetFileName( stm.csound.strファイル名 )); } - public void RemoveMixer( CSound cs ) + public void RemoveMixer(CSound cs) { - stmixer stm = new stmixer() + STMixer stm = new STMixer() { bIsAdd = false, - csound = cs + csound = cs, + b演奏終了後も再生が続くチップである = false }; - queueMixerSound.Enqueue( stm ); -// Debug.WriteLine( "★Queue: remove " + Path.GetFileName( stm.csound.strファイル名 )); + queueMixerSound.Enqueue(stm); + // Debug.WriteLine( "★Queue: remove " + Path.GetFileName( stm.csound.strファイル名 )); + } + public void ManageMixerQueue() + { + // もしサウンドの登録/削除が必要なら、実行する + if (queueMixerSound.Count > 0) + { + //Debug.WriteLine( "☆queueLength=" + queueMixerSound.Count ); + DateTime dtnow = DateTime.Now; + TimeSpan ts = dtnow - dtLastQueueOperation; + int nInterval = ( CDTXMania.Instance.ConfigIni.bVSyncWait ) ? 7 : 1; + int nMaxDequeueCount = ( CDTXMania.Instance.ConfigIni.bVSyncWait ) ? 2 : 1; + if (ts.Milliseconds > nInterval) + { + for (int i = 0; i < nMaxDequeueCount && queueMixerSound.Count > 0; i++) + { + dtLastQueueOperation = dtnow; + STMixer stm = queueMixerSound.Dequeue(); + if (stm.bIsAdd) + { + CDTXMania.Instance.Sound管理.AddMixer(stm.csound, db再生速度, stm.b演奏終了後も再生が続くチップである); + } + else + { + CDTXMania.Instance.Sound管理.RemoveMixer(stm.csound); + } + } + } + } + } + + /// + /// 演奏開始前に適切なサイズのAVIテクスチャを作成しておくことで、AVI再生開始時のもたつきをなくす + /// + protected void PrepareAVITexture() + { + if (CDTXMania.Instance.ConfigIni.bAVI) + { + foreach (CChip pChip in CDTXMania.Instance.DTX.listChip) + { + if (pChip.eチャンネル番号 == EChannel.Movie || pChip.eチャンネル番号 == EChannel.MovieFull) + { + // 最初に再生するAVIチップに合わせて、テクスチャを準備しておく + if (pChip.rAVI != null) + { + this.actAVI.PrepareProperSizeTexture((int)pChip.rAVI.avi.nフレーム幅, (int)pChip.rAVI.avi.nフレーム高さ); + } + break; + } + } + } } - protected E判定 e指定時刻からChipのJUDGEを返す( long nTime, CDTX.CChip pChip, int nInputAdjustTime ) + protected EJudge e指定時刻からChipのJUDGEを返す(long nTime, CChip pChip, int nInputAdjustTime, bool saveLag = true) { - if ( pChip != null ) + if (pChip != null) { - pChip.nLag = (int) ( nTime + nInputAdjustTime - pChip.n発声時刻ms ); // #23580 2011.1.3 yyagi: add "nInputAdjustTime" to add input timing adjust feature - int nDeltaTime = Math.Abs( pChip.nLag ); + // #35411 2015.08.22 chnmr0 modified add check save lag flag for ghost + int lag = (int)(nTime + nInputAdjustTime - pChip.n発声時刻ms); + if (saveLag) + { + pChip.nLag = lag; + // #23580 2011.1.3 yyagi: add "nInputAdjustTime" to add input timing adjust feature + if (pChip.e楽器パート != EPart.Unknown) + { + pChip.extendInfoForGhost = this.actCombo.dgbコンボ数[pChip.e楽器パート].n現在値 > 0 ? true : false; + } + } + // #35411 modify end + + int nDeltaTime = Math.Abs(lag); //Debug.WriteLine("nAbsTime=" + (nTime - pChip.n発声時刻ms) + ", nDeltaTime=" + (nTime + nInputAdjustTime - pChip.n発声時刻ms)); - if ( nDeltaTime <= CDTXMania.nPerfect範囲ms ) + if (nDeltaTime <= CDTXMania.Instance.nPerfect範囲ms) { - return E判定.Perfect; + return EJudge.Perfect; } - if ( nDeltaTime <= CDTXMania.nGreat範囲ms ) + if (nDeltaTime <= CDTXMania.Instance.nGreat範囲ms) { - return E判定.Great; + return EJudge.Great; } - if ( nDeltaTime <= CDTXMania.nGood範囲ms ) + if (nDeltaTime <= CDTXMania.Instance.nGood範囲ms) { - return E判定.Good; + return EJudge.Good; } - if ( nDeltaTime <= CDTXMania.nPoor範囲ms ) + if (nDeltaTime <= CDTXMania.Instance.nPoor範囲ms) { - return E判定.Poor; + return EJudge.Poor; } } - return E判定.Miss; + return EJudge.Miss; } - protected CDTX.CChip r空うちChip( E楽器パート part, Eパッド pad ) + + protected CChip r空うちChip(EPart part, EPad pad) { - switch ( part ) + switch (part) { - case E楽器パート.DRUMS: - switch ( pad ) + case EPart.Drums: + switch (pad) { - case Eパッド.HH: - if ( this.r現在の空うちドラムChip.HH != null ) + case EPad.HH: + if (this.r現在の空うちドラムChip.HH != null) { return this.r現在の空うちドラムChip.HH; } - if ( CDTXMania.ConfigIni.eHHGroup != EHHGroup.ハイハットのみ打ち分ける ) + if (CDTXMania.Instance.ConfigIni.eHHGroup != EHHGroup.HO_HC) { - if ( CDTXMania.ConfigIni.eHHGroup == EHHGroup.左シンバルのみ打ち分ける ) + if (CDTXMania.Instance.ConfigIni.eHHGroup == EHHGroup.LC_HH) { return this.r現在の空うちドラムChip.HHO; } - if ( this.r現在の空うちドラムChip.HHO != null ) + if (this.r現在の空うちドラムChip.HHO != null) { return this.r現在の空うちドラムChip.HHO; } } return this.r現在の空うちドラムChip.LC; - case Eパッド.SD: + case EPad.SD: return this.r現在の空うちドラムChip.SD; - case Eパッド.BD: + case EPad.BD: return this.r現在の空うちドラムChip.BD; - case Eパッド.HT: + case EPad.HT: return this.r現在の空うちドラムChip.HT; - case Eパッド.LT: - if ( this.r現在の空うちドラムChip.LT != null ) + case EPad.LT: + if (this.r現在の空うちドラムChip.LT != null) { return this.r現在の空うちドラムChip.LT; } - if ( CDTXMania.ConfigIni.eFTGroup == EFTGroup.共通 ) + if (CDTXMania.Instance.ConfigIni.eFTGroup == EFTGroup.Group) { return this.r現在の空うちドラムChip.FT; } return null; - case Eパッド.FT: - if ( this.r現在の空うちドラムChip.FT != null ) + case EPad.FT: + if (this.r現在の空うちドラムChip.FT != null) { return this.r現在の空うちドラムChip.FT; } - if ( CDTXMania.ConfigIni.eFTGroup == EFTGroup.共通 ) + if (CDTXMania.Instance.ConfigIni.eFTGroup == EFTGroup.Group) { return this.r現在の空うちドラムChip.LT; } return null; - case Eパッド.CY: - if ( this.r現在の空うちドラムChip.CY != null ) + case EPad.CY: + if (this.r現在の空うちドラムChip.CY != null) { return this.r現在の空うちドラムChip.CY; } - if ( CDTXMania.ConfigIni.eCYGroup == ECYGroup.共通 ) + if (CDTXMania.Instance.ConfigIni.eCYGroup == ECYGroup.Group) { return this.r現在の空うちドラムChip.RD; } return null; - case Eパッド.HHO: - if ( this.r現在の空うちドラムChip.HHO != null ) + case EPad.HHO: + if (this.r現在の空うちドラムChip.HHO != null) { return this.r現在の空うちドラムChip.HHO; } - if ( CDTXMania.ConfigIni.eHHGroup != EHHGroup.ハイハットのみ打ち分ける ) + if (CDTXMania.Instance.ConfigIni.eHHGroup != EHHGroup.HO_HC) { - if ( CDTXMania.ConfigIni.eHHGroup == EHHGroup.左シンバルのみ打ち分ける ) + if (CDTXMania.Instance.ConfigIni.eHHGroup == EHHGroup.LC_HH) { return this.r現在の空うちドラムChip.HH; } - if ( this.r現在の空うちドラムChip.HH != null ) + if (this.r現在の空うちドラムChip.HH != null) { return this.r現在の空うちドラムChip.HH; } } return this.r現在の空うちドラムChip.LC; - case Eパッド.RD: - if ( this.r現在の空うちドラムChip.RD != null ) + case EPad.RD: + if (this.r現在の空うちドラムChip.RD != null) { return this.r現在の空うちドラムChip.RD; } - if ( CDTXMania.ConfigIni.eCYGroup == ECYGroup.共通 ) + if (CDTXMania.Instance.ConfigIni.eCYGroup == ECYGroup.Group) { return this.r現在の空うちドラムChip.CY; } return null; - case Eパッド.LC: - if ( this.r現在の空うちドラムChip.LC != null ) + case EPad.LC: + if (this.r現在の空うちドラムChip.LC != null) { return this.r現在の空うちドラムChip.LC; } - if ( ( CDTXMania.ConfigIni.eHHGroup != EHHGroup.ハイハットのみ打ち分ける ) && ( CDTXMania.ConfigIni.eHHGroup != EHHGroup.全部共通 ) ) + if ((CDTXMania.Instance.ConfigIni.eHHGroup != EHHGroup.HO_HC) && (CDTXMania.Instance.ConfigIni.eHHGroup != EHHGroup.Group)) { return null; } - if ( this.r現在の空うちドラムChip.HH != null ) + if (this.r現在の空うちドラムChip.HH != null) { return this.r現在の空うちドラムChip.HH; } @@ -775,163 +1008,52 @@ namespace DTXMania } break; - case E楽器パート.GUITAR: + case EPart.Guitar: return this.r現在の空うちギターChip; - case E楽器パート.BASS: + case EPart.Bass: return this.r現在の空うちベースChip; } return null; } - protected CDTX.CChip r指定時刻に一番近いChip・ヒット未済問わず不可視考慮( long nTime, int nChannel, int nInputAdjustTime ) + + protected CChip r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(long nTime, EChannel eChannel, int nInputAdjustTime) { - sw2.Start(); -//Trace.TraceInformation( "NTime={0}, nChannel={1:x2}", nTime, nChannel ); - nTime += nInputAdjustTime; // #24239 2011.1.23 yyagi InputAdjust + return r指定時刻に一番近い未ヒットChip(nTime, eChannel, nInputAdjustTime, 0, HitState.DontCare); + } - int nIndex_InitialPositionSearchingToPast; - if ( this.n現在のトップChip == -1 ) // 演奏データとして1個もチップがない場合は - { - sw2.Stop(); - return null; - } - int count = listChip.Count; - int nIndex_NearestChip_Future = nIndex_InitialPositionSearchingToPast = this.n現在のトップChip; - if ( this.n現在のトップChip >= count ) // その時点で演奏すべきチップが既に全部無くなっていたら - { - nIndex_NearestChip_Future = nIndex_InitialPositionSearchingToPast = count - 1; - } - //int nIndex_NearestChip_Future; // = nIndex_InitialPositionSearchingToFuture; - //while ( nIndex_NearestChip_Future < count ) // 未来方向への検索 - for ( ; nIndex_NearestChip_Future < count; nIndex_NearestChip_Future++) + protected void tサウンド再生(CChip rChip, long n再生開始システム時刻ms, EPart part) + { + this.tサウンド再生(rChip, n再生開始システム時刻ms, part, CDTXMania.Instance.ConfigIni.nChipVolume); + } + + protected void tサウンド再生(CChip pChip, long n再生開始システム時刻ms, EPart part, int n音量, bool bモニタ = false, bool b音程をずらして再生 = false) + { + // mute sound (auto) + // 4A: HH + // 4B: CY + // 4C: RD + // 4D: LC + // 2A: Gt + // AA: Bs + // + + if (pChip != null) { - CDTX.CChip chip = listChip[ nIndex_NearestChip_Future ]; - if ( ( ( 0x11 <= nChannel ) && ( nChannel <= 0x1a ) ) ) + bool overwrite = false; + switch (part) { - if ( ( chip.nチャンネル番号 == nChannel ) || ( chip.nチャンネル番号 == ( nChannel + 0x20 ) ) ) - { - if ( chip.n発声時刻ms > nTime ) + case EPart.Drums: + #region [ DRUMS ] { - break; - } - nIndex_InitialPositionSearchingToPast = nIndex_NearestChip_Future; - } - continue; // ほんの僅かながら高速化 - } - else if ( ( ( nChannel == 0x2f ) && ( chip.e楽器パート == E楽器パート.GUITAR ) ) || ( ( ( 0x20 <= nChannel ) && ( nChannel <= 0x28 ) ) && ( chip.nチャンネル番号 == nChannel ) ) ) - { - if ( chip.n発声時刻ms > nTime ) - { - break; - } - nIndex_InitialPositionSearchingToPast = nIndex_NearestChip_Future; - } - else if ( ( ( nChannel == 0xaf ) && ( chip.e楽器パート == E楽器パート.BASS ) ) || ( ( ( 0xa0 <= nChannel ) && ( nChannel <= 0xa8 ) ) && ( chip.nチャンネル番号 == nChannel ) ) ) - { - if ( chip.n発声時刻ms > nTime ) - { - break; - } - nIndex_InitialPositionSearchingToPast = nIndex_NearestChip_Future; - } - // nIndex_NearestChip_Future++; - } - int nIndex_NearestChip_Past = nIndex_InitialPositionSearchingToPast; - //while ( nIndex_NearestChip_Past >= 0 ) // 過去方向への検索 - for ( ; nIndex_NearestChip_Past >= 0; nIndex_NearestChip_Past-- ) - { - CDTX.CChip chip = listChip[ nIndex_NearestChip_Past ]; - if ( ( 0x11 <= nChannel ) && ( nChannel <= 0x1a ) ) - { - if ( ( chip.nチャンネル番号 == nChannel ) || ( chip.nチャンネル番号 == ( nChannel + 0x20 ) ) ) - { - break; - } - } - else if ( ( ( nChannel == 0x2f ) && ( chip.e楽器パート == E楽器パート.GUITAR ) ) || ( ( ( 0x20 <= nChannel ) && ( nChannel <= 0x28 ) ) && ( chip.nチャンネル番号 == nChannel ) ) ) - { - if ( ( 0x20 <= chip.nチャンネル番号 ) && ( chip.nチャンネル番号 <= 0x28 ) ) - { - break; - } - } - else if ( ( ( ( nChannel == 0xaf ) && ( chip.e楽器パート == E楽器パート.BASS ) ) || ( ( ( 0xa0 <= nChannel ) && ( nChannel <= 0xa8 ) ) && ( chip.nチャンネル番号 == nChannel ) ) ) - && ( ( 0xa0 <= chip.nチャンネル番号 ) && ( chip.nチャンネル番号 <= 0xa8 ) ) ) - { - break; - } - // nIndex_NearestChip_Past--; - } - - if ( nIndex_NearestChip_Future >= count ) - { - if ( nIndex_NearestChip_Past < 0 ) // 検索対象が過去未来どちらにも見つからなかった場合 - { - return null; - } - else // 検索対象が未来方向には見つからなかった(しかし過去方向には見つかった)場合 - { - sw2.Stop(); - return listChip[ nIndex_NearestChip_Past ]; - } - } - else if ( nIndex_NearestChip_Past < 0 ) // 検索対象が過去方向には見つからなかった(しかし未来方向には見つかった)場合 - { - sw2.Stop(); - return listChip[ nIndex_NearestChip_Future ]; - } - // 検索対象が過去未来の双方に見つかったなら、より近い方を採用する - CDTX.CChip nearestChip_Future = listChip[ nIndex_NearestChip_Future ]; - CDTX.CChip nearestChip_Past = listChip[ nIndex_NearestChip_Past ]; - int nDiffTime_Future = Math.Abs( (int) ( nTime - nearestChip_Future.n発声時刻ms ) ); - int nDiffTime_Past = Math.Abs( (int) ( nTime - nearestChip_Past.n発声時刻ms ) ); - if ( nDiffTime_Future >= nDiffTime_Past ) - { - sw2.Stop(); - return nearestChip_Past; - } - sw2.Stop(); - return nearestChip_Future; - } - protected void tサウンド再生( CDTX.CChip rChip, long n再生開始システム時刻ms, E楽器パート part ) - { - this.tサウンド再生( rChip, n再生開始システム時刻ms, part, CDTXMania.ConfigIni.n手動再生音量, false, false ); - } - protected void tサウンド再生( CDTX.CChip rChip, long n再生開始システム時刻ms, E楽器パート part, int n音量 ) - { - this.tサウンド再生( rChip, n再生開始システム時刻ms, part, n音量, false, false ); - } - protected void tサウンド再生( CDTX.CChip rChip, long n再生開始システム時刻ms, E楽器パート part, int n音量, bool bモニタ ) - { - this.tサウンド再生( rChip, n再生開始システム時刻ms, part, n音量, bモニタ, false ); - } - protected void tサウンド再生( CDTX.CChip pChip, long n再生開始システム時刻ms, E楽器パート part, int n音量, bool bモニタ, bool b音程をずらして再生 ) - { - // mute sound (auto) - // 4A: HH - // 4B: CY - // 4C: RD - // 4D: LC - // 2A: Gt - // AA: Bs - // - - if ( pChip != null ) - { - bool overwrite = false; - switch ( part ) - { - case E楽器パート.DRUMS: - #region [ DRUMS ] - { - int index = pChip.nチャンネル番号; - if ( ( 0x11 <= index ) && ( index <= 0x1a ) ) + int index = -1; + if (pChip.bDrums可視チップ_LP_LBD含まない) { - index -= 0x11; + index = pChip.nDrumsIndex; } - else if ( ( 0x31 <= index ) && ( index <= 0x3a ) ) + else if (pChip.bDrums不可視チップ_LP_LBD含まない) { - index -= 0x31; + index = pChip.nDrumsIndexHidden; } // mute sound (auto) // 4A: 84: HH (HO/HC) @@ -940,26 +1062,27 @@ namespace DTXMania // 4D: 87: LC // 2A: 88: Gt // AA: 89: Bs - else if ( 0x84 == index ) // 仮に今だけ追加 HHは消音処理があるので overwriteフラグ系の処理は改めて不要 + else if (EChannel.SE24 == pChip.eチャンネル番号) // 仮に今だけ追加 HHは消音処理があるので overwriteフラグ系の処理は改めて不要 { index = 0; } - else if ( ( 0x85 <= index ) && ( index <= 0x87 ) ) // 仮に今だけ追加 + else if ((EChannel.SE25 <= pChip.eチャンネル番号) && (pChip.eチャンネル番号 <= EChannel.SE27)) // 仮に今だけ追加 { - // CY RD LC - int[] ch = { 0x16, 0x19, 0x1A }; - pChip.nチャンネル番号 = ch[ pChip.nチャンネル番号 - 0x85 ]; - index = pChip.nチャンネル番号 - 0x11; + pChip.ConvertSE25_26_27toCY_RCY_LCY(); + index = pChip.nDrumsIndex; overwrite = true; } else { return; } - int nLane = this.nチャンネル0Atoレーン07[ index ]; - if ( ( nLane == 1 ) && // 今回演奏するのがHC or HO - ( index == 0 || ( index == 7 && this.n最後に再生したHHのチャンネル番号 != 0x18 && this.n最後に再生したHHのチャンネル番号 != 0x38 ) ) - // HCを演奏するか、またはHO演奏＆以前HO演奏でない＆以前不可視HO演奏でない + EChannel actChannel = EChannel.HiHatClose + index; + ELane nLane = EnumConverter.LaneFromChannel(actChannel); + if ((nLane == ELane.HH) && // 今回演奏するのがHC or HO + (index == 0 || (index == 7 && + this.e最後に再生したHHのチャンネル番号 != EChannel.HiHatOpen && + this.e最後に再生したHHのチャンネル番号 != EChannel.HiHatOpen_Hidden)) + // HCを演奏するか、またはHO演奏＆以前HO演奏でない＆以前不可視HO演奏でない ) // #24772 2011.4.4 yyagi // == HH mute condition == @@ -969,73 +1092,52 @@ namespace DTXMania // HO Yes No { // #23921 2011.1.4 yyagi: 2種類以上のオープンハイハットが発音済みだと、最後のHHOしか消せない問題に対応。 -#if TEST_NOTEOFFMODE // 2011.1.1 yyagi test - if (CDTXMania.DTX.b演奏で直前の音を消音する.HH) - { -#endif - for ( int i = 0; i < this.L最後に再生したHHの実WAV番号.Count; i++ ) // #23921 2011.1.4 yyagi + for (int i = 0; i < this.L最後に再生したHHの実WAV番号.Count; i++) // #23921 2011.1.4 yyagi { - // CDTXMania.DTX.tWavの再生停止(this.L最後に再生したHHの実WAV番号); - CDTXMania.DTX.tWavの再生停止( this.L最後に再生したHHの実WAV番号[ i ] ); // #23921 yyagi ストック分全て消音する + CDTXMania.Instance.DTX.tWavの再生停止(this.L最後に再生したHHの実WAV番号[i]); // #23921 yyagi ストック分全て消音する } this.L最後に再生したHHの実WAV番号.Clear(); -#if TEST_NOTEOFFMODE // 2011.1.1 yyagi test - } -#endif - //this.n最後に再生したHHの実WAV番号 = pChip.n整数値・内部番号; - this.n最後に再生したHHのチャンネル番号 = pChip.nチャンネル番号; + this.e最後に再生したHHのチャンネル番号 = pChip.eチャンネル番号; } -#if TEST_NOTEOFFMODE // 2011.1.4 yyagi test - if (CDTXMania.DTX.b演奏で直前の音を消音する.HH) + if (index == 0 || index == 7) { -#endif - if ( index == 0 || index == 7 || index == 0x20 || index == 0x27 ) // #23921 HOまたは不可視HO演奏時はそのチップ番号をストックしておく - { // #24772 HC, 不可視HCも消音キューに追加 - if ( this.L最後に再生したHHの実WAV番号.Count >= 16 ) // #23921 ただしストック数が16以上になるようなら、頭の1個を削って常に16未満に抑える - { // (ストックが増えてList<>のrealloc()が発生するのを予防する) - this.L最後に再生したHHの実WAV番号.RemoveAt( 0 ); + // #23921 HOまたは不可視HO演奏時はそのチップ番号をストックしておく + // #24772 HC, 不可視HCも消音キューに追加 + if (this.L最後に再生したHHの実WAV番号.Count >= 16) + { + // #23921 ただしストック数が16以上になるようなら、頭の1個を削って常に16未満に抑える + // (ストックが増えてList<>のrealloc()が発生するのを予防する) + this.L最後に再生したHHの実WAV番号.RemoveAt(0); } - if ( !this.L最後に再生したHHの実WAV番号.Contains( pChip.n整数値・内部番号 ) ) // チップ音がまだストックされてなければ + if (!this.L最後に再生したHHの実WAV番号.Contains(pChip.n整数値_内部番号)) { - this.L最後に再生したHHの実WAV番号.Add( pChip.n整数値・内部番号 ); // ストックする + // チップ音がまだストックされてなければストックする + this.L最後に再生したHHの実WAV番号.Add(pChip.n整数値_内部番号); } } -#if TEST_NOTEOFFMODE // 2011.1.4 yyagi test - } -#endif - if ( overwrite ) + if (overwrite) { - CDTXMania.DTX.tWavの再生停止( this.n最後に再生した実WAV番号[index] ); + + CDTXMania.Instance.DTX.tWavの再生停止(this.n最後に再生した実WAV番号[EnumConverter.PadFromChannel(actChannel)]); } - CDTXMania.DTX.tチップの再生( pChip, n再生開始システム時刻ms, nLane, n音量, bモニタ ); - this.n最後に再生した実WAV番号[ nLane ] = pChip.n整数値・内部番号; // nLaneでなくindexにすると、LC(1A-11=09)とギター(enumで09)がかぶってLC音が消されるので注意 + CDTXMania.Instance.DTX.tチップの再生(pChip, n再生開始システム時刻ms, n音量, bモニタ); + this.n最後に再生した実WAV番号[EnumConverter.PadFromLane(nLane)] = pChip.n整数値_内部番号; + // nLaneでなくindexにすると、LC(1A-11=09)とギター(enumで09)がかぶってLC音が消されるので注意 return; } #endregion - case E楽器パート.GUITAR: - #region [ GUITAR ] -#if TEST_NOTEOFFMODE // 2011.1.1 yyagi test - if (CDTXMania.DTX.b演奏で直前の音を消音する.Guitar) { -#endif - CDTXMania.DTX.tWavの再生停止( this.n最後に再生した実WAV番号.Guitar ); -#if TEST_NOTEOFFMODE - } -#endif - CDTXMania.DTX.tチップの再生( pChip, n再生開始システム時刻ms, (int) Eレーン.Guitar, n音量, bモニタ, b音程をずらして再生 ); - this.n最後に再生した実WAV番号.Guitar = pChip.n整数値・内部番号; + case EPart.Guitar: + #region [ GUITAR ] + CDTXMania.Instance.DTX.tWavの再生停止(this.n最後に再生した実WAV番号.GtPick); + CDTXMania.Instance.DTX.tチップの再生(pChip, n再生開始システム時刻ms, n音量, bモニタ, b音程をずらして再生); + this.n最後に再生した実WAV番号.GtPick = pChip.n整数値_内部番号; return; #endregion - case E楽器パート.BASS: - #region [ BASS ] -#if TEST_NOTEOFFMODE - if (CDTXMania.DTX.b演奏で直前の音を消音する.Bass) { -#endif - CDTXMania.DTX.tWavの再生停止( this.n最後に再生した実WAV番号.Bass ); -#if TEST_NOTEOFFMODE - } -#endif - CDTXMania.DTX.tチップの再生( pChip, n再生開始システム時刻ms, (int) Eレーン.Bass, n音量, bモニタ, b音程をずらして再生 ); - this.n最後に再生した実WAV番号.Bass = pChip.n整数値・内部番号; + case EPart.Bass: + #region [ BASS ] + CDTXMania.Instance.DTX.tWavの再生停止(this.n最後に再生した実WAV番号.BsPick); + CDTXMania.Instance.DTX.tチップの再生(pChip, n再生開始システム時刻ms, n音量, bモニタ, b音程をずらして再生); + this.n最後に再生した実WAV番号.BsPick = pChip.n整数値_内部番号; return; #endregion @@ -1044,939 +1146,1902 @@ namespace DTXMania } } } - protected void tステータスパネルの選択() + + protected EJudge tチップのヒット処理(long nHitTime, CChip pChip, bool bCorrectLane = true) { - if ( CDTXMania.bコンパクトモード ) - { - this.actStatusPanels.tラベル名からステータスパネルを決定する( null ); - } - else if ( CDTXMania.stage選曲.r確定された曲 != null ) + pChip.bHit = true; + if (pChip.e楽器パート != EPart.Unknown) { - this.actStatusPanels.tラベル名からステータスパネルを決定する( CDTXMania.stage選曲.r確定された曲.ar難易度ラベル[ CDTXMania.stage選曲.n確定された曲の難易度 ] ); + cInvisibleChip.StartSemiInvisible(pChip.e楽器パート); } - } - protected E判定 tチップのヒット処理( long nHitTime, CDTX.CChip pChip ) - { - return tチップのヒット処理( nHitTime, pChip, true ); - } - protected abstract E判定 tチップのヒット処理( long nHitTime, CDTX.CChip pChip, bool bCorrectLane ); - protected E判定 tチップのヒット処理( long nHitTime, CDTX.CChip pChip, E楽器パート screenmode ) // E楽器パート screenmode - { - return tチップのヒット処理( nHitTime, pChip, screenmode, true ); - } - protected E判定 tチップのヒット処理( long nHitTime, CDTX.CChip pChip, E楽器パート screenmode, bool bCorrectLane ) - { - pChip.bHit = true; -#region [メソッド化する前の記述(注釈化)] -// bool bPChipIsAutoPlay = false; -// bool bGtBsR = ( ( pChip.nチャンネル番号 & 4 ) > 0 ); -// bool bGtBsG = ( ( pChip.nチャンネル番号 & 2 ) > 0 ); -// bool bGtBsB = ( ( pChip.nチャンネル番号 & 1 ) > 0 ); -// bool bGtBsW = ( ( pChip.nチャンネル番号 & 0x0F ) == 0x08 ); -// bool bGtBsO = ( ( pChip.nチャンネル番号 & 0x0F ) == 0x00 ); -// if ( pChip.e楽器パート == E楽器パート.DRUMS ) -// { -// if ( bIsAutoPlay[ this.nチャンネル0Atoレーン07[ pChip.nチャンネル番号 - 0x11 ] ] ) -// { -// bPChipIsAutoPlay = true; -// } -// } -// else if ( pChip.e楽器パート == E楽器パート.GUITAR ) -// { -////Trace.TraceInformation( "chip:{0}{1}{2} ", bGtBsR, bGtBsG, bGtBsB ); -////Trace.TraceInformation( "auto:{0}{1}{2} ", bIsAutoPlay[ (int) Eレーン.GtR ], bIsAutoPlay[ (int) Eレーン.GtG ], bIsAutoPlay[ (int) Eレーン.GtB ]); -// bPChipIsAutoPlay = true; -// if ( !bIsAutoPlay[ (int) Eレーン.GtPick ] ) bPChipIsAutoPlay = false; -// else -// { -// if ( bGtBsR && !bIsAutoPlay[ (int) Eレーン.GtR ] ) bPChipIsAutoPlay = false; -// else if ( bGtBsG && !bIsAutoPlay[ (int) Eレーン.GtG ] ) bPChipIsAutoPlay = false; -// else if ( bGtBsB && !bIsAutoPlay[ (int) Eレーン.GtB ] ) bPChipIsAutoPlay = false; -// else if ( bGtBsW && !bIsAutoPlay[ (int) Eレーン.GtW ] ) bPChipIsAutoPlay = false; -// else if ( bGtBsO && -// ( !bIsAutoPlay[ (int) Eレーン.GtR] || !bIsAutoPlay[ (int) Eレーン.GtG] || !bIsAutoPlay[ (int) Eレーン.GtB] ) ) -// bPChipIsAutoPlay = false; -// } -// } -// else if ( pChip.e楽器パート == E楽器パート.BASS ) -// { -// bPChipIsAutoPlay = true; -// if ( !bIsAutoPlay[ (int) Eレーン.BsPick ] ) bPChipIsAutoPlay = false; -// else -// { -// if ( bGtBsR && !bIsAutoPlay[ (int) Eレーン.BsR ] ) bPChipIsAutoPlay = false; -// else if ( bGtBsG && bIsAutoPlay[ (int) Eレーン.BsG ] ) bPChipIsAutoPlay = false; -// else if ( bGtBsB && bIsAutoPlay[ (int) Eレーン.BsB ] ) bPChipIsAutoPlay = false; -// else if ( bGtBsW && bIsAutoPlay[ (int) Eレーン.BsW ] ) bPChipIsAutoPlay = false; -// else if ( bGtBsO && -// ( !bIsAutoPlay[ (int) Eレーン.BsR ] || !bIsAutoPlay[ (int) Eレーン.BsG ] || !bIsAutoPlay[ (int) Eレーン.BsB ] ) ) -// bPChipIsAutoPlay = false; -// } -// } -// else -// { -// this.bAUTOでないチップが１つでもバーを通過した = true; -// } -////Trace.TraceInformation( "ch={0:x2}, flag={1}", pChip.nチャンネル番号, bPChipIsAutoPlay.ToString() ); -#endregion - if ( pChip.e楽器パート == E楽器パート.UNKNOWN ) - { - this.bAUTOでないチップが１つでもバーを通過した = true; - } - bool bPChipIsAutoPlay = bCheckAutoPlay( pChip ); - - pChip.bIsAutoPlayed = bPChipIsAutoPlay; // 2011.6.10 yyagi - E判定 eJudgeResult = E判定.Auto; - switch ( pChip.e楽器パート ) - { - case E楽器パート.DRUMS: - { - int nInputAdjustTime = bPChipIsAutoPlay ? 0 : this.nInputAdjustTimeMs.Drums; - eJudgeResult = (bCorrectLane)? this.e指定時刻からChipのJUDGEを返す( nHitTime, pChip, nInputAdjustTime ) : E判定.Miss; - this.actJudgeString.Start( this.nチャンネル0Atoレーン07[ pChip.nチャンネル番号 - 0x11 ], bPChipIsAutoPlay ? E判定.Auto : eJudgeResult, pChip.nLag ); - } - break; + bool bPChipIsAutoPlay = pChip.bAssignAutoPlayState();// 2011.6.10 yyagi + EJudge eJudgeResult = EJudge.Auto; - case E楽器パート.GUITAR: - { - int nInputAdjustTime = bPChipIsAutoPlay ? 0 : this.nInputAdjustTimeMs.Guitar; - eJudgeResult = (bCorrectLane)? this.e指定時刻からChipのJUDGEを返す( nHitTime, pChip, nInputAdjustTime ) : E判定.Miss; - this.actJudgeString.Start( 10, bPChipIsAutoPlay ? E判定.Auto : eJudgeResult, pChip.nLag ); - break; - } + // ゴースト処理 #35411 2015.08.20 chnmr0 + bool bIsPerfectGhost = CDTXMania.Instance.ConfigIni.eAutoGhost[pChip.e楽器パート] == EAutoGhostData.Perfect || + CDTXMania.Instance.DTX.listAutoGhostLag[pChip.e楽器パート] == null; + int nInputAdjustTime = bPChipIsAutoPlay && bIsPerfectGhost ? 0 : CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs[pChip.e楽器パート]; + eJudgeResult = (bCorrectLane) ? this.e指定時刻からChipのJUDGEを返す(nHitTime, pChip, nInputAdjustTime) : EJudge.Miss; - case E楽器パート.BASS: - { - int nInputAdjustTime = bPChipIsAutoPlay ? 0 : this.nInputAdjustTimeMs.Bass; - eJudgeResult = (bCorrectLane)? this.e指定時刻からChipのJUDGEを返す( nHitTime, pChip, nInputAdjustTime ) : E判定.Miss; - this.actJudgeString.Start( 11, bPChipIsAutoPlay ? E判定.Auto : eJudgeResult, pChip.nLag ); - } - break; + if (pChip.e楽器パート != EPart.Unknown) + { + ELane nLane = ELane.Max; + switch (pChip.e楽器パート) + { + case EPart.Drums: + nLane = EnumConverter.LaneFromChannel(pChip.eチャンネル番号); + break; + case EPart.Guitar: + nLane = ELane.GtR; + break; + case EPart.Bass: + nLane = ELane.BsR; + break; + } + this.actJudgeString.Start(nLane, bPChipIsAutoPlay && bIsPerfectGhost ? EJudge.Auto : eJudgeResult, pChip.nLag); } - if ( !bPChipIsAutoPlay && ( pChip.e楽器パート != E楽器パート.UNKNOWN ) ) + + // ダメージ + if (!bPChipIsAutoPlay && (pChip.e楽器パート != EPart.Unknown)) { - // this.t判定にあわせてゲージを増減する( screenmode, pChip.e楽器パート, eJudgeResult ); - actGauge.Damage( screenmode, pChip.e楽器パート, eJudgeResult ); + actGauge.Damage(pChip.e楽器パート, eJudgeResult); } - switch ( pChip.e楽器パート ) + // インビジブル + if (eJudgeResult == EJudge.Poor || eJudgeResult == EJudge.Miss || eJudgeResult == EJudge.Bad) { - case E楽器パート.DRUMS: - switch ( eJudgeResult ) - { - case E判定.Miss: - case E判定.Bad: - this.nヒット数・Auto含む.Drums.Miss++; - if ( !bPChipIsAutoPlay ) - { - this.nヒット数・Auto含まない.Drums.Miss++; - } - break; - default: - this.nヒット数・Auto含む.Drums[ (int) eJudgeResult ]++; - if ( !bPChipIsAutoPlay ) - { - this.nヒット数・Auto含まない.Drums[ (int) eJudgeResult ]++; - } - break; - } + cInvisibleChip.ShowChipTemporally(pChip.e楽器パート); + } - if ( CDTXMania.ConfigIni.bドラムが全部オートプレイである || !bPChipIsAutoPlay ) - { - switch ( eJudgeResult ) + // コンボ + if (pChip.e楽器パート != EPart.Unknown) + { + switch (eJudgeResult) + { + case EJudge.Miss: + case EJudge.Bad: + this.nヒット数_Auto含む[pChip.e楽器パート].Miss++; + if (!bPChipIsAutoPlay) { - case E判定.Perfect: - case E判定.Great: - case E判定.Good: - this.actCombo.n現在のコンボ数.Drums++; - break; - - default: - this.actCombo.n現在のコンボ数.Drums = 0; - break; + this.nヒット数_Auto含まない[pChip.e楽器パート].Miss++; } - } - break; + break; + default: + // #24068 2011.1.10 ikanick changed (for Gt./Bs.) + // #24167 2011.1.16 yyagi changed (for Gt./Bs.) + this.nヒット数_Auto含む[pChip.e楽器パート][(int)eJudgeResult]++; + if (!bPChipIsAutoPlay) + { + this.nヒット数_Auto含まない[pChip.e楽器パート][(int)eJudgeResult]++; + } + break; + } - case E楽器パート.GUITAR: - case E楽器パート.BASS: - int indexInst = (int) pChip.e楽器パート; - switch ( eJudgeResult ) + bool incrementCombo = false; + + if (pChip.e楽器パート == EPart.Drums) + { + if (CDTXMania.Instance.ConfigIni.bIsAutoPlay(EPart.Drums) || !bPChipIsAutoPlay) { - case E判定.Miss: - case E判定.Bad: - this.nヒット数・Auto含む[ indexInst ].Miss++; - if ( !bPChipIsAutoPlay ) - { - this.nヒット数・Auto含まない[ indexInst ].Miss++; - } - break; - default: // #24068 2011.1.10 ikanick changed - // #24167 2011.1.16 yyagi changed - this.nヒット数・Auto含む[ indexInst ][ (int) eJudgeResult ]++; - if ( !bPChipIsAutoPlay ) - { - this.nヒット数・Auto含まない[ indexInst ][ (int) eJudgeResult ]++; - } - break; + // Dr. : 演奏したレーンだけコンボを増やす + incrementCombo = true; } - switch ( eJudgeResult ) - { - case E判定.Perfect: - case E判定.Great: - case E判定.Good: - this.actCombo.n現在のコンボ数[ indexInst ]++; - break; + } + else if (pChip.e楽器パート == EPart.Guitar || pChip.e楽器パート == EPart.Bass) + { + incrementCombo = true; + } - default: - this.actCombo.n現在のコンボ数[ indexInst ] = 0; - break; - } - break; + if( incrementCombo == true ) + { + switch (eJudgeResult) + { + case EJudge.Perfect: + case EJudge.Great: + case EJudge.Good: + this.actCombo.dgbコンボ数[pChip.e楽器パート].IncrementCombo(); + break; - default: - break; + default: + this.actCombo.dgbコンボ数[pChip.e楽器パート].ResetCombo(); + break; + } + } } - if ( ( !bPChipIsAutoPlay && ( pChip.e楽器パート != E楽器パート.UNKNOWN ) ) && ( eJudgeResult != E判定.Miss ) && ( eJudgeResult != E判定.Bad ) ) + + // スコア + if ((!bPChipIsAutoPlay && (pChip.e楽器パート != EPart.Unknown)) && (eJudgeResult != EJudge.Miss) && (eJudgeResult != EJudge.Bad)) { - int nCombos = this.actCombo.n現在のコンボ数[ (int) pChip.e楽器パート ]; + int nCombos = this.actCombo.dgbコンボ数[pChip.e楽器パート].n現在値; long nScoreDelta = 0; long[] nComboScoreDelta = new long[] { 350L, 200L, 50L, 0L }; - if ( ( nCombos <= 500 ) || ( eJudgeResult == E判定.Good ) ) + if ((nCombos <= 500) || (eJudgeResult == EJudge.Good)) + { + nScoreDelta = nComboScoreDelta[(int)eJudgeResult] * nCombos; + } + else if ((eJudgeResult == EJudge.Perfect) || (eJudgeResult == EJudge.Great)) { - nScoreDelta = nComboScoreDelta[ (int) eJudgeResult ] * nCombos; + nScoreDelta = nComboScoreDelta[(int)eJudgeResult] * 500L; } - else if ( ( eJudgeResult == E判定.Perfect ) || ( eJudgeResult == E判定.Great ) ) + this.actScore.Add(pChip.e楽器パート, nScoreDelta); + } + + // グラフ + if (pChip.e楽器パート != EPart.Unknown) + { + EPart inst = pChip.e楽器パート; + // #24074 2011.01.23 add ikanick + this.actGraph.dbCurrent[inst] = + CScoreIni.t演奏型スキルを計算して返す( + CDTXMania.Instance.DTX.n可視チップ数[inst], + this.nヒット数_Auto含まない[inst].Perfect, + this.nヒット数_Auto含まない[inst].Great, + this.nヒット数_Auto含まない[inst].Good, + this.nヒット数_Auto含まない[inst].Poor, + this.nヒット数_Auto含まない[inst].Miss, + inst, true); + + // #35411 2015.09.07 add chnmr0 + if ( + CDTXMania.Instance.DTX.listTargetGhsotLag[inst] != null && + CDTXMania.Instance.ConfigIni.eTargetGhost[inst] == ETargetGhostData.Online && + CDTXMania.Instance.DTX.n可視チップ数[inst] > 0) { - nScoreDelta = nComboScoreDelta[ (int) eJudgeResult ] * 500L; + // Online Stats の計算式 + this.actGraph.dbTarget[inst] = 100 * + (this.nヒット数_Auto含まない[inst].Perfect * 17 + + this.nヒット数_Auto含まない[inst].Great * 7 + + this.actCombo.dgbコンボ数[inst].n最高値 * 3) / + (20.0 * CDTXMania.Instance.DTX.n可視チップ数[inst]); } - this.actScore.Add( pChip.e楽器パート, bIsAutoPlay, nScoreDelta ); } return eJudgeResult; } - protected abstract void tチップのヒット処理・BadならびにTight時のMiss( E楽器パート part ); - protected abstract void tチップのヒット処理・BadならびにTight時のMiss( E楽器パート part, int nLane ); - protected void tチップのヒット処理・BadならびにTight時のMiss( E楽器パート part, E楽器パート screenmode ) - { - this.tチップのヒット処理・BadならびにTight時のMiss( part, 0, screenmode ); - } - protected void tチップのヒット処理・BadならびにTight時のMiss( E楽器パート part, int nLane, E楽器パート screenmode ) + + private void tチップのヒット処理_BadならびにTight時のMiss(EPart part, ELane nLane = ELane.LC) { - this.bAUTOでないチップが１つでもバーを通過した = true; - //this.t判定にあわせてゲージを増減する( screenmode, part, E判定.Miss ); - actGauge.Damage( screenmode, part, E判定.Miss ); - switch ( part ) + cInvisibleChip.StartSemiInvisible(part); + cInvisibleChip.ShowChipTemporally(part); + actGauge.Damage(part, EJudge.Miss); + switch (part) { - case E楽器パート.DRUMS: - if ( ( nLane >= 0 ) && ( nLane <= 7 ) ) - { - this.actJudgeString.Start( nLane, bIsAutoPlay[ nLane ] ? E判定.Auto : E判定.Miss, 999 ); - } - this.actCombo.n現在のコンボ数.Drums = 0; + case EPart.Drums: + this.actJudgeString.Start(nLane, CDTXMania.Instance.ConfigIni.bAutoPlay[EnumConverter.PadFromLane(nLane)] ? + EJudge.Auto : EJudge.Miss, 999); + this.actCombo.dgbコンボ数.Drums.ResetCombo(); return; - case E楽器パート.GUITAR: - this.actJudgeString.Start( 10, E判定.Bad, 999 ); - this.actCombo.n現在のコンボ数.Guitar = 0; + case EPart.Guitar: + this.actJudgeString.Start(ELane.GtR, EJudge.Bad, 999); + this.actCombo.dgbコンボ数.Guitar.ResetCombo(); return; - case E楽器パート.BASS: - this.actJudgeString.Start( 11, E判定.Bad, 999 ); - this.actCombo.n現在のコンボ数.Bass = 0; + case EPart.Bass: + this.actJudgeString.Start(ELane.BsR, EJudge.Bad, 999); + this.actCombo.dgbコンボ数.Bass.ResetCombo(); break; default: return; } } - - protected CDTX.CChip r指定時刻に一番近い未ヒットChip( long nTime, int nChannelFlag, int nInputAdjustTime ) - { - return this.r指定時刻に一番近い未ヒットChip( nTime, nChannelFlag, nInputAdjustTime, 0 ); - } - protected CDTX.CChip r指定時刻に一番近い未ヒットChip( long nTime, int nChannel, int nInputAdjustTime, int n検索範囲時間ms ) + + /// + /// 指定時刻に一番近いまだヒットしていないチップを返す。 + /// + /// 指定時刻 + /// 検索するチャネル。Gt.WailingSound/Bs.WailingSoundを渡した場合、Open~RGBが検索対象になる。 + /// + /// 指定時刻から検索する範囲ms + /// + protected CChip r指定時刻に一番近い未ヒットChip(long nTime, EChannel search, int nInputAdjustTime, int n検索範囲時間ms = 0, HitState hs = HitState.NotHit) { - sw2.Start(); -//Trace.TraceInformation( "nTime={0}, nChannel={1:x2}, 現在のTop={2}", nTime, nChannel,CDTXMania.DTX.listChip[ this.n現在のトップChip ].n発声時刻ms ); - nTime += nInputAdjustTime; + CChip ret = null; - int nIndex_InitialPositionSearchingToPast; - int nTimeDiff; - if ( this.n現在のトップChip == -1 ) // 演奏データとして1個もチップがない場合は - { - sw2.Stop(); - return null; - } - int count = listChip.Count; - int nIndex_NearestChip_Future = nIndex_InitialPositionSearchingToPast = this.n現在のトップChip; - if ( this.n現在のトップChip >= count ) // その時点で演奏すべきチップが既に全部無くなっていたら - { - nIndex_NearestChip_Future = nIndex_InitialPositionSearchingToPast = count - 1; - } - // int nIndex_NearestChip_Future = nIndex_InitialPositionSearchingToFuture; -// while ( nIndex_NearestChip_Future < count ) // 未来方向への検索 - for ( ; nIndex_NearestChip_Future < count; nIndex_NearestChip_Future++ ) + nTime += nInputAdjustTime; + if (this.n現在のトップChip >= 0 && this.n現在のトップChip <= CDTXMania.Instance.DTX.listChip.Count) { - CDTX.CChip chip = listChip[ nIndex_NearestChip_Future ]; - if ( !chip.bHit ) + int idxFuture = -1; + int idxPast = -1; + int idxPastStart = CDTXMania.Instance.DTX.listChip.Count - 1; + Func, bool> Found = (chip, futureOrPast) => { - if ( ( 0x11 <= nChannel ) && ( nChannel <= 0x1a ) ) + return futureOrPast(chip) && + ((hs == HitState.NotHit && !chip.bHit) || (hs == HitState.Hit && chip.bHit) || (hs == HitState.DontCare)) && + !chip.b空打ちチップである && + ( + ((search == chip.eチャンネル番号 || search + 0x20 == chip.eチャンネル番号) && chip.bDrums可視チップ_LP_LBD含まない) || + (search == chip.eチャンネル番号 && chip.bGuitar可視チップ_Wailing含む) || + (search == chip.eチャンネル番号 && chip.bBass可視チップ_Wailing含む) || + (search == EChannel.Guitar_WailingSound && chip.bGuitar可視チップ) || + (search == EChannel.Bass_WailingSound && chip.bBass可視チップ) + ); + }; + Func Future = (chip) => { return chip.n発声時刻ms > nTime; }; + Func Past = (chip) => { return chip.n発声時刻ms <= nTime; }; + Func OutOfRange = (chip) => { return n検索範囲時間ms > 0 && Math.Abs(nTime - chip.n発声時刻ms) > n検索範囲時間ms; }; + + // // 未来方向への検索 + for (int i = this.n現在のトップChip; i < CDTXMania.Instance.DTX.listChip.Count; ++i) + { + CChip chip = CDTXMania.Instance.DTX.listChip[i]; + if (Future(chip) && OutOfRange(chip)) { - if ( ( chip.nチャンネル番号 == nChannel ) || ( chip.nチャンネル番号 == ( nChannel + 0x20 ) ) ) - { - if ( chip.n発声時刻ms > nTime ) - { - break; - } - nIndex_InitialPositionSearchingToPast = nIndex_NearestChip_Future; - } - continue; + //break; } - else if ( ( ( ( nChannel == 0x2f ) && ( chip.e楽器パート == E楽器パート.GUITAR ) ) || ( ( ( 0x20 <= nChannel ) && ( nChannel <= 0x28 ) ) && ( chip.nチャンネル番号 == nChannel ) ) ) ) + if (Found(chip, Future)) { - if ( chip.n発声時刻ms > nTime ) - { - break; - } - nIndex_InitialPositionSearchingToPast = nIndex_NearestChip_Future; + idxFuture = i; + idxPastStart = i; + break; } - else if ( ( ( ( nChannel == 0xaf ) && ( chip.e楽器パート == E楽器パート.BASS ) ) || ( ( ( 0xa0 <= nChannel ) && ( nChannel <= 0xa8 ) ) && ( chip.nチャンネル番号 == nChannel ) ) ) ) + } + + // 過去方向への検索 + for (int i = idxPastStart; i >= 0; i--) + { + CChip chip = CDTXMania.Instance.DTX.listChip[i]; + if (Past(chip) && OutOfRange(chip)) { - if ( chip.n発声時刻ms > nTime ) - { - break; - } - nIndex_InitialPositionSearchingToPast = nIndex_NearestChip_Future; + //break; } - } -// nIndex_NearestChip_Future++; - } - int nIndex_NearestChip_Past = nIndex_InitialPositionSearchingToPast; -// while ( nIndex_NearestChip_Past >= 0 ) // 過去方向への検索 - for ( ; nIndex_NearestChip_Past >= 0; nIndex_NearestChip_Past-- ) - { - CDTX.CChip chip = listChip[ nIndex_NearestChip_Past ]; - if ( (!chip.bHit) && - ( - ( ( nChannel >= 0x11 ) && ( nChannel <= 0x1a ) && - ( ( chip.nチャンネル番号 == nChannel ) || ( chip.nチャンネル番号 == ( nChannel + 0x20 ) ) ) - ) - || - ( - ( ( nChannel == 0x2f ) && ( chip.e楽器パート == E楽器パート.GUITAR ) ) || - ( ( ( nChannel >= 0x20 ) && ( nChannel <= 0x28 ) ) && ( chip.nチャンネル番号 == nChannel ) ) - ) - || - ( - ( ( nChannel == 0xaf ) && ( chip.e楽器パート == E楽器パート.BASS ) ) || - ( ( ( nChannel >= 0xA0 ) && ( nChannel <= 0xa8 ) ) && ( chip.nチャンネル番号 == nChannel ) ) - ) - ) - ) + if (Found(chip, Past)) { + idxPast = i; break; } -// nIndex_NearestChip_Past--; - } - if ( ( nIndex_NearestChip_Future >= count ) && ( nIndex_NearestChip_Past < 0 ) ) // 検索対象が過去未来どちらにも見つからなかった場合 - { - sw2.Stop(); - return null; - } - CDTX.CChip nearestChip; // = null; // 以下のifブロックのいずれかで必ずnearestChipには非nullが代入されるので、null初期化を削除 - if ( nIndex_NearestChip_Future >= count ) // 検索対象が未来方向には見つからなかった(しかし過去方向には見つかった)場合 - { - nearestChip = listChip[ nIndex_NearestChip_Past ]; -// nTimeDiff = Math.Abs( (int) ( nTime - nearestChip.n発声時刻ms ) ); - } - else if ( nIndex_NearestChip_Past < 0 ) // 検索対象が過去方向には見つからなかった(しかし未来方向には見つかった)場合 - { - nearestChip = listChip[ nIndex_NearestChip_Future ]; -// nTimeDiff = Math.Abs( (int) ( nTime - nearestChip.n発声時刻ms ) ); - } - else - { - int nTimeDiff_Future = Math.Abs( (int) ( nTime - listChip[ nIndex_NearestChip_Future ].n発声時刻ms ) ); - int nTimeDiff_Past = Math.Abs( (int) ( nTime - listChip[ nIndex_NearestChip_Past ].n発声時刻ms ) ); - if ( nTimeDiff_Future < nTimeDiff_Past ) + } + + if (idxFuture < 0 && idxPast < 0) + { + // 検索対象が過去未来どちらにも見つからなかった + } + else if (idxPast >= 0) + { + // 過去方向には見つかった + ret = CDTXMania.Instance.DTX.listChip[idxPast]; + } + else if (idxFuture >= 0) { - nearestChip = listChip[ nIndex_NearestChip_Future ]; -// nTimeDiff = Math.Abs( (int) ( nTime - nearestChip.n発声時刻ms ) ); + // 未来方向には見つかった + ret = CDTXMania.Instance.DTX.listChip[idxFuture]; } else { - nearestChip = listChip[ nIndex_NearestChip_Past ]; -// nTimeDiff = Math.Abs( (int) ( nTime - nearestChip.n発声時刻ms ) ); + // どちらにも見つかった + long nTimeDiff_Future = Math.Abs(nTime - CDTXMania.Instance.DTX.listChip[idxFuture].n発声時刻ms); + long nTimeDiff_Past = Math.Abs(nTime - CDTXMania.Instance.DTX.listChip[idxPast].n発声時刻ms); + if (nTimeDiff_Future < nTimeDiff_Past) + { + ret = CDTXMania.Instance.DTX.listChip[idxFuture]; + } + else + { + ret = CDTXMania.Instance.DTX.listChip[idxPast]; + } + } + + if (ret != null) + { + if (OutOfRange(ret)) + { + // チップは見つかったが、検索範囲時間外だった場合 + ret = null; + } } } - nTimeDiff = Math.Abs( (int) ( nTime - nearestChip.n発声時刻ms ) ); - if ( ( n検索範囲時間ms > 0 ) && ( nTimeDiff > n検索範囲時間ms ) ) // チップは見つかったが、検索範囲時間外だった場合 - { - sw2.Stop(); - return null; - } - sw2.Stop(); - return nearestChip; + return ret; } - protected CDTX.CChip r次に来る指定楽器Chipを更新して返す( E楽器パート inst ) + protected CChip r次に来る指定楽器Chipを更新して返す(EPart inst) { - switch ( (int) inst ) + CChip ret = null; + int nInputAdjustTime; + if (inst == EPart.Guitar) { - case (int)E楽器パート.GUITAR: - return r次にくるギターChipを更新して返す(); - case (int)E楽器パート.BASS: - return r次にくるベースChipを更新して返す(); - default: - return null; + nInputAdjustTime = CDTXMania.Instance.ConfigIni.bAutoPlay.GtPick ? + 0 : CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs.Guitar; + ret = this.r指定時刻に一番近い未ヒットChip(CSound管理.rc演奏用タイマ.n現在時刻, EChannel.Guitar_WailingSound, nInputAdjustTime, 500); + this.r次にくるギターChip = ret; } - } - protected CDTX.CChip r次にくるギターChipを更新して返す() - { - int nInputAdjustTime = this.bIsAutoPlay.GtPick ? 0 : this.nInputAdjustTimeMs.Guitar; - this.r次にくるギターChip = this.r指定時刻に一番近い未ヒットChip( CSound管理.rc演奏用タイマ.n現在時刻, 0x2f, nInputAdjustTime, 500 ); - return this.r次にくるギターChip; - } - protected CDTX.CChip r次にくるベースChipを更新して返す() - { - int nInputAdjustTime = this.bIsAutoPlay.BsPick ? 0 : this.nInputAdjustTimeMs.Bass; - this.r次にくるベースChip = this.r指定時刻に一番近い未ヒットChip( CSound管理.rc演奏用タイマ.n現在時刻, 0xaf, nInputAdjustTime, 500 ); - return this.r次にくるベースChip; + else if (inst == EPart.Bass) + { + nInputAdjustTime = CDTXMania.Instance.ConfigIni.bAutoPlay.BsPick ? + 0 : CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs.Bass; + ret = this.r指定時刻に一番近い未ヒットChip(CSound管理.rc演奏用タイマ.n現在時刻, EChannel.Bass_WailingSound, nInputAdjustTime, 500); + this.r次にくるベースChip = ret; + } + return ret; } - protected void ChangeInputAdjustTimeInPlaying( IInputDevice keyboard, int plusminus ) // #23580 2011.1.16 yyagi UI for InputAdjustTime in playing screen. + protected void ChangeInputAdjustTimeInPlaying(IInputDevice keyboard, int plusminus) // #23580 2011.1.16 yyagi UI for InputAdjustTime in playing screen. { - int part, offset = plusminus; - if ( keyboard.bキーが押されている( (int) SlimDX.DirectInput.Key.LeftShift ) || keyboard.bキーが押されている( (int) SlimDX.DirectInput.Key.RightShift ) ) // Guitar InputAdjustTime + EPart part; + int offset = plusminus; + if (keyboard.bキーが押されている((int)SlimDX.DirectInput.Key.LeftShift) || keyboard.bキーが押されている((int)SlimDX.DirectInput.Key.RightShift)) // Guitar InputAdjustTime { - part = (int) E楽器パート.GUITAR; + part = EPart.Guitar; } - else if ( keyboard.bキーが押されている( (int) SlimDX.DirectInput.Key.LeftAlt ) || keyboard.bキーが押されている( (int) SlimDX.DirectInput.Key.RightAlt ) ) // Bass InputAdjustTime + else if (keyboard.bキーが押されている((int)SlimDX.DirectInput.Key.LeftAlt) || keyboard.bキーが押されている((int)SlimDX.DirectInput.Key.RightAlt)) // Bass InputAdjustTime { - part = (int) E楽器パート.BASS; + part = EPart.Bass; } - else // Drums InputAdjustTime + else { - part = (int) E楽器パート.DRUMS; + // Drums InputAdjustTime + part = EPart.Drums; } - if ( !keyboard.bキーが押されている( (int) SlimDX.DirectInput.Key.LeftControl ) && !keyboard.bキーが押されている( (int) SlimDX.DirectInput.Key.RightControl ) ) + if (!keyboard.bキーが押されている((int)SlimDX.DirectInput.Key.LeftControl) && !keyboard.bキーが押されている((int)SlimDX.DirectInput.Key.RightControl)) { offset *= 10; } - this.nInputAdjustTimeMs[ part ] += offset; - if ( this.nInputAdjustTimeMs[ part ] > 0 ) - { - this.nInputAdjustTimeMs[ part ] = 0; - } - else if ( this.nInputAdjustTimeMs[ part ] < -99 ) - { - this.nInputAdjustTimeMs[ part ] = -99; - } - CDTXMania.ConfigIni.nInputAdjustTimeMs[ part ] = this.nInputAdjustTimeMs[ part ]; + CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs[part].Value = CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs[part] + offset; } - protected abstract void t入力処理・ドラム(); - protected abstract void ドラムスクロール速度アップ(); - protected abstract void ドラムスクロール速度ダウン(); - protected void tキー入力() + private void t入力処理_ドラム() { - IInputDevice keyboard = CDTXMania.Input管理.Keyboard; - if ( keyboard.bキーが押された( (int) SlimDX.DirectInput.Key.F1 ) && - ( keyboard.bキーが押されている( (int) SlimDX.DirectInput.Key.RightShift ) || keyboard.bキーが押されている( (int) SlimDX.DirectInput.Key.LeftShift ) ) ) - { // shift+f1 (pause) - this.bPAUSE = !this.bPAUSE; - if ( this.bPAUSE ) + for (EPad ePad = EPad.DrumsPadMin; ePad < EPad.DrumsPadMax; ePad++) // #27029 2012.1.4 from: <10 to <=10; Eパッドの要素が１つ（HP）増えたため。 + // 2012.1.5 yyagi: (int)Eパッド.MAX に変更。Eパッドの要素数への依存を無くすため。 + { + List listInputEvent = CDTXMania.Instance.Pad.GetEvents(ePad); + + if ((listInputEvent == null) || (listInputEvent.Count == 0)) { - CSound管理.rc演奏用タイマ.t一時停止(); - CDTXMania.Timer.t一時停止(); - CDTXMania.DTX.t全チップの再生一時停止(); + continue; } - else + + this.t入力メソッド記憶(EPart.Drums); + + #region [ 打ち分けグループ調整 ] + //----------------------------- + EHHGroup eHHGroup = CDTXMania.Instance.ConfigIni.eHHGroup; + EFTGroup eFTGroup = CDTXMania.Instance.ConfigIni.eFTGroup; + ECYGroup eCYGroup = CDTXMania.Instance.ConfigIni.eCYGroup; + + if (!CDTXMania.Instance.DTX.bチップがある.Ride && (eCYGroup == ECYGroup.None)) { - CSound管理.rc演奏用タイマ.t再開(); - CDTXMania.Timer.t再開(); - CDTXMania.DTX.t全チップの再生再開(); - } - } - if ( ( !this.bPAUSE && ( base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED ) ) && ( base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト ) ) - { - this.t入力処理・ドラム(); - this.t入力処理・ギターベース( E楽器パート.GUITAR ); - this.t入力処理・ギターベース( E楽器パート.BASS ); - if ( keyboard.bキーが押された( (int) SlimDX.DirectInput.Key.UpArrow ) && ( keyboard.bキーが押されている( (int) SlimDX.DirectInput.Key.RightShift ) || keyboard.bキーが押されている( (int) SlimDX.DirectInput.Key.LeftShift ) ) ) - { // shift (+ctrl) + UpArrow (BGMAdjust) - CDTXMania.DTX.t各自動再生音チップの再生時刻を変更する( ( keyboard.bキーが押されている( (int) SlimDX.DirectInput.Key.LeftControl ) || keyboard.bキーが押されている( (int) SlimDX.DirectInput.Key.RightControl ) ) ? 1 : 10 ); - CDTXMania.DTX.tWave再生位置自動補正(); - } - else if ( keyboard.bキーが押された( (int) SlimDX.DirectInput.Key.DownArrow ) && ( keyboard.bキーが押されている( (int) SlimDX.DirectInput.Key.RightShift ) || keyboard.bキーが押されている( (int) SlimDX.DirectInput.Key.LeftShift ) ) ) - { // shift + DownArrow (BGMAdjust) - CDTXMania.DTX.t各自動再生音チップの再生時刻を変更する( ( keyboard.bキーが押されている( (int) SlimDX.DirectInput.Key.LeftControl ) || keyboard.bキーが押されている( (int) SlimDX.DirectInput.Key.RightControl ) ) ? -1 : -10 ); - CDTXMania.DTX.tWave再生位置自動補正(); - } - else if ( keyboard.bキーが押された( (int) SlimDX.DirectInput.Key.UpArrow ) ) - { // UpArrow(scrollspeed up) - ドラムスクロール速度アップ(); - } - else if ( keyboard.bキーが押された( (int) SlimDX.DirectInput.Key.DownArrow ) ) - { // DownArrow (scrollspeed down) - ドラムスクロール速度ダウン(); + eCYGroup = ECYGroup.Group; } - else if ( keyboard.bキーが押された( (int) SlimDX.DirectInput.Key.Delete ) ) - { // del (debug info) - CDTXMania.ConfigIni.b演奏情報を表示する = !CDTXMania.ConfigIni.b演奏情報を表示する; + if (!CDTXMania.Instance.DTX.bチップがある.HHOpen && (eHHGroup == EHHGroup.None)) + { + eHHGroup = EHHGroup.LC_HH; } - else if ( keyboard.bキーが押された( (int) SlimDX.DirectInput.Key.LeftArrow ) ) // #24243 2011.1.16 yyagi UI for InputAdjustTime in playing screen. + if (!CDTXMania.Instance.DTX.bチップがある.HHOpen && (eHHGroup == EHHGroup.HO_HC)) { - ChangeInputAdjustTimeInPlaying( keyboard, -1 ); + eHHGroup = EHHGroup.Group; } - else if ( keyboard.bキーが押された( (int) SlimDX.DirectInput.Key.RightArrow ) ) // #24243 2011.1.16 yyagi UI for InputAdjustTime in playing screen. + if (!CDTXMania.Instance.DTX.bチップがある.LeftCymbal && (eHHGroup == EHHGroup.None)) { - ChangeInputAdjustTimeInPlaying( keyboard, +1 ); + eHHGroup = EHHGroup.HO_HC; } - else if ( ( base.eフェーズID == CStage.Eフェーズ.共通_通常状態 ) && ( keyboard.bキーが押された( (int) SlimDX.DirectInput.Key.Escape ) || CDTXMania.Pad.b押されたGB( Eパッド.FT ) ) ) - { // escape (exit) - this.actFO.tフェードアウト開始(); - base.eフェーズID = CStage.Eフェーズ.共通_フェードアウト; - this.eフェードアウト完了時の戻り値 = E演奏画面の戻り値.演奏中断; + if (!CDTXMania.Instance.DTX.bチップがある.LeftCymbal && (eHHGroup == EHHGroup.LC_HH)) + { + eHHGroup = EHHGroup.Group; } - } - } + //----------------------------- + #endregion - protected void t入力メソッド記憶( E楽器パート part ) - { - if ( CDTXMania.Pad.st検知したデバイス.Keyboard ) - { - this.b演奏にキーボードを使った[ (int) part ] = true; - } - if ( CDTXMania.Pad.st検知したデバイス.Joypad ) - { - this.b演奏にジョイパッドを使った[ (int) part ] = true; - } - if ( CDTXMania.Pad.st検知したデバイス.MIDIIN ) - { - this.b演奏にMIDI入力を使った[ (int) part ] = true; - } - if ( CDTXMania.Pad.st検知したデバイス.Mouse ) - { - this.b演奏にマウスを使った[ (int) part ] = true; - } - } + foreach (STInputEvent inputEvent in listInputEvent) + { + if (!inputEvent.b押された) + continue; + long nTime = inputEvent.nTimeStamp - CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻; + EPad nPad09 = (ePad == EPad.HP) ? EPad.BD : ePad; // #27029 2012.1.5 yyagi + int nInputAdjustTime = CDTXMania.Instance.ConfigIni.bAutoPlay[nPad09] ? 0 : CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs.Drums; + bool bHitted = false; - protected abstract void t進行描画・AVI(); - protected void t進行描画・AVI(int x, int y) - { - if ( ( ( base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED ) && ( base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト ) ) && ( !CDTXMania.ConfigIni.bストイックモード && CDTXMania.ConfigIni.bAVI有効 ) ) - { - this.actAVI.t進行描画( x, y ); - } - } - protected abstract void t進行描画・BGA(); - protected void t進行描画・BGA(int x, int y) - { - if ( ( ( base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED ) && ( base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト ) ) && ( !CDTXMania.ConfigIni.bストイックモード && CDTXMania.ConfigIni.bBGA有効 ) ) - { - this.actBGA.t進行描画( x, y ); - } - } - protected abstract void t進行描画・DANGER(); - protected void t進行描画・MIDIBGM() - { - if ( base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED ) - { - CStage.Eフェーズ eフェーズid1 = base.eフェーズID; - } - } - protected void t進行描画・RGBボタン() - { - if ( CDTXMania.ConfigIni.eDark != Eダークモード.FULL ) - { - this.actRGB.On進行描画(); - } - } - protected void t進行描画・STAGEFAILED() - { - if ( ( ( base.eフェーズID == CStage.Eフェーズ.演奏_STAGE_FAILED ) || ( base.eフェーズID == CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト ) ) && ( ( this.actStageFailed.On進行描画() != 0 ) && ( base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト ) ) ) - { - this.eフェードアウト完了時の戻り値 = E演奏画面の戻り値.ステージ失敗; - base.eフェーズID = CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト; - this.actFO.tフェードアウト開始(); + #region [ (A) ヒットしていればヒット処理して次の inputEvent へ ] + //----------------------------- + switch (ePad) + { + case EPad.HH: + #region [ HHとLC(groupingしている場合) のヒット処理 ] + //----------------------------- + { + if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.HH) + continue; // 電子ドラムによる意図的なクロストークを無効にする + + CChip chipHC = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.HiHatClose, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1); // HiHat Close + CChip chipHO = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.HiHatOpen, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1); // HiHat Open + CChip chipLC = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.LeftCymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1); // LC + EJudge e判定HC = (chipHC != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipHC, nInputAdjustTime) : EJudge.Miss; + EJudge e判定HO = (chipHO != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipHO, nInputAdjustTime) : EJudge.Miss; + EJudge e判定LC = (chipLC != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipLC, nInputAdjustTime) : EJudge.Miss; + switch (eHHGroup) + { + case EHHGroup.HO_HC: + #region [ HCとLCのヒット処理 ] + //----------------------------- + if ((e判定HC != EJudge.Miss) && (e判定LC != EJudge.Miss)) + { + if (chipHC.n発声位置 < chipLC.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity); + } + else if (chipHC.n発声位置 > chipLC.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HH, chipLC, inputEvent.nVelocity); + } + else + { + this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity); + this.tドラムヒット処理(nTime, EPad.HH, chipLC, inputEvent.nVelocity); + } + bHitted = true; + } + else if (e判定HC != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity); + bHitted = true; + } + else if (e判定LC != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.HH, chipLC, inputEvent.nVelocity); + bHitted = true; + } + if (!bHitted) + break; + continue; + //----------------------------- + #endregion + + case EHHGroup.LC_HH: + #region [ HCとHOのヒット処理 ] + //----------------------------- + if ((e判定HC != EJudge.Miss) && (e判定HO != EJudge.Miss)) + { + if (chipHC.n発声位置 < chipHO.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity); + } + else if (chipHC.n発声位置 > chipHO.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HH, chipHO, inputEvent.nVelocity); + } + else + { + this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity); + this.tドラムヒット処理(nTime, EPad.HH, chipHO, inputEvent.nVelocity); + } + bHitted = true; + } + else if (e判定HC != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity); + bHitted = true; + } + else if (e判定HO != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.HH, chipHO, inputEvent.nVelocity); + bHitted = true; + } + if (!bHitted) + break; + continue; + //----------------------------- + #endregion + + case EHHGroup.Group: + #region [ HC,HO,LCのヒット処理 ] + //----------------------------- + if (((e判定HC != EJudge.Miss) && (e判定HO != EJudge.Miss)) && (e判定LC != EJudge.Miss)) + { + CChip chip; + CChip[] chipArray = new CChip[] { chipHC, chipHO, chipLC }; + // ここから、chipArrayをn発生位置の小さい順に並び替える + if (chipArray[1].n発声位置 > chipArray[2].n発声位置) + { + chip = chipArray[1]; + chipArray[1] = chipArray[2]; + chipArray[2] = chip; + } + if (chipArray[0].n発声位置 > chipArray[1].n発声位置) + { + chip = chipArray[0]; + chipArray[0] = chipArray[1]; + chipArray[1] = chip; + } + if (chipArray[1].n発声位置 > chipArray[2].n発声位置) + { + chip = chipArray[1]; + chipArray[1] = chipArray[2]; + chipArray[2] = chip; + } + this.tドラムヒット処理(nTime, EPad.HH, chipArray[0], inputEvent.nVelocity); + if (chipArray[0].n発声位置 == chipArray[1].n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HH, chipArray[1], inputEvent.nVelocity); + } + if (chipArray[0].n発声位置 == chipArray[2].n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HH, chipArray[2], inputEvent.nVelocity); + } + bHitted = true; + } + else if ((e判定HC != EJudge.Miss) && (e判定HO != EJudge.Miss)) + { + if (chipHC.n発声位置 < chipHO.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity); + } + else if (chipHC.n発声位置 > chipHO.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HH, chipHO, inputEvent.nVelocity); + } + else + { + this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity); + this.tドラムヒット処理(nTime, EPad.HH, chipHO, inputEvent.nVelocity); + } + bHitted = true; + } + else if ((e判定HC != EJudge.Miss) && (e判定LC != EJudge.Miss)) + { + if (chipHC.n発声位置 < chipLC.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity); + } + else if (chipHC.n発声位置 > chipLC.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HH, chipLC, inputEvent.nVelocity); + } + else + { + this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity); + this.tドラムヒット処理(nTime, EPad.HH, chipLC, inputEvent.nVelocity); + } + bHitted = true; + } + else if ((e判定HO != EJudge.Miss) && (e判定LC != EJudge.Miss)) + { + if (chipHO.n発声位置 < chipLC.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HH, chipHO, inputEvent.nVelocity); + } + else if (chipHO.n発声位置 > chipLC.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HH, chipLC, inputEvent.nVelocity); + } + else + { + this.tドラムヒット処理(nTime, EPad.HH, chipHO, inputEvent.nVelocity); + this.tドラムヒット処理(nTime, EPad.HH, chipLC, inputEvent.nVelocity); + } + bHitted = true; + } + else if (e判定HC != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity); + bHitted = true; + } + else if (e判定HO != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.HH, chipHO, inputEvent.nVelocity); + bHitted = true; + } + else if (e判定LC != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.HH, chipLC, inputEvent.nVelocity); + bHitted = true; + } + if (!bHitted) + break; + continue; + //----------------------------- + #endregion + + default: + #region [ 全部打ち分け時のヒット処理 ] + //----------------------------- + if (e判定HC != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity); + bHitted = true; + } + if (!bHitted) + break; + continue; + //----------------------------- + #endregion + } + if (!bHitted) + break; + continue; + } + //----------------------------- + #endregion + + case EPad.SD: + #region [ SDのヒット処理 ] + //----------------------------- + if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.SD) // #23857 2010.12.12 yyagi: to support VelocityMin + continue; // 電子ドラムによる意図的なクロストークを無効にする + if (!this.tドラムヒット処理(nTime, EPad.SD, this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.Snare, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1), inputEvent.nVelocity)) + break; + continue; + //----------------------------- + #endregion + + case EPad.BD: + #region [ BDのヒット処理 ] + //----------------------------- + if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.BD) // #23857 2010.12.12 yyagi: to support VelocityMin + continue; // 電子ドラムによる意図的なクロストークを無効にする + if (!this.tドラムヒット処理(nTime, EPad.BD, this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.BassDrum, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1), inputEvent.nVelocity)) + break; + continue; + //----------------------------- + #endregion + + case EPad.HT: + #region [ HTのヒット処理 ] + //----------------------------- + if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.HT) // #23857 2010.12.12 yyagi: to support VelocityMin + continue; // 電子ドラムによる意図的なクロストークを無効にする + if (this.tドラムヒット処理(nTime, EPad.HT, this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.HighTom, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1), inputEvent.nVelocity)) + continue; + break; + //----------------------------- + #endregion + + case EPad.LT: + #region [ LTとFT(groupingしている場合)のヒット処理 ] + //----------------------------- + { + if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.LT) // #23857 2010.12.12 yyagi: to support VelocityMin + continue; // 電子ドラムによる意図的なクロストークを無効にする + CChip chipLT = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.LowTom, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1); + CChip chipFT = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.FloorTom, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1); + EJudge e判定LT = (chipLT != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipLT, nInputAdjustTime) : EJudge.Miss; + EJudge e判定FT = (chipFT != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipFT, nInputAdjustTime) : EJudge.Miss; + switch (eFTGroup) + { + case EFTGroup.None: + #region [ LTのヒット処理 ] + //----------------------------- + if (e判定LT != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.LT, chipLT, inputEvent.nVelocity); + bHitted = true; + } + break; + //----------------------------- + #endregion + + case EFTGroup.Group: + #region [ LTとFTのヒット処理 ] + //----------------------------- + if ((e判定LT != EJudge.Miss) && (e判定FT != EJudge.Miss)) + { + if (chipLT.n発声位置 < chipFT.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.LT, chipLT, inputEvent.nVelocity); + } + else if (chipLT.n発声位置 > chipFT.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.LT, chipFT, inputEvent.nVelocity); + } + else + { + this.tドラムヒット処理(nTime, EPad.LT, chipLT, inputEvent.nVelocity); + this.tドラムヒット処理(nTime, EPad.LT, chipFT, inputEvent.nVelocity); + } + bHitted = true; + } + else if (e判定LT != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.LT, chipLT, inputEvent.nVelocity); + bHitted = true; + } + else if (e判定FT != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.LT, chipFT, inputEvent.nVelocity); + bHitted = true; + } + break; + //----------------------------- + #endregion + } + if (!bHitted) + break; + continue; + } + //----------------------------- + #endregion + + case EPad.FT: + #region [ FTとLT(groupingしている場合)のヒット処理 ] + //----------------------------- + { + if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.FT) // #23857 2010.12.12 yyagi: to support VelocityMin + continue; // 電子ドラムによる意図的なクロストークを無効にする + CChip chipLT = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.LowTom, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1); + CChip chipFT = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.FloorTom, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1); + EJudge e判定LT = (chipLT != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipLT, nInputAdjustTime) : EJudge.Miss; + EJudge e判定FT = (chipFT != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipFT, nInputAdjustTime) : EJudge.Miss; + switch (eFTGroup) + { + case EFTGroup.None: + #region [ FTのヒット処理 ] + //----------------------------- + if (e判定FT != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.FT, chipFT, inputEvent.nVelocity); + bHitted = true; + } + //----------------------------- + #endregion + break; + + case EFTGroup.Group: + #region [ FTとLTのヒット処理 ] + //----------------------------- + if ((e判定LT != EJudge.Miss) && (e判定FT != EJudge.Miss)) + { + if (chipLT.n発声位置 < chipFT.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.FT, chipLT, inputEvent.nVelocity); + } + else if (chipLT.n発声位置 > chipFT.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.FT, chipFT, inputEvent.nVelocity); + } + else + { + this.tドラムヒット処理(nTime, EPad.FT, chipLT, inputEvent.nVelocity); + this.tドラムヒット処理(nTime, EPad.FT, chipFT, inputEvent.nVelocity); + } + bHitted = true; + } + else if (e判定LT != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.FT, chipLT, inputEvent.nVelocity); + bHitted = true; + } + else if (e判定FT != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.FT, chipFT, inputEvent.nVelocity); + bHitted = true; + } + //----------------------------- + #endregion + break; + } + if (!bHitted) + break; + continue; + } + //----------------------------- + #endregion + + case EPad.CY: + #region [ CY(とLCとRD:groupingしている場合)のヒット処理 ] + //----------------------------- + { + if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.CY) // #23857 2010.12.12 yyagi: to support VelocityMin + continue; // 電子ドラムによる意図的なクロストークを無効にする + CChip chipCY = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.Cymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1); + CChip chipRD = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.RideCymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1); + CChip chipLC = CDTXMania.Instance.ConfigIni.bCymbalFree ? this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.LeftCymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1) : null; + EJudge e判定CY = (chipCY != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipCY, nInputAdjustTime) : EJudge.Miss; + EJudge e判定RD = (chipRD != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipRD, nInputAdjustTime) : EJudge.Miss; + EJudge e判定LC = (chipLC != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipLC, nInputAdjustTime) : EJudge.Miss; + CChip[] chipArray = new CChip[] { chipCY, chipRD, chipLC }; + EJudge[] e判定Array = new EJudge[] { e判定CY, e判定RD, e判定LC }; + const int NumOfChips = 3; // chipArray.GetLength(0) + + // CY/RD/LC群を, n発生位置の小さい順に並べる + nullを大きい方に退かす + SortChipsByNTime(chipArray, e判定Array, NumOfChips); + switch (eCYGroup) + { + case ECYGroup.None: + if (!CDTXMania.Instance.ConfigIni.bCymbalFree) + { + if (e判定CY != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.CY, chipCY, inputEvent.nVelocity); + bHitted = true; + } + if (!bHitted) + break; + continue; + } + for (int i = 0; i < NumOfChips; i++) + { + if ((e判定Array[i] != EJudge.Miss) && ((chipArray[i] == chipCY) || (chipArray[i] == chipLC))) + { + this.tドラムヒット処理(nTime, EPad.CY, chipArray[i], inputEvent.nVelocity); + bHitted = true; + break; + } + //num10++; + } + if (e判定CY != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.CY, chipCY, inputEvent.nVelocity); + bHitted = true; + } + if (!bHitted) + break; + continue; + + case ECYGroup.Group: + if (!CDTXMania.Instance.ConfigIni.bCymbalFree) + { + for (int i = 0; i < NumOfChips; i++) + { + if ((e判定Array[i] != EJudge.Miss) && ((chipArray[i] == chipCY) || (chipArray[i] == chipRD))) + { + this.tドラムヒット処理(nTime, EPad.CY, chipArray[i], inputEvent.nVelocity); + bHitted = true; + break; + } + } + if (!bHitted) + break; + continue; + } + for (int i = 0; i < NumOfChips; i++) + { + if (e判定Array[i] != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.CY, chipArray[i], inputEvent.nVelocity); + bHitted = true; + break; + } + } + if (!bHitted) + break; + continue; + } + if (!bHitted) + break; + continue; + } + //----------------------------- + #endregion + + case EPad.HHO: + #region [ HO(とHCとLC:groupingしている場合)のヒット処理 ] + //----------------------------- + { + if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.HH) + continue; // 電子ドラムによる意図的なクロストークを無効にする + + CChip chipHC = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.HiHatClose, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1); + CChip chipHO = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.HiHatOpen, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1); + CChip chipLC = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.LeftCymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1); + EJudge e判定HC = (chipHC != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipHC, nInputAdjustTime) : EJudge.Miss; + EJudge e判定HO = (chipHO != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipHO, nInputAdjustTime) : EJudge.Miss; + EJudge e判定LC = (chipLC != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipLC, nInputAdjustTime) : EJudge.Miss; + switch (eHHGroup) + { + case EHHGroup.None: + if (e判定HO != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity); + bHitted = true; + } + if (!bHitted) + break; + continue; + + case EHHGroup.HO_HC: + if ((e判定HO != EJudge.Miss) && (e判定LC != EJudge.Miss)) + { + if (chipHO.n発声位置 < chipLC.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity); + } + else if (chipHO.n発声位置 > chipLC.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipLC, inputEvent.nVelocity); + } + else + { + this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity); + this.tドラムヒット処理(nTime, EPad.HHO, chipLC, inputEvent.nVelocity); + } + bHitted = true; + } + else if (e判定HO != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity); + bHitted = true; + } + else if (e判定LC != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipLC, inputEvent.nVelocity); + bHitted = true; + } + if (!bHitted) + break; + continue; + + case EHHGroup.LC_HH: + if ((e判定HC != EJudge.Miss) && (e判定HO != EJudge.Miss)) + { + if (chipHC.n発声位置 < chipHO.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipHC, inputEvent.nVelocity); + } + else if (chipHC.n発声位置 > chipHO.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity); + } + else + { + this.tドラムヒット処理(nTime, EPad.HHO, chipHC, inputEvent.nVelocity); + this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity); + } + bHitted = true; + } + else if (e判定HC != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipHC, inputEvent.nVelocity); + bHitted = true; + } + else if (e判定HO != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity); + bHitted = true; + } + if (!bHitted) + break; + continue; + + case EHHGroup.Group: + if (((e判定HC != EJudge.Miss) && (e判定HO != EJudge.Miss)) && (e判定LC != EJudge.Miss)) + { + CChip chip; + CChip[] chipArray = new CChip[] { chipHC, chipHO, chipLC }; + // ここから、chipArrayをn発生位置の小さい順に並び替える + if (chipArray[1].n発声位置 > chipArray[2].n発声位置) + { + chip = chipArray[1]; + chipArray[1] = chipArray[2]; + chipArray[2] = chip; + } + if (chipArray[0].n発声位置 > chipArray[1].n発声位置) + { + chip = chipArray[0]; + chipArray[0] = chipArray[1]; + chipArray[1] = chip; + } + if (chipArray[1].n発声位置 > chipArray[2].n発声位置) + { + chip = chipArray[1]; + chipArray[1] = chipArray[2]; + chipArray[2] = chip; + } + this.tドラムヒット処理(nTime, EPad.HHO, chipArray[0], inputEvent.nVelocity); + if (chipArray[0].n発声位置 == chipArray[1].n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipArray[1], inputEvent.nVelocity); + } + if (chipArray[0].n発声位置 == chipArray[2].n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipArray[2], inputEvent.nVelocity); + } + bHitted = true; + } + else if ((e判定HC != EJudge.Miss) && (e判定HO != EJudge.Miss)) + { + if (chipHC.n発声位置 < chipHO.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipHC, inputEvent.nVelocity); + } + else if (chipHC.n発声位置 > chipHO.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity); + } + else + { + this.tドラムヒット処理(nTime, EPad.HHO, chipHC, inputEvent.nVelocity); + this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity); + } + bHitted = true; + } + else if ((e判定HC != EJudge.Miss) && (e判定LC != EJudge.Miss)) + { + if (chipHC.n発声位置 < chipLC.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipHC, inputEvent.nVelocity); + } + else if (chipHC.n発声位置 > chipLC.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipLC, inputEvent.nVelocity); + } + else + { + this.tドラムヒット処理(nTime, EPad.HHO, chipHC, inputEvent.nVelocity); + this.tドラムヒット処理(nTime, EPad.HHO, chipLC, inputEvent.nVelocity); + } + bHitted = true; + } + else if ((e判定HO != EJudge.Miss) && (e判定LC != EJudge.Miss)) + { + if (chipHO.n発声位置 < chipLC.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity); + } + else if (chipHO.n発声位置 > chipLC.n発声位置) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipLC, inputEvent.nVelocity); + } + else + { + this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity); + this.tドラムヒット処理(nTime, EPad.HHO, chipLC, inputEvent.nVelocity); + } + bHitted = true; + } + else if (e判定HC != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipHC, inputEvent.nVelocity); + bHitted = true; + } + else if (e判定HO != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity); + bHitted = true; + } + else if (e判定LC != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.HHO, chipLC, inputEvent.nVelocity); + bHitted = true; + } + if (!bHitted) + break; + continue; + } + if (!bHitted) + break; + continue; + } + //----------------------------- + #endregion + + case EPad.RD: + #region [ RD(とCYとLC:groupingしている場合)のヒット処理 ] + //----------------------------- + { + if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.RD) // #23857 2010.12.12 yyagi: to support VelocityMin + continue; // 電子ドラムによる意図的なクロストークを無効にする + CChip chipCY = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.Cymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1); + CChip chipRD = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.RideCymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1); + CChip chipLC = CDTXMania.Instance.ConfigIni.bCymbalFree ? this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.LeftCymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1) : null; + EJudge e判定CY = (chipCY != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipCY, nInputAdjustTime) : EJudge.Miss; + EJudge e判定RD = (chipRD != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipRD, nInputAdjustTime) : EJudge.Miss; + EJudge e判定LC = (chipLC != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipLC, nInputAdjustTime) : EJudge.Miss; + CChip[] chipArray = new CChip[] { chipCY, chipRD, chipLC }; + EJudge[] e判定Array = new EJudge[] { e判定CY, e判定RD, e判定LC }; + const int NumOfChips = 3; // chipArray.GetLength(0) + + // HH/CY群を, n発生位置の小さい順に並べる + nullを大きい方に退かす + SortChipsByNTime(chipArray, e判定Array, NumOfChips); + switch (eCYGroup) + { + case ECYGroup.None: + if (e判定RD != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.RD, chipRD, inputEvent.nVelocity); + bHitted = true; + } + break; + + case ECYGroup.Group: + if (!CDTXMania.Instance.ConfigIni.bCymbalFree) + { + for (int i = 0; i < NumOfChips; i++) + { + if ((e判定Array[i] != EJudge.Miss) && ((chipArray[i] == chipCY) || (chipArray[i] == chipRD))) + { + this.tドラムヒット処理(nTime, EPad.CY, chipArray[i], inputEvent.nVelocity); + bHitted = true; + break; + } + } + break; + } + for (int i = 0; i < NumOfChips; i++) + { + if (e判定Array[i] != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.CY, chipArray[i], inputEvent.nVelocity); + bHitted = true; + break; + } + } + break; + } + if (bHitted) + { + continue; + } + break; + } + //----------------------------- + #endregion + + case EPad.LC: + #region [ LC(とHC/HOとCYと:groupingしている場合)のヒット処理 ] + //----------------------------- + { + if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.LC) // #23857 2010.12.12 yyagi: to support VelocityMin + continue; // 電子ドラムによる意図的なクロストークを無効にする + CChip chipHC = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.HiHatClose, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1); // HC + CChip chipHO = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.HiHatOpen, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1); // HO + CChip chipLC = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.LeftCymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1); // LC + CChip chipCY = CDTXMania.Instance.ConfigIni.bCymbalFree ? this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.Cymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1) : null; + CChip chipRD = CDTXMania.Instance.ConfigIni.bCymbalFree ? this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.RideCymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1) : null; + EJudge e判定HC = (chipHC != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipHC, nInputAdjustTime) : EJudge.Miss; + EJudge e判定HO = (chipHO != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipHO, nInputAdjustTime) : EJudge.Miss; + EJudge e判定LC = (chipLC != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipLC, nInputAdjustTime) : EJudge.Miss; + EJudge e判定CY = (chipCY != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipCY, nInputAdjustTime) : EJudge.Miss; + EJudge e判定RD = (chipRD != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipRD, nInputAdjustTime) : EJudge.Miss; + CChip[] chipArray = new CChip[] { chipHC, chipHO, chipLC, chipCY, chipRD }; + EJudge[] e判定Array = new EJudge[] { e判定HC, e判定HO, e判定LC, e判定CY, e判定RD }; + const int NumOfChips = 5; // chipArray.GetLength(0) + + // HH/CY群を, n発生位置の小さい順に並べる + nullを大きい方に退かす + SortChipsByNTime(chipArray, e判定Array, NumOfChips); + switch (eHHGroup) + { + case EHHGroup.None: + case EHHGroup.LC_HH: + if (!CDTXMania.Instance.ConfigIni.bCymbalFree) + { + if (e判定LC != EJudge.Miss) + { + this.tドラムヒット処理(nTime, EPad.LC, chipLC, inputEvent.nVelocity); + bHitted = true; + } + if (!bHitted) + break; + continue; + } + for (int i = 0; i < NumOfChips; i++) + { + if ((e判定Array[i] != EJudge.Miss) && (((chipArray[i] == chipLC) || (chipArray[i] == chipCY)) || ((chipArray[i] == chipRD) && (CDTXMania.Instance.ConfigIni.eCYGroup == ECYGroup.Group)))) + { + this.tドラムヒット処理(nTime, EPad.LC, chipArray[i], inputEvent.nVelocity); + bHitted = true; + break; + } + } + if (!bHitted) + break; + continue; + + case EHHGroup.HO_HC: + case EHHGroup.Group: + if (!CDTXMania.Instance.ConfigIni.bCymbalFree) + { + for (int i = 0; i < NumOfChips; i++) + { + if ((e判定Array[i] != EJudge.Miss) && (((chipArray[i] == chipLC) || (chipArray[i] == chipHC)) || (chipArray[i] == chipHO))) + { + this.tドラムヒット処理(nTime, EPad.LC, chipArray[i], inputEvent.nVelocity); + bHitted = true; + break; + } + } + if (!bHitted) + break; + continue; + } + for (int i = 0; i < NumOfChips; i++) + { + if ((e判定Array[i] != EJudge.Miss) && ((chipArray[i] != chipRD) || (CDTXMania.Instance.ConfigIni.eCYGroup == ECYGroup.Group))) + { + this.tドラムヒット処理(nTime, EPad.LC, chipArray[i], inputEvent.nVelocity); + bHitted = true; + break; + } + } + if (!bHitted) + break; + continue; + } + if (!bHitted) + break; + + break; + } + //----------------------------- + #endregion + + case EPad.HP: // #27029 2012.1.4 from + #region [ HPのヒット処理 ] + //----------------- + if (CDTXMania.Instance.ConfigIni.eBDGroup == EBDGroup.Group) + { + #region [ BDとみなしてヒット処理 ] + //----------------- + if (!this.tドラムヒット処理(nTime, EPad.BD, this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.BassDrum, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1), inputEvent.nVelocity)) + break; + continue; + //----------------- + #endregion + } + else + { + #region [ HPのヒット処理 ] + //----------------- + continue; // 何もしない。この入力を完全に無視するので、break しないこと。 + //----------------- + #endregion + } + //----------------- + #endregion + } + //----------------------------- + #endregion + #region [ (B) ヒットしてなかった場合は、レーンフラッシュ、パッドアニメ、空打ち音再生を実行 ] + //----------------------------- + EPad pad = ePad; // 以下、nPad の代わりに pad を用いる。（成りすまし用） + + if (ePad == EPad.HP) + { + // #27029 2012.1.4 from: HP&BD 時の HiHatPedal の場合は BD に成りすます。 + pad = EPad.BD; + //（ HP|BD 時のHP入力はここまでこないので無視。） + } + + // レーンフラッシュ + this.actLaneFlushD.Start(EnumConverter.LaneFromPad(pad), ((float)inputEvent.nVelocity) / 127f); + + // パッド画像のヒット処理用 + + // パッドアニメ + this.actPad.Hit(pad); + + // 空打ち音 + if (CDTXMania.Instance.ConfigIni.bDrumsHitSound) + { + CChip rChip = this.r空うちChip(EPart.Drums, pad); + if (rChip != null) + { + // (B1) 空打ち音が譜面で指定されているのでそれを再生する。 + this.tサウンド再生(rChip, CSound管理.rc演奏用タイマ.nシステム時刻, EPart.Drums, CDTXMania.Instance.ConfigIni.nChipVolume, CDTXMania.Instance.ConfigIni.bEmphasizePlaySound.Drums); + } + else + { + #region [ (B2) 空打ち音が指定されていないので一番近いチップを探して再生する。] + switch (pad) + { + case EPad.HH: + { + CChip chipHC = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.HiHatClose, nInputAdjustTime); + CChip chipHO = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.HiHatOpen, nInputAdjustTime); + CChip chipLC = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.LeftCymbal, nInputAdjustTime); + switch (CDTXMania.Instance.ConfigIni.eHHGroup.Value) + { + case EHHGroup.HO_HC: + rChip = (chipHC != null) ? chipHC : chipLC; + break; + + case EHHGroup.LC_HH: + rChip = (chipHC != null) ? chipHC : chipHO; + break; + + case EHHGroup.Group: + if (chipHC != null) + { + rChip = chipHC; + } + else if (chipHO == null) + { + rChip = chipLC; + } + else if (chipLC == null) + { + rChip = chipHO; + } + else if (chipHO.n発声位置 < chipLC.n発声位置) + { + rChip = chipHO; + } + else + { + rChip = chipLC; + } + break; + + default: + rChip = chipHC; + break; + } + } + break; + + case EPad.LT: + { + CChip chipLT = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.LowTom, nInputAdjustTime); + CChip chipFT = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.FloorTom, nInputAdjustTime); + if (CDTXMania.Instance.ConfigIni.eFTGroup != EFTGroup.None) + rChip = (chipLT != null) ? chipLT : chipFT; + else + rChip = chipLT; + } + break; + + case EPad.FT: + { + CChip chipLT = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.LowTom, nInputAdjustTime); + CChip chipFT = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.FloorTom, nInputAdjustTime); + if (CDTXMania.Instance.ConfigIni.eFTGroup != EFTGroup.None) + rChip = (chipFT != null) ? chipFT : chipLT; + else + rChip = chipFT; + } + break; + + case EPad.CY: + { + CChip chipCY = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.Cymbal, nInputAdjustTime); + CChip chipRD = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.RideCymbal, nInputAdjustTime); + if (CDTXMania.Instance.ConfigIni.eCYGroup != ECYGroup.None) + rChip = (chipCY != null) ? chipCY : chipRD; + else + rChip = chipCY; + } + break; + + case EPad.HHO: + { + CChip chipHC = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.HiHatClose, nInputAdjustTime); + CChip chipHO = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.HiHatOpen, nInputAdjustTime); + CChip chipLC = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.LeftCymbal, nInputAdjustTime); + switch (CDTXMania.Instance.ConfigIni.eHHGroup.Value) + { + case EHHGroup.None: + rChip = chipHO; + break; + + case EHHGroup.HO_HC: + rChip = (chipHO != null) ? chipHO : chipLC; + break; + + case EHHGroup.LC_HH: + rChip = (chipHO != null) ? chipHO : chipHC; + break; + + case EHHGroup.Group: + if (chipHO != null) + { + rChip = chipHO; + } + else if (chipHC == null) + { + rChip = chipLC; + } + else if (chipLC == null) + { + rChip = chipHC; + } + else if (chipHC.n発声位置 < chipLC.n発声位置) + { + rChip = chipHC; + } + else + { + rChip = chipLC; + } + break; + } + } + break; + + case EPad.RD: + { + CChip chipCY = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.Cymbal, nInputAdjustTime); + CChip chipRD = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.RideCymbal, nInputAdjustTime); + if (CDTXMania.Instance.ConfigIni.eCYGroup != ECYGroup.None) + rChip = (chipRD != null) ? chipRD : chipCY; + else + rChip = chipRD; + } + break; + + case EPad.LC: + { + CChip chipHC = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.HiHatClose, nInputAdjustTime); + CChip chipHO = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.HiHatOpen, nInputAdjustTime); + CChip chipLC = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.LeftCymbal, nInputAdjustTime); + switch (CDTXMania.Instance.ConfigIni.eHHGroup.Value) + { + case EHHGroup.None: + case EHHGroup.LC_HH: + rChip = chipLC; + break; + + case EHHGroup.HO_HC: + case EHHGroup.Group: + if (chipLC != null) + { + rChip = chipLC; + } + else if (chipHC == null) + { + rChip = chipHO; + } + else if (chipHO == null) + { + rChip = chipHC; + } + else if (chipHC.n発声位置 < chipHO.n発声位置) + { + rChip = chipHC; + } + else + { + rChip = chipHO; + } + break; + } + } + break; + + default: + rChip = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EnumConverter.ChannelFromPad(pad), nInputAdjustTime); + break; + } + if (rChip != null) + { + // 空打ち音が見つかったので再生する。 + this.tサウンド再生(rChip, CSound管理.rc演奏用タイマ.nシステム時刻, EPart.Drums, CDTXMania.Instance.ConfigIni.nChipVolume, CDTXMania.Instance.ConfigIni.bEmphasizePlaySound.Drums); + } + //----------------- + #endregion + } + } + + // BAD or TIGHT 時の処理。 + if (CDTXMania.Instance.ConfigIni.bTight) + this.tチップのヒット処理_BadならびにTight時のMiss(EPart.Drums, EnumConverter.LaneFromPad(pad));//nパッド0Atoレーン07[(int)pad] + //----------------------------- + #endregion + } } } - protected void t進行描画・WailingBonus() + + private void ドラムスクロール速度アップ() { - if ( ( base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED ) && ( base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト ) ) + int scrollSpeed = CDTXMania.Instance.ConfigIni.nScrollSpeed.Drums; + CDTXMania.Instance.ConfigIni.nScrollSpeed.Drums.Value = scrollSpeed + 1; + float f = (float)CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Drums / (scrollSpeed + 1); + if (scrollSpeed < CDTXMania.Instance.ConfigIni.nScrollSpeed.Drums) { - this.actWailingBonus.On進行描画(); + CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Drums.Value = ((int)(f * (CDTXMania.Instance.ConfigIni.nScrollSpeed.Drums + 1) + 0.5)); } } - protected abstract void t進行描画・Wailing枠(); - protected void t進行描画・Wailing枠(int GtWailingFrameX, int BsWailingFrameX, int GtWailingFrameY, int BsWailingFrameY) + + private void ドラムスクロール速度ダウン() { - if ( ( CDTXMania.ConfigIni.eDark != Eダークモード.FULL ) && CDTXMania.ConfigIni.bGuitar有効 ) + int scrollSpeed = CDTXMania.Instance.ConfigIni.nScrollSpeed.Drums; + CDTXMania.Instance.ConfigIni.nScrollSpeed.Drums.Value = (scrollSpeed - 1); + float f = (float)CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Drums / (scrollSpeed + 1); + if (scrollSpeed > CDTXMania.Instance.ConfigIni.nScrollSpeed.Drums) { - if ( this.txWailing枠 != null ) + CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Drums.Value = ((int)(f * (CDTXMania.Instance.ConfigIni.nScrollSpeed.Drums + 1) + 0.5)); + } + } + + private int nStartTime_ = 0; + + protected void tキー入力() + { + IInputDevice keyboard = CDTXMania.Instance.Input管理.Keyboard; + if (keyboard.bキーが押された((int)SlimDX.DirectInput.Key.F1) && + (keyboard.bキーが押されている((int)SlimDX.DirectInput.Key.RightShift) || keyboard.bキーが押されている((int)SlimDX.DirectInput.Key.LeftShift))) + { // shift+f1 (pause) + this.bPAUSE = !this.bPAUSE; + if (this.bPAUSE) { - if ( CDTXMania.DTX.bチップがある.Guitar ) + nStartTime_ = (int)CSound管理.rc演奏用タイマ.n現在時刻; + CSound管理.rc演奏用タイマ.t一時停止(); + CDTXMania.Instance.Timer.t一時停止(); + CDTXMania.Instance.DTX.t全チップの再生一時停止(); + CDTXMania.Instance.DTX.t全AVIの一時停止(); + } + else + { + CDTXMania.Instance.DTX.t全AVIの再生再開(); + // CDTXMania.Instance.DTX.t全チップの再生再開(); + #region [ PAUSE連打でのBGMずれ対策 (AVIはずれたままになるが無視・・・) ] + + List pausedCSound = new List(); + for (int i = this.n現在のトップChip; i >= 0; i--) { - this.txWailing枠.t2D描画( CDTXMania.app.Device, GtWailingFrameX, GtWailingFrameY ); + CChip pChip = CDTXMania.Instance.DTX.listChip[i]; + int nDuration = pChip.GetDuration(); + + if ((pChip.n発声時刻ms + nDuration > 0) && (pChip.n発声時刻ms <= nStartTime_) && (nStartTime_ <= pChip.n発声時刻ms + nDuration)) + { + if (pChip.bWAVを使うチャンネルである && !pChip.b空打ちチップである) // wav系チャンネル、且つ、空打ちチップではない + { + CDTX.CWAV wc; + bool b = CDTXMania.Instance.DTX.listWAV.TryGetValue(pChip.n整数値_内部番号, out wc); + if (!b) continue; + + if ((wc.bIsBGMSound && CDTXMania.Instance.ConfigIni.bBGMPlay) || (!wc.bIsBGMSound)) + { + CDTXMania.Instance.DTX.tチップの再生(pChip, CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻 + pChip.n発声時刻ms, CDTXMania.Instance.DTX.nモニタを考慮した音量(EPart.Unknown)); + #region [ PAUSEする ] + int j = wc.n現在再生中のサウンド番号; + if (wc.rSound[j] != null) + { + wc.rSound[j].t再生を一時停止する(); + wc.rSound[j].t再生位置を変更する(nStartTime_ - pChip.n発声時刻ms); + pausedCSound.Add(wc.rSound[j]); + } + #endregion + } + } + } } - if ( CDTXMania.DTX.bチップがある.Bass ) + foreach (CSound cs in pausedCSound) { - this.txWailing枠.t2D描画( CDTXMania.app.Device, BsWailingFrameX, BsWailingFrameY ); + cs.tサウンドを再生する(); } + + #endregion + CDTXMania.Instance.Timer.t再開(); + CSound管理.rc演奏用タイマ.t再開(); } } - } - - - protected void t進行描画・チップファイアGB() - { - this.actChipFireGB.On進行描画(); - } - protected abstract void t進行描画・パネル文字列(); - protected void t進行描画・パネル文字列(int x, int y) - { - if ( ( base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED ) && ( base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト ) ) + if ((!this.bPAUSE && (base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED)) && (base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト)) { - this.actPanel.t進行描画( x, y ); + if (CDTXMania.Instance.ConfigIni.bDrums有効) + { + this.t入力処理_ドラム(); + } + if (CDTXMania.Instance.ConfigIni.bGuitar有効) + { + this.t入力処理_ギターベース(EPart.Guitar); + this.t入力処理_ギターベース(EPart.Bass); + } + + if (keyboard.bキーが押された((int)SlimDX.DirectInput.Key.UpArrow) && (keyboard.bキーが押されている((int)SlimDX.DirectInput.Key.RightShift) || keyboard.bキーが押されている((int)SlimDX.DirectInput.Key.LeftShift))) + { // shift (+ctrl) + UpArrow (BGMAdjust) + CDTXMania.Instance.DTX.t各自動再生音チップの再生時刻を変更する((keyboard.bキーが押されている((int)SlimDX.DirectInput.Key.LeftControl) || keyboard.bキーが押されている((int)SlimDX.DirectInput.Key.RightControl)) ? 1 : 10); + CDTXMania.Instance.DTX.tWave再生位置自動補正(); + } + else if (keyboard.bキーが押された((int)SlimDX.DirectInput.Key.DownArrow) && (keyboard.bキーが押されている((int)SlimDX.DirectInput.Key.RightShift) || keyboard.bキーが押されている((int)SlimDX.DirectInput.Key.LeftShift))) + { // shift + DownArrow (BGMAdjust) + CDTXMania.Instance.DTX.t各自動再生音チップの再生時刻を変更する((keyboard.bキーが押されている((int)SlimDX.DirectInput.Key.LeftControl) || keyboard.bキーが押されている((int)SlimDX.DirectInput.Key.RightControl)) ? -1 : -10); + CDTXMania.Instance.DTX.tWave再生位置自動補正(); + } + else if (keyboard.bキーが押された((int)SlimDX.DirectInput.Key.UpArrow)) + { // UpArrow(scrollspeed up) + ドラムスクロール速度アップ(); + } + else if (keyboard.bキーが押された((int)SlimDX.DirectInput.Key.DownArrow)) + { // DownArrow (scrollspeed down) + ドラムスクロール速度ダウン(); + } + else if (keyboard.bキーが押された((int)SlimDX.DirectInput.Key.Delete)) + { // del (debug info) + CDTXMania.Instance.ConfigIni.bDebugInfo.Value = !CDTXMania.Instance.ConfigIni.bDebugInfo; + } + else if (keyboard.bキーが押された((int)SlimDX.DirectInput.Key.LeftArrow)) // #24243 2011.1.16 yyagi UI for InputAdjustTime in playing screen. + { + ChangeInputAdjustTimeInPlaying(keyboard, -1); + } + else if (keyboard.bキーが押された((int)SlimDX.DirectInput.Key.RightArrow)) // #24243 2011.1.16 yyagi UI for InputAdjustTime in playing screen. + { + ChangeInputAdjustTimeInPlaying(keyboard, +1); + } + else if (keyboard.bキーが押された((int)SlimDX.DirectInput.Key.F5)) + { + int nVal = CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Drums - 1; + CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Drums.Value = + CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Guitar.Value = + CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Bass.Value = nVal; + } + else if (keyboard.bキーが押された((int)SlimDX.DirectInput.Key.F6)) + { + int nVal = CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Drums + 1; + CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Drums.Value = + CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Guitar.Value = + CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Bass.Value = nVal; + } + else if ((base.eフェーズID == CStage.Eフェーズ.共通_通常状態) && + (keyboard.bキーが押された((int)SlimDX.DirectInput.Key.Escape) || + CDTXMania.Instance.Pad.bCancelPadIsPressedGB())) + { + // escape (exit) + this.actFO.tフェードアウト開始(); + base.eフェーズID = CStage.Eフェーズ.共通_フェードアウト; + this.eフェードアウト完了時の戻り値 = E演奏画面の戻り値.演奏中断; + } } } - protected void tパネル文字列の設定() - { - this.actPanel.SetPanelString( string.IsNullOrEmpty( CDTXMania.DTX.PANEL ) ? CDTXMania.DTX.TITLE : CDTXMania.DTX.PANEL ); - } - - protected void t進行描画・ゲージ() + protected void t入力メソッド記憶(EPart part) { - if ( ( ( CDTXMania.ConfigIni.eDark != Eダークモード.HALF ) && ( CDTXMania.ConfigIni.eDark != Eダークモード.FULL ) ) && ( ( base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED ) && ( base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト ) ) ) + if (CDTXMania.Instance.Pad.st検知したデバイス.Keyboard) { - this.actGauge.On進行描画(); + this.b演奏にキーボードを使った[part] = true; + } + if (CDTXMania.Instance.Pad.st検知したデバイス.Joypad) + { + this.b演奏にジョイパッドを使った[part] = true; + } + if (CDTXMania.Instance.Pad.st検知したデバイス.MIDIIN) + { + this.b演奏にMIDI入力を使った[part] = true; + } + if (CDTXMania.Instance.Pad.st検知したデバイス.Mouse) + { + this.b演奏にマウスを使った[part] = true; } } - protected void t進行描画・コンボ() - { - this.actCombo.On進行描画(); - } - protected void t進行描画・スコア() - { - this.actScore.On進行描画(); - } - protected void t進行描画・ステータスパネル() - { - this.actStatusPanels.On進行描画(); - } - protected bool t進行描画・チップ( E楽器パート ePlayMode ) + + /// + /// チップに関連する処理を行う。 + /// + /// 演奏が終了したかどうかを示す値 + protected bool t進行描画_チップ() { - if ( ( base.eフェーズID == CStage.Eフェーズ.演奏_STAGE_FAILED ) || ( base.eフェーズID == CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト ) ) + if ((base.eフェーズID == CStage.Eフェーズ.演奏_STAGE_FAILED) || (base.eフェーズID == CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト)) { return true; } - if ( ( this.n現在のトップChip == -1 ) || ( this.n現在のトップChip >= listChip.Count ) ) + if ((this.n現在のトップChip == -1) || (this.n現在のトップChip >= CDTXMania.Instance.DTX.listChip.Count)) { return true; } - if ( this.n現在のトップChip == -1 ) + if (this.n現在のトップChip == -1) { return true; } - //double speed = 264.0; // BPM150の時の1小節の長さ[dot] - const double speed = 234.0; // BPM150の時の1小節の長さ[dot] - - double ScrollSpeedDrums = ( this.act譜面スクロール速度.db現在の譜面スクロール速度.Drums + 1.0 ) * 0.5 * 37.5 * speed / 60000.0; - double ScrollSpeedGuitar = ( this.act譜面スクロール速度.db現在の譜面スクロール速度.Guitar + 1.0 ) * 0.5 * 0.5 * 37.5 * speed / 60000.0; - double ScrollSpeedBass = ( this.act譜面スクロール速度.db現在の譜面スクロール速度.Bass + 1.0 ) * 0.5 * 0.5 * 37.5 * speed / 60000.0; - - CDTX dTX = CDTXMania.DTX; - CConfigIni configIni = CDTXMania.ConfigIni; - for ( int nCurrentTopChip = this.n現在のトップChip; nCurrentTopChip < dTX.listChip.Count; nCurrentTopChip++ ) + //CDTX dTX = CDTXMania.Instance.DTX; + //CConfigIni configIni = CDTXMania.Instance.ConfigIni; + for (int nCurrentTopChip = this.n現在のトップChip; nCurrentTopChip < CDTXMania.Instance.DTX.listChip.Count; nCurrentTopChip++) { - CDTX.CChip pChip = dTX.listChip[ nCurrentTopChip ]; -//Debug.WriteLine( "nCurrentTopChip=" + nCurrentTopChip + ", ch=" + pChip.nチャンネル番号.ToString("x2") + ", 発音位置=" + pChip.n発声位置 + ", 発声時刻ms=" + pChip.n発声時刻ms ); - pChip.nバーからの距離dot.Drums = (int) ( ( pChip.n発声時刻ms - CSound管理.rc演奏用タイマ.n現在時刻 ) * ScrollSpeedDrums ); - pChip.nバーからの距離dot.Guitar = (int) ( ( pChip.n発声時刻ms - CSound管理.rc演奏用タイマ.n現在時刻 ) * ScrollSpeedGuitar ); - pChip.nバーからの距離dot.Bass = (int) ( ( pChip.n発声時刻ms - CSound管理.rc演奏用タイマ.n現在時刻 ) * ScrollSpeedBass ); - if ( Math.Min( Math.Min( pChip.nバーからの距離dot.Drums, pChip.nバーからの距離dot.Guitar ), pChip.nバーからの距離dot.Bass ) > 450 ) + CChip pChip = CDTXMania.Instance.DTX.listChip[nCurrentTopChip]; + //Debug.WriteLine( "nCurrentTopChip=" + nCurrentTopChip + ", ch=" + pChip.nチャンネル番号.ToString("x2") + ", 発音位置=" + pChip.n発声位置 + ", 発声時刻ms=" + pChip.n発声時刻ms ); + pChip.CalcDistanceFromBar(CSound管理.rc演奏用タイマ.n現在時刻, this.act譜面スクロール速度.db現在の譜面スクロール速度); + if (Math.Min(Math.Min(pChip.nバーからの距離dot.Drums, pChip.nバーからの距離dot.Guitar), pChip.nバーからの距離dot.Bass) > 450 * Scale.Y) { break; } -// if ( ( ( nCurrentTopChip == this.n現在のトップChip ) && ( pChip.nバーからの距離dot.Drums < -65 ) ) && pChip.bHit ) // #28026 2012.4.5 yyagi; 信心ワールドエンドの曲終了後リザルトになかなか行かない問題の修正 - if ( ( dTX.listChip[ this.n現在のトップChip ].nバーからの距離dot.Drums < -65 ) && dTX.listChip[ this.n現在のトップChip ].bHit ) + if ((CDTXMania.Instance.DTX.listChip[this.n現在のトップChip].nバーからの距離dot.Drums < -65 * Scale.Y) && // 小節線の消失処理などに影響するため、 + (CDTXMania.Instance.DTX.listChip[this.n現在のトップChip].nバーからの距離dot.Guitar < -65 * Scale.Y) && // Drumsのスクロールスピードだけには依存させない。 + (CDTXMania.Instance.DTX.listChip[this.n現在のトップChip].nバーからの距離dot.Bass < -65 * Scale.Y) && + CDTXMania.Instance.DTX.listChip[this.n現在のトップChip].bHit) { -// nCurrentTopChip = ++this.n現在のトップChip; ++this.n現在のトップChip; - continue; - } - - bool bPChipIsAutoPlay = bCheckAutoPlay( pChip ); - - int nInputAdjustTime = ( bPChipIsAutoPlay || (pChip.e楽器パート == E楽器パート.UNKNOWN) )? 0 : this.nInputAdjustTimeMs[ (int) pChip.e楽器パート ]; - - if ( ( ( pChip.e楽器パート != E楽器パート.UNKNOWN ) && !pChip.bHit ) && - ( ( pChip.nバーからの距離dot.Drums < 0 ) && ( this.e指定時刻からChipのJUDGEを返す( CSound管理.rc演奏用タイマ.n現在時刻, pChip, nInputAdjustTime ) == E判定.Miss ) ) ) - { - this.tチップのヒット処理( CSound管理.rc演奏用タイマ.n現在時刻, pChip ); - } - switch ( pChip.nチャンネル番号 ) - { - #region [ 01: BGM ] - case 0x01: // BGM - if ( !pChip.bHit && ( pChip.nバーからの距離dot.Drums < 0 ) ) - { - pChip.bHit = true; - if ( configIni.bBGM音を発声する ) - { - dTX.tチップの再生( pChip, CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻 + pChip.n発声時刻ms, (int) Eレーン.BGM, dTX.nモニタを考慮した音量( E楽器パート.UNKNOWN ) ); - } - } - break; - #endregion - #region [ 03: BPM変更 ] - case 0x03: // BPM変更 - if ( !pChip.bHit && ( pChip.nバーからの距離dot.Drums < 0 ) ) - { - pChip.bHit = true; - this.actPlayInfo.dbBPM = ( pChip.n整数値 * ( ( (double) configIni.n演奏速度 ) / 20.0 ) ) + dTX.BASEBPM; - } - break; - #endregion - #region [ 04, 07, 55, 56,57, 58, 59, 60:レイヤーBGA ] - case 0x04: // レイヤーBGA - case 0x07: - case 0x55: - case 0x56: - case 0x57: - case 0x58: - case 0x59: - case 0x60: - if ( !pChip.bHit && ( pChip.nバーからの距離dot.Drums < 0 ) ) - { - pChip.bHit = true; - if ( configIni.bBGA有効 ) - { - switch ( pChip.eBGA種別 ) - { - case EBGA種別.BMPTEX: - if ( pChip.rBMPTEX != null ) - { - this.actBGA.Start( pChip.nチャンネル番号, null, pChip.rBMPTEX, pChip.rBMPTEX.tx画像.sz画像サイズ.Width, pChip.rBMPTEX.tx画像.sz画像サイズ.Height, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ); - } - break; + continue; + } + bool bPChipIsAutoPlay = pChip.bAssignAutoPlayState(); - case EBGA種別.BGA: - if ( ( pChip.rBGA != null ) && ( ( pChip.rBMP != null ) || ( pChip.rBMPTEX != null ) ) ) - { - this.actBGA.Start( pChip.nチャンネル番号, pChip.rBMP, pChip.rBMPTEX, pChip.rBGA.pt画像側右下座標.X - pChip.rBGA.pt画像側左上座標.X, pChip.rBGA.pt画像側右下座標.Y - pChip.rBGA.pt画像側左上座標.Y, 0, 0, pChip.rBGA.pt画像側左上座標.X, pChip.rBGA.pt画像側左上座標.Y, 0, 0, pChip.rBGA.pt表示座標.X, pChip.rBGA.pt表示座標.Y, 0, 0, 0 ); - } - break; + int nInputAdjustTime = (bPChipIsAutoPlay || (pChip.e楽器パート == EPart.Unknown)) ? 0 : CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs[pChip.e楽器パート]; - case EBGA種別.BGAPAN: - if ( ( pChip.rBGAPan != null ) && ( ( pChip.rBMP != null ) || ( pChip.rBMPTEX != null ) ) ) - { - this.actBGA.Start( pChip.nチャンネル番号, pChip.rBMP, pChip.rBMPTEX, pChip.rBGAPan.sz開始サイズ.Width, pChip.rBGAPan.sz開始サイズ.Height, pChip.rBGAPan.sz終了サイズ.Width, pChip.rBGAPan.sz終了サイズ.Height, pChip.rBGAPan.pt画像側開始位置.X, pChip.rBGAPan.pt画像側開始位置.Y, pChip.rBGAPan.pt画像側終了位置.X, pChip.rBGAPan.pt画像側終了位置.Y, pChip.rBGAPan.pt表示側開始位置.X, pChip.rBGAPan.pt表示側開始位置.Y, pChip.rBGAPan.pt表示側終了位置.X, pChip.rBGAPan.pt表示側終了位置.Y, pChip.n総移動時間 ); - } - break; + EPart inst = pChip.e楽器パート; + if (((pChip.e楽器パート != EPart.Unknown) && !pChip.bHit) && + ((pChip.nバーからの距離dot[inst] < -40 * Scale.Y) && + (this.e指定時刻からChipのJUDGEを返す(CSound管理.rc演奏用タイマ.n現在時刻, pChip, nInputAdjustTime) == EJudge.Miss))) + { + this.tチップのヒット処理(CSound管理.rc演奏用タイマ.n現在時刻, pChip); //チップ消失(Hitせずスルーした場合) + } + if (((pChip.e楽器パート != EPart.Unknown) && !pChip.bHit) && + ((pChip.nバーからの距離dot[inst] + CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset[inst] < 0))) + { + //Debug.WriteLine( "透明度＝" + pChip.n透明度 ); + pChip.n透明度 -= 12; // チップが判定バーを越えたら、徐々に透明にする。VSyncWaitの有無で加減が変わるが・・ + if (pChip.n透明度 < 0) + { + pChip.n透明度 = 0; + } + } - default: - if ( pChip.rBMP != null ) - { - this.actBGA.Start( pChip.nチャンネル番号, pChip.rBMP, null, pChip.rBMP.n幅, pChip.rBMP.n高さ, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ); - } - break; - } - } - } - break; - #endregion - #region [ 08: BPM変更(拡張) ] - case 0x08: // BPM変更(拡張) - if ( !pChip.bHit && ( pChip.nバーからの距離dot.Drums < 0 ) ) + // #35411 chnmr0 add (ターゲットゴースト) + if (CDTXMania.Instance.ConfigIni.eTargetGhost[inst] != ETargetGhostData.None && + CDTXMania.Instance.DTX.listTargetGhsotLag[inst] != null && + pChip.e楽器パート != EPart.Unknown && + pChip.nバーからの距離dot[inst] < 0) + { + if (!pChip.bTargetGhost判定済み) + { + pChip.bTargetGhost判定済み = true; + + int ghostLag = 128; + if (0 <= pChip.n楽器パートでの出現順 && pChip.n楽器パートでの出現順 < CDTXMania.Instance.DTX.listTargetGhsotLag[inst].Count) { - pChip.bHit = true; - if ( dTX.listBPM.ContainsKey( pChip.n整数値・内部番号 ) ) + ghostLag = CDTXMania.Instance.DTX.listTargetGhsotLag[inst][pChip.n楽器パートでの出現順]; + // 上位８ビットが１ならコンボが途切れている（ギターBAD空打ちでコンボ数を再現するための措置） + if (ghostLag > 255) { - this.actPlayInfo.dbBPM = ( dTX.listBPM[ pChip.n整数値・内部番号 ].dbBPM値 * ( ( (double) configIni.n演奏速度 ) / 20.0 ) ) + dTX.BASEBPM; + this.nコンボ数_TargetGhost[inst] = 0; } + ghostLag = (ghostLag & 255) - 128; } - break; - #endregion - #region [ 11-1a: ドラム演奏 ] - case 0x11: // ドラム演奏 - case 0x12: - case 0x13: - case 0x14: - case 0x15: - case 0x16: - case 0x17: - case 0x18: - case 0x19: - case 0x1a: - this.t進行描画・チップ・ドラムス( configIni, ref dTX, ref pChip ); - break; - #endregion - #region [ 1f: フィルインサウンド(ドラム) ] - case 0x1f: // フィルインサウンド(ドラム) - if ( !pChip.bHit && ( pChip.nバーからの距離dot.Drums < 0 ) ) - { - pChip.bHit = true; - this.r現在の歓声Chip.Drums = pChip; - } - break; - #endregion - #region [ 20-27: ギター演奏 ] - case 0x20: // ギター演奏 - case 0x21: - case 0x22: - case 0x23: - case 0x24: - case 0x25: - case 0x26: - case 0x27: - this.t進行描画・チップ・ギターベース( configIni, ref dTX, ref pChip, E楽器パート.GUITAR ); - break; - #endregion - #region [ 28: ウェイリング(ギター) ] - case 0x28: // ウェイリング(ギター) - this.t進行描画・チップ・ギター・ウェイリング( configIni, ref dTX, ref pChip ); - break; - #endregion - #region [ 2f: ウェイリングサウンド(ギター) ] - case 0x2f: // ウェイリングサウンド(ギター) - if ( !pChip.bHit && ( pChip.nバーからの距離dot.Guitar < 0 ) ) + else if (CDTXMania.Instance.ConfigIni.eTargetGhost[inst] == ETargetGhostData.Perfect) { - pChip.bHit = true; - this.r現在の歓声Chip.Guitar = pChip; + ghostLag = 0; } - break; - #endregion - #region [ 31-3a: 不可視チップ配置(ドラム) ] - case 0x31: // 不可視チップ配置(ドラム) - case 0x32: - case 0x33: - case 0x34: - case 0x35: - case 0x36: - case 0x37: - case 0x38: - case 0x39: - case 0x3a: - if ( !pChip.bHit && ( pChip.nバーからの距離dot.Drums < 0 ) ) + + if (ghostLag <= 127) { - pChip.bHit = true; + EJudge eJudge = this.e指定時刻からChipのJUDGEを返す(pChip.n発声時刻ms + ghostLag, pChip, 0, false); + this.nヒット数_TargetGhost[inst][(int)eJudge]++; + if (eJudge == EJudge.Miss || eJudge == EJudge.Poor) + { + this.n最大コンボ数_TargetGhost[inst] = Math.Max(this.n最大コンボ数_TargetGhost[inst], this.nコンボ数_TargetGhost[inst]); + this.nコンボ数_TargetGhost[inst] = 0; + } + else + { + this.nコンボ数_TargetGhost[inst]++; + } } - break; - #endregion - #region [ 50: 小節線 ] - case 0x50: // 小節線 + } + } + + if (pChip[EChannel.BGM] && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0)) + { + pChip.bHit = true; + if (CDTXMania.Instance.ConfigIni.bBGMPlay) + { + //long t = CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻 + pChip.n発声時刻ms; + //Trace.TraceInformation( "BGM再生開始: 演奏タイマのn前回リセットしたときのシステム時刻=" + CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻 + ", pChip.n発生時刻ms=" + pChip.n発声時刻ms + ", 合計=" + t ); + CDTXMania.Instance.DTX.tチップの再生(pChip, CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻 + pChip.n発声時刻ms, CDTXMania.Instance.DTX.nモニタを考慮した音量(EPart.Unknown)); + } + } + else if (pChip[EChannel.BPM] && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0)) + { + pChip.bHit = true; + this.actPlayInfo.dbBPM = (pChip.n整数値 * (((double)CDTXMania.Instance.ConfigIni.nPlaySpeed) / 20.0)) + CDTXMania.Instance.DTX.BASEBPM; + } + else if (pChip.bBGALayer && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0)) + { + pChip.bHit = true; + if (CDTXMania.Instance.ConfigIni.bBGA) + { + switch (pChip.eBGA種別) { - this.t進行描画・チップ・小節線( configIni, ref dTX, ref pChip ); - break; + case EBGAType.BMPTEX: + if (pChip.rBMPTEX != null) + { + this.actBGA.Start(pChip, null, pChip.rBMPTEX, pChip.rBMPTEX.tx画像.sz画像サイズ.Width, pChip.rBMPTEX.tx画像.sz画像サイズ.Height, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + } + break; + + case EBGAType.BGA: + if ((pChip.rBGA != null) && ((pChip.rBMP != null) || (pChip.rBMPTEX != null))) + { + this.actBGA.Start(pChip, pChip.rBMP, pChip.rBMPTEX, pChip.rBGA.pt画像側右下座標.X - pChip.rBGA.pt画像側左上座標.X, pChip.rBGA.pt画像側右下座標.Y - pChip.rBGA.pt画像側左上座標.Y, 0, 0, pChip.rBGA.pt画像側左上座標.X, pChip.rBGA.pt画像側左上座標.Y, 0, 0, pChip.rBGA.pt表示座標.X, pChip.rBGA.pt表示座標.Y, 0, 0, 0); + } + break; + + case EBGAType.BGAPAN: + if ((pChip.rBGAPan != null) && ((pChip.rBMP != null) || (pChip.rBMPTEX != null))) + { + this.actBGA.Start(pChip, pChip.rBMP, pChip.rBMPTEX, pChip.rBGAPan.sz開始サイズ.Width, pChip.rBGAPan.sz開始サイズ.Height, pChip.rBGAPan.sz終了サイズ.Width, pChip.rBGAPan.sz終了サイズ.Height, pChip.rBGAPan.pt画像側開始位置.X, pChip.rBGAPan.pt画像側開始位置.Y, pChip.rBGAPan.pt画像側終了位置.X, pChip.rBGAPan.pt画像側終了位置.Y, pChip.rBGAPan.pt表示側開始位置.X, pChip.rBGAPan.pt表示側開始位置.Y, pChip.rBGAPan.pt表示側終了位置.X, pChip.rBGAPan.pt表示側終了位置.Y, pChip.n総移動時間); + } + break; + + default: + if (pChip.rBMP != null) + { + this.actBGA.Start(pChip, pChip.rBMP, null, pChip.rBMP.n幅, pChip.rBMP.n高さ, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + } + break; } - #endregion - #region [ 51: 拍線 ] - case 0x51: // 拍線 - if ( !pChip.bHit && ( pChip.nバーからの距離dot.Drums < 0 ) ) + } + } + else if (pChip[EChannel.BPMEx] && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0)) + { + pChip.bHit = true; + if (CDTXMania.Instance.DTX.listBPM.ContainsKey(pChip.n整数値_内部番号)) + { + this.actPlayInfo.dbBPM = (CDTXMania.Instance.DTX.listBPM[pChip.n整数値_内部番号].dbBPM値 * + (((double)CDTXMania.Instance.ConfigIni.nPlaySpeed) / 20.0)) + + CDTXMania.Instance.DTX.BASEBPM; + } + } + else if (pChip.bDrums可視チップ && pChip.b空打ちチップである) + { + if (!pChip.bHit && (pChip.nバーからの距離dot.Drums < 0)) + { + pChip.bHit = true; + if (CDTXMania.Instance.ConfigIni.bDrums有効) { - pChip.bHit = true; + this.r現在の空うちドラムChip[(int)(EnumConverter.PadFromChannel(pChip.eチャンネル番号) - EPad.DrumsPadMin)] = pChip; } - if ( ( ePlayMode == E楽器パート.DRUMS ) && ( configIni.eDark != Eダークモード.FULL ) && pChip.b可視 && ( this.txチップ != null ) ) + } + } + else if (pChip.bDrums可視チップ_LP_LBD含まない) + { + this.t進行描画_チップ_ドラムス(ref pChip); + } + else if (pChip[EChannel.DrumsFillin] && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0)) + { + pChip.bHit = true; + this.r現在の歓声Chip.Drums = pChip; + } + else if (pChip.bGuitar可視チップ) + { + this.t進行描画_チップ_ギターベース(ref pChip, EPart.Guitar); + } + else if (pChip[EChannel.Guitar_Wailing]) + { + this.t進行描画_チップ_ウェイリング(ref pChip); + } + else if (pChip[EChannel.Guitar_WailingSound] && !pChip.bHit && (pChip.nバーからの距離dot.Guitar < 0)) + { + pChip.bHit = true; + this.r現在の歓声Chip.Guitar = pChip; + } + else if (pChip.bDrums不可視チップ && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0)) + { + pChip.bHit = true; + } + else if (pChip[EChannel.BarLine] || pChip[EChannel.BeatLine])// 小節線 + { + this.t進行描画_チップ_小節線_拍線(ref pChip); + } + else if (pChip[EChannel.MIDIChorus] && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0)) + { + pChip.bHit = true; + } + else if (pChip[EChannel.FillIn]) + { + this.t進行描画_チップ_フィルイン(ref pChip); + } + else if (pChip.bMovie && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0)) + { + pChip.bHit = true; + if (CDTXMania.Instance.ConfigIni.bAVI) + { + if (CDTXMania.Instance.DTX.bチップがある.BGA) { - this.txチップ.t2D描画( CDTXMania.app.Device, 0x23, configIni.bReverse.Drums ? ( ( 0x38 + pChip.nバーからの距離dot.Drums ) - 1 ) : ( ( 0x1a6 - pChip.nバーからの距離dot.Drums ) - 1 ), new Rectangle( 0, 0x1bf, 0x128, 1 ) ); + this.actAVI.bHasBGA = true; } - break; - #endregion - #region [ 52: MIDIコーラス ] - case 0x52: // MIDIコーラス - if ( !pChip.bHit && ( pChip.nバーからの距離dot.Drums < 0 ) ) + if (pChip.eチャンネル番号 == EChannel.MovieFull || CDTXMania.Instance.ConfigIni.bFullAVI) { - pChip.bHit = true; + this.actAVI.bFullScreenMovie = true; } - break; - #endregion - #region [ 53: フィルイン ] - case 0x53: // フィルイン - this.t進行描画・チップ・フィルイン( configIni, ref dTX, ref pChip ); - break; - #endregion - #region [ 54: 動画再生 ] - case 0x54: // 動画再生 - if ( !pChip.bHit && ( pChip.nバーからの距離dot.Drums < 0 ) ) + switch (pChip.eAVI種別) { - pChip.bHit = true; - if ( configIni.bAVI有効 ) - { - switch ( pChip.eAVI種別 ) + case EAVIType.AVI: { - case EAVI種別.AVI: - if ( pChip.rAVI != null ) - { - this.actAVI.Start( pChip.nチャンネル番号, pChip.rAVI, 0x116, 0x163, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, pChip.n発声時刻ms ); - } - break; + int startWidth = !this.actAVI.bFullScreenMovie ? 278 : SampleFramework.GameWindowSize.Width; + int startHeight = !this.actAVI.bFullScreenMovie ? 355 : SampleFramework.GameWindowSize.Height; + this.actAVI.Start(pChip.eチャンネル番号, pChip.rAVI, startWidth, startHeight, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, pChip.n発声時刻ms); + } + break; - case EAVI種別.AVIPAN: - if ( pChip.rAVIPan != null ) - { - this.actAVI.Start( pChip.nチャンネル番号, pChip.rAVI, pChip.rAVIPan.sz開始サイズ.Width, pChip.rAVIPan.sz開始サイズ.Height, pChip.rAVIPan.sz終了サイズ.Width, pChip.rAVIPan.sz終了サイズ.Height, pChip.rAVIPan.pt動画側開始位置.X, pChip.rAVIPan.pt動画側開始位置.Y, pChip.rAVIPan.pt動画側終了位置.X, pChip.rAVIPan.pt動画側終了位置.Y, pChip.rAVIPan.pt表示側開始位置.X, pChip.rAVIPan.pt表示側開始位置.Y, pChip.rAVIPan.pt表示側終了位置.X, pChip.rAVIPan.pt表示側終了位置.Y, pChip.n総移動時間, pChip.n発声時刻ms ); - } - break; + case EAVIType.AVIPAN: + if (pChip.rAVIPan != null) + { + this.actAVI.Start(pChip.eチャンネル番号, pChip.rAVI, pChip.rAVIPan.sz開始サイズ.Width, pChip.rAVIPan.sz開始サイズ.Height, pChip.rAVIPan.sz終了サイズ.Width, pChip.rAVIPan.sz終了サイズ.Height, pChip.rAVIPan.pt動画側開始位置.X, pChip.rAVIPan.pt動画側開始位置.Y, pChip.rAVIPan.pt動画側終了位置.X, pChip.rAVIPan.pt動画側終了位置.Y, pChip.rAVIPan.pt表示側開始位置.X, pChip.rAVIPan.pt表示側開始位置.Y, pChip.rAVIPan.pt表示側終了位置.X, pChip.rAVIPan.pt表示側終了位置.Y, pChip.n総移動時間, pChip.n発声時刻ms); } - } - } - break; - #endregion - #region [ 61-92: 自動再生(BGM, SE) ] - case 0x61: - case 0x62: - case 0x63: - case 0x64: // 自動再生(BGM, SE) - case 0x65: - case 0x66: - case 0x67: - case 0x68: - case 0x69: - case 0x70: - case 0x71: - case 0x72: - case 0x73: - case 0x74: - case 0x75: - case 0x76: - case 0x77: - case 0x78: - case 0x79: - case 0x80: - case 0x81: - case 0x82: - case 0x83: - case 0x90: - case 0x91: - case 0x92: - if ( !pChip.bHit && ( pChip.nバーからの距離dot.Drums < 0 ) ) - { - pChip.bHit = true; - if ( configIni.bBGM音を発声する ) - { - dTX.tWavの再生停止( this.n最後に再生したBGMの実WAV番号[ pChip.nチャンネル番号 - 0x61 ] ); - dTX.tチップの再生( pChip, CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻 + pChip.n発声時刻ms, ( int ) Eレーン.BGM, dTX.nモニタを考慮した音量( E楽器パート.UNKNOWN ) ); - this.n最後に再生したBGMの実WAV番号[ pChip.nチャンネル番号 - 0x61 ] = pChip.n整数値・内部番号; - } + break; } - break; - #endregion - - - #region [ 84-89: 仮: override sound ] // #26338 2011.11.8 yyagi - case 0x84: // HH (HO/HC) - case 0x85: // CY - case 0x86: // RD - case 0x87: // LC - case 0x88: // Guitar - case 0x89: // Bass + } + } + else if (pChip.bSE && !pChip.bOverrideSE && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0)) + { + pChip.bHit = true; + if (CDTXMania.Instance.ConfigIni.bBGMPlay) + { + CDTXMania.Instance.DTX.tWavの再生停止(this.n最後に再生したBGMの実WAV番号[pChip.eチャンネル番号 - EChannel.SE01]); + CDTXMania.Instance.DTX.tチップの再生(pChip, CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻 + pChip.n発声時刻ms, CDTXMania.Instance.DTX.nモニタを考慮した音量(EPart.Unknown)); + this.n最後に再生したBGMの実WAV番号[pChip.eチャンネル番号 - EChannel.SE01] = pChip.n整数値_内部番号; + } + } + else if (pChip.bOverrideSE && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0)) + { + // override sound // mute sound (auto) // 4A: 84: HH (HO/HC) // 4B: 85: CY @@ -1985,451 +3050,401 @@ namespace DTXMania // 2A: 88: Gt // AA: 89: Bs - // CDTXMania.DTX.tWavの再生停止( this.n最後に再生した実WAV番号.Guitar ); - // CDTXMania.DTX.tチップの再生( pChip, n再生開始システム時刻ms, 8, n音量, bモニタ, b音程をずらして再生 ); - // this.n最後に再生した実WAV番号.Guitar = pChip.n整数値・内部番号; + // CDTXMania.Instance.DTX.tWavの再生停止( this.n最後に再生した実WAV番号.Guitar ); + // CDTXMania.Instance.DTX.tチップの再生( pChip, n再生開始システム時刻ms, 8, n音量, bモニタ, b音程をずらして再生 ); + // this.n最後に再生した実WAV番号.Guitar = pChip.n整数値_内部番号; // protected void tサウンド再生( CDTX.CChip pChip, long n再生開始システム時刻ms, E楽器パート part, int n音量, bool bモニタ, bool b音程をずらして再生 ) - if ( !pChip.bHit && ( pChip.nバーからの距離dot.Drums < 0 ) ) - { - pChip.bHit = true; - E楽器パート[] p = { E楽器パート.DRUMS, E楽器パート.DRUMS, E楽器パート.DRUMS, E楽器パート.DRUMS, E楽器パート.GUITAR, E楽器パート.BASS }; - - E楽器パート pp = p[ pChip.nチャンネル番号 - 0x84 ]; - -// if ( pp == E楽器パート.DRUMS ) { // pChip.nチャンネル番号= ..... HHとか、ドラムの場合は変える。 -// // HC CY RD LC -// int[] ch = { 0x11, 0x16, 0x19, 0x1A }; -// pChip.nチャンネル番号 = ch[ pChip.nチャンネル番号 - 0x84 ]; -// } - this.tサウンド再生( pChip, CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻 + pChip.n発声時刻ms, pp, dTX.nモニタを考慮した音量( pp ) ); - } - break; - #endregion + pChip.bHit = true; + EPart[] p = { EPart.Drums, EPart.Drums, EPart.Drums, EPart.Drums, EPart.Guitar, EPart.Bass }; - #region [ a0-a7: ベース演奏 ] - case 0xa0: // ベース演奏 - case 0xa1: - case 0xa2: - case 0xa3: - case 0xa4: - case 0xa5: - case 0xa6: - case 0xa7: - this.t進行描画・チップ・ギターベース( configIni, ref dTX, ref pChip, E楽器パート.BASS ); - break; - #endregion - #region [ a8: ウェイリング(ベース) ] - case 0xa8: // ウェイリング(ベース) - this.t進行描画・チップ・ベース・ウェイリング( configIni, ref dTX, ref pChip ); - break; - #endregion - #region [ af: ウェイリングサウンド(ベース) ] - case 0xaf: // ウェイリングサウンド(ベース) - if ( !pChip.bHit && ( pChip.nバーからの距離dot.Bass < 0 ) ) - { - pChip.bHit = true; - this.r現在の歓声Chip.Bass = pChip; - } - break; - #endregion - #region [ b1-b9, bc: 空打ち音設定(ドラム) ] - case 0xb1: // 空打ち音設定(ドラム) - case 0xb2: - case 0xb3: - case 0xb4: - case 0xb5: - case 0xb6: - case 0xb7: - case 0xb8: - case 0xb9: - case 0xbc: - this.t進行描画・チップ・空打ち音設定・ドラム( configIni, ref dTX, ref pChip ); - break; - #endregion - #region [ ba: 空打ち音設定(ギター) ] - case 0xba: // 空打ち音設定(ギター) - if ( !pChip.bHit && ( pChip.nバーからの距離dot.Guitar < 0 ) ) - { - pChip.bHit = true; - this.r現在の空うちギターChip = pChip; - pChip.nチャンネル番号 = 0x20; - } - break; - #endregion - #region [ bb: 空打ち音設定(ベース) ] - case 0xbb: // 空打ち音設定(ベース) - if ( !pChip.bHit && ( pChip.nバーからの距離dot.Bass < 0 ) ) - { - pChip.bHit = true; - this.r現在の空うちベースChip = pChip; - pChip.nチャンネル番号 = 0xA0; - } - break; - #endregion - #region [ c4, c7, d5-d9, e0: BGA画像入れ替え ] - case 0xc4: - case 0xc7: - case 0xd5: - case 0xd6: // BGA画像入れ替え - case 0xd7: - case 0xd8: - case 0xd9: - case 0xe0: - if ( !pChip.bHit && ( pChip.nバーからの距離dot.Drums < 0 ) ) - { - pChip.bHit = true; - if ( ( configIni.bBGA有効 && ( pChip.eBGA種別 == EBGA種別.BMP ) ) || ( pChip.eBGA種別 == EBGA種別.BMPTEX ) ) - { - for ( int i = 0; i < 8; i++ ) - { - if ( this.nBGAスコープチャンネルマップ[ 0, i ] == pChip.nチャンネル番号 ) - { - this.actBGA.ChangeScope( this.nBGAスコープチャンネルマップ[ 1, i ], pChip.rBMP, pChip.rBMPTEX ); - } - } - } - } - break; - #endregion - #region [ da: ミキサーへチップ音追加 ] - case 0xDA: - if ( !pChip.bHit && ( pChip.nバーからの距離dot.Drums < 0 ) ) + EPart pp = p[pChip.eチャンネル番号 - EChannel.SE24]; + + // if ( pp == E楽器パート.DRUMS ) { // pChip.nチャンネル番号= ..... HHとか、ドラムの場合は変える。 + // // HC CY RD LC + // int[] ch = { 0x11, 0x16, 0x19, 0x1A }; + // pChip.nチャンネル番号 = ch[ pChip.nチャンネル番号 - 0x84 ]; + // } + this.tサウンド再生(pChip, CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻 + pChip.n発声時刻ms, pp, CDTXMania.Instance.DTX.nモニタを考慮した音量(pp)); + } + + else if (pChip.bBass可視チップ) + { + this.t進行描画_チップ_ギターベース(ref pChip, EPart.Bass); + } + else if (pChip[EChannel.Bass_Wailing]) + { + this.t進行描画_チップ_ウェイリング(ref pChip); + } + else if (pChip[EChannel.Bass_WailingSound] && !pChip.bHit && (pChip.nバーからの距離dot.Bass < 0)) + { + pChip.bHit = true; + this.r現在の歓声Chip.Bass = pChip; + } + else if (pChip[EChannel.Guitar_NoChip] && !pChip.bHit && (pChip.nバーからの距離dot.Guitar < 0)) + { + pChip.bHit = true; + this.r現在の空うちギターChip = pChip; + pChip.ConvertGBNoChip(); + } + else if (pChip[EChannel.Bass_NoChip] && !pChip.bHit && (pChip.nバーからの距離dot.Bass < 0)) + { + pChip.bHit = true; + this.r現在の空うちベースChip = pChip; + pChip.ConvertGBNoChip(); + } + else if (pChip.bBGALayerSwap && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0)) + { + pChip.bHit = true; + if ((CDTXMania.Instance.ConfigIni.bBGA && (pChip.eBGA種別 == EBGAType.BMP)) || (pChip.eBGA種別 == EBGAType.BMPTEX)) + { + this.actBGA.ChangeScope(pChip); + } + } + else if (pChip[EChannel.MixerAdd] && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0)) + { + //Debug.WriteLine( "[DA(AddMixer)] BAR=" + pChip.n発声位置 / 384 + " ch=" + pChip.nチャンネル番号.ToString( "x2" ) + ", wav=" + pChip.n整数値.ToString( "x2" ) + ", time=" + pChip.n発声時刻ms ); + pChip.bHit = true; + if (CDTXMania.Instance.DTX.listWAV.ContainsKey(pChip.n整数値_内部番号)) // 参照が遠いので後日最適化する + { + CDTX.CWAV wc = CDTXMania.Instance.DTX.listWAV[pChip.n整数値_内部番号]; + //Debug.Write( "[AddMixer] BAR=" + pChip.n発声位置 / 384 + ", wav=" + Path.GetFileName( wc.strファイル名 ) + ", time=" + pChip.n発声時刻ms ); + + for (int i = 0; i < CDTXMania.Instance.ConfigIni.nPolyphonicSounds; i++) { -//Debug.WriteLine( "[DA(AddMixer)] BAR=" + pChip.n発声位置 / 384 + " ch=" + pChip.nチャンネル番号.ToString( "x2" ) + ", wav=" + pChip.n整数値.ToString( "x2" ) + ", time=" + pChip.n発声時刻ms ); - pChip.bHit = true; - if ( listWAV.ContainsKey( pChip.n整数値・内部番号 ) ) // 参照が遠いので後日最適化する + if (wc.rSound[i] != null) { - CDTX.CWAV wc = listWAV[ pChip.n整数値・内部番号 ]; - for ( int i = 0; i < nPolyphonicSounds; i++ ) - { - if ( wc.rSound[ i ] != null ) - { - //CDTXMania.Sound管理.AddMixer( wc.rSound[ i ] ); - AddMixer( wc.rSound[ i ] ); - } - } + //CDTXMania.Instance.Sound管理.AddMixer( wc.rSound[ i ] ); + AddMixer(wc.rSound[i], pChip.b演奏終了後も再生が続くチップである); } + //else + //{ + // Debug.WriteLine( ", nPoly=" + i + ", Mix=" + CDTXMania.Instance.Sound管理.GetMixingStreams() ); + // break; + //} + //if ( i == nPolyphonicSounds - 1 ) + //{ + // Debug.WriteLine( ", nPoly=" + nPolyphonicSounds + ", Mix=" + CDTXMania.Instance.Sound管理.GetMixingStreams() ); + //} } - break; - #endregion - #region [ db: ミキサーからチップ音削除 ] - case 0xDB: - if ( !pChip.bHit && ( pChip.nバーからの距離dot.Drums < 0 ) ) + } + } + else if (pChip[EChannel.MixerRemove] && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0)) + { + //Debug.WriteLine( "[DB(RemoveMixer)] BAR=" + pChip.n発声位置 / 384 + " ch=" + pChip.nチャンネル番号.ToString( "x2" ) + ", wav=" + pChip.n整数値.ToString( "x2" ) + ", time=" + pChip.n発声時刻ms ); + pChip.bHit = true; + if (CDTXMania.Instance.DTX.listWAV.ContainsKey(pChip.n整数値_内部番号)) // 参照が遠いので後日最適化する + { + CDTX.CWAV wc = CDTXMania.Instance.DTX.listWAV[pChip.n整数値_内部番号]; + //Debug.Write( "[DelMixer] BAR=" + pChip.n発声位置 / 384 + ", wav=" + Path.GetFileName( wc.strファイル名 ) + ", time=" + pChip.n発声時刻ms ); + for (int i = 0; i < CDTXMania.Instance.ConfigIni.nPolyphonicSounds; i++) { -//Debug.WriteLine( "[DB(RemoveMixer)] BAR=" + pChip.n発声位置 / 384 + " ch=" + pChip.nチャンネル番号.ToString( "x2" ) + ", wav=" + pChip.n整数値.ToString( "x2" ) + ", time=" + pChip.n発声時刻ms ); - pChip.bHit = true; - if ( listWAV.ContainsKey( pChip.n整数値・内部番号 ) ) // 参照が遠いので後日最適化する + if (wc.rSound[i] != null) { - CDTX.CWAV wc = listWAV[ pChip.n整数値・内部番号 ]; - for ( int i = 0; i < nPolyphonicSounds; i++ ) - { - if ( wc.rSound[ i ] != null ) - { - //CDTXMania.Sound管理.RemoveMixer( wc.rSound[ i ] ); - RemoveMixer( wc.rSound[ i ] ); - } - } + //CDTXMania.Instance.Sound管理.RemoveMixer( wc.rSound[ i ] ); + if (!wc.rSound[i].b演奏終了後も再生が続くチップである) // #32248 2013.10.16 yyagi + { // DTX終了後も再生が続くチップの0xDB登録をなくすことはできず。 + RemoveMixer(wc.rSound[i]); // (ミキサー解除のタイミングが遅延する場合の対応が面倒なので。) + } // そこで、代わりにフラグをチェックしてミキサー削除ロジックへの遷移をカットする。 } + //else + //{ + // Debug.WriteLine( ", nPoly=" + i + ", Mix=" + CDTXMania.Instance.Sound管理.GetMixingStreams() ); + // break; + //} + //if ( i == nPolyphonicSounds - 1 ) + //{ + // Debug.WriteLine( ", nPoly=" + nPolyphonicSounds + ", Mix=" + CDTXMania.Instance.Sound管理.GetMixingStreams() ); + //} } - break; - #endregion - #region [ その他(未定義) ] - default: - if ( !pChip.bHit && ( pChip.nバーからの距離dot.Drums < 0 ) ) + } + } + else if ( pChip[ EChannel.Click ] && !pChip.bHit && ( pChip.nバーからの距離dot.Drums < 0 ) ) + { + pChip.bHit = true; + if ( CDTXMania.Instance.ConfigIni.eClickType != EClickType.Off ) + { + switch (pChip.n整数値) { - pChip.bHit = true; + case 1: + CDTXMania.Instance.Skin.soundClickHigh.t再生する(); + break; + case 2: + CDTXMania.Instance.Skin.soundClickLow.t再生する(); + break; } - break; - #endregion + } + } + else if ( !pChip.bHit && ( pChip.nバーからの距離dot.Drums < 0 ) ) + { + // other chips + pChip.bHit = true; } } return false; } - private bool bCheckAutoPlay( CDTX.CChip pChip ) + public void t再読込() { - bool bPChipIsAutoPlay = false; - bool bGtBsR = ( ( pChip.nチャンネル番号 & 4 ) > 0 ); - bool bGtBsG = ( ( pChip.nチャンネル番号 & 2 ) > 0 ); - bool bGtBsB = ( ( pChip.nチャンネル番号 & 1 ) > 0 ); - bool bGtBsW = ( ( pChip.nチャンネル番号 & 0x0F ) == 0x08 ); - bool bGtBsO = ( ( pChip.nチャンネル番号 & 0x0F ) == 0x00 ); - //if ( ( - // ( ( pChip.e楽器パート == E楽器パート.DRUMS ) && bIsAutoPlay[ this.nチャンネル0Atoレーン07[ pChip.nチャンネル番号 - 0x11 ] ] ) || - // ( ( pChip.e楽器パート == E楽器パート.GUITAR ) && bIsAutoPlay.Guitar ) ) || - // ( ( pChip.e楽器パート == E楽器パート.BASS ) && bIsAutoPlay.Bass ) - // ) - //// if ((pChip.e楽器パート == E楽器パート.DRUMS) && bIsAutoPlay[this.nチャンネル0Atoレーン07[pChip.nチャンネル番号 - 0x11]]) - //{ - // bPChipIsAutoPlay = true; - //} - if ( pChip.e楽器パート == E楽器パート.DRUMS ) - { - if ( bIsAutoPlay[ this.nチャンネル0Atoレーン07[ pChip.nチャンネル番号 - 0x11 ] ] ) - { - bPChipIsAutoPlay = true; - } - } - else if ( pChip.e楽器パート == E楽器パート.GUITAR ) + CDTXMania.Instance.DTX.t全チップの再生停止とミキサーからの削除(); + this.eフェードアウト完了時の戻り値 = E演奏画面の戻り値.再読込_再演奏; + base.eフェーズID = CStage.Eフェーズ.演奏_再読込; + this.bPAUSE = false; + + // #34048 2014.7.16 yyagi + #region [ 読み込み画面に遷移する前に、設定変更した可能性があるパラメータをConfigIniクラスに書き戻す ] + for (EPart i = EPart.Drums; i <= EPart.Bass; i++) { - //Trace.TraceInformation( "chip:{0}{1}{2} ", bGtBsR, bGtBsG, bGtBsB ); - //Trace.TraceInformation( "auto:{0}{1}{2} ", bIsAutoPlay[ (int) Eレーン.GtR ], bIsAutoPlay[ (int) Eレーン.GtG ], bIsAutoPlay[ (int) Eレーン.GtB ]); - bPChipIsAutoPlay = true; - if ( bIsAutoPlay[ (int) Eレーン.GtPick ] == false ) bPChipIsAutoPlay = false; - else - { - if ( bGtBsR == true && bIsAutoPlay[ (int) Eレーン.GtR ] == false ) bPChipIsAutoPlay = false; - else if ( bGtBsG == true && bIsAutoPlay[ (int) Eレーン.GtG ] == false ) bPChipIsAutoPlay = false; - else if ( bGtBsB == true && bIsAutoPlay[ (int) Eレーン.GtB ] == false ) bPChipIsAutoPlay = false; - else if ( bGtBsW == true && bIsAutoPlay[ (int) Eレーン.GtW ] == false ) bPChipIsAutoPlay = false; - else if ( bGtBsO == true && - ( bIsAutoPlay[ (int) Eレーン.GtR ] == false || bIsAutoPlay[ (int) Eレーン.GtG ] == false || bIsAutoPlay[ (int) Eレーン.GtB ] == false ) ) - bPChipIsAutoPlay = false; - } - //Trace.TraceInformation( "{0:x2}: {1}", pChip.nチャンネル番号, bPChipIsAutoPlay.ToString() ); + CDTXMania.Instance.ConfigIni.nViewerScrollSpeed[i] = CDTXMania.Instance.ConfigIni.nScrollSpeed[i]; } - else if ( pChip.e楽器パート == E楽器パート.BASS ) + CDTXMania.Instance.ConfigIni.bDebugInfo = CDTXMania.Instance.ConfigIni.bViewerShowDebugStatus; + #endregion + } + + public void t停止() + { + CDTXMania.Instance.DTX.t全チップの再生停止とミキサーからの削除(); + this.actAVI.Stop(); + this.actBGA.Stop(); + this.actPanel.Stop(); // PANEL表示停止 + CDTXMania.Instance.Timer.t一時停止(); // 再生時刻カウンタ停止 + + this.n現在のトップChip = CDTXMania.Instance.DTX.listChip.Count - 1; // 終端にシーク + + // 自分自身のOn活性化()相当の処理もすべき。 + } + + /// + /// 演奏位置を変更する。 + /// + /// 演奏開始小節番号 + /// 演奏済み情報(bHit)をクリアするかどうか + public void t演奏位置の変更(int nStartBar) + { + // まず全サウンドオフにする + CDTXMania.Instance.DTX.t全チップの再生停止(); + this.actAVI.Stop(); + this.actBGA.Stop(); + + #region [ 再生開始小節の変更 ] + // +1が必要 + nStartBar++; + + #region [ 演奏済みフラグのついたChipをリセットする ] + for (int i = 0; i < CDTXMania.Instance.DTX.listChip.Count; i++) { - bPChipIsAutoPlay = true; - if ( bIsAutoPlay[ (int) Eレーン.BsPick ] == false ) bPChipIsAutoPlay = false; - else + CChip pChip = CDTXMania.Instance.DTX.listChip[i]; + if (pChip.bHit) { - if ( bGtBsR == true && bIsAutoPlay[ (int) Eレーン.BsR ] == false ) bPChipIsAutoPlay = false; - else if ( bGtBsG == true && bIsAutoPlay[ (int) Eレーン.BsG ] == false ) bPChipIsAutoPlay = false; - else if ( bGtBsB == true && bIsAutoPlay[ (int) Eレーン.BsB ] == false ) bPChipIsAutoPlay = false; - else if ( bGtBsW == true && bIsAutoPlay[ (int) Eレーン.BsW ] == false ) bPChipIsAutoPlay = false; - else if ( bGtBsO == true && - ( bIsAutoPlay[ (int) Eレーン.BsR ] == false || bIsAutoPlay[ (int) Eレーン.BsG ] == false || bIsAutoPlay[ (int) Eレーン.BsB ] == false ) ) - bPChipIsAutoPlay = false; + CChip p = (CChip)pChip.Clone(); + p.bHit = false; + CDTXMania.Instance.DTX.listChip[i] = p; } } - return bPChipIsAutoPlay; - } - - protected abstract void t進行描画・チップ・ドラムス( CConfigIni configIni, ref CDTX dTX, ref CDTX.CChip pChip ); - //protected abstract void t進行描画・チップ・ギター( CConfigIni configIni, ref CDTX dTX, ref CDTX.CChip pChip ); - protected abstract void t進行描画・チップ・ギターベース( CConfigIni configIni, ref CDTX dTX, ref CDTX.CChip pChip, E楽器パート inst ); + #endregion - protected void t進行描画・チップ・ギターベース( CConfigIni configIni, ref CDTX dTX, ref CDTX.CChip pChip, E楽器パート inst, - int barYNormal, int barYReverse, int showRangeY0, int showRangeY1, int openXg, int openXb, - int rectOpenOffsetX, int rectOpenOffsetY, int openChipWidth, int chipHeight, - int chipWidth, int guitarNormalX, int guitarLeftyX, int bassNormalX, int bassLeftyX, int drawDeltaX, int chipTexDeltaX ) - { - int instIndex = (int) inst; - if ( configIni.bGuitar有効 ) + #region [ 処理を開始するチップの特定 ] + //for ( int i = this.n現在のトップChip; i < CDTXMania.Instance.DTX.listChip.Count; i++ ) + bool bSuccessSeek = false; + for (int i = 0; i < CDTXMania.Instance.DTX.listChip.Count; i++) { - #region [ Hidden/Sudden処理 ] - if ( configIni.bSudden[ instIndex ] ) + CChip pChip = CDTXMania.Instance.DTX.listChip[i]; + if (pChip.n発声位置 < 384 * nStartBar) { - pChip.b可視 = pChip.nバーからの距離dot[ instIndex ] < 200; + continue; } - if ( configIni.bHidden[ instIndex ] && ( pChip.nバーからの距離dot[ instIndex ] < 100 ) ) + else { - pChip.b可視 = false; + bSuccessSeek = true; + this.n現在のトップChip = i; + break; } - #endregion + } + if (!bSuccessSeek) + { + // this.n現在のトップChip = CDTXMania.Instance.DTX.listChip.Count - 1; + this.n現在のトップChip = 0; // 対象小節が存在しないなら、最初から再生 + } + #endregion + + #region [ 演奏開始の発声時刻msを取得し、タイマに設定 ] + int nStartTime = CDTXMania.Instance.DTX.listChip[this.n現在のトップChip].n発声時刻ms; + + CSound管理.rc演奏用タイマ.tリセット(); // これでPAUSE解除されるので、次のPAUSEチェックは不要 + //if ( !this.bPAUSE ) + //{ + CSound管理.rc演奏用タイマ.t一時停止(); + //} + CSound管理.rc演奏用タイマ.n現在時刻 = nStartTime; + #endregion + + List pausedCSound = new List(); - bool bChipHasR = ( ( pChip.nチャンネル番号 & 4 ) > 0 ); - bool bChipHasG = ( ( pChip.nチャンネル番号 & 2 ) > 0 ); - bool bChipHasB = ( ( pChip.nチャンネル番号 & 1 ) > 0 ); - bool bChipHasW = ( ( pChip.nチャンネル番号 & 0x0F ) == 0x08 ); - bool bChipIsO = ( ( pChip.nチャンネル番号 & 0x0F ) == 0x00 ); + #region [ BGMやギターなど、演奏開始のタイミングで再生がかかっているサウンドのの途中再生開始 ] // (CDTXのt入力・行解析・チップ配置()で小節番号が+1されているのを削っておくこと) + for (int i = this.n現在のトップChip; i >= 0; i--) + { + CChip pChip = CDTXMania.Instance.DTX.listChip[i]; + int nDuration = pChip.GetDuration(); - #region [ chip描画 ] - int OPEN = ( inst == E楽器パート.GUITAR ) ? 0x20 : 0xA0; - if ( !pChip.bHit && pChip.b可視 ) + if ((pChip.n発声時刻ms + nDuration > 0) && (pChip.n発声時刻ms <= nStartTime) && (nStartTime <= pChip.n発声時刻ms + nDuration)) { - int y = configIni.bReverse[ instIndex ] ? ( barYReverse - pChip.nバーからの距離dot[ instIndex ] ) : ( barYNormal + pChip.nバーからの距離dot[ instIndex ] ); - if ( ( showRangeY0 < y ) && ( y < showRangeY1 ) ) + if (pChip.bWAVを使うチャンネルである && !pChip.b空打ちチップである) // wav系チャンネル、且つ、空打ちチップではない { - if ( this.txチップ != null ) - { - int nアニメカウンタ現在の値 = this.ctチップ模様アニメ[ instIndex ].n現在の値; - if ( pChip.nチャンネル番号 == OPEN ) - { - int xo = ( inst == E楽器パート.GUITAR ) ? openXg : openXb; - this.txチップ.t2D描画( CDTXMania.app.Device, xo, y - 2, new Rectangle( rectOpenOffsetX, rectOpenOffsetY + ( ( nアニメカウンタ現在の値 % 5 ) * chipHeight ), openChipWidth, chipHeight ) ); - } - Rectangle rc = new Rectangle( rectOpenOffsetX, nアニメカウンタ現在の値 * chipHeight, chipWidth, chipHeight ); - int x; - if ( inst == E楽器パート.GUITAR ) - { - x = ( configIni.bLeft.Guitar ) ? guitarLeftyX : guitarNormalX; - } - else - { - x = ( configIni.bLeft.Bass ) ? bassLeftyX : bassNormalX; - } - int deltaX = ( configIni.bLeft[ instIndex ] ) ? -drawDeltaX : +drawDeltaX; + CDTX.CWAV wc; + bool b = CDTXMania.Instance.DTX.listWAV.TryGetValue(pChip.n整数値_内部番号, out wc); + if (!b) continue; -//Trace.TraceInformation( "chip={0:x2}, E楽器パート={1}, x={2}", pChip.nチャンネル番号, inst, x ); - if ( bChipHasR ) - { - this.txチップ.t2D描画( CDTXMania.app.Device, x, y - chipHeight / 2, rc ); - } - rc.X += chipTexDeltaX; - x += deltaX; - if ( bChipHasG ) - { - this.txチップ.t2D描画( CDTXMania.app.Device, x, y - chipHeight / 2, rc ); - } - rc.X += chipTexDeltaX; - x += deltaX; - if ( bChipHasB ) + if ((wc.bIsBGMSound && CDTXMania.Instance.ConfigIni.bBGMPlay) || (!wc.bIsBGMSound)) + { + CDTXMania.Instance.DTX.tチップの再生(pChip, CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻 + pChip.n発声時刻ms, CDTXMania.Instance.DTX.nモニタを考慮した音量(EPart.Unknown)); + #region [ PAUSEする ] + int j = wc.n現在再生中のサウンド番号; + if (wc.rSound[j] != null) { - this.txチップ.t2D描画( CDTXMania.app.Device, x, y - chipHeight / 2, rc ); + wc.rSound[j].t再生を一時停止する(); + wc.rSound[j].t再生位置を変更する(nStartTime - pChip.n発声時刻ms); + pausedCSound.Add(wc.rSound[j]); } + #endregion } } } - #endregion - //if ( ( configIni.bAutoPlay.Guitar && !pChip.bHit ) && ( pChip.nバーからの距離dot.Guitar < 0 ) ) - if ( ( !pChip.bHit ) && ( pChip.nバーからの距離dot[ instIndex ] < 0 ) ) - { - int lo = ( inst == E楽器パート.GUITAR ) ? 0 : 3; // lane offset - bool autoR = ( inst == E楽器パート.GUITAR ) ? bIsAutoPlay.GtR : bIsAutoPlay.BsR; - bool autoG = ( inst == E楽器パート.GUITAR ) ? bIsAutoPlay.GtG : bIsAutoPlay.BsG; - bool autoB = ( inst == E楽器パート.GUITAR ) ? bIsAutoPlay.GtB : bIsAutoPlay.BsB; - bool autoPick = ( inst == E楽器パート.GUITAR ) ? bIsAutoPlay.GtPick : bIsAutoPlay.BsPick; - bool pushingR = CDTXMania.Pad.b押されている( inst, Eパッド.R ); - bool pushingG = CDTXMania.Pad.b押されている( inst, Eパッド.G ); - bool pushingB = CDTXMania.Pad.b押されている( inst, Eパッド.B ); + } + #endregion + #region [ 演奏開始時点で既に表示されているBGAとAVIの、シークと再生 ] + this.actBGA.SkipStart(nStartTime); + this.actAVI.SkipStart(nStartTime); + #endregion + #region [ PAUSEしていたサウンドを一斉に再生再開する(ただしタイマを止めているので、ここではまだ再生開始しない) ] + foreach (CSound cs in pausedCSound) + { + cs.tサウンドを再生する(); + } + pausedCSound.Clear(); + pausedCSound = null; + #endregion + #region [ タイマを再開して、PAUSEから復帰する ] + CSound管理.rc演奏用タイマ.n現在時刻 = nStartTime; + CDTXMania.Instance.Timer.tリセット(); // これでPAUSE解除されるので、3行先の再開()は不要 + CDTXMania.Instance.Timer.n現在時刻 = nStartTime; // Debug表示のTime: 表記を正しくするために必要 + CSound管理.rc演奏用タイマ.t再開(); + //CDTXMania.Instance.Timer.t再開(); + this.bPAUSE = false; // システムがPAUSE状態だったら、強制解除 + this.actPanel.Start(); + #endregion + #endregion + } - #region [ Chip Fire effects ] - bool bSuccessOPEN = bChipIsO && ( autoR || !pushingR ) && ( autoG || !pushingG ) && ( autoB || !pushingB ); - if ( ( bChipHasR && ( autoR || pushingR ) && autoPick ) || bSuccessOPEN ) - { - this.actChipFireGB.Start( 0 + lo ); - } - if ( ( bChipHasG && ( autoG || pushingG ) && autoPick ) || bSuccessOPEN ) - { - this.actChipFireGB.Start( 1 + lo ); - } - if ( ( bChipHasB && ( autoB || pushingB ) && autoPick ) || bSuccessOPEN ) - { - this.actChipFireGB.Start( 2 + lo ); - } - #endregion - if ( autoPick ) - { - bool bMiss = true; - if ( bChipHasR == autoR && bChipHasG == autoG && bChipHasB == autoB ) // autoレーンとチップレーン一致時はOK - { // この条件を加えないと、同時に非autoレーンを押下している時にNGとなってしまう。 - bMiss = false; - } - else if ( ( autoR || ( bChipHasR == pushingR ) ) && ( autoG || ( bChipHasG == pushingG ) ) && ( autoB || ( bChipHasB == pushingB ) ) ) - // ( bChipHasR == ( pushingR | autoR ) ) && ( bChipHasG == ( pushingG | autoG ) ) && ( bChipHasB == ( pushingB | autoB ) ) ) - { - bMiss = false; - } - else if ( ( ( bChipIsO == true ) && ( !pushingR | autoR ) && ( !pushingG | autoG ) && ( !pushingB | autoB ) ) ) // OPEN時 - { - bMiss = false; - } - pChip.bHit = true; - this.tサウンド再生( pChip, CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻 + pChip.n発声時刻ms, inst, dTX.nモニタを考慮した音量( inst ), false, bMiss ); - this.r次にくるギターChip = null; - if ( !bMiss ) - { - this.tチップのヒット処理( pChip.n発声時刻ms, pChip ); - } - else - { - pChip.nLag = 0; // tチップのヒット処理()の引数最後がfalseの時はpChip.nLagを計算しないため、ここでAutoPickかつMissのLag=0を代入 - this.tチップのヒット処理( pChip.n発声時刻ms, pChip, false ); - } - int chWailingChip = ( inst == E楽器パート.GUITAR ) ? 0x28 : 0xA8; - CDTX.CChip item = this.r指定時刻に一番近い未ヒットChip( pChip.n発声時刻ms, chWailingChip, this.nInputAdjustTimeMs[ instIndex ], 140 ); - if ( item != null && !bMiss ) - { - this.queWailing[ instIndex ].Enqueue( item ); - } - } - } - return; - } // end of "if configIni.bGuitar有効" - if ( !pChip.bHit && ( pChip.nバーからの距離dot[ instIndex ] < 0 ) ) // Guitar/Bass無効の場合は、自動演奏する + + /// + /// DTXV用の設定をする。(全AUTOなど) + /// 元の設定のバックアップなどはしないので、あとでConfig.iniを上書き保存しないこと。 + /// + protected void tDTXV用の設定() + { + for (EPad i = EPad.Min; i < EPad.Max; ++i) { - pChip.bHit = true; - this.tサウンド再生( pChip, CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻 + pChip.n発声時刻ms, inst, dTX.nモニタを考慮した音量( inst ) ); + CDTXMania.Instance.ConfigIni.bAutoPlay[i].Value = true; + } + CDTXMania.Instance.ConfigIni.bAVI.Value = true; + CDTXMania.Instance.ConfigIni.bBGA.Value = true; + for (EPart i = EPart.Drums; i <= EPart.Bass; i++) + { + CDTXMania.Instance.ConfigIni.bGraph[i].Value = false; + CDTXMania.Instance.ConfigIni.eSudHidInv[i].Value = ESudHidInv.Off; + CDTXMania.Instance.ConfigIni.bLight[i].Value = false; + CDTXMania.Instance.ConfigIni.bReverse[i].Value = false; + CDTXMania.Instance.ConfigIni.eRandom[i].Value = ERandom.Off; + CDTXMania.Instance.ConfigIni.nMinComboDisp[i].Value = 65535; + CDTXMania.Instance.ConfigIni.bDisplayJudge[i].Value = false; + CDTXMania.Instance.ConfigIni.bDisplayCombo[i].Value = false; } + CDTXMania.Instance.ConfigIni.eDark.Value = EDark.Off; + CDTXMania.Instance.ConfigIni.bDebugInfo.Value = CDTXMania.Instance.ConfigIni.bViewerShowDebugStatus; + CDTXMania.Instance.ConfigIni.bFillin.Value = true; + CDTXMania.Instance.ConfigIni.bScoreIni.Value = false; + CDTXMania.Instance.ConfigIni.bStageFailed.Value = false; + CDTXMania.Instance.ConfigIni.bTight.Value = false; + CDTXMania.Instance.ConfigIni.bStoicMode.Value = false; + CDTXMania.Instance.ConfigIni.bDrumsHitSound.Value = true; + CDTXMania.Instance.ConfigIni.bBGMPlay.Value = true; + CDTXMania.Instance.ConfigIni.nRisky.Value = 0; + CDTXMania.Instance.ConfigIni.nShowLagType.Value = EShowLagType.Off; } - - protected virtual void t進行描画・チップ・ギターベース・ウェイリング( CConfigIni configIni, ref CDTX dTX, ref CDTX.CChip pChip, E楽器パート inst ) + private void t進行描画_チップ_ウェイリング(ref CChip pChip) { - int indexInst = (int) inst; - if ( configIni.bGuitar有効 ) + if (CDTXMania.Instance.ConfigIni.bGuitar有効) { - #region [ Sudden/Hidden処理 ] - if ( configIni.bSudden[indexInst] ) + EPart indexInst = pChip.bGuitar可視チップ_Wailing含む ? EPart.Guitar : EPart.Bass; + #region [ Sud Hid Inv 処理 ] + if ( + CDTXMania.Instance.ConfigIni.eSudHidInv[indexInst] == ESudHidInv.FullInv || + CDTXMania.Instance.ConfigIni.eSudHidInv[indexInst] == ESudHidInv.SemiInv) { - pChip.b可視 = pChip.nバーからの距離dot[indexInst] < 200; + cInvisibleChip.SetInvisibleStatus(ref pChip); } - if ( configIni.bHidden[indexInst] && ( pChip.nバーからの距離dot[indexInst] < 100 ) ) + else { - pChip.b可視 = false; + if (CDTXMania.Instance.ConfigIni.eSudHidInv[indexInst] == ESudHidInv.Sudden || + CDTXMania.Instance.ConfigIni.eSudHidInv[indexInst] == ESudHidInv.SudHid) + { + pChip.b可視 = (pChip.nバーからの距離dot[indexInst] < CDTXMania.Instance.ConfigIni.nSuddenFrom[indexInst]); + } + if (CDTXMania.Instance.ConfigIni.eSudHidInv[indexInst] == ESudHidInv.Hidden || + CDTXMania.Instance.ConfigIni.eSudHidInv[indexInst] == ESudHidInv.SudHid) + { + pChip.b可視 = pChip.nバーからの距離dot[indexInst] >= CDTXMania.Instance.ConfigIni.nHiddenFrom[indexInst]; + } } #endregion - // - // ここにチップ更新処理が入る(overrideで入れる)。といっても座標とチップサイズが違うだけで処理はまるまる同じ。 - // - if ( !pChip.bHit && ( pChip.nバーからの距離dot[indexInst] < 0 ) ) + cWailingChip[(int)indexInst].t進行描画_チップ_ウェイリング(ref pChip, ref txチップGB, ref ctWailingチップ模様アニメ); + + if (!pChip.bHit && (pChip.nバーからの距離dot[indexInst] < 0)) { - if ( pChip.nバーからの距離dot[indexInst] < -234 ) // #25253 2011.5.29 yyagi: Don't set pChip.bHit=true for wailing at once. It need to 1sec-delay (234pix per 1sec). + if (pChip.nバーからの距離dot[indexInst] < -234 * Scale.Y) // #25253 2011.5.29 yyagi: Don't set pChip.bHit=true for wailing at once. It need to 1sec-delay (234pix per 1sec). { pChip.bHit = true; } - bool autoW = ( inst == E楽器パート.GUITAR ) ? configIni.bAutoPlay.GtW : configIni.bAutoPlay.BsW; - //if ( configIni.bAutoPlay[ ((int) Eレーン.Guitar - 1) + indexInst ] ) // このような、バグの入りやすい書き方(GT/BSのindex値が他と異なる)はいずれ見直したい - if ( autoW ) + bool autoW = (indexInst == EPart.Guitar) ? CDTXMania.Instance.ConfigIni.bAutoPlay.GtWail : CDTXMania.Instance.ConfigIni.bAutoPlay.BsWail; + if (autoW) { - // pChip.bHit = true; // #25253 2011.5.29 yyagi: Set pChip.bHit=true if autoplay. - // this.actWailingBonus.Start( inst, this.r現在の歓声Chip[indexInst] ); - // #23886 2012.5.22 yyagi; To support auto Wailing; Don't do wailing for ALL wailing chips. Do wailing for queued wailing chip. - // wailing chips are queued when 1) manually wailing and not missed at that time 2) AutoWailing=ON and not missed at that time + // #25253 2011.5.29 yyagi: Set pChip.bHit=true if autoplay. + // pChip.bHit = true; + // this.actWailingBonus.Start( inst, this.r現在の歓声Chip[indexInst] ); + // #23886 2012.5.22 yyagi; To support auto Wailing; Don't do wailing for ALL wailing chips. Do wailing for queued wailing chip. + // wailing chips are queued when 1) manually wailing and not missed at that time 2) AutoWailing=ON and not missed at that time long nTimeStamp_Wailed = pChip.n発声時刻ms + CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻; - DoWailingFromQueue( inst, nTimeStamp_Wailed, autoW ); + DoWailingFromQueue(indexInst, nTimeStamp_Wailed, autoW); } + cInvisibleChip.StartSemiInvisible(indexInst); } return; } pChip.bHit = true; } - protected virtual void t進行描画・チップ・ギター・ウェイリング( CConfigIni configIni, ref CDTX dTX, ref CDTX.CChip pChip ) - { - t進行描画・チップ・ギターベース・ウェイリング( configIni, ref dTX, ref pChip, E楽器パート.GUITAR ); - } - protected abstract void t進行描画・チップ・フィルイン( CConfigIni configIni, ref CDTX dTX, ref CDTX.CChip pChip ); - protected abstract void t進行描画・チップ・小節線( CConfigIni configIni, ref CDTX dTX, ref CDTX.CChip pChip ); - //protected abstract void t進行描画・チップ・ベース( CConfigIni configIni, ref CDTX dTX, ref CDTX.CChip pChip ); - protected virtual void t進行描画・チップ・ベース・ウェイリング( CConfigIni configIni, ref CDTX dTX, ref CDTX.CChip pChip ) - { - t進行描画・チップ・ギターベース・ウェイリング( configIni, ref dTX, ref pChip, E楽器パート.BASS ); - } - protected abstract void t進行描画・チップ・空打ち音設定・ドラム( CConfigIni configIni, ref CDTX dTX, ref CDTX.CChip pChip ); - protected void t進行描画・チップアニメ() + + protected void t進行描画_チップアニメ() { - for ( int i = 0; i < 3; i++ ) // 0=drums, 1=guitar, 2=bass + for (EPart i = EPart.Drums; i <= EPart.Bass; i++) // 0=drums, 1=guitar, 2=bass { - if ( this.ctチップ模様アニメ[ i ] != null ) + if (this.ctチップ模様アニメ[i] != null) { - this.ctチップ模様アニメ[ i ].t進行Loop(); + this.ctチップ模様アニメ[i].t進行Loop(); } } - if ( this.ctWailingチップ模様アニメ != null ) + if (this.ctWailingチップ模様アニメ != null) { this.ctWailingチップ模様アニメ.t進行Loop(); } } - protected bool t進行描画・フェードイン・アウト() + protected bool t進行描画_フェードイン_アウト() { - switch ( base.eフェーズID ) + switch (base.eフェーズID) { case CStage.Eフェーズ.共通_フェードイン: - if ( this.actFI.On進行描画() != 0 ) + if (this.actFI.On進行描画() != 0) { base.eフェーズID = CStage.Eフェーズ.共通_通常状態; } @@ -2437,367 +3452,412 @@ namespace DTXMania case CStage.Eフェーズ.共通_フェードアウト: case CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト: - if ( this.actFO.On進行描画() != 0 ) + if (this.actFO.On進行描画() != 0) { return true; } break; case CStage.Eフェーズ.演奏_STAGE_CLEAR_フェードアウト: - if ( this.actFOClear.On進行描画() == 0 ) + if (this.actFOClear.On進行描画() == 0) { break; } return true; - + } return false; } - protected void t進行描画・レーンフラッシュD() - { - if ( ( CDTXMania.ConfigIni.eDark == Eダークモード.OFF ) && ( base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED ) && ( base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト ) ) - { - this.actLaneFlushD.On進行描画(); - } - } - protected void t進行描画・レーンフラッシュGB() - { - if ( ( CDTXMania.ConfigIni.eDark == Eダークモード.OFF ) && CDTXMania.ConfigIni.bGuitar有効 ) - { - this.actLaneFlushGB.On進行描画(); - } - } - protected abstract void t進行描画・演奏情報(); - protected void t進行描画・演奏情報(int x, int y) + + protected virtual void t入力処理_ギターベース(EPart inst) { - if ( !CDTXMania.ConfigIni.b演奏情報を表示しない ) + #region [ スクロール速度変更 ] + int scrollSpeed = CDTXMania.Instance.ConfigIni.nScrollSpeed[inst]; + bool scrollSpeedChanged = false; + float f = (float)CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset[inst] / (scrollSpeed + 1); + if ( + CDTXMania.Instance.Pad.b押されている(inst == EPart.Guitar ? EPad.GtDecide : EPad.BsDecide) && + CDTXMania.Instance.Pad.b押された(inst == EPart.Guitar ? EPad.GtB : EPad.BsB) + ) { - this.actPlayInfo.t進行描画( x, y ); + CDTXMania.Instance.ConfigIni.nScrollSpeed[inst].Value = scrollSpeed + 1; + if (scrollSpeed < CDTXMania.Instance.ConfigIni.nScrollSpeed[inst]) + { + scrollSpeedChanged = true; + } } - } - protected void t進行描画・背景() - { - if ( CDTXMania.ConfigIni.eDark == Eダークモード.OFF ) + if ( + CDTXMania.Instance.Pad.b押されている(inst == EPart.Guitar ? EPad.GtDecide : EPad.BsDecide) && + CDTXMania.Instance.Pad.b押された(inst == EPart.Guitar ? EPad.GtR : EPad.BsR) + ) { - if ( this.tx背景 != null ) + CDTXMania.Instance.ConfigIni.nScrollSpeed[inst].Value = scrollSpeed - 1; + if (scrollSpeed > CDTXMania.Instance.ConfigIni.nScrollSpeed[inst]) { - this.tx背景.t2D描画( CDTXMania.app.Device, 0, 0 ); + scrollSpeedChanged = true; } } - else + if (scrollSpeedChanged) { - CDTXMania.app.Device.Clear( ClearFlags.ZBuffer | ClearFlags.Target, Color.Black, 0f, 0 ); + // 判定ラインも付随 + CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset[inst].Value = (int)(f * CDTXMania.Instance.ConfigIni.nScrollSpeed[inst] + 0.5); } - } + #endregion - protected void t進行描画・判定ライン() - { - if ( CDTXMania.ConfigIni.eDark != Eダークモード.FULL ) + if (!CDTXMania.Instance.ConfigIni.bGuitar有効 || !CDTXMania.Instance.DTX.bチップがある[inst]) + { + return; + } + + int R = (inst == EPart.Guitar) ? 0 : 3; + int G = R + 1; + int B = R + 2; + bool autoW = (inst == EPart.Guitar) ? CDTXMania.Instance.ConfigIni.bAutoPlay.GtWail : CDTXMania.Instance.ConfigIni.bAutoPlay.BsWail; + bool autoR = (inst == EPart.Guitar) ? CDTXMania.Instance.ConfigIni.bAutoPlay.GtR : CDTXMania.Instance.ConfigIni.bAutoPlay.BsR; + bool autoG = (inst == EPart.Guitar) ? CDTXMania.Instance.ConfigIni.bAutoPlay.GtG : CDTXMania.Instance.ConfigIni.bAutoPlay.BsG; + bool autoB = (inst == EPart.Guitar) ? CDTXMania.Instance.ConfigIni.bAutoPlay.GtB : CDTXMania.Instance.ConfigIni.bAutoPlay.BsB; + bool autoPick = (inst == EPart.Guitar) ? CDTXMania.Instance.ConfigIni.bAutoPlay.GtPick : CDTXMania.Instance.ConfigIni.bAutoPlay.BsPick; + int nAutoW = (autoW) ? 8 : 0; + int nAutoR = (autoR) ? 4 : 0; + int nAutoG = (autoG) ? 2 : 0; + int nAutoB = (autoB) ? 1 : 0; + int nAutoMask = nAutoW | nAutoR | nAutoG | nAutoB; + + CChip chip = this.r次に来る指定楽器Chipを更新して返す(inst); + if (chip != null) { - int y = CDTXMania.ConfigIni.bReverse.Drums ? 0x35 : 0x1a3; - for ( int i = 0x20; i < 0x14f; i += 8 ) + if ((chip.bGuitarBass_R) && autoR) { - if ( this.txヒットバー != null ) - { - this.txヒットバー.t2D描画( CDTXMania.app.Device, i, y, new Rectangle( 0, 0, ( ( i + 8 ) >= 0x14f ) ? ( 7 - ( ( i + 8 ) - 0x14f ) ) : 8, 8 ) ); - } + this.actLaneFlushGB.Start(R); + this.actRGB.Push(R); + } + if ((chip.bGuitarBass_G) && autoG) + { + this.actLaneFlushGB.Start(G); + this.actRGB.Push(G); + } + if ((chip.bGuitarBass_B) && autoB) + { + this.actLaneFlushGB.Start(B); + this.actRGB.Push(B); } } - } - protected void t進行描画・判定文字列() - { - this.actJudgeString.On進行描画(); - } - protected void t進行描画・判定文字列1・通常位置指定の場合() - { - if ( ( (E判定文字表示位置) CDTXMania.ConfigIni.判定文字表示位置.Drums ) != E判定文字表示位置.判定ライン上または横 ) + + int pressingR = CDTXMania.Instance.Pad.b押されている(inst == EPart.Guitar ? EPad.GtR : EPad.BsR) ? 4 : 0; + this.t入力メソッド記憶(inst); + int pressingG = CDTXMania.Instance.Pad.b押されている(inst == EPart.Guitar ? EPad.GtG : EPad.BsG) ? 2 : 0; + this.t入力メソッド記憶(inst); + int pressingB = CDTXMania.Instance.Pad.b押されている(inst == EPart.Guitar ? EPad.GtB : EPad.BsB) ? 1 : 0; + this.t入力メソッド記憶(inst); + int pressingRGB = pressingR | pressingG | pressingB; + if (pressingR != 0) { - this.actJudgeString.On進行描画(); + this.actLaneFlushGB.Start(R); + this.actRGB.Push(R); } - } - protected void t進行描画・判定文字列2・判定ライン上指定の場合() - { - if ( ( (E判定文字表示位置) CDTXMania.ConfigIni.判定文字表示位置.Drums ) == E判定文字表示位置.判定ライン上または横 ) + if (pressingG != 0) { - this.actJudgeString.On進行描画(); + this.actLaneFlushGB.Start(G); + this.actRGB.Push(G); } - } - - protected void t進行描画・譜面スクロール速度() - { - this.act譜面スクロール速度.On進行描画(); - } - - protected abstract void t背景テクスチャの生成(); - protected void t背景テクスチャの生成( string DefaultBgFilename, Rectangle bgrect, string bgfilename ) - { - Bitmap image = null; - bool flag = true; - - if ( bgfilename != null && File.Exists( bgfilename ) ) + if (pressingB != 0) + { + this.actLaneFlushGB.Start(B); + this.actRGB.Push(B); + } + // auto pickだとここから先に行かないので注意 + List events = CDTXMania.Instance.Pad.GetEvents(inst == EPart.Guitar ? EPad.GtPick : EPad.BsPick); + if ((events != null) && (events.Count > 0)) { - try + foreach (STInputEvent eventPick in events) { - Bitmap bitmap2 = null; - bitmap2 = new Bitmap( bgfilename ); - if ( ( bitmap2.Size.Width == 0 ) && ( bitmap2.Size.Height == 0 ) ) + if (!eventPick.b押された) { - this.tx背景 = null; - return; + continue; } - Bitmap bitmap3 = new Bitmap(SampleFramework.GameWindowSize.Width, SampleFramework.GameWindowSize.Height); - Graphics graphics = Graphics.FromImage( bitmap3 ); - for ( int i = 0; i < SampleFramework.GameWindowSize.Height; i += bitmap2.Size.Height ) + this.t入力メソッド記憶(inst); + long nTime = eventPick.nTimeStamp - CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻; + EChannel chWailingSound = (inst == EPart.Guitar) ? EChannel.Guitar_WailingSound : EChannel.Bass_WailingSound; + + // WailingSound チャンネルでE楽器パート.GUITARなチップ全てにヒットする + CChip pChip = this.r指定時刻に一番近い未ヒットChip( + nTime, chWailingSound, + CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs[inst], + CDTXMania.Instance.nPoor範囲ms + 1); + + EJudge e判定 = this.e指定時刻からChipのJUDGEを返す(nTime, pChip, + CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs[inst]); + //Trace.TraceInformation("ch={0:x2}, mask1={1:x1}, mask2={2:x2}", pChip.nチャンネル番号, ( pChip.nチャンネル番号 & ~nAutoMask ) & 0x0F, ( flagRGB & ~nAutoMask) & 0x0F ); + if ( + (pChip != null) && + ((((int)pChip.eチャンネル番号 & ~nAutoMask) & 0x0F) == ((pressingRGB & ~nAutoMask) & 0x0F)) && + (e判定 != EJudge.Miss)) { - for ( int j = 0; j < SampleFramework.GameWindowSize.Width; j += bitmap2.Size.Width ) + bool bChipHasR = pChip.bGuitarBass_R; + bool bChipHasG = pChip.bGuitarBass_G; + bool bChipHasB = pChip.bGuitarBass_B; + bool bChipHasW = pChip.bGuitarBass_Wailing; + bool bChipIsO = pChip.bGuitarBass_Open; + bool bSuccessOPEN = bChipIsO && (autoR || pressingR == 0) && (autoG || pressingG == 0) && (autoB || pressingB == 0); + if ((bChipHasR && (autoR || pressingR != 0)) || bSuccessOPEN) + { + this.actChipFireGB.Start(R); + } + if ((bChipHasG && (autoG || pressingG != 0)) || bSuccessOPEN) { - graphics.DrawImage( bitmap2, j, i, bitmap2.Width, bitmap2.Height ); + this.actChipFireGB.Start(G); } + if ((bChipHasB && (autoB || pressingB != 0)) || bSuccessOPEN) + { + this.actChipFireGB.Start(B); + } + this.tチップのヒット処理(nTime, pChip); + this.tサウンド再生(pChip, CSound管理.rc演奏用タイマ.nシステム時刻, inst, CDTXMania.Instance.ConfigIni.nChipVolume, CDTXMania.Instance.ConfigIni.bEmphasizePlaySound[inst], e判定 == EJudge.Poor); + EChannel chWailingChip = (inst == EPart.Guitar) ? EChannel.Guitar_Wailing : EChannel.Bass_Wailing; + CChip item = this.r指定時刻に一番近い未ヒットChip(nTime, chWailingChip, CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs[inst], 140); + if (item != null) + { + this.queWailing[inst].Enqueue(item); + } + continue; + } + + // 以下、間違いレーンでのピック時 + CChip NoChipPicked = (inst == EPart.Guitar) ? this.r現在の空うちギターChip : this.r現在の空うちベースChip; + if ((NoChipPicked != null) || ((NoChipPicked = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, chWailingSound, CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs[inst])) != null)) + { + this.tサウンド再生(NoChipPicked, CSound管理.rc演奏用タイマ.nシステム時刻, inst, CDTXMania.Instance.ConfigIni.nChipVolume, CDTXMania.Instance.ConfigIni.bEmphasizePlaySound[inst], true); + } + if (!CDTXMania.Instance.ConfigIni.bLight[inst]) + { + this.tチップのヒット処理_BadならびにTight時のMiss(inst); } - graphics.Dispose(); - bitmap2.Dispose(); - image = new Bitmap( CSkin.Path( DefaultBgFilename ) ); - graphics = Graphics.FromImage( image ); - ColorMatrix matrix2 = new ColorMatrix(); - matrix2.Matrix00 = 1f; - matrix2.Matrix11 = 1f; - matrix2.Matrix22 = 1f; - matrix2.Matrix33 = ( (float) CDTXMania.ConfigIni.n背景の透過度 ) / 255f; - matrix2.Matrix44 = 1f; - ColorMatrix newColorMatrix = matrix2; - ImageAttributes imageAttr = new ImageAttributes(); - imageAttr.SetColorMatrix( newColorMatrix ); - graphics.DrawImage( bitmap3, new Rectangle( 0, 0, SampleFramework.GameWindowSize.Width, SampleFramework.GameWindowSize.Height ), 0, 0, SampleFramework.GameWindowSize.Width, SampleFramework.GameWindowSize.Height, GraphicsUnit.Pixel, imageAttr ); - imageAttr.Dispose(); - graphics.DrawImage( bitmap3, bgrect, bgrect.X, bgrect.Y, bgrect.Width, bgrect.Height, GraphicsUnit.Pixel ); - graphics.Dispose(); - bitmap3.Dispose(); - flag = false; - } - catch - { - Trace.TraceError( "背景画像の読み込みに失敗しました。({0})", new object[] { bgfilename } ); } } - if ( flag ) + List list = CDTXMania.Instance.Pad.GetEvents(inst == EPart.Guitar ? EPad.GtWail : EPad.BsWail); + if ((list != null) && (list.Count > 0)) { - bgfilename = CSkin.Path( DefaultBgFilename ); - try + foreach (STInputEvent eventWailed in list) { - image = new Bitmap( bgfilename ); + if (!eventWailed.b押された) + { + continue; + } + DoWailingFromQueue(inst, eventWailed.nTimeStamp, autoW); } - catch + } + } + + private void DoWailingFromQueue(EPart inst, long nTimeStamp_Wailed, bool autoW) + { + long nTimeWailed = nTimeStamp_Wailed - CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻; + CChip chipWailing; + while ((this.queWailing[inst].Count > 0) && ((chipWailing = this.queWailing[inst].Dequeue()) != null)) + { + if ((nTimeWailed - chipWailing.n発声時刻ms) <= 1000) // #24245 2011.1.26 yyagi: 800 -> 1000 { - Trace.TraceError( "背景画像の読み込みに失敗しました。({0})", new object[] { bgfilename } ); - this.tx背景 = null; - return; + chipWailing.bHit = true; + this.actWailingBonus.Start(inst, this.r現在の歓声Chip[inst]); + if (!autoW) + { + int nCombo = (this.actCombo.dgbコンボ数[inst].n現在値 < 500) ? this.actCombo.dgbコンボ数[inst].n現在値 : 500; + // #24245 2011.1.26 yyagi changed DRUMS->BASS, add nCombo conditions + this.actScore.Add(inst, nCombo * 3000L); + } } } - if ( ( CDTXMania.DTX.listBMP.Count > 0 ) || ( CDTXMania.DTX.listBMPTEX.Count > 0 ) ) + } + + + + // t入力処理・ドラム()からメソッドを抽出したもの。 + /// + /// chipArrayの中を, n発生位置の小さい順に並べる + nullを大きい方に退かす。セットでe判定Arrayも並べ直す。 + /// + /// ソート対象chip群 + /// ソート対象e判定群 + /// チップ数 + private static void SortChipsByNTime(CChip[] chipArray, EJudge[] e判定Array, int NumOfChips) + { + for (int i = 0; i < NumOfChips - 1; i++) { - Graphics graphics2 = Graphics.FromImage( image ); - graphics2.FillRectangle( Brushes.Black, bgrect.X, bgrect.Y, bgrect.Width, bgrect.Height ); - graphics2.Dispose(); + for (int j = NumOfChips - 1; j > i; j--) + { + if ((chipArray[j - 1] == null) || ((chipArray[j] != null) && (chipArray[j - 1].n発声位置 > chipArray[j].n発声位置))) + { + // swap + CChip chipTemp = chipArray[j - 1]; + chipArray[j - 1] = chipArray[j]; + chipArray[j] = chipTemp; + EJudge e判定Temp = e判定Array[j - 1]; + e判定Array[j - 1] = e判定Array[j]; + e判定Array[j] = e判定Temp; + } + } } - try + } + private bool tドラムヒット処理(long nHitTime, EPad type, CChip pChip, int n強弱度合い0to127) + { + if (pChip == null) { - this.tx背景 = new CTexture( CDTXMania.app.Device, image, CDTXMania.TextureFormat ); + return false; } - catch ( CTextureCreateFailedException ) + // Ech定義 channel = pChip.eチャンネル番号; + int index = -1; + if (pChip.bDrums可視チップ_LP_LBD含まない) { - Trace.TraceError( "背景テクスチャの生成に失敗しました。" ); - this.tx背景 = null; + index = pChip.nDrumsIndex; } - image.Dispose(); - } - - protected virtual void t入力処理・ギター() - { - t入力処理・ギターベース( E楽器パート.GUITAR ); - } - protected virtual void t入力処理・ベース() - { - t入力処理・ギターベース( E楽器パート.BASS ); - } - - - protected virtual void t入力処理・ギターベース(E楽器パート inst) - { - int indexInst = (int) inst; - #region [ スクロール速度変更 ] - if ( CDTXMania.Pad.b押されている( inst, Eパッド.Decide ) && CDTXMania.Pad.b押された( inst, Eパッド.B ) ) + else if (pChip.bDrums不可視チップ_LP_LBD含まない) { - CDTXMania.ConfigIni.n譜面スクロール速度[indexInst] = Math.Min( CDTXMania.ConfigIni.n譜面スクロール速度[indexInst] + 1, 0x7cf ); + index = pChip.nDrumsIndexHidden; } - if ( CDTXMania.Pad.b押されている( inst, Eパッド.Decide ) && CDTXMania.Pad.b押された( inst, Eパッド.R ) ) + ELane eLane = EnumConverter.LaneFromChannel(index + EChannel.HiHatClose);// nチャンネル0Atoレーン07[index]; + EPad ePad = EnumConverter.PadFromChannel(index + EChannel.HiHatClose); //nチャンネル0Atoパッド08[index]; + bool bPChipIsAutoPlay = CDTXMania.Instance.ConfigIni.bAutoPlay[ePad]; + int nInputAdjustTime = bPChipIsAutoPlay ? 0 : CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs.Drums; + EJudge e判定 = this.e指定時刻からChipのJUDGEを返す(nHitTime, pChip, nInputAdjustTime); + if (e判定 == EJudge.Miss) { - CDTXMania.ConfigIni.n譜面スクロール速度[indexInst] = Math.Max( CDTXMania.ConfigIni.n譜面スクロール速度[indexInst] - 1, 0 ); + return false; } - #endregion - - if ( !CDTXMania.ConfigIni.bGuitar有効 || !CDTXMania.DTX.bチップがある[indexInst] ) + this.tチップのヒット処理(nHitTime, pChip); + this.actLaneFlushD.Start(eLane, ((float)n強弱度合い0to127) / 127f); + this.actPad.Hit(ePad); + if ((e判定 != EJudge.Poor) && (e判定 != EJudge.Miss)) { - return; + bool flag = this.bフィルイン中; + bool flag2 = this.bフィルイン中 && this.bフィルイン区間の最後のChipである(pChip); + // bool flag3 = flag2; + // #31602 2013.6.24 yyagi 判定ラインの表示位置をずらしたら、チップのヒットエフェクトの表示もずらすために、nJudgeLine..を追加 + this.actChipFireD.Start(eLane, flag, flag2, flag2); } - - int R = ( inst == E楽器パート.GUITAR ) ? 0 : 3; - int G = R + 1; - int B = R + 2; - bool autoW = ( inst == E楽器パート.GUITAR ) ? bIsAutoPlay.GtW : bIsAutoPlay.BsW; - bool autoR = ( inst == E楽器パート.GUITAR ) ? bIsAutoPlay.GtR : bIsAutoPlay.BsR; - bool autoG = ( inst == E楽器パート.GUITAR ) ? bIsAutoPlay.GtG : bIsAutoPlay.BsG; - bool autoB = ( inst == E楽器パート.GUITAR ) ? bIsAutoPlay.GtB : bIsAutoPlay.BsB; - bool autoPick = ( inst == E楽器パート.GUITAR ) ? bIsAutoPlay.GtPick : bIsAutoPlay.BsPick; - int nAutoW = ( autoW ) ? 8 : 0; - int nAutoR = ( autoR ) ? 4 : 0; - int nAutoG = ( autoG ) ? 2 : 0; - int nAutoB = ( autoB ) ? 1 : 0; - int nAutoMask = nAutoW | nAutoR | nAutoG | nAutoB; - -// if ( bIsAutoPlay[ (int) Eレーン.Guitar - 1 + indexInst ] ) // このような、バグの入りやすい書き方(GT/BSのindex値が他と異なる)はいずれ見直したい -// { - CDTX.CChip chip = this.r次に来る指定楽器Chipを更新して返す(inst); - if ( chip != null ) + if (CDTXMania.Instance.ConfigIni.bDrumsHitSound) { - if ( ( chip.nチャンネル番号 & 4 ) != 0 && autoR ) - { - this.actLaneFlushGB.Start( R ); - this.actRGB.Push( R ); - } - if ( ( chip.nチャンネル番号 & 2 ) != 0 && autoG ) + CChip rChip = null; + bool bIsChipsoundPriorToPad = true; + if (((type == EPad.HH) || (type == EPad.HHO)) || (type == EPad.LC)) { - this.actLaneFlushGB.Start( G ); - this.actRGB.Push( G ); + bIsChipsoundPriorToPad = CDTXMania.Instance.ConfigIni.eHitSoundPriorityHH == EHitSoundPriority.Chip; } - if ( ( chip.nチャンネル番号 & 1 ) != 0 && autoB ) + else if ((type == EPad.LT) || (type == EPad.FT)) { - this.actLaneFlushGB.Start( B ); - this.actRGB.Push( B ); + bIsChipsoundPriorToPad = CDTXMania.Instance.ConfigIni.eHitSoundPriorityFT == EHitSoundPriority.Chip; } -// } - - } -// else - { - int pushingR = CDTXMania.Pad.b押されている( inst, Eパッド.R ) ? 4 : 0; - this.t入力メソッド記憶( inst ); - int pushingG = CDTXMania.Pad.b押されている( inst, Eパッド.G ) ? 2 : 0; - this.t入力メソッド記憶( inst ); - int pushingB = CDTXMania.Pad.b押されている( inst, Eパッド.B ) ? 1 : 0; - this.t入力メソッド記憶( inst ); - int flagRGB = pushingR | pushingG | pushingB; - if ( pushingR != 0 ) - { - this.actLaneFlushGB.Start( R ); - this.actRGB.Push( R ); - } - if ( pushingG != 0 ) + else if ((type == EPad.CY) || (type == EPad.RD)) { - this.actLaneFlushGB.Start( G ); - this.actRGB.Push( G ); + bIsChipsoundPriorToPad = CDTXMania.Instance.ConfigIni.eHitSoundPriorityCY == EHitSoundPriority.Chip; } - if ( pushingB != 0 ) + if (bIsChipsoundPriorToPad) { - this.actLaneFlushGB.Start( B ); - this.actRGB.Push( B ); + rChip = pChip; } - // auto pickだとここから先に行かないので注意 - List events = CDTXMania.Pad.GetEvents( inst, Eパッド.Pick ); - if ( ( events != null ) && ( events.Count > 0 ) ) + else { - foreach ( STInputEvent eventPick in events ) + EPad hH = type; + if (!CDTXMania.Instance.DTX.bチップがある.HHOpen && (type == EPad.HHO)) { - if ( !eventPick.b押された ) - { - continue; - } - this.t入力メソッド記憶( inst ); - long nTime = eventPick.nTimeStamp - CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻; - int chWailingSound = ( inst == E楽器パート.GUITAR ) ? 0x2F : 0xAF; - CDTX.CChip pChip = this.r指定時刻に一番近い未ヒットChip( nTime, chWailingSound, this.nInputAdjustTimeMs[indexInst] ); // E楽器パート.GUITARなチップ全てにヒットする - E判定 e判定 = this.e指定時刻からChipのJUDGEを返す( nTime, pChip, this.nInputAdjustTimeMs[indexInst] ); -//Trace.TraceInformation("ch={0:x2}, mask1={1:x1}, mask2={2:x2}", pChip.nチャンネル番号, ( pChip.nチャンネル番号 & ~nAutoMask ) & 0x0F, ( flagRGB & ~nAutoMask) & 0x0F ); - if ( ( pChip != null ) && ( ( ( pChip.nチャンネル番号 & ~nAutoMask ) & 0x0F ) == ( ( flagRGB & ~nAutoMask) & 0x0F ) ) && ( e判定 != E判定.Miss ) ) - { - bool bChipHasR = ( ( pChip.nチャンネル番号 & 4 ) > 0 ); - bool bChipHasG = ( ( pChip.nチャンネル番号 & 2 ) > 0 ); - bool bChipHasB = ( ( pChip.nチャンネル番号 & 1 ) > 0 ); - bool bChipHasW = ( ( pChip.nチャンネル番号 & 0x0F ) == 0x08 ); - bool bChipIsO = ( ( pChip.nチャンネル番号 & 0x0F ) == 0x00 ); - bool bSuccessOPEN = bChipIsO && ( autoR || pushingR == 0 ) && ( autoG || pushingG == 0 ) && ( autoB || pushingB == 0 ); - if ( ( bChipHasR && ( autoR || pushingR != 0 ) ) || bSuccessOPEN ) - //if ( ( pushingR != 0 ) || autoR || ( flagRGB == 0 ) ) - { - this.actChipFireGB.Start( R ); - } - if ( ( bChipHasG && ( autoG || pushingG != 0 ) ) || bSuccessOPEN ) - //if ( ( pushingG != 0 ) || autoG || ( flagRGB == 0 ) ) - { - this.actChipFireGB.Start( G ); - } - if ( ( bChipHasB && ( autoB || pushingB != 0 ) ) || bSuccessOPEN ) - //if ( ( pushingB != 0 ) || autoB || ( flagRGB == 0 ) ) - { - this.actChipFireGB.Start( B ); - } - this.tチップのヒット処理( nTime, pChip ); - this.tサウンド再生( pChip, CSound管理.rc演奏用タイマ.nシステム時刻, inst, CDTXMania.ConfigIni.n手動再生音量, CDTXMania.ConfigIni.b演奏音を強調する[indexInst], e判定 == E判定.Poor ); - int chWailingChip = ( inst == E楽器パート.GUITAR ) ? 0x28 : 0xA8; - CDTX.CChip item = this.r指定時刻に一番近い未ヒットChip( nTime, chWailingChip, this.nInputAdjustTimeMs[ indexInst ], 140 ); - if ( item != null ) - { - this.queWailing[indexInst].Enqueue( item ); - } - continue; - } - - // 以下、間違いレーンでのピック時 - CDTX.CChip NoChipPicked = ( inst == E楽器パート.GUITAR ) ? this.r現在の空うちギターChip : this.r現在の空うちベースChip; - if ( ( NoChipPicked != null ) || ( ( NoChipPicked = this.r指定時刻に一番近いChip・ヒット未済問わず不可視考慮( nTime, chWailingSound, this.nInputAdjustTimeMs[indexInst] ) ) != null ) ) - { - this.tサウンド再生( NoChipPicked, CSound管理.rc演奏用タイマ.nシステム時刻, inst, CDTXMania.ConfigIni.n手動再生音量, CDTXMania.ConfigIni.b演奏音を強調する[indexInst], true ); - } - if ( !CDTXMania.ConfigIni.bLight[indexInst] ) - { - this.tチップのヒット処理・BadならびにTight時のMiss( inst ); - } + hH = EPad.HH; } - } - List list = CDTXMania.Pad.GetEvents(inst, Eパッド.Wail ); - if ( ( list != null ) && ( list.Count > 0 ) ) - { - foreach ( STInputEvent eventWailed in list ) + if (!CDTXMania.Instance.DTX.bチップがある.Ride && (type == EPad.RD)) { - if ( !eventWailed.b押された ) - { - continue; - } - DoWailingFromQueue( inst, eventWailed.nTimeStamp, autoW ); + hH = EPad.CY; + } + if (!CDTXMania.Instance.DTX.bチップがある.LeftCymbal && (type == EPad.LC)) + { + hH = EPad.HH; + } + rChip = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nHitTime, EnumConverter.ChannelFromPad(hH), nInputAdjustTime); + if (rChip == null) + { + rChip = pChip; } } + this.tサウンド再生(rChip, CSound管理.rc演奏用タイマ.nシステム時刻, EPart.Drums, CDTXMania.Instance.ConfigIni.nChipVolume, CDTXMania.Instance.ConfigIni.bEmphasizePlaySound.Drums); } + return true; } - private void DoWailingFromQueue( E楽器パート inst, long nTimeStamp_Wailed, bool autoW ) + protected bool bフィルイン区間の最後のChipである(CChip pChip) { - int indexInst = (int) inst; - long nTimeWailed = nTimeStamp_Wailed - CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻; - CDTX.CChip chipWailing; - while ( ( this.queWailing[ indexInst ].Count > 0 ) && ( ( chipWailing = this.queWailing[ indexInst ].Dequeue() ) != null ) ) + if (pChip == null) + { + return false; + } + int num = pChip.n発声位置; + for (int i = CDTXMania.Instance.DTX.listChip.IndexOf(pChip) + 1; i < CDTXMania.Instance.DTX.listChip.Count; i++) { - if ( ( nTimeWailed - chipWailing.n発声時刻ms ) <= 1000 ) // #24245 2011.1.26 yyagi: 800 -> 1000 + pChip = CDTXMania.Instance.DTX.listChip[i]; + if ((pChip[EChannel.FillIn]) && (pChip.n整数値 == 2)) { - chipWailing.bHit = true; - this.actWailingBonus.Start( inst, this.r現在の歓声Chip[ indexInst ] ); - //if ( !bIsAutoPlay[indexInst] ) - if ( !autoW ) + return true; + } + if ((pChip.bDrums可視チップ_LP_LBD含まない) && (pChip.n発声位置 - num) > 0x18) + { + return false; + } + } + return true; + } + + private void t進行描画_チップ_フィルイン(ref CChip pChip) + { + if (!pChip.bHit && (pChip.nバーからの距離dot.Drums < 0)) + { + pChip.bHit = true; + + if (CDTXMania.Instance.ConfigIni.bDrums有効) + { + switch (pChip.n整数値) { - int nCombo = ( this.actCombo.n現在のコンボ数[ indexInst ] < 500 ) ? this.actCombo.n現在のコンボ数[ indexInst ] : 500; - this.actScore.Add( inst, bIsAutoPlay, nCombo * 3000L ); // #24245 2011.1.26 yyagi changed DRUMS->BASS, add nCombo conditions + case 0x01: // フィルイン開始 + if (CDTXMania.Instance.ConfigIni.bFillin) + { + this.bフィルイン中 = true; + } + break; + + case 0x02: // フィルイン終了 + if (CDTXMania.Instance.ConfigIni.bFillin) + { + this.bフィルイン中 = false; + } + if (((this.actCombo.dgbコンボ数.Drums.n現在値 > 0) || CDTXMania.Instance.ConfigIni.bIsAutoPlay(EPart.Drums)) && CDTXMania.Instance.ConfigIni.bAudience) + { + if (this.r現在の歓声Chip.Drums != null) + { + CDTXMania.Instance.DTX.tチップの再生(this.r現在の歓声Chip.Drums, CSound管理.rc演奏用タイマ.nシステム時刻, CDTXMania.Instance.DTX.nモニタを考慮した音量(EPart.Unknown)); + } + else + { + CDTXMania.Instance.Skin.sound歓声音.n位置_次に鳴るサウンド = 0; + CDTXMania.Instance.Skin.sound歓声音.t再生する(); + } + } + break; +#if TEST_NOTEOFFMODE // 2011.1.1 yyagi TEST + case 0x04: // HH消音あり(従来同等) + CDTXMania.Instance.DTX.b演奏で直前の音を消音する.HH = true; + break; + case 0x05: // HH消音無し + CDTXMania.Instance.DTX.b演奏で直前の音を消音する.HH = false; + break; + case 0x06: // ギター消音あり(従来同等) + CDTXMania.Instance.DTX.b演奏で直前の音を消音する.Gutiar = true; + break; + case 0x07: // ギター消音無し + CDTXMania.Instance.DTX.b演奏で直前の音を消音する.Gutiar = false; + break; + case 0x08: // ベース消音あり(従来同等) + CDTXMania.Instance.DTX.b演奏で直前の音を消音する.Bass = true; + break; + case 0x09: // ベース消音無し + CDTXMania.Instance.DTX.b演奏で直前の音を消音する.Bass = false; + break; +#endif } } } } - #endregion } }