DTXMania/コード/ステージ/07.演奏/CStage演奏画面共通.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Text;
   4 using System.Runtime;
   5 using System.Runtime.InteropServices;
   6 using System.Drawing;
   7 using System.Drawing.Imaging;
   8 using System.IO;
   9 using System.Diagnostics;
  10 using System.Threading;
  11 using System.Threading.Tasks;
  12
  13 using SharpDX;
  14 using SharpDX.Direct3D9;
  15 using FDK;
  16
  17 using SlimDXKey = SlimDX.DirectInput.Key;
  18
  19 namespace DTXMania
  20 {
  21         /// <summary>
  22         /// 演奏画面の共通クラス (ドラム演奏画面, ギター演奏画面の継承元)
  23         /// </summary>
  24         internal partial class CStage演奏画面共通 : CStage
  25         {
  26                 #region [Member_Activities]
  27                 CAct演奏AVI actAVI;
  28                 CAct演奏BGA actBGA;
  29                 CAct演奏チップファイアGB actChipFireGB;
  30                 CAct演奏Combo共通 actCombo;
  31                 CAct演奏Danger共通 actDANGER;
  32                 CActFIFOBlack actFI;
  33                 CActFIFOBlack actFO;
  34                 CActFIFOWhite actFOClear;
  35                 CAct演奏ゲージ共通 actGauge;
  36                 CAct演奏判定文字列共通 actJudgeString;
  37                 CAct演奏DrumsレーンフラッシュD actLaneFlushD;
  38                 CAct演奏レーンフラッシュGB共通 actLaneFlushGB;
  39                 CActオプションパネル actOptionPanel;
  40                 CAct演奏パネル文字列 actPanel;
  41                 CAct演奏演奏情報 actPlayInfo;
  42                 CAct演奏RGB共通 actRGB;
  43                 CAct演奏スコア共通 actScore;
  44                 CAct演奏ステージ失敗 actStageFailed;
  45                 CAct演奏WailingBonus共通 actWailingBonus;
  46                 CAct演奏スクロール速度 act譜面スクロール速度;
  47                 CAct演奏DrumsチップファイアD actChipFireD;
  48                 // #24074 2011.01.23 add ikanick
  49                 CAct演奏グラフ actGraph;
  50                 CAct演奏Drumsパッド actPad;
  51                 CAct演奏Lane actLane;
  52                 #endregion
  53
  54                 bool bPAUSE;
  55                 STDGBSValue<bool> b演奏にMIDI入力を使った;
  56                 STDGBSValue<bool> b演奏にキーボードを使った;
  57                 STDGBSValue<bool> b演奏にジョイパッドを使った;
  58                 STDGBSValue<bool> b演奏にマウスを使った;
  59
  60                 CCounter ctWailingチップ模様アニメ;
  61                 STDGBSValue<CCounter> ctチップ模様アニメ;
  62
  63                 E演奏画面の戻り値 eフェードアウト完了時の戻り値;
  64
  65                 STDGBSValue<CHitCountOfRank> nヒット数_Auto含まない;
  66                 STDGBSValue<CHitCountOfRank> nヒット数_Auto含む;
  67                 // #35411 2015.08.21 chnmr0 add
  68                 STDGBSValue<CHitCountOfRank> nヒット数_TargetGhost;
  69                 STDGBSValue<int> nコンボ数_TargetGhost;
  70                 STDGBSValue<int> n最大コンボ数_TargetGhost;
  71                 int n現在のトップChip = -1;
  72                 int[] n最後に再生したBGMの実WAV番号 = new int[50];
  73                 EChannel e最後に再生したHHのチャンネル番号;
  74                 // #23921 2011.1.4 yyagi: change "int" to "List<int>", for recording multiple wav No.
  75                 List<int> L最後に再生したHHの実WAV番号;
  76                 // #26388 2011.11.8 yyagi: change "n最後に再生した実WAV番号.GUITAR" and "n最後に再生した実WAV番号.BASS"
  77                 STPadValue<int> n最後に再生した実WAV番号;
  78                 // #24820 2013.1.21 yyagi まずは単純にAdd/Removeを1個のキューでまとめて管理するやり方で設計する
  79                 volatile Queue<STMixer> queueMixerSound;
  80                 DateTime dtLastQueueOperation;
  81                 bool bIsDirectSound;
  82                 double db再生速度;
  83                 bool bValidScore;
  84                 bool bフィルイン中; // drums only
  85
  86                 STDGBSValue<Queue<CChip>> queWailing;
  87                 STDGBSValue<CChip> r現在の歓声Chip;
  88                 STPadValue<CChip> r空打ちドラムチップ = new STPadValue<CChip>();
  89                 CChip r現在の空うちギターChip;
  90                 ST空打ち r現在の空うちドラムChip;
  91                 CChip r現在の空うちベースChip;
  92                 CChip r次にくるギターChip;
  93                 CChip r次にくるベースChip;
  94
  95                 CTexture txWailing枠;
  96                 CTexture txチップ;
  97                 CTexture txチップGB;
  98                 CTexture txヒットバー;
  99                 CTexture txヒットバーGB;
 100                 CTexture tx背景;
 101
 102                 CInvisibleChip cInvisibleChip;
 103                 CWailingChip共通[] cWailingChip;
 104
 105                 STDGBSValue<CScoreIni.C演奏記録> record;
 106
 107                 long nLastSendMessageTime;
 108
 109 #if TEST_MEASUREFRAMEDRAWTIME
 110                 Stopwatch sw = new Stopwatch();
 111                 List<long> swlist = new List<long>(100000);
 112                 List<long> tmlist = new List<long>(100000);
 113 #endif
 114
 115                 public CStage演奏画面共通()
 116                 {
 117                         base.eステージID = CStage.Eステージ.演奏;
 118                         base.eフェーズID = CStage.Eフェーズ.共通_通常状態;
 119                         base.b活性化してない = true;
 120                         base.list子Activities.Add(this.actPad = new CAct演奏Drumsパッド());
 121                         base.list子Activities.Add(this.actChipFireD = new CAct演奏DrumsチップファイアD());
 122                         base.list子Activities.Add(this.actChipFireGB = new CAct演奏チップファイアGB());
 123                         base.list子Activities.Add(this.actStageFailed = new CAct演奏ステージ失敗());
 124                         base.list子Activities.Add(this.actDANGER = new CAct演奏Danger共通());
 125                         base.list子Activities.Add(this.actAVI = new CAct演奏AVI());
 126                         base.list子Activities.Add(this.actBGA = new CAct演奏BGA());
 127                         base.list子Activities.Add(this.actPanel = new CAct演奏パネル文字列());
 128                         base.list子Activities.Add(this.act譜面スクロール速度 = new CAct演奏スクロール速度());
 129                         base.list子Activities.Add(this.actWailingBonus = new CAct演奏WailingBonus共通());
 130                         base.list子Activities.Add(this.actScore = new CAct演奏スコア共通());
 131                         base.list子Activities.Add(this.actRGB = new CAct演奏RGB共通());
 132                         base.list子Activities.Add(this.actLaneFlushD = new CAct演奏DrumsレーンフラッシュD());
 133                         base.list子Activities.Add(this.actLaneFlushGB = new CAct演奏レーンフラッシュGB共通());
 134                         base.list子Activities.Add(this.actJudgeString = new CAct演奏判定文字列共通());
 135                         base.list子Activities.Add(this.actGauge = new CAct演奏ゲージ共通());
 136                         base.list子Activities.Add(this.actGraph = new CAct演奏グラフ());
 137                         base.list子Activities.Add(this.actCombo = new CAct演奏Combo共通());
 138                         base.list子Activities.Add(this.actPlayInfo = new CAct演奏演奏情報());
 139                         base.list子Activities.Add(this.actFI = new CActFIFOBlack());
 140                         base.list子Activities.Add(this.actFO = new CActFIFOBlack());
 141                         base.list子Activities.Add(this.actFOClear = new CActFIFOWhite());
 142                         base.list子Activities.Add(this.actLane = new CAct演奏Lane());
 143                         list子Activities.Add(actOptionPanel = new CActオプションパネル(EOptionPanelDirection.Vertical));
 144                 }
 145
 146                 #region [ PlayRecordSave ]
 147                 private void t演奏結果を格納する_ドラム()
 148                 {
 149                         record.Drums = new CScoreIni.C演奏記録();
 150                         CScoreIni.C演奏記録 Drums = Record.Drums;
 151                         bool allauto = CDTXMania.Instance.ConfigIni.bIsAutoPlay(EPart.Drums);
 152                         if (CDTXMania.Instance.DTX.bチップがある.Drums && CDTXMania.Instance.ConfigIni.bDrums有効)
 153                         {
 154                                 Drums.nスコア = (long)this.actScore.Get(EPart.Drums);
 155                                 Drums.dbゲーム型スキル値 = CScoreIni.tゲーム型スキルを計算して返す(CDTXMania.Instance.DTX.LEVEL.Drums, CDTXMania.Instance.DTX.n可視チップ数.Drums, this.nヒット数_Auto含まない.Drums.Perfect,
 156                                                 this.actCombo.dgbコンボ数.Drums.n最高値,
 157                                                 EPart.Drums);
 158                                 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);
 159                                 Drums.nPerfect数 = allauto ? this.nヒット数_Auto含む.Drums.Perfect : this.nヒット数_Auto含まない.Drums.Perfect;
 160                                 Drums.nGreat数 = allauto ? this.nヒット数_Auto含む.Drums.Great : this.nヒット数_Auto含まない.Drums.Great;
 161                                 Drums.nGood数 = allauto ? this.nヒット数_Auto含む.Drums.Good : this.nヒット数_Auto含まない.Drums.Good;
 162                                 Drums.nPoor数 = allauto ? this.nヒット数_Auto含む.Drums.Poor : this.nヒット数_Auto含まない.Drums.Poor;
 163                                 Drums.nMiss数 = allauto ? this.nヒット数_Auto含む.Drums.Miss : this.nヒット数_Auto含まない.Drums.Miss;
 164                                 Drums.nPerfect数_Auto含まない = this.nヒット数_Auto含まない.Drums.Perfect;
 165                                 Drums.nGreat数_Auto含まない = this.nヒット数_Auto含まない.Drums.Great;
 166                                 Drums.nGood数_Auto含まない = this.nヒット数_Auto含まない.Drums.Good;
 167                                 Drums.nPoor数_Auto含まない = this.nヒット数_Auto含まない.Drums.Poor;
 168                                 Drums.nMiss数_Auto含まない = this.nヒット数_Auto含まない.Drums.Miss;
 169                                 Drums.n最大コンボ数 = this.actCombo.dgbコンボ数.Drums.n最高値;
 170                                 Drums.n全チップ数 = CDTXMania.Instance.DTX.n可視チップ数.Drums;
 171                                 for ( EPad i = EPad.Min; i < EPad.BassPadMax; i++ )
 172                                 {
 173                                         Drums.bAutoPlay[i] = CDTXMania.Instance.ConfigIni.bAutoPlay[i];
 174                                 }
 175                                 Drums.bTight = CDTXMania.Instance.ConfigIni.bTight;
 176                                 for (EPart i = EPart.Drums; i <= EPart.Bass; i++)
 177                                 {
 178                                         Drums.eSudHidInv[i] = CDTXMania.Instance.ConfigIni.eSudHidInv[i];
 179                                         Drums.bReverse[i] = CDTXMania.Instance.ConfigIni.bReverse[i];
 180                                         Drums.eRandom[i] = CDTXMania.Instance.ConfigIni.eRandom[i];
 181                                         Drums.bLight[i] = CDTXMania.Instance.ConfigIni.bLight[i];
 182                                         Drums.f譜面スクロール速度[i] = ((float)(CDTXMania.Instance.ConfigIni.nScrollSpeed[i] + 1)) * 0.5f;
 183                                 }
 184                                 Drums.eDark = CDTXMania.Instance.ConfigIni.eDark;
 185                                 Drums.n演奏速度分子 = CDTXMania.Instance.ConfigIni.nPlaySpeed;
 186                                 Drums.n演奏速度分母 = 20;
 187                                 Drums.e譜面レーンタイプ.Drums = CDTXMania.Instance.DTX.n使用レーン数.Drums;
 188                                 Drums.e譜面レーンタイプ.Guitar= CDTXMania.Instance.DTX.n使用レーン数.Guitar;
 189                                 Drums.e譜面レーンタイプ.Bass  = CDTXMania.Instance.DTX.n使用レーン数.Bass;
 190                                 Drums.eHHGroup = CDTXMania.Instance.ConfigIni.eHHGroup.Value;
 191                                 Drums.eFTGroup = CDTXMania.Instance.ConfigIni.eFTGroup.Value;
 192                                 Drums.eCYGroup = CDTXMania.Instance.ConfigIni.eCYGroup.Value;
 193                                 Drums.eHitSoundPriorityHH = CDTXMania.Instance.ConfigIni.eHitSoundPriorityHH.Value;
 194                                 Drums.eHitSoundPriorityFT = CDTXMania.Instance.ConfigIni.eHitSoundPriorityFT.Value;
 195                                 Drums.eHitSoundPriorityCY = CDTXMania.Instance.ConfigIni.eHitSoundPriorityCY.Value;
 196                                 Drums.bGuitar有効 = CDTXMania.Instance.ConfigIni.bGuitar有効;
 197                                 Drums.bDrums有効 = CDTXMania.Instance.ConfigIni.bDrums有効;
 198                                 Drums.bSTAGEFAILED有効 = CDTXMania.Instance.ConfigIni.bStageFailed;
 199                                 Drums.eダメージレベル = CDTXMania.Instance.ConfigIni.eDamageLevel;
 200                                 Drums.eMetronome = CDTXMania.Instance.ConfigIni.eClickType;
 201                                 Drums.b演奏にキーボードを使用した = this.b演奏にキーボードを使った.Drums;
 202                                 Drums.b演奏にMIDI入力を使用した = this.b演奏にMIDI入力を使った.Drums;
 203                                 Drums.b演奏にジョイパッドを使用した = this.b演奏にジョイパッドを使った.Drums;
 204                                 Drums.b演奏にマウスを使用した = this.b演奏にマウスを使った.Drums;
 205                                 Drums.nPerfectになる範囲ms = CDTXMania.Instance.nPerfect範囲ms;
 206                                 Drums.nGreatになる範囲ms = CDTXMania.Instance.nGreat範囲ms;
 207                                 Drums.nGoodになる範囲ms = CDTXMania.Instance.nGood範囲ms;
 208                                 Drums.nPoorになる範囲ms = CDTXMania.Instance.nPoor範囲ms;
 209                                 Drums.strDTXManiaのバージョン = CDTXMania.VERSION;
 210                                 Drums.最終更新日時 = DateTime.Now.ToString();
 211                                 // #35461 chnmr0 add
 212                                 Drums.nRisky = CDTXMania.Instance.ConfigIni.nRisky;
 213                                 // #35417 chnmr0 add
 214                                 Drums.bギターとベースを入れ替えた = CDTXMania.Instance.ConfigIni.bIsSwappedGuitarBass;
 215                         }
 216                 }
 217                 private void t演奏結果を格納する_ギター()
 218                 {
 219                         record.Guitar = new CScoreIni.C演奏記録();
 220                         CScoreIni.C演奏記録 Guitar = Record.Guitar;
 221                         bool allauto = CDTXMania.Instance.ConfigIni.bIsAutoPlay(EPart.Guitar);
 222                         if (CDTXMania.Instance.DTX.bチップがある.Guitar)
 223                         {
 224                                 Guitar.nスコア = (long)this.actScore.Get(EPart.Guitar);
 225                                 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);
 226                                 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);
 227                                 Guitar.nPerfect数 = allauto ? this.nヒット数_Auto含む.Guitar.Perfect : this.nヒット数_Auto含まない.Guitar.Perfect;
 228                                 Guitar.nGreat数 = allauto ? this.nヒット数_Auto含む.Guitar.Great : this.nヒット数_Auto含まない.Guitar.Great;
 229                                 Guitar.nGood数 = allauto ? this.nヒット数_Auto含む.Guitar.Good : this.nヒット数_Auto含まない.Guitar.Good;
 230                                 Guitar.nPoor数 = allauto ? this.nヒット数_Auto含む.Guitar.Poor : this.nヒット数_Auto含まない.Guitar.Poor;
 231                                 Guitar.nMiss数 = allauto ? this.nヒット数_Auto含む.Guitar.Miss : this.nヒット数_Auto含まない.Guitar.Miss;
 232                                 Guitar.nPerfect数_Auto含まない = this.nヒット数_Auto含まない.Guitar.Perfect;
 233                                 Guitar.nGreat数_Auto含まない = this.nヒット数_Auto含まない.Guitar.Great;
 234                                 Guitar.nGood数_Auto含まない = this.nヒット数_Auto含まない.Guitar.Good;
 235                                 Guitar.nPoor数_Auto含まない = this.nヒット数_Auto含まない.Guitar.Poor;
 236                                 Guitar.nMiss数_Auto含まない = this.nヒット数_Auto含まない.Guitar.Miss;
 237                                 Guitar.n最大コンボ数 = this.actCombo.dgbコンボ数.Guitar.n最高値;
 238                                 Guitar.n全チップ数 = CDTXMania.Instance.DTX.n可視チップ数.Guitar;
 239                                 for (EPad i = EPad.Min; i < EPad.BassPadMax; i++)
 240                                 {
 241                                         Guitar.bAutoPlay[i] = CDTXMania.Instance.ConfigIni.bAutoPlay[i];
 242                                 }
 243                                 Guitar.bTight = CDTXMania.Instance.ConfigIni.bTight;
 244                                 for (EPart i = EPart.Drums; i <= EPart.Bass; i++)
 245                                 {
 246                                         Guitar.eSudHidInv[i] = CDTXMania.Instance.ConfigIni.eSudHidInv[i];
 247                                         Guitar.bReverse[i] = CDTXMania.Instance.ConfigIni.bReverse[i];
 248                                         Guitar.eRandom[i] = CDTXMania.Instance.ConfigIni.eRandom[i];
 249                                         Guitar.bLight[i] = CDTXMania.Instance.ConfigIni.bLight[i];
 250                                         Guitar.f譜面スクロール速度[i] = ((float)(CDTXMania.Instance.ConfigIni.nScrollSpeed[i] + 1)) * 0.5f;
 251                                 }
 252                                 Guitar.eDark = CDTXMania.Instance.ConfigIni.eDark;
 253                                 Guitar.n演奏速度分子 = CDTXMania.Instance.ConfigIni.nPlaySpeed;
 254                                 Guitar.n演奏速度分母 = 20;
 255                                 Guitar.eHHGroup = CDTXMania.Instance.ConfigIni.eHHGroup;
 256                                 Guitar.eFTGroup = CDTXMania.Instance.ConfigIni.eFTGroup;
 257                                 Guitar.eCYGroup = CDTXMania.Instance.ConfigIni.eCYGroup;
 258                                 Guitar.e譜面レーンタイプ.Drums = CDTXMania.Instance.DTX.n使用レーン数.Drums;
 259                                 Guitar.e譜面レーンタイプ.Guitar = CDTXMania.Instance.DTX.n使用レーン数.Guitar;
 260                                 Guitar.e譜面レーンタイプ.Bass = CDTXMania.Instance.DTX.n使用レーン数.Bass;
 261                                 Guitar.eHitSoundPriorityHH = CDTXMania.Instance.ConfigIni.eHitSoundPriorityHH;
 262                                 Guitar.eHitSoundPriorityFT = CDTXMania.Instance.ConfigIni.eHitSoundPriorityFT;
 263                                 Guitar.eHitSoundPriorityCY = CDTXMania.Instance.ConfigIni.eHitSoundPriorityCY;
 264                                 Guitar.bGuitar有効 = CDTXMania.Instance.ConfigIni.bGuitar有効;
 265                                 Guitar.bDrums有効 = CDTXMania.Instance.ConfigIni.bDrums有効;
 266                                 Guitar.bSTAGEFAILED有効 = CDTXMania.Instance.ConfigIni.bStageFailed;
 267                                 Guitar.eダメージレベル = CDTXMania.Instance.ConfigIni.eDamageLevel;
 268                                 Guitar.eMetronome = CDTXMania.Instance.ConfigIni.eClickType;
 269                                 Guitar.b演奏にキーボードを使用した = this.b演奏にキーボードを使った.Guitar;
 270                                 Guitar.b演奏にMIDI入力を使用した = this.b演奏にMIDI入力を使った.Guitar;
 271                                 Guitar.b演奏にジョイパッドを使用した = this.b演奏にジョイパッドを使った.Guitar;
 272                                 Guitar.b演奏にマウスを使用した = this.b演奏にマウスを使った.Guitar;
 273                                 Guitar.nPerfectになる範囲ms = CDTXMania.Instance.nPerfect範囲ms;
 274                                 Guitar.nGreatになる範囲ms = CDTXMania.Instance.nGreat範囲ms;
 275                                 Guitar.nGoodになる範囲ms = CDTXMania.Instance.nGood範囲ms;
 276                                 Guitar.nPoorになる範囲ms = CDTXMania.Instance.nPoor範囲ms;
 277                                 Guitar.strDTXManiaのバージョン = CDTXMania.VERSION;
 278                                 Guitar.最終更新日時 = DateTime.Now.ToString();
 279                                 // #35417 chnmr0 add
 280                                 Guitar.bギターとベースを入れ替えた = CDTXMania.Instance.ConfigIni.bIsSwappedGuitarBass;
 281                         }
 282                 }
 283                 private void t演奏結果を格納する_ベース()
 284                 {
 285                         record.Bass = new CScoreIni.C演奏記録();
 286                         CScoreIni.C演奏記録 Bass = Record.Bass;
 287                         bool allauto = CDTXMania.Instance.ConfigIni.bIsAutoPlay(EPart.Bass);
 288                         if (CDTXMania.Instance.DTX.bチップがある.Bass)
 289                         {
 290                                 Bass.nスコア = (long)this.actScore.Get(EPart.Bass);
 291                                 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);
 292                                 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);
 293                                 Bass.nPerfect数 = allauto ? this.nヒット数_Auto含む.Bass.Perfect : this.nヒット数_Auto含まない.Bass.Perfect;
 294                                 Bass.nGreat数 = allauto ? this.nヒット数_Auto含む.Bass.Great : this.nヒット数_Auto含まない.Bass.Great;
 295                                 Bass.nGood数 = allauto ? this.nヒット数_Auto含む.Bass.Good : this.nヒット数_Auto含まない.Bass.Good;
 296                                 Bass.nPoor数 = allauto ? this.nヒット数_Auto含む.Bass.Poor : this.nヒット数_Auto含まない.Bass.Poor;
 297                                 Bass.nMiss数 = allauto ? this.nヒット数_Auto含む.Bass.Miss : this.nヒット数_Auto含まない.Bass.Miss;
 298                                 Bass.nPerfect数_Auto含まない = this.nヒット数_Auto含まない.Bass.Perfect;
 299                                 Bass.nGreat数_Auto含まない = this.nヒット数_Auto含まない.Bass.Great;
 300                                 Bass.nGood数_Auto含まない = this.nヒット数_Auto含まない.Bass.Good;
 301                                 Bass.nPoor数_Auto含まない = this.nヒット数_Auto含まない.Bass.Poor;
 302                                 Bass.nMiss数_Auto含まない = this.nヒット数_Auto含まない.Bass.Miss;
 303                                 Bass.n最大コンボ数 = this.actCombo.dgbコンボ数.Bass.n最高値;
 304                                 Bass.n全チップ数 = CDTXMania.Instance.DTX.n可視チップ数.Bass;
 305                                 for (EPad i = EPad.Min; i < EPad.BassPadMax; i++)
 306                                 {
 307                                         Bass.bAutoPlay[i] = CDTXMania.Instance.ConfigIni.bAutoPlay[i];
 308                                 }
 309                                 Bass.bTight = CDTXMania.Instance.ConfigIni.bTight;
 310                                 for (EPart i = EPart.Drums; i <= EPart.Bass; i++)
 311                                 {
 312                                         Bass.eSudHidInv[i] = CDTXMania.Instance.ConfigIni.eSudHidInv[i];
 313                                         Bass.bReverse[i] = CDTXMania.Instance.ConfigIni.bReverse[i];
 314                                         Bass.eRandom[i] = CDTXMania.Instance.ConfigIni.eRandom[i];
 315                                         Bass.bLight[i] = CDTXMania.Instance.ConfigIni.bLight[i];
 316                                         Bass.f譜面スクロール速度[i] = ((float)(CDTXMania.Instance.ConfigIni.nScrollSpeed[i] + 1)) * 0.5f;
 317                                 }
 318                                 Bass.eDark = CDTXMania.Instance.ConfigIni.eDark;
 319                                 Bass.n演奏速度分子 = CDTXMania.Instance.ConfigIni.nPlaySpeed;
 320                                 Bass.n演奏速度分母 = 20;
 321                                 Bass.eHHGroup = CDTXMania.Instance.ConfigIni.eHHGroup;
 322                                 Bass.eFTGroup = CDTXMania.Instance.ConfigIni.eFTGroup;
 323                                 Bass.eCYGroup = CDTXMania.Instance.ConfigIni.eCYGroup;
 324                                 Bass.e譜面レーンタイプ.Drums = CDTXMania.Instance.DTX.n使用レーン数.Drums;
 325                                 Bass.e譜面レーンタイプ.Guitar = CDTXMania.Instance.DTX.n使用レーン数.Guitar;
 326                                 Bass.e譜面レーンタイプ.Bass = CDTXMania.Instance.DTX.n使用レーン数.Bass;
 327                                 Bass.eHitSoundPriorityHH = CDTXMania.Instance.ConfigIni.eHitSoundPriorityHH;
 328                                 Bass.eHitSoundPriorityFT = CDTXMania.Instance.ConfigIni.eHitSoundPriorityFT;
 329                                 Bass.eHitSoundPriorityCY = CDTXMania.Instance.ConfigIni.eHitSoundPriorityCY;
 330                                 Bass.bGuitar有効 = CDTXMania.Instance.ConfigIni.bGuitar有効;
 331                                 Bass.bDrums有効 = CDTXMania.Instance.ConfigIni.bDrums有効;
 332                                 Bass.bSTAGEFAILED有効 = CDTXMania.Instance.ConfigIni.bStageFailed;
 333                                 Bass.eダメージレベル = CDTXMania.Instance.ConfigIni.eDamageLevel;
 334                                 // #24280 2011.1.29 yyagi
 335                                 Bass.eMetronome = CDTXMania.Instance.ConfigIni.eClickType;
 336                                 Bass.b演奏にキーボードを使用した = this.b演奏にキーボードを使った.Bass;
 337                                 Bass.b演奏にMIDI入力を使用した = this.b演奏にMIDI入力を使った.Bass;
 338                                 Bass.b演奏にジョイパッドを使用した = this.b演奏にジョイパッドを使った.Bass;
 339                                 Bass.b演奏にマウスを使用した = this.b演奏にマウスを使った.Bass;
 340                                 Bass.nPerfectになる範囲ms = CDTXMania.Instance.nPerfect範囲ms;
 341                                 Bass.nGreatになる範囲ms = CDTXMania.Instance.nGreat範囲ms;
 342                                 Bass.nGoodになる範囲ms = CDTXMania.Instance.nGood範囲ms;
 343                                 Bass.nPoorになる範囲ms = CDTXMania.Instance.nPoor範囲ms;
 344                                 Bass.strDTXManiaのバージョン = CDTXMania.VERSION;
 345                                 Bass.最終更新日時 = DateTime.Now.ToString();
 346                                 // #35417 chnmr0 add
 347                                 Bass.bギターとベースを入れ替えた = CDTXMania.Instance.ConfigIni.bIsSwappedGuitarBass;
 348                         }
 349                 }
 350                 #endregion
 351
 352                 // CStage 実装
 353                 public override void On活性化()
 354                 {
 355                         if (base.b活性化してない)
 356                         {
 357                                 this.bフィルイン中 = false;
 358                                 this.dtLastQueueOperation = DateTime.MinValue;
 359                                 this.eフェードアウト完了時の戻り値 = E演奏画面の戻り値.継続;
 360                                 this.n現在のトップChip = (CDTXMania.Instance.DTX.listChip.Count > 0) ? 0 : -1;
 361                                 n最後に再生した実WAV番号 = new STPadValue<int>();
 362                                 this.L最後に再生したHHの実WAV番号 = new List<int>(16);
 363                                 this.e最後に再生したHHのチャンネル番号 = 0;
 364                                 this.n最後に再生した実WAV番号.GtPick = -1;
 365                                 this.n最後に再生した実WAV番号.BsPick = -1;
 366                                 for (int i = 0; i < 50; i++)
 367                                 {
 368                                         this.n最後に再生したBGMの実WAV番号[i] = -1;
 369                                 }
 370                                 this.r次にくるギターChip = null;
 371                                 this.r次にくるベースChip = null;
 372                                 for (int j = 0; j < 10; j++)
 373                                 {
 374                                         this.r現在の空うちドラムChip[j] = null;
 375                                 }
 376                                 this.r現在の空うちギターChip = null;
 377                                 this.r現在の空うちベースChip = null;
 378                                 cInvisibleChip = new CInvisibleChip(CDTXMania.Instance.ConfigIni.nChipDisplayTimeMs, CDTXMania.Instance.ConfigIni.nChipFadeoutTimeMs);
 379                                 this.n最大コンボ数_TargetGhost = new STDGBSValue<int>();
 380
 381                                 for (EPart k = EPart.Drums; k <= EPart.Bass; k++)
 382                                 {
 383                                         this.nヒット数_Auto含まない[k] = new CHitCountOfRank();
 384                                         this.nヒット数_Auto含む[k] = new CHitCountOfRank();
 385                                         this.nヒット数_TargetGhost[k] = new CHitCountOfRank();
 386                                         this.queWailing[k] = new Queue<CChip>();
 387                                         this.r現在の歓声Chip[k] = null;
 388                                         if (CDTXMania.Instance.DTXVmode.Enabled)
 389                                         {
 390                                                 CDTXMania.Instance.ConfigIni.nScrollSpeed[k] = CDTXMania.Instance.ConfigIni.nViewerScrollSpeed[k];
 391                                         }
 392
 393                                         this.b演奏にキーボードを使った[k] = false;
 394                                         this.b演奏にジョイパッドを使った[k] = false;
 395                                         this.b演奏にMIDI入力を使った[k] = false;
 396                                         this.b演奏にマウスを使った[k] = false;
 397                                 }
 398
 399                                 cInvisibleChip.Reset();
 400                                 actGauge.Init(CDTXMania.Instance.ConfigIni.nRisky);
 401                                 // 効果音のストリームをミキサーから解除しておく
 402                                 CDTXMania.Instance.Skin.tRemoveMixerAll();
 403                                 queueMixerSound = new Queue<STMixer>(64);
 404                                 bIsDirectSound = (CDTXMania.Instance.Sound管理.CurrentSoundDeviceType == ESoundDeviceType.DirectSound);
 405                                 this.bPAUSE = false;
 406
 407                                 if (CDTXMania.Instance.DTXVmode.Enabled)
 408                                 {
 409                                         db再生速度 = CDTXMania.Instance.DTX.dbDTXVPlaySpeed;
 410                                         CDTXMania.Instance.ConfigIni.nPlaySpeed.Value = (int)(CDTXMania.Instance.DTX.dbDTXVPlaySpeed * 20 + 0.5);
 411                                 }
 412                                 else
 413                                 {
 414                                         db再生速度 = ((double)CDTXMania.Instance.ConfigIni.nPlaySpeed) / 20.0;
 415                                 }
 416
 417                                 bValidScore = (CDTXMania.Instance.DTXVmode.Enabled || CDTXMania.Instance.DTX2WAVmode.Enabled) ? false : true;
 418
 419                                 cWailingChip = new CWailingChip共通[3];
 420                                 // 0:未使用, 1:Gutiar, 2:Bass
 421                                 cWailingChip[1] = new CWailingChip共通();
 422                                 cWailingChip[2] = new CWailingChip共通();
 423
 424                                 #region [ 演奏開始前にmixer登録しておくべきサウンド(開幕してすぐに鳴らすことになるチップ音)を登録しておく ]
 425                                 foreach (CChip pChip in CDTXMania.Instance.DTX.listChip)
 426                                 {
 427                                         //                              Debug.WriteLine( "CH=" + pChip.nチャンネル番号.ToString( "x2" ) + ", 整数値=" + pChip.n整数値 +  ", time=" + pChip.n発声時刻ms );
 428                                         if (pChip.n発声時刻ms <= 0)
 429                                         {
 430                                                 if (pChip.eチャンネル番号 == EChannel.MixerAdd)
 431                                                 {
 432                                                         pChip.bHit = true;
 433                                                         //                                              Trace.TraceInformation( "first [DA] BAR=" + pChip.n発声位置 / 384 + " ch=" + pChip.nチャンネル番号.ToString( "x2" ) + ", wav=" + pChip.n整数値 + ", time=" + pChip.n発声時刻ms );
 434                                                         if (CDTXMania.Instance.DTX.listWAV.ContainsKey(pChip.n整数値_内部番号))
 435                                                         {
 436                                                                 CDTX.CWAV wc = CDTXMania.Instance.DTX.listWAV[pChip.n整数値_内部番号];
 437                                                                 for (int i = 0; i < Math.Max(CDTXMania.Instance.ConfigIni.nPolyphonicSounds, CDTXMania.Instance.ConfigIni.nPolyphonicSoundsGB); i++)
 438                                                                 {
 439                                                                         if (wc.rSound[i] != null)
 440                                                                         {
 441                                                                                 CDTXMania.Instance.Sound管理.AddMixer(wc.rSound[i], db再生速度, pChip.b演奏終了後も再生が続くチップである);
 442                                                                                 //AddMixer( wc.rSound[ i ] );           // 最初はqueueを介さず直接ミキサー登録する
 443                                                                         }
 444                                                                 }
 445                                                         }
 446                                                 }
 447                                         }
 448                                         else
 449                                         {
 450                                                 break;
 451                                         }
 452                                 }
 453                                 #endregion
 454
 455
 456                                 if (CDTXMania.Instance.ConfigIni.bIsSwappedGuitarBass)  // #24063 2011.1.24 yyagi Gt/Bsの譜面情報入れ替え
 457                                 {
 458                                         CDTXMania.Instance.DTX.SwapGuitarBassInfos();
 459                                 }
 460
 461
 462                                 for (EPart inst = EPart.Drums; inst <= EPart.Bass; ++inst)
 463                                 {
 464                                         // MODIFY_BEGIN #25398 2011.06.07 FROM
 465                                         if (CDTXMania.Instance.bコンパクトモード)
 466                                         {
 467                                                 var score = new Cスコア();
 468                                                 CDTXMania.Instance.Songs管理.tScoreIniを読み込んで譜面情報を設定する(CDTXMania.Instance.strコンパクトモードファイル + ".score.ini", ref score);
 469                                                 this.actGraph.dbTarget[inst] = score.譜面情報.最大スキル[inst];
 470                                         }
 471                                         else
 472                                         {
 473                                                 if (CDTXMania.Instance.ConfigIni.b楽器有効(inst))
 474                                                 {
 475                                                         this.actGraph.dbTarget[inst] = CDTXMania.Instance.stage選曲.r確定されたスコア.譜面情報.最大スキル[inst];   // #24074 2011.01.23 add ikanick
 476
 477                                                         // ゴースト利用可のなとき、0で初期化
 478                                                         if (CDTXMania.Instance.ConfigIni.eTargetGhost[inst] != ETargetGhostData.None)
 479                                                         {
 480                                                                 if (CDTXMania.Instance.DTX.listTargetGhsotLag[inst] != null)
 481                                                                 {
 482                                                                         this.actGraph.dbTarget[inst] = 0;
 483                                                                 }
 484                                                         }
 485                                                 }
 486                                         }
 487                                         // MODIFY_END #25398
 488                                 }
 489
 490                                 for (EPart part = EPart.Drums; part <= EPart.Bass; ++part)
 491                                 {
 492                                         if (CDTXMania.Instance.ConfigIni.b楽器有効(part))
 493                                         {
 494                                                 actOptionPanel.Pos[part] = new Coordinates.CXY(CDTXMania.Instance.ConfigIni.cdInstX[part][CDTXMania.Instance.ConfigIni.eActiveInst]
 495                                                         - CDTXMania.Instance.Coordinates.ImgOptionPanel.W, 0);
 496                                         }
 497                                 }
 498
 499                                 base.On活性化();
 500
 501                                 // PANELの設定は、base.On活性化()の後に(actPanelの活性化の後)行うこと。
 502                                 // さもないと、actPanelが活性化されていないため、パネル文字列の設定が機能しなくなる。
 503                                 string strLabel = (CDTXMania.Instance.stage選曲.r確定された曲 == null)?
 504                                         null : CDTXMania.Instance.stage選曲.r確定された曲.ar難易度ラベル[ CDTXMania.Instance.stage選曲.n確定された曲の難易度 ];
 505                                 string strPanel = CDTXMania.Instance.DTX.TITLE;
 506                                 //string strSETDEFlabel = CDTXMania.Instance.stage選曲.r確定された曲.strタイトル;
 507                                 if ( !string.IsNullOrWhiteSpace( strLabel ) && !strPanel.ToLower().Contains(strLabel.ToLower() )
 508                                 //      && (strPanel == strSETDEFlabel)
 509                                 )
 510                                 {
 511                                         strPanel += " (" + strLabel + ")";
 512                                 }
 513                                 this.actPanel.SetPanelString( strPanel );
 514
 515                                 nLastSendMessageTime = 0;
 516
 517 #if TEST_MEASUREFRAMEDRAWTIME
 518                                 swlist.Clear();
 519                                 swlist.Capacity = 100000;
 520                                 sw.Reset();
 521                                 sw.Start();
 522                                 tmlist.Clear();
 523                                 tmlist.Capacity = 100000;
 524 #endif
 525                         }
 526                 }
 527                 public override void On非活性化()
 528                 {
 529                         if (b活性化してる)
 530                         {
 531                                 // #23921 2011.1.4 yyagi
 532                                 L最後に再生したHHの実WAV番号.Clear();
 533                                 L最後に再生したHHの実WAV番号 = null;
 534                                 for (EPart i = 0; i <= EPart.Bass; i++)
 535                                 {
 536                                         queWailing[i].Clear();
 537                                         queWailing[i] = null;
 538                                 }
 539                                 ctWailingチップ模様アニメ = null;
 540                                 ctチップ模様アニメ.Drums = null;
 541                                 ctチップ模様アニメ.Guitar = null;
 542                                 ctチップ模様アニメ.Bass = null;
 543                                 queueMixerSound.Clear();
 544                                 queueMixerSound = null;
 545                                 cInvisibleChip.Dispose();
 546                                 cInvisibleChip = null;
 547                                 base.On非活性化();
 548
 549 #if TEST_MEASUREFRAMEDRAWTIME
 550                                 sw.Stop();
 551                                 Trace.TraceInformation("Freq={0:F10}", Stopwatch.Frequency);
 552                                 Trace.TraceInformation("IsHighResolution=" + Stopwatch.IsHighResolution);
 553                                 Trace.TraceInformation("Count=" + swlist.Count );
 554                                 double last_d = 0;
 555                                 long last_t = 0;
 556                                 int p = 0;
 557                                 foreach (long l in swlist)
 558                                 {
 559                                         double d = (double)l / Stopwatch.Frequency;
 560                                         double d2 = d - last_d;
 561                                         long t = tmlist[p++];
 562                                         long t2 = t - last_t;
 563                                         Trace.TraceInformation("{0:F10}, {1:F10}, {2:d6}, {3:d3}", d, d2, t, t2);
 564                                         last_d = d;
 565                                         last_t = t;
 566                                 }
 567                                 swlist.Clear();
 568 #endif
 569                         }
 570                 }
 571                 public override void OnManagedリソースの作成()
 572                 {
 573                         if (b活性化してる)
 574                         {
 575                                 txチップ = TextureFactory.tテクスチャの生成(CSkin.Path(@"Graphics\ScreenPlayDrums chips.png"));
 576                                 txチップGB = TextureFactory.tテクスチャの生成(CSkin.Path(@"Graphics\ScreenPlayGuitar chips.png"));
 577                                 txヒットバー = TextureFactory.tテクスチャの生成(CSkin.Path(@"Graphics\ScreenPlayDrums hit-bar.png"));
 578                                 txヒットバーGB = TextureFactory.tテクスチャの生成(CSkin.Path(@"Graphics\ScreenPlayDrums hit-bar guitar.png"));
 579                                 txWailing枠 = TextureFactory.tテクスチャの生成(CSkin.Path(@"Graphics\ScreenPlay wailing cursor.png"));
 580                                 t背景テクスチャの生成();
 581                                 base.OnManagedリソースの作成();
 582                         }
 583
 584                 }
 585                 public override void OnManagedリソースの解放()
 586                 {
 587                         if (b活性化してる)
 588                         {
 589                                 TextureFactory.tテクスチャの解放(ref this.tx背景);
 590                                 TextureFactory.tテクスチャの解放(ref this.txWailing枠);
 591                                 TextureFactory.tテクスチャの解放(ref this.txヒットバーGB);
 592                                 TextureFactory.tテクスチャの解放(ref this.txヒットバー);
 593                                 TextureFactory.tテクスチャの解放(ref this.txチップGB);
 594                                 TextureFactory.tテクスチャの解放(ref this.txチップ);
 595                                 base.OnManagedリソースの解放();
 596                         }
 597                 }
 598                 public override int On進行描画()
 599                 {
 600                         if (b活性化してる)
 601                         {
 602                                 bool bIsFinishedPlaying = false;
 603                                 bool bIsFinishedFadeout = false;
 604
 605                                 if (b初めての進行描画)
 606                                 {
 607                                         PrepareAVITexture();
 608
 609                                         CSound管理.rc演奏用タイマ.tリセット();
 610                                         CDTXMania.Instance.Timer.tリセット();
 611                                         if (CDTXMania.Instance.ConfigIni.bDrums有効)
 612                                         {
 613                                                 ctチップ模様アニメ.Drums = new CCounter(0, 48, 10, CDTXMania.Instance.Timer);
 614                                         }
 615                                         if (CDTXMania.Instance.ConfigIni.bGuitar有効)
 616                                         {
 617                                                 ctチップ模様アニメ.Guitar = new CCounter(0, 48, 20, CDTXMania.Instance.Timer);
 618                                                 ctチップ模様アニメ.Bass = new CCounter(0, 48, 20, CDTXMania.Instance.Timer);
 619                                                 ctWailingチップ模様アニメ = new CCounter(0, 4, 50, CDTXMania.Instance.Timer);
 620                                         }
 621
 622                                         // this.actChipFireD.Start( Eレーン.HH );    // #31554 2013.6.12 yyagi
 623                                         // 初チップヒット時のもたつき回避。最初にactChipFireD.Start()するときにJITが掛かって？
 624                                         // ものすごく待たされる(2回目以降と比べると2,3桁tick違う)。そこで最初の画面フェードインの間に
 625                                         // 一発Start()を掛けてJITの結果を生成させておく。
 626
 627                                         base.eフェーズID = CStage.Eフェーズ.共通_フェードイン;
 628                                         actFI.tフェードイン開始();
 629
 630                                         if (CDTXMania.Instance.DTXVmode.Enabled)
 631                                         {
 632                                                 #region [ DTXV用の再生設定にする(全AUTOなど) ]
 633                                                 tDTXV用の設定();
 634                                                 #endregion
 635                                                 t演奏位置の変更(CDTXMania.Instance.DTXVmode.nStartBar);
 636                                         }
 637
 638                                         CDTXMania.Instance.Sound管理.tDisableUpdateBufferAutomatically();
 639                                         b初めての進行描画 = false;
 640                                 }
 641
 642                                 #region [ stage failed ]
 643                                 if (CDTXMania.Instance.ConfigIni.bStageFailed && (base.eフェーズID == CStage.Eフェーズ.共通_通常状態))
 644                                 {
 645                                         if (actGauge.IsFailed)
 646                                         {
 647                                                 actStageFailed.Start();
 648                                                 CDTXMania.Instance.DTX.t全チップの再生停止();
 649                                                 base.eフェーズID = CStage.Eフェーズ.演奏_STAGE_FAILED;
 650                                         }
 651                                 }
 652                                 #endregion
 653
 654                                 // Background
 655                                 if (CDTXMania.Instance.ConfigIni.eDark == EDark.Off)
 656                                 {
 657                                         if (tx背景 != null)
 658                                         {
 659                                                 tx背景.t2D描画(CDTXMania.Instance.Device, 0, 0);
 660                                         }
 661                                 }
 662
 663                                 if (base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED &&
 664                                         base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト)
 665                                 {
 666                                         // AVI / BGA
 667                                         //actAVI.t進行描画(
 668                                         //      CDTXMania.Instance.ConfigIni.cdAVIX[CDTXMania.Instance.ConfigIni.eActiveInst],
 669                                         //      CDTXMania.Instance.ConfigIni.cdAVIY[CDTXMania.Instance.ConfigIni.eActiveInst],
 670                                         //      CDTXMania.Instance.Coordinates.Movie.W,
 671                                         //      CDTXMania.Instance.Coordinates.Movie.H);
 672                                         actAVI.t進行描画();
 673                                         actBGA.On進行描画();
 674                                         #region [MIDIBGM 処理?]
 675                                         if (base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED)
 676                                         {
 677                                                 CStage.Eフェーズ eフェーズid1 = base.eフェーズID;
 678                                         }
 679                                         #endregion
 680                     if (!CDTXMania.Instance.DTX2WAVmode.Enabled)
 681                     {
 682                         actLane.On進行描画();
 683                         actLaneFlushGB.On進行描画();
 684                         actPanel.On進行描画();
 685                         actScore.On進行描画();
 686                         actOptionPanel.On進行描画();
 687                         actGauge.On進行描画();
 688                         actGraph.On進行描画();
 689                         actLaneFlushD.On進行描画();
 690                                                 if (CDTXMania.Instance.ConfigIni.bStageFailed)  // #38693 2018.10.30 yyagi red-flashing only when StageFailed=ON
 691                                                 {
 692                                                         actDANGER.t進行描画(actGauge.IsDanger);
 693                                                 }
 694                     }
 695                     act譜面スクロール速度.On進行描画();
 696                                         t進行描画_判定ライン();
 697                                         actWailingBonus.On進行描画();
 698
 699                                         // RGB, Judge, Combo (Priority Under Chip)
 700                                         if (CDTXMania.Instance.ConfigIni.eJudgePriority == EJudgeDisplayPriority.Under)
 701                                         {
 702                                                 actJudgeString.On進行描画();
 703                                                 actCombo.On進行描画();
 704                                         }
 705                                         t進行描画_チップアニメ();
 706                                         bIsFinishedPlaying = t進行描画_チップ();
 707                                         actPad.On進行描画();
 708
 709                                         // RGB, Judge, Combo (Priority Over Chip)
 710                                         if (CDTXMania.Instance.ConfigIni.eJudgePriority == EJudgeDisplayPriority.Over)
 711                                         {
 712                                                 actJudgeString.On進行描画();
 713                                                 actCombo.On進行描画();
 714                                         }
 715                                         actRGB.On進行描画();
 716                                         if (!CDTXMania.Instance.DTX2WAVmode.Enabled)
 717                     {
 718                         actChipFireD.On進行描画();
 719                         actChipFireGB.On進行描画();
 720                         actPlayInfo.On進行描画();
 721                     }
 722
 723                                         // Wailing
 724                                         if ((CDTXMania.Instance.ConfigIni.eDark != EDark.Full) &&
 725                                                 CDTXMania.Instance.ConfigIni.bGuitar有効)
 726                                         {
 727                                                 int GtWailingFrameX = CDTXMania.Instance.ConfigIni.GetLaneX(ELane.GtW) +
 728                                                         (CDTXMania.Instance.ConfigIni.GetLaneW(ELane.GtW) - CDTXMania.Instance.Coordinates.ImgGtWailingFrame.W) / 2;
 729                                                 int BsWailingFrameX = CDTXMania.Instance.ConfigIni.GetLaneX(ELane.BsW) +
 730                                                         (CDTXMania.Instance.ConfigIni.GetLaneW(ELane.BsW) - CDTXMania.Instance.Coordinates.ImgGtWailingFrame.W) / 2;
 731                                                 int GtWailingFrameY = C演奏判定ライン座標共通.n判定ラインY座標(EPart.Guitar, true, true);
 732                                                 int BsWailingFrameY = C演奏判定ライン座標共通.n判定ラインY座標(EPart.Bass, true, true);
 733
 734                                                 if (txWailing枠 != null)
 735                                                 {
 736                                                         if (CDTXMania.Instance.DTX.bチップがある.Guitar)
 737                                                         {
 738                                                                 txWailing枠.t2D描画(CDTXMania.Instance.Device, GtWailingFrameX, GtWailingFrameY);
 739                                                         }
 740                                                         if (CDTXMania.Instance.DTX.bチップがある.Bass)
 741                                                         {
 742                                                                 txWailing枠.t2D描画(CDTXMania.Instance.Device, BsWailingFrameX, BsWailingFrameY);
 743                                                         }
 744                                                 }
 745                                         }
 746                                 }
 747
 748                                 // Stage Failed
 749                                 if (((base.eフェーズID == CStage.Eフェーズ.演奏_STAGE_FAILED) ||
 750                                         (base.eフェーズID == CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト)) &&
 751                                         ((actStageFailed.On進行描画() != 0) &&
 752                                         (base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト)))
 753                                 {
 754                                         eフェードアウト完了時の戻り値 = E演奏画面の戻り値.ステージ失敗;
 755                                         base.eフェーズID = CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト;
 756                                         actFO.tフェードアウト開始();
 757                                 }
 758
 759                                 bIsFinishedFadeout = this.t進行描画_フェードイン_アウト();
 760                                 if (bIsFinishedPlaying && (base.eフェーズID == CStage.Eフェーズ.共通_通常状態))
 761                                 {
 762                                         if (CDTXMania.Instance.DTXVmode.Enabled)
 763                                         {
 764                                                 if (CDTXMania.Instance.Timer.b停止していない)
 765                                                 {
 766                                                         actPanel.Stop();
 767                                                         CDTXMania.Instance.Timer.t一時停止();
 768                                                 }
 769                                                 Thread.Sleep(5);
 770                                                 // DTXCからの次のメッセージを待ち続ける
 771                                         }
 772                     else if (CDTXMania.Instance.DTX2WAVmode.Enabled)
 773                     {
 774                                                 // すべての再生が終わるのを待って、録音を終了し、アプリを終了する
 775                                                 bool bPlaying = true;
 776                                                 while (bPlaying)
 777                                                 {
 778                                                         bPlaying = CDTXMania.Instance.DTX.tWavのいずれかが再生中();
 779                                                         if (bPlaying)
 780                                                         {
 781                                                                 Thread.Sleep(5);
 782                                                         }
 783                                                 }
 784
 785                                                 FDK.CSound管理.t録音終了();
 786
 787                                                 this.eフェードアウト完了時の戻り値 = E演奏画面の戻り値.演奏中断;
 788                                                 base.eフェーズID = CStage.Eフェーズ.共通_終了状態;
 789                                                 return (int)this.eフェードアウト完了時の戻り値;
 790                                         }
 791                                         else
 792                                         {
 793                                                 this.eフェードアウト完了時の戻り値 = E演奏画面の戻り値.ステージクリア;
 794                                                 base.eフェーズID = CStage.Eフェーズ.演奏_STAGE_CLEAR_フェードアウト;
 795                                                 this.actFOClear.tフェードアウト開始();
 796                                                 t演奏結果を格納する_ドラム();
 797                                                 t演奏結果を格納する_ギター();
 798                                                 t演奏結果を格納する_ベース();
 799
 800                                                 if (CDTXMania.Instance.ConfigIni.bDrums有効)
 801                                                 {
 802                                                         for (EPad pad = EPad.DrumsPadMin; pad < EPad.DrumsPadMax; pad++)
 803                                                         {
 804                                                                 r空打ちドラムチップ[pad] = r空うちChip(EPart.Drums, pad);
 805                                                                 if (r空打ちドラムチップ[pad] == null)
 806                                                                 {
 807                                                                         r空打ちドラムチップ[pad] = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(
 808                                                                                         CSound管理.rc演奏用タイマ.n現在時刻,
 809                                                                                         EnumConverter.ChannelFromPad(pad),
 810                                                                                         CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs.Drums);
 811                                                                 }
 812                                                         }
 813                                                 }
 814
 815                                                 if (CDTXMania.Instance.ConfigIni.bIsSwappedGuitarBass)      // #24063 2011.1.24 yyagi Gt/Bsを入れ替えていたなら、演奏結果も入れ替える
 816                                                 {
 817                                                         CScoreIni.C演奏記録 t;
 818                                                         t = record.Guitar;
 819                                                         record.Guitar = record.Bass;
 820                                                         record.Bass = t;
 821
 822                                                         // 譜面情報も元に戻す
 823                                                         // #35417 2015.08.30 changed フラグにアクセスしている箇所が見つかったため有効化
 824                                                         // #35417 2015.8.18 yyagi: AUTO系のフラグ入れ替えは削除可能!?。以後AUTOフラグに全くアクセスしておらず、意味がないため。
 825                                                         // (直下でb全AUTOである にアクセスしているが、既に計算済みのクラスへのアクセスであり、ここでの交換対象ではない)
 826                                                         CDTXMania.Instance.DTX.SwapGuitarBassInfos();
 827                                                         // #24415 2011.2.27 yyagi
 828                                                         // リザルト集計時のみ、Auto系のフラグも元に戻す。
 829                                                         // これを戻すのは、リザルト集計後。
 830                                                         // "case CStage.Eステージ.結果:"のところ。
 831                                                         CDTXMania.Instance.ConfigIni.SwapGuitarBassInfos_AutoFlags();
 832                                                 }
 833                                         }
 834                                 }
 835                                 if (this.eフェードアウト完了時の戻り値 == E演奏画面の戻り値.再読込_再演奏)
 836                                 {
 837                                         bIsFinishedFadeout = true;
 838                                 }
 839                                 if (bIsFinishedFadeout)
 840                                 {
 841                                         return (int)this.eフェードアウト完了時の戻り値;
 842                                 }
 843
 844                                 // DTX2WAVに進捗状況を送信。1秒ごとに1回ずつ送信する。
 845                                 if (CDTXMania.Instance.DTX2WAVmode.Enabled)
 846                                 {
 847                                         if (nLastSendMessageTime + 1000 < CDTXMania.Instance.Timer.n現在時刻)
 848                                         {
 849                                                 int nEstimateTimeMs = (CDTXMania.Instance.DTX.listChip.Count > 0) ? CDTXMania.Instance.DTX.listChip[CDTXMania.Instance.DTX.listChip.Count - 1].n発声時刻ms : 0;
 850                                                 CDTXMania.Instance.DTX2WAVmode.SendMessage2DTX2WAV("TIME," + CDTXMania.Instance.Timer.n現在時刻.ToString() + "," + nEstimateTimeMs.ToString());
 851                                                 nLastSendMessageTime = CDTXMania.Instance.Timer.n現在時刻;
 852                                         }
 853                                 }
 854
 855                                 ManageMixerQueue();
 856
 857                                 // キー入力
 858
 859                                 if (CDTXMania.Instance.act現在入力を占有中のプラグイン == null)
 860                                 {
 861                                         this.tキー入力();
 862                                 }
 863
 864 #if TEST_MEASUREFRAMEDRAWTIME
 865                                 swlist.Add(sw.ElapsedTicks);
 866                                 tmlist.Add(CSound管理.rc演奏用タイマ.n現在時刻ms);
 867 #endif
 868                         }
 869                         return 0;
 870                 }
 871
 872                 // その他
 873                 public STPadValue<CChip> GetNoChipDrums()
 874                 {
 875                         return r空打ちドラムチップ;
 876                 }
 877                 public STDGBSValue<CScoreIni.C演奏記録> Record
 878                 {
 879                         get
 880                         {
 881                                 return record;
 882                         }
 883                 }
 884                 public void AddMixer(CSound cs, bool _b演奏終了後も再生が続くチップである)
 885                 {
 886                         STMixer stm = new STMixer()
 887                         {
 888                                 bIsAdd = true,
 889                                 csound = cs,
 890                                 b演奏終了後も再生が続くチップである = _b演奏終了後も再生が続くチップである
 891                         };
 892                         queueMixerSound.Enqueue(stm);
 893                         //              Debug.WriteLine( "★Queue: add " + Path.GetFileName( stm.csound.strファイル名 ));
 894                 }
 895                 public void RemoveMixer(CSound cs)
 896                 {
 897                         STMixer stm = new STMixer()
 898                         {
 899                                 bIsAdd = false,
 900                                 csound = cs,
 901                                 b演奏終了後も再生が続くチップである = false
 902                         };
 903                         queueMixerSound.Enqueue(stm);
 904                         //              Debug.WriteLine( "★Queue: remove " + Path.GetFileName( stm.csound.strファイル名 ));
 905                 }
 906                 public void ManageMixerQueue()
 907                 {
 908                         // もしサウンドの登録/削除が必要なら、実行する
 909                         if (queueMixerSound.Count > 0)
 910                         {
 911                                 //Debug.WriteLine( "☆queueLength=" + queueMixerSound.Count );
 912                                 DateTime dtnow = DateTime.Now;
 913                                 TimeSpan ts = dtnow - dtLastQueueOperation;
 914                                 int nInterval = ( CDTXMania.Instance.ConfigIni.bVSyncWait ) ? 7 : 1;
 915                                 int nMaxDequeueCount = ( CDTXMania.Instance.ConfigIni.bVSyncWait ) ? 2 : 1;
 916                                 if (ts.Milliseconds > nInterval)
 917                                 {
 918                                         for (int i = 0; i < nMaxDequeueCount && queueMixerSound.Count > 0; i++)
 919                                         {
 920                                                 dtLastQueueOperation = dtnow;
 921                                                 STMixer stm = queueMixerSound.Dequeue();
 922                                                 if (stm.bIsAdd)
 923                                                 {
 924                                                 //      var task = Task.Run(() =>
 925                                                 //      {
 926                                                            CDTXMania.Instance.Sound管理.AddMixer(stm.csound, db再生速度, stm.b演奏終了後も再生が続くチップである);
 927                                                 //      });
 928                                                 }
 929                                                 else
 930                                                 {
 931                                                 //      var task = Task.Run(() =>
 932                                                 //      {
 933                                                                 CDTXMania.Instance.Sound管理.RemoveMixer(stm.csound);
 934                                                 //      });
 935                                                 }
 936                                         }
 937                                 }
 938                         }
 939                 }
 940
 941                 /// <summary>
 942                 /// 演奏開始前に適切なサイズのAVIテクスチャを作成しておくことで、AVI再生開始時のもたつきをなくす
 943                 /// </summary>
 944                 protected void PrepareAVITexture()
 945                 {
 946                         if (CDTXMania.Instance.ConfigIni.bAVI)
 947                         {
 948                                 foreach (CChip pChip in CDTXMania.Instance.DTX.listChip)
 949                                 {
 950                                         if (pChip.eチャンネル番号 == EChannel.Movie || pChip.eチャンネル番号 == EChannel.MovieFull)
 951                                         {
 952                                                 // 最初に再生するAVIチップに合わせて、テクスチャを準備しておく
 953                                                 if (pChip.rAVI != null)
 954                                                 {
 955                                                         this.actAVI.PrepareProperSizeTexture((int)pChip.rAVI.avi.nフレーム幅, (int)pChip.rAVI.avi.nフレーム高さ);
 956                                                 }
 957                                                 break;
 958                                         }
 959                                 }
 960                         }
 961                 }
 962
 963                 protected EJudge e指定時刻からChipのJUDGEを返す(long nTime, CChip pChip, int nInputAdjustTime, bool saveLag = true)
 964                 {
 965                         if (pChip != null)
 966                         {
 967                                 // #35411 2015.08.22 chnmr0 modified add check save lag flag for ghost
 968                                 int lag = (int)(nTime + nInputAdjustTime - pChip.n発声時刻ms);
 969                                 if (saveLag)
 970                                 {
 971                                         pChip.nLag = lag;
 972 //Trace.TraceInformation($"lag={lag}, chip={pChip.n整数値.ToString("x2")}");
 973                                         // #23580 2011.1.3 yyagi: add "nInputAdjustTime" to add input timing adjust feature
 974                                         if (pChip.e楽器パート != EPart.Unknown)
 975                                         {
 976                                                 pChip.extendInfoForGhost = this.actCombo.dgbコンボ数[pChip.e楽器パート].n現在値 > 0 ? true : false;
 977                                         }
 978                                 }
 979                                 // #35411 modify end
 980
 981                                 int nDeltaTime = Math.Abs(lag);
 982                                 //Debug.WriteLine("nAbsTime=" + (nTime - pChip.n発声時刻ms) + ", nDeltaTime=" + (nTime + nInputAdjustTime - pChip.n発声時刻ms));
 983                                 if (nDeltaTime <= CDTXMania.Instance.nPerfect範囲ms)
 984                                 {
 985                                         return EJudge.Perfect;
 986                                 }
 987                                 if (nDeltaTime <= CDTXMania.Instance.nGreat範囲ms)
 988                                 {
 989                                         return EJudge.Great;
 990                                 }
 991                                 if (nDeltaTime <= CDTXMania.Instance.nGood範囲ms)
 992                                 {
 993                                         return EJudge.Good;
 994                                 }
 995                                 if (nDeltaTime <= CDTXMania.Instance.nPoor範囲ms)
 996                                 {
 997                                         return EJudge.Poor;
 998                                 }
 999                         }
1000                         return EJudge.Miss;
1001                 }
1002
1003                 protected CChip r空うちChip(EPart part, EPad pad)
1004                 {
1005                         switch (part)
1006                         {
1007                                 case EPart.Drums:
1008                                         switch (pad)
1009                                         {
1010                                                 case EPad.HH:
1011                                                         if (this.r現在の空うちドラムChip.HH != null)
1012                                                         {
1013                                                                 return this.r現在の空うちドラムChip.HH;
1014                                                         }
1015                                                         if (CDTXMania.Instance.ConfigIni.eHHGroup != EHHGroup.HO_HC)
1016                                                         {
1017                                                                 if (CDTXMania.Instance.ConfigIni.eHHGroup == EHHGroup.LC_HH)
1018                                                                 {
1019                                                                         return this.r現在の空うちドラムChip.HHO;
1020                                                                 }
1021                                                                 if (this.r現在の空うちドラムChip.HHO != null)
1022                                                                 {
1023                                                                         return this.r現在の空うちドラムChip.HHO;
1024                                                                 }
1025                                                         }
1026                                                         return this.r現在の空うちドラムChip.LC;
1027
1028                                                 case EPad.SD:
1029                                                         return this.r現在の空うちドラムChip.SD;
1030
1031                                                 case EPad.BD:
1032                                                         return this.r現在の空うちドラムChip.BD;
1033
1034                                                 case EPad.HT:
1035                                                         return this.r現在の空うちドラムChip.HT;
1036
1037                                                 case EPad.LT:
1038                                                         if (this.r現在の空うちドラムChip.LT != null)
1039                                                         {
1040                                                                 return this.r現在の空うちドラムChip.LT;
1041                                                         }
1042                                                         if (CDTXMania.Instance.ConfigIni.eFTGroup == EFTGroup.Group)
1043                                                         {
1044                                                                 return this.r現在の空うちドラムChip.FT;
1045                                                         }
1046                                                         return null;
1047
1048                                                 case EPad.FT:
1049                                                         if (this.r現在の空うちドラムChip.FT != null)
1050                                                         {
1051                                                                 return this.r現在の空うちドラムChip.FT;
1052                                                         }
1053                                                         if (CDTXMania.Instance.ConfigIni.eFTGroup == EFTGroup.Group)
1054                                                         {
1055                                                                 return this.r現在の空うちドラムChip.LT;
1056                                                         }
1057                                                         return null;
1058
1059                                                 case EPad.CY:
1060                                                         if (this.r現在の空うちドラムChip.CY != null)
1061                                                         {
1062                                                                 return this.r現在の空うちドラムChip.CY;
1063                                                         }
1064                                                         if (CDTXMania.Instance.ConfigIni.eCYGroup == ECYGroup.Group)
1065                                                         {
1066                                                                 return this.r現在の空うちドラムChip.RD;
1067                                                         }
1068                                                         return null;
1069
1070                                                 case EPad.HHO:
1071                                                         if (this.r現在の空うちドラムChip.HHO != null)
1072                                                         {
1073                                                                 return this.r現在の空うちドラムChip.HHO;
1074                                                         }
1075                                                         if (CDTXMania.Instance.ConfigIni.eHHGroup != EHHGroup.HO_HC)
1076                                                         {
1077                                                                 if (CDTXMania.Instance.ConfigIni.eHHGroup == EHHGroup.LC_HH)
1078                                                                 {
1079                                                                         return this.r現在の空うちドラムChip.HH;
1080                                                                 }
1081                                                                 if (this.r現在の空うちドラムChip.HH != null)
1082                                                                 {
1083                                                                         return this.r現在の空うちドラムChip.HH;
1084                                                                 }
1085                                                         }
1086                                                         return this.r現在の空うちドラムChip.LC;
1087
1088                                                 case EPad.RD:
1089                                                         if (this.r現在の空うちドラムChip.RD != null)
1090                                                         {
1091                                                                 return this.r現在の空うちドラムChip.RD;
1092                                                         }
1093                                                         if (CDTXMania.Instance.ConfigIni.eCYGroup == ECYGroup.Group)
1094                                                         {
1095                                                                 return this.r現在の空うちドラムChip.CY;
1096                                                         }
1097                                                         return null;
1098
1099                                                 case EPad.LC:
1100                                                         if (this.r現在の空うちドラムChip.LC != null)
1101                                                         {
1102                                                                 return this.r現在の空うちドラムChip.LC;
1103                                                         }
1104                                                         if ((CDTXMania.Instance.ConfigIni.eHHGroup != EHHGroup.HO_HC) && (CDTXMania.Instance.ConfigIni.eHHGroup != EHHGroup.Group))
1105                                                         {
1106                                                                 return null;
1107                                                         }
1108                                                         if (this.r現在の空うちドラムChip.HH != null)
1109                                                         {
1110                                                                 return this.r現在の空うちドラムChip.HH;
1111                                                         }
1112                                                         return this.r現在の空うちドラムChip.HHO;
1113                                         }
1114                                         break;
1115
1116                                 case EPart.Guitar:
1117                                         return this.r現在の空うちギターChip;
1118
1119                                 case EPart.Bass:
1120                                         return this.r現在の空うちベースChip;
1121                         }
1122                         return null;
1123                 }
1124
1125                 protected CChip r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(long nTime, EChannel eChannel, int nInputAdjustTime)
1126                 {
1127                         return r指定時刻に一番近い未ヒットChip(nTime, eChannel, nInputAdjustTime, 0, HitState.DontCare);
1128                 }
1129
1130                 protected void tサウンド再生(CChip rChip, long n再生開始システム時刻ms, EPart part)
1131                 {
1132                         this.tサウンド再生(rChip, n再生開始システム時刻ms, part, CDTXMania.Instance.ConfigIni.nChipVolume);
1133                 }
1134
1135                 protected void tサウンド再生(CChip pChip, long n再生開始システム時刻ms, EPart part, int n音量, bool bモニタ = false, bool b音程をずらして再生 = false)
1136                 {
1137                         // mute sound (auto)
1138                         // 4A: HH
1139                         // 4B: CY
1140                         // 4C: RD
1141                         // 4D: LC
1142                         // 2A: Gt
1143                         // AA: Bs
1144                         //
1145
1146                         if (pChip != null)
1147                         {
1148                                 bool overwrite = false;
1149                                 switch (part)
1150                                 {
1151                                         case EPart.Drums:
1152                                                 #region [ DRUMS ]
1153                                                 {
1154                                                         int index = -1;
1155                                                         if (pChip.bDrums可視チップ_LP_LBD含まない)
1156                                                         {
1157                                                                 index = pChip.nDrumsIndex;
1158                                                         }
1159                                                         else if (pChip.bDrums不可視チップ_LP_LBD含まない)
1160                                                         {
1161                                                                 index = pChip.nDrumsIndexHidden;
1162                                                         }
1163                                                         // mute sound (auto)
1164                                                         // 4A: 84: HH (HO/HC)
1165                                                         // 4B: 85: CY
1166                                                         // 4C: 86: RD
1167                                                         // 4D: 87: LC
1168                                                         // 2A: 88: Gt
1169                                                         // AA: 89: Bs
1170                                                         else if (EChannel.SE24 == pChip.eチャンネル番号)  // 仮に今だけ追加 HHは消音処理があるので overwriteフラグ系の処理は改めて不要
1171                                                         {
1172                                                                 index = 0;
1173                                                         }
1174                                                         else if ((EChannel.SE25 <= pChip.eチャンネル番号) && (pChip.eチャンネル番号 <= EChannel.SE27))  // 仮に今だけ追加
1175                                                         {
1176                                                                 pChip.ConvertSE25_26_27toCY_RCY_LCY();
1177                                                                 index = pChip.nDrumsIndex;
1178                                                                 overwrite = true;
1179                                                         }
1180                                                         else
1181                                                         {
1182                                                                 return;
1183                                                         }
1184                                                         EChannel actChannel = EChannel.HiHatClose + index;
1185                                                         ELane nLane = EnumConverter.LaneFromChannel(actChannel);
1186                                                         if ((nLane == ELane.HH) && // 今回演奏するのがHC or HO
1187                                                                         (index == 0 || (index == 7 &&
1188                                                                         this.e最後に再生したHHのチャンネル番号 != EChannel.HiHatOpen &&
1189                                                                         this.e最後に再生したHHのチャンネル番号 != EChannel.HiHatOpen_Hidden))
1190                                                         // HCを演奏するか、またはHO演奏＆以前HO演奏でない＆以前不可視HO演奏でない
1191                                                         )
1192                                                         // #24772 2011.4.4 yyagi
1193                                                         // == HH mute condition ==
1194                                                         //                      current HH              So, the mute logics are:
1195                                                         //                              HC      HO              1) All played HC/HOs should be queueing
1196                                                         // last HH      HC  Yes Yes             2) If you aren't in "both current/last HH are HO", queued HH should be muted.
1197                                                         //                      HO      Yes     No
1198                                                         {
1199                                                                 // #23921 2011.1.4 yyagi: 2種類以上のオープンハイハットが発音済みだと、最後のHHOしか消せない問題に対応。
1200                                                                 for (int i = 0; i < this.L最後に再生したHHの実WAV番号.Count; i++)      // #23921 2011.1.4 yyagi
1201                                                                 {
1202                                                                         CDTXMania.Instance.DTX.tWavの再生停止(this.L最後に再生したHHの実WAV番号[i]);    // #23921 yyagi ストック分全て消音する
1203                                                                 }
1204                                                                 this.L最後に再生したHHの実WAV番号.Clear();
1205                                                                 this.e最後に再生したHHのチャンネル番号 = pChip.eチャンネル番号;
1206                                                         }
1207                                                         if (index == 0 || index == 7)
1208                                                         {
1209                                                                 // #23921 HOまたは不可視HO演奏時はそのチップ番号をストックしておく
1210                                                                 // #24772 HC, 不可視HCも消音キューに追加
1211                                                                 if (this.L最後に再生したHHの実WAV番号.Count >= 16)
1212                                                                 {
1213                                                                         // #23921 ただしストック数が16以上になるようなら、頭の1個を削って常に16未満に抑える
1214                                                                         // (ストックが増えてList<>のrealloc()が発生するのを予防する)
1215                                                                         this.L最後に再生したHHの実WAV番号.RemoveAt(0);
1216                                                                 }
1217                                                                 if (!this.L最後に再生したHHの実WAV番号.Contains(pChip.n整数値_内部番号))
1218                                                                 {
1219                                                                         // チップ音がまだストックされてなければストックする
1220                                                                         this.L最後に再生したHHの実WAV番号.Add(pChip.n整数値_内部番号);
1221                                                                 }
1222                                                         }
1223                                                         if (overwrite)
1224                                                         {
1225
1226                                                                 CDTXMania.Instance.DTX.tWavの再生停止(this.n最後に再生した実WAV番号[EnumConverter.PadFromChannel(actChannel)]);
1227                                                         }
1228                                                         CDTXMania.Instance.DTX.tチップの再生(pChip, n再生開始システム時刻ms, n音量, bモニタ);
1229                                                         this.n最後に再生した実WAV番号[EnumConverter.PadFromLane(nLane)] = pChip.n整数値_内部番号;
1230                                                         // nLaneでなくindexにすると、LC(1A-11=09)とギター(enumで09)がかぶってLC音が消されるので注意
1231                                                         return;
1232                                                 }
1233                                         #endregion
1234                                         case EPart.Guitar:
1235                                                 #region [ GUITAR ]
1236                                                 CDTXMania.Instance.DTX.tWavの再生停止(this.n最後に再生した実WAV番号.GtPick);
1237                                                 CDTXMania.Instance.DTX.tチップの再生(pChip, n再生開始システム時刻ms, n音量, bモニタ, b音程をずらして再生);
1238                                                 this.n最後に再生した実WAV番号.GtPick = pChip.n整数値_内部番号;
1239                                                 return;
1240                                         #endregion
1241                                         case EPart.Bass:
1242                                                 #region [ BASS ]
1243                                                 CDTXMania.Instance.DTX.tWavの再生停止(this.n最後に再生した実WAV番号.BsPick);
1244                                                 CDTXMania.Instance.DTX.tチップの再生(pChip, n再生開始システム時刻ms, n音量, bモニタ, b音程をずらして再生);
1245                                                 this.n最後に再生した実WAV番号.BsPick = pChip.n整数値_内部番号;
1246                                                 return;
1247                                         #endregion
1248
1249                                         default:
1250                                                 break;
1251                                 }
1252                         }
1253                 }
1254
1255                 protected EJudge tチップのヒット処理(long nHitTime, CChip pChip, bool bCorrectLane = true)
1256                 {
1257                         pChip.bHit = true;
1258                         if (pChip.e楽器パート != EPart.Unknown)
1259                         {
1260                                 cInvisibleChip.StartSemiInvisible(pChip.e楽器パート);
1261                         }
1262                         bool bPChipIsAutoPlay = pChip.bAssignAutoPlayState();// 2011.6.10 yyagi
1263                         EJudge eJudgeResult = EJudge.Auto;
1264
1265                         // ゴースト処理 #35411 2015.08.20 chnmr0
1266                         bool bIsPerfectGhost = CDTXMania.Instance.ConfigIni.eAutoGhost[pChip.e楽器パート] == EAutoGhostData.Perfect ||
1267                                                         CDTXMania.Instance.DTX.listAutoGhostLag[pChip.e楽器パート] == null;
1268                         int nInputAdjustTime = bPChipIsAutoPlay && bIsPerfectGhost ? 0 : CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs[pChip.e楽器パート];
1269                         eJudgeResult = (bCorrectLane) ? this.e指定時刻からChipのJUDGEを返す(nHitTime, pChip, nInputAdjustTime) : EJudge.Miss;
1270
1271                         if (pChip.e楽器パート != EPart.Unknown)
1272                         {
1273                                 ELane nLane = ELane.Max;
1274                                 switch (pChip.e楽器パート)
1275                                 {
1276                                         case EPart.Drums:
1277                                                 nLane = EnumConverter.LaneFromChannel(pChip.eチャンネル番号);
1278                                                 break;
1279                                         case EPart.Guitar:
1280                                                 nLane = ELane.GtR;
1281                                                 break;
1282                                         case EPart.Bass:
1283                                                 nLane = ELane.BsR;
1284                                                 break;
1285                                 }
1286                                 this.actJudgeString.Start(nLane, bPChipIsAutoPlay && bIsPerfectGhost ? EJudge.Auto : eJudgeResult, pChip.nLag);
1287                         }
1288
1289                         // ダメージ
1290                         if (!bPChipIsAutoPlay && (pChip.e楽器パート != EPart.Unknown))
1291                         {
1292                                 actGauge.Damage(pChip.e楽器パート, eJudgeResult);
1293                         }
1294
1295                         // インビジブル
1296                         if (eJudgeResult == EJudge.Poor || eJudgeResult == EJudge.Miss || eJudgeResult == EJudge.Bad)
1297                         {
1298                                 cInvisibleChip.ShowChipTemporally(pChip.e楽器パート);
1299                         }
1300
1301                         // コンボ
1302                         if (pChip.e楽器パート != EPart.Unknown)
1303                         {
1304                                 switch (eJudgeResult)
1305                                 {
1306                                         case EJudge.Miss:
1307                                         case EJudge.Bad:
1308                                                 this.nヒット数_Auto含む[pChip.e楽器パート].Miss++;
1309                                                 if (!bPChipIsAutoPlay)
1310                                                 {
1311                                                         this.nヒット数_Auto含まない[pChip.e楽器パート].Miss++;
1312                                                 }
1313                                                 break;
1314                                         default:
1315                                                 // #24068 2011.1.10 ikanick changed (for Gt./Bs.)
1316                                                 // #24167 2011.1.16 yyagi changed  (for Gt./Bs.)
1317                                                 this.nヒット数_Auto含む[pChip.e楽器パート][(int)eJudgeResult]++;
1318                                                 if (!bPChipIsAutoPlay)
1319                                                 {
1320                                                         this.nヒット数_Auto含まない[pChip.e楽器パート][(int)eJudgeResult]++;
1321                                                 }
1322                                                 break;
1323                                 }
1324
1325                                 bool incrementCombo = false;
1326
1327                                 if (pChip.e楽器パート == EPart.Drums)
1328                                 {
1329                                         if (CDTXMania.Instance.ConfigIni.bIsAutoPlay(EPart.Drums) || !bPChipIsAutoPlay)
1330                                         {
1331                                                 // Dr. : 演奏したレーンだけコンボを増やす
1332                                                 incrementCombo = true;
1333                                         }
1334                                 }
1335                                 else if (pChip.e楽器パート == EPart.Guitar || pChip.e楽器パート == EPart.Bass)
1336                                 {
1337                                         incrementCombo = true;
1338                                 }
1339
1340                 if( incrementCombo == true )
1341                 {
1342                     switch (eJudgeResult)
1343                     {
1344                         case EJudge.Perfect:
1345                         case EJudge.Great:
1346                         case EJudge.Good:
1347                             this.actCombo.dgbコンボ数[pChip.e楽器パート].IncrementCombo();
1348                             break;
1349
1350                         default:
1351                             this.actCombo.dgbコンボ数[pChip.e楽器パート].ResetCombo();
1352                             break;
1353                     }
1354                 }
1355                         }
1356
1357                         // スコア
1358                         if ((!bPChipIsAutoPlay && (pChip.e楽器パート != EPart.Unknown)) && (eJudgeResult != EJudge.Miss) && (eJudgeResult != EJudge.Bad))
1359                         {
1360                                 int nCombos = this.actCombo.dgbコンボ数[pChip.e楽器パート].n現在値;
1361                                 long nScoreDelta = 0;
1362                                 long[] nComboScoreDelta = new long[] { 350L, 200L, 50L, 0L };
1363                                 if ((nCombos <= 500) || (eJudgeResult == EJudge.Good))
1364                                 {
1365                                         nScoreDelta = nComboScoreDelta[(int)eJudgeResult] * nCombos;
1366                                 }
1367                                 else if ((eJudgeResult == EJudge.Perfect) || (eJudgeResult == EJudge.Great))
1368                                 {
1369                                         nScoreDelta = nComboScoreDelta[(int)eJudgeResult] * 500L;
1370                                 }
1371                                 this.actScore.Add(pChip.e楽器パート, nScoreDelta);
1372                         }
1373
1374                         // グラフ
1375                         if (pChip.e楽器パート != EPart.Unknown)
1376                         {
1377                                 EPart inst = pChip.e楽器パート;
1378                                 // #24074 2011.01.23 add ikanick
1379                                 this.actGraph.dbCurrent[inst] =
1380                                                 CScoreIni.t演奏型スキルを計算して返す(
1381                                                 CDTXMania.Instance.DTX.n可視チップ数[inst],
1382                                                 this.nヒット数_Auto含まない[inst].Perfect,
1383                                                 this.nヒット数_Auto含まない[inst].Great,
1384                                                 this.nヒット数_Auto含まない[inst].Good,
1385                                                 this.nヒット数_Auto含まない[inst].Poor,
1386                                                 this.nヒット数_Auto含まない[inst].Miss,
1387                                                 inst, true);
1388
1389                                 // #35411 2015.09.07 add chnmr0
1390                                 if (
1391                                                 CDTXMania.Instance.DTX.listTargetGhsotLag[inst] != null &&
1392                                                 CDTXMania.Instance.ConfigIni.eTargetGhost[inst] == ETargetGhostData.Online &&
1393                                                 CDTXMania.Instance.DTX.n可視チップ数[inst] > 0)
1394                                 {
1395                                         // Online Stats の計算式
1396                                         this.actGraph.dbTarget[inst] = 100 *
1397                                                                                                         (this.nヒット数_Auto含まない[inst].Perfect * 17 +
1398                                                                                                          this.nヒット数_Auto含まない[inst].Great * 7 +
1399                                                                                                          this.actCombo.dgbコンボ数[inst].n最高値 * 3) /
1400                                                                                                          (20.0 * CDTXMania.Instance.DTX.n可視チップ数[inst]);
1401                                 }
1402                         }
1403                         return eJudgeResult;
1404                 }
1405
1406                 private void tチップのヒット処理_BadならびにTight時のMiss(EPart part, ELane nLane = ELane.LC)
1407                 {
1408                         cInvisibleChip.StartSemiInvisible(part);
1409                         cInvisibleChip.ShowChipTemporally(part);
1410                         actGauge.Damage(part, EJudge.Miss);
1411                         switch (part)
1412                         {
1413                                 case EPart.Drums:
1414                                         this.actJudgeString.Start(nLane, CDTXMania.Instance.ConfigIni.bAutoPlay[EnumConverter.PadFromLane(nLane)] ?
1415                                                         EJudge.Auto : EJudge.Miss, 999);
1416                                         this.actCombo.dgbコンボ数.Drums.ResetCombo();
1417                                         return;
1418
1419                                 case EPart.Guitar:
1420                                         this.actJudgeString.Start(ELane.GtR, EJudge.Bad, 999);
1421                                         this.actCombo.dgbコンボ数.Guitar.ResetCombo();
1422                                         return;
1423
1424                                 case EPart.Bass:
1425                                         this.actJudgeString.Start(ELane.BsR, EJudge.Bad, 999);
1426                                         this.actCombo.dgbコンボ数.Bass.ResetCombo();
1427                                         break;
1428
1429                                 default:
1430                                         return;
1431                         }
1432                 }
1433
1434                 /// <summary>
1435                 /// 指定時刻に一番近いまだヒットしていないチップを返す。
1436                 /// </summary>
1437                 /// <param name="nTime">指定時刻</param>
1438                 /// <param name="search">検索するチャネル。Gt.WailingSound/Bs.WailingSoundを渡した場合、Open~RGBが検索対象になる。</param>
1439                 /// <param name="nInputAdjustTime"></param>
1440                 /// <param name="n検索範囲時間ms">指定時刻から検索する範囲ms</param>
1441                 /// <returns></returns>
1442                 protected CChip r指定時刻に一番近い未ヒットChip(long nTime, EChannel search, int nInputAdjustTime, int n検索範囲時間ms = 0, HitState hs = HitState.NotHit)
1443                 {
1444                         CChip ret = null;
1445
1446                         nTime += nInputAdjustTime;
1447                         if (this.n現在のトップChip >= 0 && this.n現在のトップChip <= CDTXMania.Instance.DTX.listChip.Count)
1448                         {
1449                                 int idxFuture = -1;
1450                                 int idxPast = -1;
1451                                 int idxPastStart = CDTXMania.Instance.DTX.listChip.Count - 1;
1452                                 Func<CChip, Func<CChip, bool>, bool> Found = (chip, futureOrPast) =>
1453                                 {
1454                                         return futureOrPast(chip) &&
1455                                                         ((hs == HitState.NotHit && !chip.bHit) || (hs == HitState.Hit && chip.bHit) || (hs == HitState.DontCare)) &&
1456                                                         !chip.b空打ちチップである &&
1457                                                         (
1458                                                         ((search == chip.eチャンネル番号 || search + 0x20 == chip.eチャンネル番号) && chip.bDrums可視チップ_LP_LBD含まない) ||
1459                                                         (search == chip.eチャンネル番号 && chip.bGuitar可視チップ_Wailing含む) ||
1460                                                         (search == chip.eチャンネル番号 && chip.bBass可視チップ_Wailing含む) ||
1461                                                         (search == EChannel.Guitar_WailingSound && chip.bGuitar可視チップ) ||
1462                                                         (search == EChannel.Bass_WailingSound && chip.bBass可視チップ)
1463                                                         );
1464                                 };
1465                                 Func<CChip, bool> Future = (chip) => { return chip.n発声時刻ms > nTime; };
1466                                 Func<CChip, bool> Past = (chip) => { return chip.n発声時刻ms <= nTime; };
1467                                 Func<CChip, bool> OutOfRange = (chip) => { return n検索範囲時間ms > 0 && Math.Abs(nTime - chip.n発声時刻ms) > n検索範囲時間ms; };
1468
1469                                 // // 未来方向への検索
1470                                 for (int i = this.n現在のトップChip; i < CDTXMania.Instance.DTX.listChip.Count; ++i)
1471                                 {
1472                                         CChip chip = CDTXMania.Instance.DTX.listChip[i];
1473                                         if (Future(chip) && OutOfRange(chip))
1474                                         {
1475                                                 //break;
1476                                         }
1477                                         if (Found(chip, Future))
1478                                         {
1479                                                 idxFuture = i;
1480                                                 idxPastStart = i;
1481                                                 break;
1482                                         }
1483                                 }
1484
1485                                 // 過去方向への検索
1486                                 for (int i = idxPastStart; i >= 0; i--)
1487                                 {
1488                                         CChip chip = CDTXMania.Instance.DTX.listChip[i];
1489                                         if (Past(chip) && OutOfRange(chip))
1490                                         {
1491                                                 //break;
1492                                         }
1493                                         if (Found(chip, Past))
1494                                         {
1495                                                 idxPast = i;
1496                                                 break;
1497                                         }
1498                                 }
1499
1500                                 if (idxFuture < 0 && idxPast < 0)
1501                                 {
1502                                         // 検索対象が過去未来どちらにも見つからなかった
1503                                 }
1504                                 else if (idxPast >= 0 && idxFuture < 0)
1505                                 {
1506                                         // 過去方向にのみ見つかった
1507                                         ret = CDTXMania.Instance.DTX.listChip[idxPast];
1508                                 }
1509                                 else if (idxFuture >= 0 && idxPast < 0)
1510                                 {
1511                                         // 未来方向にのみ見つかった
1512                                         ret = CDTXMania.Instance.DTX.listChip[idxFuture];
1513                                 }
1514                                 else
1515                                 {
1516                                         // どちらにも見つかった
1517                                         long nTimeDiff_Future = Math.Abs(nTime - CDTXMania.Instance.DTX.listChip[idxFuture].n発声時刻ms);
1518                                         long nTimeDiff_Past = Math.Abs(nTime - CDTXMania.Instance.DTX.listChip[idxPast].n発声時刻ms);
1519                                         if (nTimeDiff_Future < nTimeDiff_Past)
1520                                         {
1521                                                 ret = CDTXMania.Instance.DTX.listChip[idxFuture];
1522                                                 // ここは、必要に応じて、過去チップを優先させる条件を追加した方がbetter??
1523                                         }
1524                                         else
1525                                         {
1526                                                 ret = CDTXMania.Instance.DTX.listChip[idxPast];
1527                                         }
1528                                 }
1529
1530                                 if (ret != null)
1531                                 {
1532                                         if (OutOfRange(ret))
1533                                         {
1534                                                 // チップは見つかったが、検索範囲時間外だった場合
1535                                                 ret = null;
1536                                         }
1537                                 }
1538                         }
1539                         return ret;
1540                 }
1541
1542                 protected CChip r次に来る指定楽器Chipを更新して返す(EPart inst)
1543                 {
1544                         CChip ret = null;
1545                         int nInputAdjustTime;
1546                         if (inst == EPart.Guitar)
1547                         {
1548                                 nInputAdjustTime = CDTXMania.Instance.ConfigIni.bAutoPlay.GtPick ?
1549                                                 0 : CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs.Guitar;
1550                                 ret = this.r指定時刻に一番近い未ヒットChip(CSound管理.rc演奏用タイマ.n現在時刻, EChannel.Guitar_WailingSound, nInputAdjustTime, 500);
1551                                 this.r次にくるギターChip = ret;
1552                         }
1553                         else if (inst == EPart.Bass)
1554                         {
1555                                 nInputAdjustTime = CDTXMania.Instance.ConfigIni.bAutoPlay.BsPick ?
1556                                                 0 : CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs.Bass;
1557                                 ret = this.r指定時刻に一番近い未ヒットChip(CSound管理.rc演奏用タイマ.n現在時刻, EChannel.Bass_WailingSound, nInputAdjustTime, 500);
1558                                 this.r次にくるベースChip = ret;
1559                         }
1560                         return ret;
1561                 }
1562
1563                 protected void ChangeInputAdjustTimeInPlaying(IInputDevice keyboard, int plusminus)     // #23580 2011.1.16 yyagi UI for InputAdjustTime in playing screen.
1564                 {
1565                         EPart part;
1566                         int offset = plusminus;
1567                         if (keyboard.bキーが押されている((int)SlimDXKey.LeftShift) || keyboard.bキーが押されている((int)SlimDXKey.RightShift))  // Guitar InputAdjustTime
1568                         {
1569                                 part = EPart.Guitar;
1570                         }
1571                         else if (keyboard.bキーが押されている((int)SlimDXKey.LeftAlt) || keyboard.bキーが押されている((int)SlimDXKey.RightAlt)) // Bass InputAdjustTime
1572                         {
1573                                 part = EPart.Bass;
1574                         }
1575                         else
1576                         {
1577                                 // Drums InputAdjustTime
1578                                 part = EPart.Drums;
1579                         }
1580                         if (!keyboard.bキーが押されている((int)SlimDXKey.LeftControl) && !keyboard.bキーが押されている((int)SlimDXKey.RightControl))
1581                         {
1582                                 offset *= 10;
1583                         }
1584
1585                         CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs[part].Value = CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs[part] + offset;
1586                 }
1587
1588                 private void t入力処理_ドラム()
1589                 {
1590                         for (EPad ePad = EPad.DrumsPadMin; ePad < EPad.DrumsPadMax; ePad++)        // #27029 2012.1.4 from: <10 to <=10; Eパッドの要素が１つ（HP）増えたため。
1591                                                                                                                                                                          //               2012.1.5 yyagi: (int)Eパッド.MAX に変更。Eパッドの要素数への依存を無くすため。
1592                         {
1593                                 List<STInputEvent> listInputEvent = CDTXMania.Instance.Pad.GetEvents(ePad);
1594
1595                                 if ((listInputEvent == null) || (listInputEvent.Count == 0))
1596                                 {
1597                                         continue;
1598                                 }
1599
1600                                 this.t入力メソッド記憶(EPart.Drums);
1601
1602                                 #region [ 打ち分けグループ調整 ]
1603                                 //-----------------------------
1604                                 EHHGroup eHHGroup = CDTXMania.Instance.ConfigIni.eHHGroup;
1605                                 EFTGroup eFTGroup = CDTXMania.Instance.ConfigIni.eFTGroup;
1606                                 ECYGroup eCYGroup = CDTXMania.Instance.ConfigIni.eCYGroup;
1607
1608                                 if (!CDTXMania.Instance.DTX.bチップがある.Ride && (eCYGroup == ECYGroup.Off))
1609                                 {
1610                                         eCYGroup = ECYGroup.Group;
1611                                 }
1612                                 if (!CDTXMania.Instance.DTX.bチップがある.HHOpen && (eHHGroup == EHHGroup.Off))
1613                                 {
1614                                         eHHGroup = EHHGroup.LC_HH;
1615                                 }
1616                                 if (!CDTXMania.Instance.DTX.bチップがある.HHOpen && (eHHGroup == EHHGroup.HO_HC))
1617                                 {
1618                                         eHHGroup = EHHGroup.Group;
1619                                 }
1620                                 if (!CDTXMania.Instance.DTX.bチップがある.LeftCymbal && (eHHGroup == EHHGroup.Off))
1621                                 {
1622                                         eHHGroup = EHHGroup.HO_HC;
1623                                 }
1624                                 if (!CDTXMania.Instance.DTX.bチップがある.LeftCymbal && (eHHGroup == EHHGroup.LC_HH))
1625                                 {
1626                                         eHHGroup = EHHGroup.Group;
1627                                 }
1628                                 //-----------------------------
1629                                 #endregion
1630
1631                                 foreach (STInputEvent inputEvent in listInputEvent)
1632                                 {
1633                                         if (!inputEvent.b押された)
1634                                                 continue;
1635
1636                                         long nTime = inputEvent.nTimeStamp - CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻;
1637                                         EPad nPad09 = (ePad == EPad.HP) ? EPad.BD : ePad;      // #27029 2012.1.5 yyagi
1638                                         int nInputAdjustTime = CDTXMania.Instance.ConfigIni.bAutoPlay[nPad09] ? 0 : CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs.Drums;
1639                                         bool bHitted = false;
1640
1641                                         #region [ (A) ヒットしていればヒット処理して次の inputEvent へ ]
1642                                         //-----------------------------
1643                                         switch (ePad)
1644                                         {
1645                                                 case EPad.HH:
1646                                                         #region [ HHとLC(groupingしている場合) のヒット処理 ]
1647                                                         //-----------------------------
1648                                                         {
1649                                                                 if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.HH)
1650                                                                         continue;   // 電子ドラムによる意図的なクロストークを無効にする
1651
1652                                                                 CChip chipHC = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.HiHatClose, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1);    // HiHat Close
1653                                                                 CChip chipHO = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.HiHatOpen, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1); // HiHat Open
1654                                                                 CChip chipLC = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.LeftCymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1);    // LC
1655                                                                 EJudge e判定HC = (chipHC != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipHC, nInputAdjustTime) : EJudge.Miss;
1656                                                                 EJudge e判定HO = (chipHO != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipHO, nInputAdjustTime) : EJudge.Miss;
1657                                                                 EJudge e判定LC = (chipLC != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipLC, nInputAdjustTime) : EJudge.Miss;
1658                                                                 switch (eHHGroup)
1659                                                                 {
1660                                                                         case EHHGroup.HO_HC:
1661                                                                                 #region [ HCとLCのヒット処理 ]
1662                                                                                 //-----------------------------
1663                                                                                 if ((e判定HC != EJudge.Miss) && (e判定LC != EJudge.Miss))
1664                                                                                 {
1665                                                                                         if (chipHC.n発声位置 < chipLC.n発声位置)
1666                                                                                         {
1667                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity);
1668                                                                                         }
1669                                                                                         else if (chipHC.n発声位置 > chipLC.n発声位置)
1670                                                                                         {
1671                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipLC, inputEvent.nVelocity);
1672                                                                                         }
1673                                                                                         else
1674                                                                                         {
1675                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity);
1676                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipLC, inputEvent.nVelocity);
1677                                                                                         }
1678                                                                                         bHitted = true;
1679                                                                                 }
1680                                                                                 else if (e判定HC != EJudge.Miss)
1681                                                                                 {
1682                                                                                         this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity);
1683                                                                                         bHitted = true;
1684                                                                                 }
1685                                                                                 else if (e判定LC != EJudge.Miss)
1686                                                                                 {
1687                                                                                         this.tドラムヒット処理(nTime, EPad.HH, chipLC, inputEvent.nVelocity);
1688                                                                                         bHitted = true;
1689                                                                                 }
1690                                                                                 if (!bHitted)
1691                                                                                         break;
1692                                                                                 continue;
1693                                                                         //-----------------------------
1694                                                                         #endregion
1695
1696                                                                         case EHHGroup.LC_HH:
1697                                                                                 #region [ HCとHOのヒット処理 ]
1698                                                                                 //-----------------------------
1699                                                                                 if ((e判定HC != EJudge.Miss) && (e判定HO != EJudge.Miss))
1700                                                                                 {
1701                                                                                         if (chipHC.n発声位置 < chipHO.n発声位置)
1702                                                                                         {
1703                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity);
1704                                                                                         }
1705                                                                                         else if (chipHC.n発声位置 > chipHO.n発声位置)
1706                                                                                         {
1707                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipHO, inputEvent.nVelocity);
1708                                                                                         }
1709                                                                                         else
1710                                                                                         {
1711                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity);
1712                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipHO, inputEvent.nVelocity);
1713                                                                                         }
1714                                                                                         bHitted = true;
1715                                                                                 }
1716                                                                                 else if (e判定HC != EJudge.Miss)
1717                                                                                 {
1718                                                                                         this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity);
1719                                                                                         bHitted = true;
1720                                                                                 }
1721                                                                                 else if (e判定HO != EJudge.Miss)
1722                                                                                 {
1723                                                                                         this.tドラムヒット処理(nTime, EPad.HH, chipHO, inputEvent.nVelocity);
1724                                                                                         bHitted = true;
1725                                                                                 }
1726                                                                                 if (!bHitted)
1727                                                                                         break;
1728                                                                                 continue;
1729                                                                         //-----------------------------
1730                                                                         #endregion
1731
1732                                                                         case EHHGroup.Group:
1733                                                                                 #region [ HC,HO,LCのヒット処理 ]
1734                                                                                 //-----------------------------
1735                                                                                 if (((e判定HC != EJudge.Miss) && (e判定HO != EJudge.Miss)) && (e判定LC != EJudge.Miss))
1736                                                                                 {
1737                                                                                         CChip chip;
1738                                                                                         CChip[] chipArray = new CChip[] { chipHC, chipHO, chipLC };
1739                                                                                         // ここから、chipArrayをn発生位置の小さい順に並び替える
1740                                                                                         if (chipArray[1].n発声位置 > chipArray[2].n発声位置)
1741                                                                                         {
1742                                                                                                 chip = chipArray[1];
1743                                                                                                 chipArray[1] = chipArray[2];
1744                                                                                                 chipArray[2] = chip;
1745                                                                                         }
1746                                                                                         if (chipArray[0].n発声位置 > chipArray[1].n発声位置)
1747                                                                                         {
1748                                                                                                 chip = chipArray[0];
1749                                                                                                 chipArray[0] = chipArray[1];
1750                                                                                                 chipArray[1] = chip;
1751                                                                                         }
1752                                                                                         if (chipArray[1].n発声位置 > chipArray[2].n発声位置)
1753                                                                                         {
1754                                                                                                 chip = chipArray[1];
1755                                                                                                 chipArray[1] = chipArray[2];
1756                                                                                                 chipArray[2] = chip;
1757                                                                                         }
1758                                                                                         this.tドラムヒット処理(nTime, EPad.HH, chipArray[0], inputEvent.nVelocity);
1759                                                                                         if (chipArray[0].n発声位置 == chipArray[1].n発声位置)
1760                                                                                         {
1761                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipArray[1], inputEvent.nVelocity);
1762                                                                                         }
1763                                                                                         if (chipArray[0].n発声位置 == chipArray[2].n発声位置)
1764                                                                                         {
1765                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipArray[2], inputEvent.nVelocity);
1766                                                                                         }
1767                                                                                         bHitted = true;
1768                                                                                 }
1769                                                                                 else if ((e判定HC != EJudge.Miss) && (e判定HO != EJudge.Miss))
1770                                                                                 {
1771                                                                                         if (chipHC.n発声位置 < chipHO.n発声位置)
1772                                                                                         {
1773                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity);
1774                                                                                         }
1775                                                                                         else if (chipHC.n発声位置 > chipHO.n発声位置)
1776                                                                                         {
1777                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipHO, inputEvent.nVelocity);
1778                                                                                         }
1779                                                                                         else
1780                                                                                         {
1781                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity);
1782                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipHO, inputEvent.nVelocity);
1783                                                                                         }
1784                                                                                         bHitted = true;
1785                                                                                 }
1786                                                                                 else if ((e判定HC != EJudge.Miss) && (e判定LC != EJudge.Miss))
1787                                                                                 {
1788                                                                                         if (chipHC.n発声位置 < chipLC.n発声位置)
1789                                                                                         {
1790                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity);
1791                                                                                         }
1792                                                                                         else if (chipHC.n発声位置 > chipLC.n発声位置)
1793                                                                                         {
1794                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipLC, inputEvent.nVelocity);
1795                                                                                         }
1796                                                                                         else
1797                                                                                         {
1798                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity);
1799                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipLC, inputEvent.nVelocity);
1800                                                                                         }
1801                                                                                         bHitted = true;
1802                                                                                 }
1803                                                                                 else if ((e判定HO != EJudge.Miss) && (e判定LC != EJudge.Miss))
1804                                                                                 {
1805                                                                                         if (chipHO.n発声位置 < chipLC.n発声位置)
1806                                                                                         {
1807                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipHO, inputEvent.nVelocity);
1808                                                                                         }
1809                                                                                         else if (chipHO.n発声位置 > chipLC.n発声位置)
1810                                                                                         {
1811                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipLC, inputEvent.nVelocity);
1812                                                                                         }
1813                                                                                         else
1814                                                                                         {
1815                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipHO, inputEvent.nVelocity);
1816                                                                                                 this.tドラムヒット処理(nTime, EPad.HH, chipLC, inputEvent.nVelocity);
1817                                                                                         }
1818                                                                                         bHitted = true;
1819                                                                                 }
1820                                                                                 else if (e判定HC != EJudge.Miss)
1821                                                                                 {
1822                                                                                         this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity);
1823                                                                                         bHitted = true;
1824                                                                                 }
1825                                                                                 else if (e判定HO != EJudge.Miss)
1826                                                                                 {
1827                                                                                         this.tドラムヒット処理(nTime, EPad.HH, chipHO, inputEvent.nVelocity);
1828                                                                                         bHitted = true;
1829                                                                                 }
1830                                                                                 else if (e判定LC != EJudge.Miss)
1831                                                                                 {
1832                                                                                         this.tドラムヒット処理(nTime, EPad.HH, chipLC, inputEvent.nVelocity);
1833                                                                                         bHitted = true;
1834                                                                                 }
1835                                                                                 if (!bHitted)
1836                                                                                         break;
1837                                                                                 continue;
1838                                                                         //-----------------------------
1839                                                                         #endregion
1840
1841                                                                         default:
1842                                                                                 #region [ 全部打ち分け時のヒット処理 ]
1843                                                                                 //-----------------------------
1844                                                                                 if (e判定HC != EJudge.Miss)
1845                                                                                 {
1846                                                                                         this.tドラムヒット処理(nTime, EPad.HH, chipHC, inputEvent.nVelocity);
1847                                                                                         bHitted = true;
1848                                                                                 }
1849                                                                                 if (!bHitted)
1850                                                                                         break;
1851                                                                                 continue;
1852                                                                                 //-----------------------------
1853                                                                                 #endregion
1854                                                                 }
1855                                                                 if (!bHitted)
1856                                                                         break;
1857                                                                 continue;
1858                                                         }
1859                                                 //-----------------------------
1860                                                 #endregion
1861
1862                                                 case EPad.SD:
1863                                                         #region [ SDのヒット処理 ]
1864                                                         //-----------------------------
1865                                                         if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.SD)   // #23857 2010.12.12 yyagi: to support VelocityMin
1866                                                                 continue;   // 電子ドラムによる意図的なクロストークを無効にする
1867                                                         if (!this.tドラムヒット処理(nTime, EPad.SD, this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.Snare, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1), inputEvent.nVelocity))
1868                                                                 break;
1869                                                         continue;
1870                                                 //-----------------------------
1871                                                 #endregion
1872
1873                                                 case EPad.BD:
1874                                                         #region [ BDのヒット処理 ]
1875                                                         //-----------------------------
1876                                                         if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.BD)   // #23857 2010.12.12 yyagi: to support VelocityMin
1877                                                                 continue;   // 電子ドラムによる意図的なクロストークを無効にする
1878                                                         if (!this.tドラムヒット処理(nTime, EPad.BD, this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.BassDrum, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1), inputEvent.nVelocity))
1879                                                                 break;
1880                                                         continue;
1881                                                 //-----------------------------
1882                                                 #endregion
1883
1884                                                 case EPad.HT:
1885                                                         #region [ HTのヒット処理 ]
1886                                                         //-----------------------------
1887                                                         if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.HT)   // #23857 2010.12.12 yyagi: to support VelocityMin
1888                                                                 continue;   // 電子ドラムによる意図的なクロストークを無効にする
1889                                                         if (this.tドラムヒット処理(nTime, EPad.HT, this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.HighTom, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1), inputEvent.nVelocity))
1890                                                                 continue;
1891                                                         break;
1892                                                 //-----------------------------
1893                                                 #endregion
1894
1895                                                 case EPad.LT:
1896                                                         #region [ LTとFT(groupingしている場合)のヒット処理 ]
1897                                                         //-----------------------------
1898                                                         {
1899                                                                 if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.LT)   // #23857 2010.12.12 yyagi: to support VelocityMin
1900                                                                         continue;   // 電子ドラムによる意図的なクロストークを無効にする
1901                                                                 CChip chipLT = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.LowTom, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1);
1902                                                                 CChip chipFT = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.FloorTom, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1);
1903                                                                 EJudge e判定LT = (chipLT != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipLT, nInputAdjustTime) : EJudge.Miss;
1904                                                                 EJudge e判定FT = (chipFT != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipFT, nInputAdjustTime) : EJudge.Miss;
1905                                                                 switch (eFTGroup)
1906                                                                 {
1907                                                                         case EFTGroup.Off:
1908                                                                                 #region [ LTのヒット処理 ]
1909                                                                                 //-----------------------------
1910                                                                                 if (e判定LT != EJudge.Miss)
1911                                                                                 {
1912                                                                                         this.tドラムヒット処理(nTime, EPad.LT, chipLT, inputEvent.nVelocity);
1913                                                                                         bHitted = true;
1914                                                                                 }
1915                                                                                 break;
1916                                                                         //-----------------------------
1917                                                                         #endregion
1918
1919                                                                         case EFTGroup.Group:
1920                                                                                 #region [ LTとFTのヒット処理 ]
1921                                                                                 //-----------------------------
1922                                                                                 if ((e判定LT != EJudge.Miss) && (e判定FT != EJudge.Miss))
1923                                                                                 {
1924                                                                                         if (chipLT.n発声位置 < chipFT.n発声位置)
1925                                                                                         {
1926                                                                                                 this.tドラムヒット処理(nTime, EPad.LT, chipLT, inputEvent.nVelocity);
1927                                                                                         }
1928                                                                                         else if (chipLT.n発声位置 > chipFT.n発声位置)
1929                                                                                         {
1930                                                                                                 this.tドラムヒット処理(nTime, EPad.LT, chipFT, inputEvent.nVelocity);
1931                                                                                         }
1932                                                                                         else
1933                                                                                         {
1934                                                                                                 this.tドラムヒット処理(nTime, EPad.LT, chipLT, inputEvent.nVelocity);
1935                                                                                                 this.tドラムヒット処理(nTime, EPad.LT, chipFT, inputEvent.nVelocity);
1936                                                                                         }
1937                                                                                         bHitted = true;
1938                                                                                 }
1939                                                                                 else if (e判定LT != EJudge.Miss)
1940                                                                                 {
1941                                                                                         this.tドラムヒット処理(nTime, EPad.LT, chipLT, inputEvent.nVelocity);
1942                                                                                         bHitted = true;
1943                                                                                 }
1944                                                                                 else if (e判定FT != EJudge.Miss)
1945                                                                                 {
1946                                                                                         this.tドラムヒット処理(nTime, EPad.LT, chipFT, inputEvent.nVelocity);
1947                                                                                         bHitted = true;
1948                                                                                 }
1949                                                                                 break;
1950                                                                                 //-----------------------------
1951                                                                                 #endregion
1952                                                                 }
1953                                                                 if (!bHitted)
1954                                                                         break;
1955                                                                 continue;
1956                                                         }
1957                                                 //-----------------------------
1958                                                 #endregion
1959
1960                                                 case EPad.FT:
1961                                                         #region [ FTとLT(groupingしている場合)のヒット処理 ]
1962                                                         //-----------------------------
1963                                                         {
1964                                                                 if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.FT)   // #23857 2010.12.12 yyagi: to support VelocityMin
1965                                                                         continue;   // 電子ドラムによる意図的なクロストークを無効にする
1966                                                                 CChip chipLT = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.LowTom, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1);
1967                                                                 CChip chipFT = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.FloorTom, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1);
1968                                                                 EJudge e判定LT = (chipLT != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipLT, nInputAdjustTime) : EJudge.Miss;
1969                                                                 EJudge e判定FT = (chipFT != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipFT, nInputAdjustTime) : EJudge.Miss;
1970                                                                 switch (eFTGroup)
1971                                                                 {
1972                                                                         case EFTGroup.Off:
1973                                                                                 #region [ FTのヒット処理 ]
1974                                                                                 //-----------------------------
1975                                                                                 if (e判定FT != EJudge.Miss)
1976                                                                                 {
1977                                                                                         this.tドラムヒット処理(nTime, EPad.FT, chipFT, inputEvent.nVelocity);
1978                                                                                         bHitted = true;
1979                                                                                 }
1980                                                                                 //-----------------------------
1981                                                                                 #endregion
1982                                                                                 break;
1983
1984                                                                         case EFTGroup.Group:
1985                                                                                 #region [ FTとLTのヒット処理 ]
1986                                                                                 //-----------------------------
1987                                                                                 if ((e判定LT != EJudge.Miss) && (e判定FT != EJudge.Miss))
1988                                                                                 {
1989                                                                                         if (chipLT.n発声位置 < chipFT.n発声位置)
1990                                                                                         {
1991                                                                                                 this.tドラムヒット処理(nTime, EPad.FT, chipLT, inputEvent.nVelocity);
1992                                                                                         }
1993                                                                                         else if (chipLT.n発声位置 > chipFT.n発声位置)
1994                                                                                         {
1995                                                                                                 this.tドラムヒット処理(nTime, EPad.FT, chipFT, inputEvent.nVelocity);
1996                                                                                         }
1997                                                                                         else
1998                                                                                         {
1999                                                                                                 this.tドラムヒット処理(nTime, EPad.FT, chipLT, inputEvent.nVelocity);
2000                                                                                                 this.tドラムヒット処理(nTime, EPad.FT, chipFT, inputEvent.nVelocity);
2001                                                                                         }
2002                                                                                         bHitted = true;
2003                                                                                 }
2004                                                                                 else if (e判定LT != EJudge.Miss)
2005                                                                                 {
2006                                                                                         this.tドラムヒット処理(nTime, EPad.FT, chipLT, inputEvent.nVelocity);
2007                                                                                         bHitted = true;
2008                                                                                 }
2009                                                                                 else if (e判定FT != EJudge.Miss)
2010                                                                                 {
2011                                                                                         this.tドラムヒット処理(nTime, EPad.FT, chipFT, inputEvent.nVelocity);
2012                                                                                         bHitted = true;
2013                                                                                 }
2014                                                                                 //-----------------------------
2015                                                                                 #endregion
2016                                                                                 break;
2017                                                                 }
2018                                                                 if (!bHitted)
2019                                                                         break;
2020                                                                 continue;
2021                                                         }
2022                                                 //-----------------------------
2023                                                 #endregion
2024
2025                                                 case EPad.CY:
2026                                                         #region [ CY(とLCとRD:groupingしている場合)のヒット処理 ]
2027                                                         //-----------------------------
2028                                                         {
2029                                                                 if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.CY)   // #23857 2010.12.12 yyagi: to support VelocityMin
2030                                                                         continue;   // 電子ドラムによる意図的なクロストークを無効にする
2031                                                                 CChip chipCY = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.Cymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1);
2032                                                                 CChip chipRD = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.RideCymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1);
2033                                                                 CChip chipLC = CDTXMania.Instance.ConfigIni.bCymbalFree ? this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.LeftCymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1) : null;
2034                                                                 EJudge e判定CY = (chipCY != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipCY, nInputAdjustTime) : EJudge.Miss;
2035                                                                 EJudge e判定RD = (chipRD != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipRD, nInputAdjustTime) : EJudge.Miss;
2036                                                                 EJudge e判定LC = (chipLC != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipLC, nInputAdjustTime) : EJudge.Miss;
2037                                                                 CChip[] chipArray = new CChip[] { chipCY, chipRD, chipLC };
2038                                                                 EJudge[] e判定Array = new EJudge[] { e判定CY, e判定RD, e判定LC };
2039                                                                 const int NumOfChips = 3;   // chipArray.GetLength(0)
2040
2041                                                                 // CY/RD/LC群を, n発生位置の小さい順に並べる + nullを大きい方に退かす
2042                                                                 SortChipsByNTime(chipArray, e判定Array, NumOfChips);
2043                                                                 switch (eCYGroup)
2044                                                                 {
2045                                                                         case ECYGroup.Off:
2046                                                                                 if (!CDTXMania.Instance.ConfigIni.bCymbalFree)
2047                                                                                 {
2048                                                                                         if (e判定CY != EJudge.Miss)
2049                                                                                         {
2050                                                                                                 this.tドラムヒット処理(nTime, EPad.CY, chipCY, inputEvent.nVelocity);
2051                                                                                                 bHitted = true;
2052                                                                                         }
2053                                                                                         if (!bHitted)
2054                                                                                                 break;
2055                                                                                         continue;
2056                                                                                 }
2057                                                                                 for (int i = 0; i < NumOfChips; i++)
2058                                                                                 {
2059                                                                                         if ((e判定Array[i] != EJudge.Miss) && ((chipArray[i] == chipCY) || (chipArray[i] == chipLC)))
2060                                                                                         {
2061                                                                                                 this.tドラムヒット処理(nTime, EPad.CY, chipArray[i], inputEvent.nVelocity);
2062                                                                                                 bHitted = true;
2063                                                                                                 break;
2064                                                                                         }
2065                                                                                         //num10++;
2066                                                                                 }
2067                                                                                 if (e判定CY != EJudge.Miss)
2068                                                                                 {
2069                                                                                         this.tドラムヒット処理(nTime, EPad.CY, chipCY, inputEvent.nVelocity);
2070                                                                                         bHitted = true;
2071                                                                                 }
2072                                                                                 if (!bHitted)
2073                                                                                         break;
2074                                                                                 continue;
2075
2076                                                                         case ECYGroup.Group:
2077                                                                                 if (!CDTXMania.Instance.ConfigIni.bCymbalFree)
2078                                                                                 {
2079                                                                                         for (int i = 0; i < NumOfChips; i++)
2080                                                                                         {
2081                                                                                                 if ((e判定Array[i] != EJudge.Miss) && ((chipArray[i] == chipCY) || (chipArray[i] == chipRD)))
2082                                                                                                 {
2083                                                                                                         this.tドラムヒット処理(nTime, EPad.CY, chipArray[i], inputEvent.nVelocity);
2084                                                                                                         bHitted = true;
2085                                                                                                         break;
2086                                                                                                 }
2087                                                                                         }
2088                                                                                         if (!bHitted)
2089                                                                                                 break;
2090                                                                                         continue;
2091                                                                                 }
2092                                                                                 for (int i = 0; i < NumOfChips; i++)
2093                                                                                 {
2094                                                                                         if (e判定Array[i] != EJudge.Miss)
2095                                                                                         {
2096                                                                                                 this.tドラムヒット処理(nTime, EPad.CY, chipArray[i], inputEvent.nVelocity);
2097                                                                                                 bHitted = true;
2098                                                                                                 break;
2099                                                                                         }
2100                                                                                 }
2101                                                                                 if (!bHitted)
2102                                                                                         break;
2103                                                                                 continue;
2104                                                                 }
2105                                                                 if (!bHitted)
2106                                                                         break;
2107                                                                 continue;
2108                                                         }
2109                                                 //-----------------------------
2110                                                 #endregion
2111
2112                                                 case EPad.HHO:
2113                                                         #region [ HO(とHCとLC:groupingしている場合)のヒット処理 ]
2114                                                         //-----------------------------
2115                                                         {
2116                                                                 if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.HH)
2117                                                                         continue;   // 電子ドラムによる意図的なクロストークを無効にする
2118
2119                                                                 CChip chipHC = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.HiHatClose, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1);
2120                                                                 CChip chipHO = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.HiHatOpen, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1);
2121                                                                 CChip chipLC = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.LeftCymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1);
2122                                                                 EJudge e判定HC = (chipHC != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipHC, nInputAdjustTime) : EJudge.Miss;
2123                                                                 EJudge e判定HO = (chipHO != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipHO, nInputAdjustTime) : EJudge.Miss;
2124                                                                 EJudge e判定LC = (chipLC != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipLC, nInputAdjustTime) : EJudge.Miss;
2125                                                                 switch (eHHGroup)
2126                                                                 {
2127                                                                         case EHHGroup.Off:
2128                                                                                 if (e判定HO != EJudge.Miss)
2129                                                                                 {
2130                                                                                         this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity);
2131                                                                                         bHitted = true;
2132                                                                                 }
2133                                                                                 if (!bHitted)
2134                                                                                         break;
2135                                                                                 continue;
2136
2137                                                                         case EHHGroup.HO_HC:
2138                                                                                 if ((e判定HO != EJudge.Miss) && (e判定LC != EJudge.Miss))
2139                                                                                 {
2140                                                                                         if (chipHO.n発声位置 < chipLC.n発声位置)
2141                                                                                         {
2142                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity);
2143                                                                                         }
2144                                                                                         else if (chipHO.n発声位置 > chipLC.n発声位置)
2145                                                                                         {
2146                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipLC, inputEvent.nVelocity);
2147                                                                                         }
2148                                                                                         else
2149                                                                                         {
2150                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity);
2151                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipLC, inputEvent.nVelocity);
2152                                                                                         }
2153                                                                                         bHitted = true;
2154                                                                                 }
2155                                                                                 else if (e判定HO != EJudge.Miss)
2156                                                                                 {
2157                                                                                         this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity);
2158                                                                                         bHitted = true;
2159                                                                                 }
2160                                                                                 else if (e判定LC != EJudge.Miss)
2161                                                                                 {
2162                                                                                         this.tドラムヒット処理(nTime, EPad.HHO, chipLC, inputEvent.nVelocity);
2163                                                                                         bHitted = true;
2164                                                                                 }
2165                                                                                 if (!bHitted)
2166                                                                                         break;
2167                                                                                 continue;
2168
2169                                                                         case EHHGroup.LC_HH:
2170                                                                                 if ((e判定HC != EJudge.Miss) && (e判定HO != EJudge.Miss))
2171                                                                                 {
2172                                                                                         if (chipHC.n発声位置 < chipHO.n発声位置)
2173                                                                                         {
2174                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipHC, inputEvent.nVelocity);
2175                                                                                         }
2176                                                                                         else if (chipHC.n発声位置 > chipHO.n発声位置)
2177                                                                                         {
2178                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity);
2179                                                                                         }
2180                                                                                         else
2181                                                                                         {
2182                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipHC, inputEvent.nVelocity);
2183                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity);
2184                                                                                         }
2185                                                                                         bHitted = true;
2186                                                                                 }
2187                                                                                 else if (e判定HC != EJudge.Miss)
2188                                                                                 {
2189                                                                                         this.tドラムヒット処理(nTime, EPad.HHO, chipHC, inputEvent.nVelocity);
2190                                                                                         bHitted = true;
2191                                                                                 }
2192                                                                                 else if (e判定HO != EJudge.Miss)
2193                                                                                 {
2194                                                                                         this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity);
2195                                                                                         bHitted = true;
2196                                                                                 }
2197                                                                                 if (!bHitted)
2198                                                                                         break;
2199                                                                                 continue;
2200
2201                                                                         case EHHGroup.Group:
2202                                                                                 if (((e判定HC != EJudge.Miss) && (e判定HO != EJudge.Miss)) && (e判定LC != EJudge.Miss))
2203                                                                                 {
2204                                                                                         CChip chip;
2205                                                                                         CChip[] chipArray = new CChip[] { chipHC, chipHO, chipLC };
2206                                                                                         // ここから、chipArrayをn発生位置の小さい順に並び替える
2207                                                                                         if (chipArray[1].n発声位置 > chipArray[2].n発声位置)
2208                                                                                         {
2209                                                                                                 chip = chipArray[1];
2210                                                                                                 chipArray[1] = chipArray[2];
2211                                                                                                 chipArray[2] = chip;
2212                                                                                         }
2213                                                                                         if (chipArray[0].n発声位置 > chipArray[1].n発声位置)
2214                                                                                         {
2215                                                                                                 chip = chipArray[0];
2216                                                                                                 chipArray[0] = chipArray[1];
2217                                                                                                 chipArray[1] = chip;
2218                                                                                         }
2219                                                                                         if (chipArray[1].n発声位置 > chipArray[2].n発声位置)
2220                                                                                         {
2221                                                                                                 chip = chipArray[1];
2222                                                                                                 chipArray[1] = chipArray[2];
2223                                                                                                 chipArray[2] = chip;
2224                                                                                         }
2225                                                                                         this.tドラムヒット処理(nTime, EPad.HHO, chipArray[0], inputEvent.nVelocity);
2226                                                                                         if (chipArray[0].n発声位置 == chipArray[1].n発声位置)
2227                                                                                         {
2228                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipArray[1], inputEvent.nVelocity);
2229                                                                                         }
2230                                                                                         if (chipArray[0].n発声位置 == chipArray[2].n発声位置)
2231                                                                                         {
2232                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipArray[2], inputEvent.nVelocity);
2233                                                                                         }
2234                                                                                         bHitted = true;
2235                                                                                 }
2236                                                                                 else if ((e判定HC != EJudge.Miss) && (e判定HO != EJudge.Miss))
2237                                                                                 {
2238                                                                                         if (chipHC.n発声位置 < chipHO.n発声位置)
2239                                                                                         {
2240                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipHC, inputEvent.nVelocity);
2241                                                                                         }
2242                                                                                         else if (chipHC.n発声位置 > chipHO.n発声位置)
2243                                                                                         {
2244                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity);
2245                                                                                         }
2246                                                                                         else
2247                                                                                         {
2248                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipHC, inputEvent.nVelocity);
2249                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity);
2250                                                                                         }
2251                                                                                         bHitted = true;
2252                                                                                 }
2253                                                                                 else if ((e判定HC != EJudge.Miss) && (e判定LC != EJudge.Miss))
2254                                                                                 {
2255                                                                                         if (chipHC.n発声位置 < chipLC.n発声位置)
2256                                                                                         {
2257                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipHC, inputEvent.nVelocity);
2258                                                                                         }
2259                                                                                         else if (chipHC.n発声位置 > chipLC.n発声位置)
2260                                                                                         {
2261                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipLC, inputEvent.nVelocity);
2262                                                                                         }
2263                                                                                         else
2264                                                                                         {
2265                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipHC, inputEvent.nVelocity);
2266                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipLC, inputEvent.nVelocity);
2267                                                                                         }
2268                                                                                         bHitted = true;
2269                                                                                 }
2270                                                                                 else if ((e判定HO != EJudge.Miss) && (e判定LC != EJudge.Miss))
2271                                                                                 {
2272                                                                                         if (chipHO.n発声位置 < chipLC.n発声位置)
2273                                                                                         {
2274                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity);
2275                                                                                         }
2276                                                                                         else if (chipHO.n発声位置 > chipLC.n発声位置)
2277                                                                                         {
2278                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipLC, inputEvent.nVelocity);
2279                                                                                         }
2280                                                                                         else
2281                                                                                         {
2282                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity);
2283                                                                                                 this.tドラムヒット処理(nTime, EPad.HHO, chipLC, inputEvent.nVelocity);
2284                                                                                         }
2285                                                                                         bHitted = true;
2286                                                                                 }
2287                                                                                 else if (e判定HC != EJudge.Miss)
2288                                                                                 {
2289                                                                                         this.tドラムヒット処理(nTime, EPad.HHO, chipHC, inputEvent.nVelocity);
2290                                                                                         bHitted = true;
2291                                                                                 }
2292                                                                                 else if (e判定HO != EJudge.Miss)
2293                                                                                 {
2294                                                                                         this.tドラムヒット処理(nTime, EPad.HHO, chipHO, inputEvent.nVelocity);
2295                                                                                         bHitted = true;
2296                                                                                 }
2297                                                                                 else if (e判定LC != EJudge.Miss)
2298                                                                                 {
2299                                                                                         this.tドラムヒット処理(nTime, EPad.HHO, chipLC, inputEvent.nVelocity);
2300                                                                                         bHitted = true;
2301                                                                                 }
2302                                                                                 if (!bHitted)
2303                                                                                         break;
2304                                                                                 continue;
2305                                                                 }
2306                                                                 if (!bHitted)
2307                                                                         break;
2308                                                                 continue;
2309                                                         }
2310                                                 //-----------------------------
2311                                                 #endregion
2312
2313                                                 case EPad.RD:
2314                                                         #region [ RD(とCYとLC:groupingしている場合)のヒット処理 ]
2315                                                         //-----------------------------
2316                                                         {
2317                                                                 if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.RD)   // #23857 2010.12.12 yyagi: to support VelocityMin
2318                                                                         continue;   // 電子ドラムによる意図的なクロストークを無効にする
2319                                                                 CChip chipCY = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.Cymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1);
2320                                                                 CChip chipRD = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.RideCymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1);
2321                                                                 CChip chipLC = CDTXMania.Instance.ConfigIni.bCymbalFree ? this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.LeftCymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1) : null;
2322                                                                 EJudge e判定CY = (chipCY != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipCY, nInputAdjustTime) : EJudge.Miss;
2323                                                                 EJudge e判定RD = (chipRD != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipRD, nInputAdjustTime) : EJudge.Miss;
2324                                                                 EJudge e判定LC = (chipLC != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipLC, nInputAdjustTime) : EJudge.Miss;
2325                                                                 CChip[] chipArray = new CChip[] { chipCY, chipRD, chipLC };
2326                                                                 EJudge[] e判定Array = new EJudge[] { e判定CY, e判定RD, e判定LC };
2327                                                                 const int NumOfChips = 3;   // chipArray.GetLength(0)
2328
2329                                                                 // HH/CY群を, n発生位置の小さい順に並べる + nullを大きい方に退かす
2330                                                                 SortChipsByNTime(chipArray, e判定Array, NumOfChips);
2331                                                                 switch (eCYGroup)
2332                                                                 {
2333                                                                         case ECYGroup.Off:
2334                                                                                 if (e判定RD != EJudge.Miss)
2335                                                                                 {
2336                                                                                         this.tドラムヒット処理(nTime, EPad.RD, chipRD, inputEvent.nVelocity);
2337                                                                                         bHitted = true;
2338                                                                                 }
2339                                                                                 break;
2340
2341                                                                         case ECYGroup.Group:
2342                                                                                 if (!CDTXMania.Instance.ConfigIni.bCymbalFree)
2343                                                                                 {
2344                                                                                         for (int i = 0; i < NumOfChips; i++)
2345                                                                                         {
2346                                                                                                 if ((e判定Array[i] != EJudge.Miss) && ((chipArray[i] == chipCY) || (chipArray[i] == chipRD)))
2347                                                                                                 {
2348                                                                                                         this.tドラムヒット処理(nTime, EPad.CY, chipArray[i], inputEvent.nVelocity);
2349                                                                                                         bHitted = true;
2350                                                                                                         break;
2351                                                                                                 }
2352                                                                                         }
2353                                                                                         break;
2354                                                                                 }
2355                                                                                 for (int i = 0; i < NumOfChips; i++)
2356                                                                                 {
2357                                                                                         if (e判定Array[i] != EJudge.Miss)
2358                                                                                         {
2359                                                                                                 this.tドラムヒット処理(nTime, EPad.CY, chipArray[i], inputEvent.nVelocity);
2360                                                                                                 bHitted = true;
2361                                                                                                 break;
2362                                                                                         }
2363                                                                                 }
2364                                                                                 break;
2365                                                                 }
2366                                                                 if (bHitted)
2367                                                                 {
2368                                                                         continue;
2369                                                                 }
2370                                                                 break;
2371                                                         }
2372                                                 //-----------------------------
2373                                                 #endregion
2374
2375                                                 case EPad.LC:
2376                                                         #region [ LC(とHC/HOとCYと:groupingしている場合)のヒット処理 ]
2377                                                         //-----------------------------
2378                                                         {
2379                                                                 if (inputEvent.nVelocity <= CDTXMania.Instance.ConfigIni.nVelocityMin.LC)   // #23857 2010.12.12 yyagi: to support VelocityMin
2380                                                                         continue;   // 電子ドラムによる意図的なクロストークを無効にする
2381                                                                 CChip chipHC = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.HiHatClose, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1);    // HC
2382                                                                 CChip chipHO = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.HiHatOpen, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1); // HO
2383                                                                 CChip chipLC = this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.LeftCymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1);    // LC
2384                                                                 CChip chipCY = CDTXMania.Instance.ConfigIni.bCymbalFree ? this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.Cymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1) : null;
2385                                                                 CChip chipRD = CDTXMania.Instance.ConfigIni.bCymbalFree ? this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.RideCymbal, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1) : null;
2386                                                                 EJudge e判定HC = (chipHC != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipHC, nInputAdjustTime) : EJudge.Miss;
2387                                                                 EJudge e判定HO = (chipHO != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipHO, nInputAdjustTime) : EJudge.Miss;
2388                                                                 EJudge e判定LC = (chipLC != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipLC, nInputAdjustTime) : EJudge.Miss;
2389                                                                 EJudge e判定CY = (chipCY != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipCY, nInputAdjustTime) : EJudge.Miss;
2390                                                                 EJudge e判定RD = (chipRD != null) ? this.e指定時刻からChipのJUDGEを返す(nTime, chipRD, nInputAdjustTime) : EJudge.Miss;
2391                                                                 CChip[] chipArray = new CChip[] { chipHC, chipHO, chipLC, chipCY, chipRD };
2392                                                                 EJudge[] e判定Array = new EJudge[] { e判定HC, e判定HO, e判定LC, e判定CY, e判定RD };
2393                                                                 const int NumOfChips = 5;   // chipArray.GetLength(0)
2394
2395                                                                 // HH/CY群を, n発生位置の小さい順に並べる + nullを大きい方に退かす
2396                                                                 SortChipsByNTime(chipArray, e判定Array, NumOfChips);
2397                                                                 switch (eHHGroup)
2398                                                                 {
2399                                                                         case EHHGroup.Off:
2400                                                                         case EHHGroup.LC_HH:
2401                                                                                 if (!CDTXMania.Instance.ConfigIni.bCymbalFree)
2402                                                                                 {
2403                                                                                         if (e判定LC != EJudge.Miss)
2404                                                                                         {
2405                                                                                                 this.tドラムヒット処理(nTime, EPad.LC, chipLC, inputEvent.nVelocity);
2406                                                                                                 bHitted = true;
2407                                                                                         }
2408                                                                                         if (!bHitted)
2409                                                                                                 break;
2410                                                                                         continue;
2411                                                                                 }
2412                                                                                 for (int i = 0; i < NumOfChips; i++)
2413                                                                                 {
2414                                                                                         if ((e判定Array[i] != EJudge.Miss) && (((chipArray[i] == chipLC) || (chipArray[i] == chipCY)) || ((chipArray[i] == chipRD) && (CDTXMania.Instance.ConfigIni.eCYGroup == ECYGroup.Group))))
2415                                                                                         {
2416                                                                                                 this.tドラムヒット処理(nTime, EPad.LC, chipArray[i], inputEvent.nVelocity);
2417                                                                                                 bHitted = true;
2418                                                                                                 break;
2419                                                                                         }
2420                                                                                 }
2421                                                                                 if (!bHitted)
2422                                                                                         break;
2423                                                                                 continue;
2424
2425                                                                         case EHHGroup.HO_HC:
2426                                                                         case EHHGroup.Group:
2427                                                                                 if (!CDTXMania.Instance.ConfigIni.bCymbalFree)
2428                                                                                 {
2429                                                                                         for (int i = 0; i < NumOfChips; i++)
2430                                                                                         {
2431                                                                                                 if ((e判定Array[i] != EJudge.Miss) && (((chipArray[i] == chipLC) || (chipArray[i] == chipHC)) || (chipArray[i] == chipHO)))
2432                                                                                                 {
2433                                                                                                         this.tドラムヒット処理(nTime, EPad.LC, chipArray[i], inputEvent.nVelocity);
2434                                                                                                         bHitted = true;
2435                                                                                                         break;
2436                                                                                                 }
2437                                                                                         }
2438                                                                                         if (!bHitted)
2439                                                                                                 break;
2440                                                                                         continue;
2441                                                                                 }
2442                                                                                 for (int i = 0; i < NumOfChips; i++)
2443                                                                                 {
2444                                                                                         if ((e判定Array[i] != EJudge.Miss) && ((chipArray[i] != chipRD) || (CDTXMania.Instance.ConfigIni.eCYGroup == ECYGroup.Group)))
2445                                                                                         {
2446                                                                                                 this.tドラムヒット処理(nTime, EPad.LC, chipArray[i], inputEvent.nVelocity);
2447                                                                                                 bHitted = true;
2448                                                                                                 break;
2449                                                                                         }
2450                                                                                 }
2451                                                                                 if (!bHitted)
2452                                                                                         break;
2453                                                                                 continue;
2454                                                                 }
2455                                                                 if (!bHitted)
2456                                                                         break;
2457
2458                                                                 break;
2459                                                         }
2460                                                 //-----------------------------
2461                                                 #endregion
2462
2463                                                 case EPad.HP:       // #27029 2012.1.4 from
2464                                                         #region [ HPのヒット処理 ]
2465                                                         //-----------------
2466                                                         if (CDTXMania.Instance.ConfigIni.eBDGroup == EBDGroup.Group)
2467                                                         {
2468                                                                 #region [ BDとみなしてヒット処理 ]
2469                                                                 //-----------------
2470                                                                 if (!this.tドラムヒット処理(nTime, EPad.BD, this.r指定時刻に一番近い未ヒットChip(nTime, EChannel.BassDrum, nInputAdjustTime, CDTXMania.Instance.nPoor範囲ms + 1), inputEvent.nVelocity))
2471                                                                         break;
2472                                                                 continue;
2473                                                                 //-----------------
2474                                                                 #endregion
2475                                                         }
2476                                                         else
2477                                                         {
2478                                                                 #region [ HPのヒット処理 ]
2479                                                                 //-----------------
2480                                                                 continue;   // 何もしない。この入力を完全に無視するので、break しないこと。
2481                                                                                                                 //-----------------
2482                                                                 #endregion
2483                                                         }
2484                                                         //-----------------
2485                                                         #endregion
2486                                         }
2487                                         //-----------------------------
2488                                         #endregion
2489                                         #region [ (B) ヒットしてなかった場合は、レーンフラッシュ、パッドアニメ、空打ち音再生を実行 ]
2490                                         //-----------------------------
2491                                         EPad pad = ePad; // 以下、nPad の代わりに pad を用いる。（成りすまし用）
2492
2493                                         if (ePad == EPad.HP)
2494                                         {
2495                                                 // #27029 2012.1.4 from: HP&BD 時の HiHatPedal の場合は BD に成りすます。
2496                                                 pad = EPad.BD;
2497                                                 //（ HP|BD 時のHP入力はここまでこないので無視。）
2498                                         }
2499
2500                                         // レーンフラッシュ
2501                                         this.actLaneFlushD.Start(EnumConverter.LaneFromPad(pad), ((float)inputEvent.nVelocity) / 127f);
2502
2503                                         // パッド画像のヒット処理用
2504
2505                                         // パッドアニメ
2506                                         this.actPad.Hit(pad);
2507
2508                                         // 空打ち音
2509                                         if (CDTXMania.Instance.ConfigIni.bDrumsHitSound)
2510                                         {
2511                                                 CChip rChip = this.r空うちChip(EPart.Drums, pad);
2512                                                 if (rChip != null)
2513                                                 {
2514                                                         // (B1) 空打ち音が譜面で指定されているのでそれを再生する。
2515                                                         this.tサウンド再生(rChip, CSound管理.rc演奏用タイマ.nシステム時刻, EPart.Drums, CDTXMania.Instance.ConfigIni.nChipVolume, CDTXMania.Instance.ConfigIni.bEmphasizePlaySound.Drums);
2516                                                 }
2517                                                 else
2518                                                 {
2519                                                         #region [ (B2) 空打ち音が指定されていないので一番近いチップを探して再生する。]
2520                                                         switch (pad)
2521                                                         {
2522                                                                 case EPad.HH:
2523                                                                         {
2524                                                                                 CChip chipHC = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.HiHatClose, nInputAdjustTime);
2525                                                                                 CChip chipHO = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.HiHatOpen, nInputAdjustTime);
2526                                                                                 CChip chipLC = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.LeftCymbal, nInputAdjustTime);
2527                                                                                 switch (CDTXMania.Instance.ConfigIni.eHHGroup.Value)
2528                                                                                 {
2529                                                                                         case EHHGroup.HO_HC:
2530                                                                                                 rChip = (chipHC != null) ? chipHC : chipLC;
2531                                                                                                 break;
2532
2533                                                                                         case EHHGroup.LC_HH:
2534                                                                                                 rChip = (chipHC != null) ? chipHC : chipHO;
2535                                                                                                 break;
2536
2537                                                                                         case EHHGroup.Group:
2538                                                                                                 if (chipHC != null)
2539                                                                                                 {
2540                                                                                                         rChip = chipHC;
2541                                                                                                 }
2542                                                                                                 else if (chipHO == null)
2543                                                                                                 {
2544                                                                                                         rChip = chipLC;
2545                                                                                                 }
2546                                                                                                 else if (chipLC == null)
2547                                                                                                 {
2548                                                                                                         rChip = chipHO;
2549                                                                                                 }
2550                                                                                                 else if (chipHO.n発声位置 < chipLC.n発声位置)
2551                                                                                                 {
2552                                                                                                         rChip = chipHO;
2553                                                                                                 }
2554                                                                                                 else
2555                                                                                                 {
2556                                                                                                         rChip = chipLC;
2557                                                                                                 }
2558                                                                                                 break;
2559
2560                                                                                         default:
2561                                                                                                 rChip = chipHC;
2562                                                                                                 break;
2563                                                                                 }
2564                                                                         }
2565                                                                         break;
2566
2567                                                                 case EPad.LT:
2568                                                                         {
2569                                                                                 CChip chipLT = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.LowTom, nInputAdjustTime);
2570                                                                                 CChip chipFT = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.FloorTom, nInputAdjustTime);
2571                                                                                 if (CDTXMania.Instance.ConfigIni.eFTGroup != EFTGroup.Off)
2572                                                                                         rChip = (chipLT != null) ? chipLT : chipFT;
2573                                                                                 else
2574                                                                                         rChip = chipLT;
2575                                                                         }
2576                                                                         break;
2577
2578                                                                 case EPad.FT:
2579                                                                         {
2580                                                                                 CChip chipLT = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.LowTom, nInputAdjustTime);
2581                                                                                 CChip chipFT = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.FloorTom, nInputAdjustTime);
2582                                                                                 if (CDTXMania.Instance.ConfigIni.eFTGroup != EFTGroup.Off)
2583                                                                                         rChip = (chipFT != null) ? chipFT : chipLT;
2584                                                                                 else
2585                                                                                         rChip = chipFT;
2586                                                                         }
2587                                                                         break;
2588
2589                                                                 case EPad.CY:
2590                                                                         {
2591                                                                                 CChip chipCY = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.Cymbal, nInputAdjustTime);
2592                                                                                 CChip chipRD = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.RideCymbal, nInputAdjustTime);
2593                                                                                 if (CDTXMania.Instance.ConfigIni.eCYGroup != ECYGroup.Off)
2594                                                                                         rChip = (chipCY != null) ? chipCY : chipRD;
2595                                                                                 else
2596                                                                                         rChip = chipCY;
2597                                                                         }
2598                                                                         break;
2599
2600                                                                 case EPad.HHO:
2601                                                                         {
2602                                                                                 CChip chipHC = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.HiHatClose, nInputAdjustTime);
2603                                                                                 CChip chipHO = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.HiHatOpen, nInputAdjustTime);
2604                                                                                 CChip chipLC = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.LeftCymbal, nInputAdjustTime);
2605                                                                                 switch (CDTXMania.Instance.ConfigIni.eHHGroup.Value)
2606                                                                                 {
2607                                                                                         case EHHGroup.Off:
2608                                                                                                 rChip = chipHO;
2609                                                                                                 break;
2610
2611                                                                                         case EHHGroup.HO_HC:
2612                                                                                                 rChip = (chipHO != null) ? chipHO : chipLC;
2613                                                                                                 break;
2614
2615                                                                                         case EHHGroup.LC_HH:
2616                                                                                                 rChip = (chipHO != null) ? chipHO : chipHC;
2617                                                                                                 break;
2618
2619                                                                                         case EHHGroup.Group:
2620                                                                                                 if (chipHO != null)
2621                                                                                                 {
2622                                                                                                         rChip = chipHO;
2623                                                                                                 }
2624                                                                                                 else if (chipHC == null)
2625                                                                                                 {
2626                                                                                                         rChip = chipLC;
2627                                                                                                 }
2628                                                                                                 else if (chipLC == null)
2629                                                                                                 {
2630                                                                                                         rChip = chipHC;
2631                                                                                                 }
2632                                                                                                 else if (chipHC.n発声位置 < chipLC.n発声位置)
2633                                                                                                 {
2634                                                                                                         rChip = chipHC;
2635                                                                                                 }
2636                                                                                                 else
2637                                                                                                 {
2638                                                                                                         rChip = chipLC;
2639                                                                                                 }
2640                                                                                                 break;
2641                                                                                 }
2642                                                                         }
2643                                                                         break;
2644
2645                                                                 case EPad.RD:
2646                                                                         {
2647                                                                                 CChip chipCY = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.Cymbal, nInputAdjustTime);
2648                                                                                 CChip chipRD = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.RideCymbal, nInputAdjustTime);
2649                                                                                 if (CDTXMania.Instance.ConfigIni.eCYGroup != ECYGroup.Off)
2650                                                                                         rChip = (chipRD != null) ? chipRD : chipCY;
2651                                                                                 else
2652                                                                                         rChip = chipRD;
2653                                                                         }
2654                                                                         break;
2655
2656                                                                 case EPad.LC:
2657                                                                         {
2658                                                                                 CChip chipHC = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.HiHatClose, nInputAdjustTime);
2659                                                                                 CChip chipHO = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.HiHatOpen, nInputAdjustTime);
2660                                                                                 CChip chipLC = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EChannel.LeftCymbal, nInputAdjustTime);
2661                                                                                 switch (CDTXMania.Instance.ConfigIni.eHHGroup.Value)
2662                                                                                 {
2663                                                                                         case EHHGroup.Off:
2664                                                                                         case EHHGroup.LC_HH:
2665                                                                                                 rChip = chipLC;
2666                                                                                                 break;
2667
2668                                                                                         case EHHGroup.HO_HC:
2669                                                                                         case EHHGroup.Group:
2670                                                                                                 if (chipLC != null)
2671                                                                                                 {
2672                                                                                                         rChip = chipLC;
2673                                                                                                 }
2674                                                                                                 else if (chipHC == null)
2675                                                                                                 {
2676                                                                                                         rChip = chipHO;
2677                                                                                                 }
2678                                                                                                 else if (chipHO == null)
2679                                                                                                 {
2680                                                                                                         rChip = chipHC;
2681                                                                                                 }
2682                                                                                                 else if (chipHC.n発声位置 < chipHO.n発声位置)
2683                                                                                                 {
2684                                                                                                         rChip = chipHC;
2685                                                                                                 }
2686                                                                                                 else
2687                                                                                                 {
2688                                                                                                         rChip = chipHO;
2689                                                                                                 }
2690                                                                                                 break;
2691                                                                                 }
2692                                                                         }
2693                                                                         break;
2694
2695                                                                 default:
2696                                                                         rChip = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, EnumConverter.ChannelFromPad(pad), nInputAdjustTime);
2697                                                                         break;
2698                                                         }
2699                                                         if (rChip != null)
2700                                                         {
2701                                                                 // 空打ち音が見つかったので再生する。
2702                                                                 this.tサウンド再生(rChip, CSound管理.rc演奏用タイマ.nシステム時刻, EPart.Drums, CDTXMania.Instance.ConfigIni.nChipVolume, CDTXMania.Instance.ConfigIni.bEmphasizePlaySound.Drums);
2703                                                         }
2704                                                         //-----------------
2705                                                         #endregion
2706                                                 }
2707                                         }
2708
2709                                         // BAD or TIGHT 時の処理。
2710                                         if (CDTXMania.Instance.ConfigIni.bTight)
2711                                                 this.tチップのヒット処理_BadならびにTight時のMiss(EPart.Drums, EnumConverter.LaneFromPad(pad));//nパッド0Atoレーン07[(int)pad]
2712                                                                                                                                                                                                                                                                                                                                                                                 //-----------------------------
2713                                         #endregion
2714                                 }
2715                         }
2716                 }
2717
2718                 private void ドラムスクロール速度アップ()
2719                 {
2720                         int scrollSpeed = CDTXMania.Instance.ConfigIni.nScrollSpeed.Drums;
2721                         CDTXMania.Instance.ConfigIni.nScrollSpeed.Drums.Value = scrollSpeed + 1;
2722                         float f = (float)CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Drums / (scrollSpeed + 1);
2723                         if (scrollSpeed < CDTXMania.Instance.ConfigIni.nScrollSpeed.Drums)
2724                         {
2725                                 CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Drums.Value = ((int)(f * (CDTXMania.Instance.ConfigIni.nScrollSpeed.Drums + 1) + 0.5));
2726                         }
2727                 }
2728
2729                 private void ドラムスクロール速度ダウン()
2730                 {
2731                         int scrollSpeed = CDTXMania.Instance.ConfigIni.nScrollSpeed.Drums;
2732                         CDTXMania.Instance.ConfigIni.nScrollSpeed.Drums.Value = (scrollSpeed - 1);
2733                         float f = (float)CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Drums / (scrollSpeed + 1);
2734                         if (scrollSpeed > CDTXMania.Instance.ConfigIni.nScrollSpeed.Drums)
2735                         {
2736                                 CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Drums.Value = ((int)(f * (CDTXMania.Instance.ConfigIni.nScrollSpeed.Drums + 1) + 0.5));
2737                         }
2738                 }
2739
2740                 private int nStartTime_ = 0;
2741                 private DateTime dtCurrentDateTime = DateTime.MinValue;
2742
2743                 protected void tキー入力()
2744                 {
2745                         IInputDevice keyboard = CDTXMania.Instance.Input管理.Keyboard;
2746                         if (keyboard.bキーが押された((int)SlimDXKey.F1) &&
2747                                         (keyboard.bキーが押されている((int)SlimDXKey.RightShift) || keyboard.bキーが押されている((int)SlimDXKey.LeftShift)))
2748                         {   // shift+f1 (pause)
2749                                 this.bPAUSE = !this.bPAUSE;
2750                                 if (this.bPAUSE)
2751                                 {
2752                                         nStartTime_ = (int)CSound管理.rc演奏用タイマ.n現在時刻;
2753                                         CSound管理.rc演奏用タイマ.t一時停止();
2754                                         CDTXMania.Instance.Timer.t一時停止();
2755                                         CDTXMania.Instance.DTX.t全チップの再生一時停止();
2756                                         CDTXMania.Instance.DTX.t全AVIの一時停止();
2757                                 }
2758                                 else
2759                                 {
2760                                         CDTXMania.Instance.DTX.t全AVIの再生再開();
2761                                         // CDTXMania.Instance.DTX.t全チップの再生再開();
2762                                         #region [ PAUSE連打でのBGMずれ対策 (AVIはずれたままになるが無視・・・) ]
2763
2764                                         List<CSound> pausedCSound = new List<CSound>();
2765                                         for (int i = this.n現在のトップChip; i >= 0; i--)
2766                                         {
2767                                                 CChip pChip = CDTXMania.Instance.DTX.listChip[i];
2768                                                 int nDuration = pChip.GetDuration();
2769
2770                                                 if ((pChip.n発声時刻ms + nDuration > 0) && (pChip.n発声時刻ms <= nStartTime_) && (nStartTime_ <= pChip.n発声時刻ms + nDuration))
2771                                                 {
2772                                                         if (pChip.bWAVを使うチャンネルである && !pChip.b空打ちチップである) // wav系チャンネル、且つ、空打ちチップではない
2773                                                         {
2774                                                                 CDTX.CWAV wc;
2775                                                                 bool b = CDTXMania.Instance.DTX.listWAV.TryGetValue(pChip.n整数値_内部番号, out wc);
2776                                                                 if (!b) continue;
2777
2778                                                                 if ((wc.bIsBGMSound && CDTXMania.Instance.ConfigIni.bBGMPlay) || (!wc.bIsBGMSound))
2779                                                                 {
2780                                                                         CDTXMania.Instance.DTX.tチップの再生(pChip, CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻 + pChip.n発声時刻ms, CDTXMania.Instance.DTX.nモニタを考慮した音量(EPart.Unknown));
2781                                                                         #region [ PAUSEする ]
2782                                                                         int j = wc.n現在再生中のサウンド番号;
2783                                                                         if (wc.rSound[j] != null)
2784                                                                         {
2785                                                                                 wc.rSound[j].t再生を一時停止する();
2786                                                                                 wc.rSound[j].t再生位置を変更する(nStartTime_ - pChip.n発声時刻ms);
2787                                                                                 pausedCSound.Add(wc.rSound[j]);
2788                                                                         }
2789                                                                         #endregion
2790                                                                 }
2791                                                         }
2792                                                 }
2793                                         }
2794                                         foreach (CSound cs in pausedCSound)
2795                                         {
2796                                                 cs.tサウンドを再生する();
2797                                         }
2798
2799                                         #endregion
2800                                         CDTXMania.Instance.Timer.t再開();
2801                                         CSound管理.rc演奏用タイマ.t再開();
2802                                 }
2803                         }
2804                         if ((!this.bPAUSE && (base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED)) && (base.eフェーズID != CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト))
2805                         {
2806                                 if (CDTXMania.Instance.ConfigIni.bDrums有効)
2807                                 {
2808                                         this.t入力処理_ドラム();
2809                                 }
2810                                 if (CDTXMania.Instance.ConfigIni.bGuitar有効)
2811                                 {
2812                                         this.t入力処理_ギターベース(EPart.Guitar);
2813                                         this.t入力処理_ギターベース(EPart.Bass);
2814                                 }
2815
2816                                 if (keyboard.bキーが押された((int)SlimDXKey.UpArrow) && (keyboard.bキーが押されている((int)SlimDXKey.RightShift) || keyboard.bキーが押されている((int)SlimDXKey.LeftShift)))
2817                                 {   // shift (+ctrl) + UpArrow (BGMAdjust)
2818                                         CDTXMania.Instance.DTX.t各自動再生音チップの再生時刻を変更する((keyboard.bキーが押されている((int)SlimDXKey.LeftControl) || keyboard.bキーが押されている((int)SlimDXKey.RightControl)) ? 1 : 10);
2819                                         CDTXMania.Instance.DTX.tWave再生位置自動補正();
2820                                 }
2821                                 else if (keyboard.bキーが押された((int)SlimDXKey.DownArrow) && (keyboard.bキーが押されている((int)SlimDXKey.RightShift) || keyboard.bキーが押されている((int)SlimDXKey.LeftShift)))
2822                                 {   // shift + DownArrow (BGMAdjust)
2823                                         CDTXMania.Instance.DTX.t各自動再生音チップの再生時刻を変更する((keyboard.bキーが押されている((int)SlimDXKey.LeftControl) || keyboard.bキーが押されている((int)SlimDXKey.RightControl)) ? -1 : -10);
2824                                         CDTXMania.Instance.DTX.tWave再生位置自動補正();
2825                                 }
2826                                 else if (keyboard.bキーが押された((int)SlimDXKey.UpArrow))
2827                                 {   // UpArrow(scrollspeed up)
2828                                         ドラムスクロール速度アップ();
2829                                 }
2830                                 else if (keyboard.bキーが押された((int)SlimDXKey.DownArrow))
2831                                 {   // DownArrow (scrollspeed down)
2832                                         ドラムスクロール速度ダウン();
2833                                 }
2834                                 else if (keyboard.bキーが押された((int)SlimDXKey.Delete))
2835                                 {   // del (debug info)
2836                                         CDTXMania.Instance.ConfigIni.bDebugInfo.Value = !CDTXMania.Instance.ConfigIni.bDebugInfo;
2837                                 }
2838                                 else if (keyboard.bキーが押された((int)SlimDXKey.LeftArrow))      // #24243 2011.1.16 yyagi UI for InputAdjustTime in playing screen.
2839                                 {
2840                                         ChangeInputAdjustTimeInPlaying(keyboard, -1);
2841                                 }
2842                                 else if (keyboard.bキーが押された((int)SlimDXKey.RightArrow))     // #24243 2011.1.16 yyagi UI for InputAdjustTime in playing screen.
2843                                 {
2844                                         ChangeInputAdjustTimeInPlaying(keyboard, +1);
2845                                 }
2846                                 else if (keyboard.bキーが押された((int)SlimDXKey.F5))
2847                                 {
2848                                         int nVal = CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Drums - 1;
2849                                         CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Drums.Value =
2850                                         CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Guitar.Value =
2851                                         CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Bass.Value = nVal;
2852                                 }
2853                                 else if (keyboard.bキーが押された((int)SlimDXKey.F6))
2854                                 {
2855                                         int nVal = CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Drums + 1;
2856                                         CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Drums.Value =
2857                                         CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Guitar.Value =
2858                                         CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset.Bass.Value = nVal;
2859                                 }
2860                                 else if (base.eフェーズID == CStage.Eフェーズ.共通_通常状態)
2861                                 {
2862                                         if (CDTXMania.Instance.Pad.bCancelPadIsPressingGB())
2863                                         {
2864                                                 if (dtCurrentDateTime == DateTime.MinValue)
2865                                                 {
2866                                                         dtCurrentDateTime = DateTime.Now;
2867                                                 }
2868                                                 else if ( DateTime.Now - dtCurrentDateTime > TimeSpan.FromMilliseconds(1000))   // #40847 keep pushing Cancel 1sec to exit
2869                                                 {
2870                                                         // escape (exit)
2871                                                         this.actFO.tフェードアウト開始();
2872                                                         base.eフェーズID = CStage.Eフェーズ.共通_フェードアウト;
2873                                                         this.eフェードアウト完了時の戻り値 = E演奏画面の戻り値.演奏中断;
2874                                                 }
2875                                         }
2876                                         else
2877                                         {
2878                                                 dtCurrentDateTime = DateTime.MinValue;
2879                                         }
2880
2881                                         if (keyboard.bキーが押された((int)SlimDXKey.Escape))
2882                                         {
2883                                                 // escape (exit)
2884                                                 this.actFO.tフェードアウト開始();
2885                                                 base.eフェーズID = CStage.Eフェーズ.共通_フェードアウト;
2886                                                 this.eフェードアウト完了時の戻り値 = E演奏画面の戻り値.演奏中断;
2887                                         }
2888                                 }
2889                         }
2890                 }
2891
2892                 protected void t入力メソッド記憶(EPart part)
2893                 {
2894                         if (CDTXMania.Instance.Pad.st検知したデバイス.Keyboard)
2895                         {
2896                                 this.b演奏にキーボードを使った[part] = true;
2897                         }
2898                         if (CDTXMania.Instance.Pad.st検知したデバイス.Joypad)
2899                         {
2900                                 this.b演奏にジョイパッドを使った[part] = true;
2901                         }
2902                         if (CDTXMania.Instance.Pad.st検知したデバイス.MIDIIN)
2903                         {
2904                                 this.b演奏にMIDI入力を使った[part] = true;
2905                         }
2906                         if (CDTXMania.Instance.Pad.st検知したデバイス.Mouse)
2907                         {
2908                                 this.b演奏にマウスを使った[part] = true;
2909                         }
2910                 }
2911
2912                 /// <summary>
2913                 /// チップに関連する処理を行う。
2914                 /// </summary>
2915                 /// <returns>演奏が終了したかどうかを示す値</returns>
2916                 protected bool t進行描画_チップ()
2917                 {
2918                         if ((base.eフェーズID == CStage.Eフェーズ.演奏_STAGE_FAILED) || (base.eフェーズID == CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト))
2919                         {
2920                                 return true;
2921                         }
2922                         if ((this.n現在のトップChip == -1) || (this.n現在のトップChip >= CDTXMania.Instance.DTX.listChip.Count))
2923                         {
2924                                 return true;
2925                         }
2926                         if (this.n現在のトップChip == -1)
2927                         {
2928                                 return true;
2929                         }
2930
2931                         //CDTX dTX = CDTXMania.Instance.DTX;
2932                         //CConfigIni configIni = CDTXMania.Instance.ConfigIni;
2933                         for (int nCurrentTopChip = this.n現在のトップChip; nCurrentTopChip < CDTXMania.Instance.DTX.listChip.Count; nCurrentTopChip++)
2934                         {
2935                                 CChip pChip = CDTXMania.Instance.DTX.listChip[nCurrentTopChip];
2936                                 //Debug.WriteLine( "nCurrentTopChip=" + nCurrentTopChip + ", ch=" + pChip.nチャンネル番号.ToString("x2") + ", 発音位置=" + pChip.n発声位置 + ", 発声時刻ms=" + pChip.n発声時刻ms );
2937                                 pChip.CalcDistanceFromBar(CSound管理.rc演奏用タイマ.n現在時刻, this.act譜面スクロール速度.db現在の譜面スクロール速度);
2938                                 if (Math.Min(Math.Min(pChip.nバーからの距離dot.Drums, pChip.nバーからの距離dot.Guitar), pChip.nバーからの距離dot.Bass) > 450 * Scale.Y)
2939                                 {
2940                                         break;
2941                                 }
2942                                 // #28026 2012.4.5 yyagi; 信心ワールドエンドの曲終了後リザルトになかなか行かない問題の修正
2943                                 if ((CDTXMania.Instance.DTX.listChip[this.n現在のトップChip].nバーからの距離dot.Drums < -65 * Scale.Y) &&   // 小節線の消失処理などに影響するため、
2944                                                 (CDTXMania.Instance.DTX.listChip[this.n現在のトップChip].nバーからの距離dot.Guitar < -65 * Scale.Y) &&  // Drumsのスクロールスピードだけには依存させない。
2945                                                 (CDTXMania.Instance.DTX.listChip[this.n現在のトップChip].nバーからの距離dot.Bass < -65 * Scale.Y) &&
2946                                                 CDTXMania.Instance.DTX.listChip[this.n現在のトップChip].bHit)
2947                                 {
2948                                         ++this.n現在のトップChip;
2949                                         continue;
2950                                 }
2951                                 bool bPChipIsAutoPlay = pChip.bAssignAutoPlayState();
2952
2953                                 int nInputAdjustTime = (bPChipIsAutoPlay || (pChip.e楽器パート == EPart.Unknown)) ? 0 : CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs[pChip.e楽器パート];
2954
2955                                 EPart inst = pChip.e楽器パート;
2956                                 if (((pChip.e楽器パート != EPart.Unknown) && !pChip.bHit) &&
2957                                                                 ((pChip.nバーからの距離dot[inst] < -40 * Scale.Y) &&
2958                                                 (this.e指定時刻からChipのJUDGEを返す(CSound管理.rc演奏用タイマ.n現在時刻, pChip, nInputAdjustTime) == EJudge.Miss)))
2959                                 {
2960                                         this.tチップのヒット処理(CSound管理.rc演奏用タイマ.n現在時刻, pChip);    //チップ消失(Hitせずスルーした場合)
2961                                 }
2962                                 if (((pChip.e楽器パート != EPart.Unknown) && !pChip.bHit) &&
2963                                                 ((pChip.nバーからの距離dot[inst] + CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset[inst] < 0)))
2964                                 {
2965                                         //Debug.WriteLine( "透明度＝" + pChip.n透明度 );
2966                                         pChip.n透明度 -= 12;       // チップが判定バーを越えたら、徐々に透明にする。VSyncWaitの有無で加減が変わるが・・
2967                                         if (pChip.n透明度 < 0)
2968                                         {
2969                                                 pChip.n透明度 = 0;
2970                                         }
2971                                 }
2972
2973                                 // #35411 chnmr0 add (ターゲットゴースト)
2974                                 if (CDTXMania.Instance.ConfigIni.eTargetGhost[inst] != ETargetGhostData.None &&
2975                                                                  CDTXMania.Instance.DTX.listTargetGhsotLag[inst] != null &&
2976                                                                  pChip.e楽器パート != EPart.Unknown &&
2977                                                                  pChip.nバーからの距離dot[inst] < 0)
2978                                 {
2979                                         if (!pChip.bTargetGhost判定済み)
2980                                         {
2981                                                 pChip.bTargetGhost判定済み = true;
2982
2983                                                 int ghostLag = 128;
2984                                                 if (0 <= pChip.n楽器パートでの出現順 && pChip.n楽器パートでの出現順 < CDTXMania.Instance.DTX.listTargetGhsotLag[inst].Count)
2985                                                 {
2986                                                         ghostLag = CDTXMania.Instance.DTX.listTargetGhsotLag[inst][pChip.n楽器パートでの出現順];
2987                                                         // 上位８ビットが１ならコンボが途切れている（ギターBAD空打ちでコンボ数を再現するための措置）
2988                                                         if (ghostLag > 255)
2989                                                         {
2990                                                                 this.nコンボ数_TargetGhost[inst] = 0;
2991                                                         }
2992                                                         ghostLag = (ghostLag & 255) - 128;
2993                                                 }
2994                                                 else if (CDTXMania.Instance.ConfigIni.eTargetGhost[inst] == ETargetGhostData.Perfect)
2995                                                 {
2996                                                         ghostLag = 0;
2997                                                 }
2998
2999                                                 if (ghostLag <= 127)
3000                                                 {
3001                                                         EJudge eJudge = this.e指定時刻からChipのJUDGEを返す(pChip.n発声時刻ms + ghostLag, pChip, 0, false);
3002                                                         this.nヒット数_TargetGhost[inst][(int)eJudge]++;
3003                                                         if (eJudge == EJudge.Miss || eJudge == EJudge.Poor)
3004                                                         {
3005                                                                 this.n最大コンボ数_TargetGhost[inst] = Math.Max(this.n最大コンボ数_TargetGhost[inst], this.nコンボ数_TargetGhost[inst]);
3006                                                                 this.nコンボ数_TargetGhost[inst] = 0;
3007                                                         }
3008                                                         else
3009                                                         {
3010                                                                 this.nコンボ数_TargetGhost[inst]++;
3011                                                         }
3012                                                 }
3013                                         }
3014                                 }
3015
3016                                 if (pChip[EChannel.BGM] && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0))
3017                                 {
3018                                         pChip.bHit = true;
3019                                         if (CDTXMania.Instance.ConfigIni.bBGMPlay)
3020                                         {
3021                                                 //long t = CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻 + pChip.n発声時刻ms;
3022                                                 //Trace.TraceInformation( "BGM再生開始: 演奏タイマのn前回リセットしたときのシステム時刻=" + CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻 + ", pChip.n発生時刻ms=" + pChip.n発声時刻ms + ", 合計=" + t );
3023                                                 CDTXMania.Instance.DTX.tチップの再生(pChip, CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻 + pChip.n発声時刻ms, CDTXMania.Instance.DTX.nモニタを考慮した音量(EPart.Unknown));
3024                                         }
3025                                 }
3026                                 else if (pChip[EChannel.BPM] && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0))
3027                                 {
3028                                         pChip.bHit = true;
3029                                         this.actPlayInfo.dbBPM = (pChip.n整数値 * (((double)CDTXMania.Instance.ConfigIni.nPlaySpeed) / 20.0)) + CDTXMania.Instance.DTX.BASEBPM;
3030                                 }
3031                                 else if (pChip.bBGALayer && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0))
3032                                 {
3033                                         pChip.bHit = true;
3034                                         if (CDTXMania.Instance.ConfigIni.bBGA)
3035                                         {
3036                                                 switch (pChip.eBGA種別)
3037                                                 {
3038                                                         case EBGAType.BMPTEX:
3039                                                                 if (pChip.rBMPTEX != null)
3040                                                                 {
3041                                                                         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);
3042                                                                 }
3043                                                                 break;
3044
3045                                                         case EBGAType.BGA:
3046                                                                 if ((pChip.rBGA != null) && ((pChip.rBMP != null) || (pChip.rBMPTEX != null)))
3047                                                                 {
3048                                                                         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);
3049                                                                 }
3050                                                                 break;
3051
3052                                                         case EBGAType.BGAPAN:
3053                                                                 if ((pChip.rBGAPan != null) && ((pChip.rBMP != null) || (pChip.rBMPTEX != null)))
3054                                                                 {
3055                                                                         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総移動時間);
3056                                                                 }
3057                                                                 break;
3058
3059                                                         default:
3060                                                                 if (pChip.rBMP != null)
3061                                                                 {
3062                                                                         this.actBGA.Start(pChip, pChip.rBMP, null, pChip.rBMP.n幅, pChip.rBMP.n高さ, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
3063                                                                 }
3064                                                                 break;
3065                                                 }
3066                                         }
3067                                 }
3068                                 else if (pChip[EChannel.BPMEx] && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0))
3069                                 {
3070                                         pChip.bHit = true;
3071                                         if (CDTXMania.Instance.DTX.listBPM.ContainsKey(pChip.n整数値_内部番号))
3072                                         {
3073                                                 this.actPlayInfo.dbBPM = (CDTXMania.Instance.DTX.listBPM[pChip.n整数値_内部番号].dbBPM値 *
3074                                                                 (((double)CDTXMania.Instance.ConfigIni.nPlaySpeed) / 20.0)) +
3075                                                                 CDTXMania.Instance.DTX.BASEBPM;
3076                                         }
3077                                 }
3078                                 else if (pChip.bDrums可視チップ && pChip.b空打ちチップである)
3079                                 {
3080                                         if (!pChip.bHit && (pChip.nバーからの距離dot.Drums < 0))
3081                                         {
3082                                                 pChip.bHit = true;
3083                                                 if (CDTXMania.Instance.ConfigIni.bDrums有効)
3084                                                 {
3085                                                         this.r現在の空うちドラムChip[(int)(EnumConverter.PadFromChannel(pChip.eチャンネル番号) - EPad.DrumsPadMin)] = pChip;
3086                                                 }
3087                                         }
3088                                 }
3089                                 else if (pChip.bDrums可視チップ_LP_LBD含まない)
3090                                 {
3091                                         this.t進行描画_チップ_ドラムス(ref pChip);
3092                                 }
3093                                 else if (pChip[EChannel.DrumsFillin] && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0))
3094                                 {
3095                                         pChip.bHit = true;
3096                                         this.r現在の歓声Chip.Drums = pChip;
3097                                 }
3098                                 else if (pChip.bGuitar可視チップ)
3099                                 {
3100                                         this.t進行描画_チップ_ギターベース(ref pChip, EPart.Guitar);
3101                                 }
3102                                 else if (pChip[EChannel.Guitar_Wailing])
3103                                 {
3104                                         this.t進行描画_チップ_ウェイリング(ref pChip);
3105                                 }
3106                                 else if (pChip[EChannel.Guitar_WailingSound] && !pChip.bHit && (pChip.nバーからの距離dot.Guitar < 0))
3107                                 {
3108                                         pChip.bHit = true;
3109                                         this.r現在の歓声Chip.Guitar = pChip;
3110                                 }
3111                                 else if (pChip.bDrums不可視チップ && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0))
3112                                 {
3113                                         pChip.bHit = true;
3114                                 }
3115                                 else if (pChip[EChannel.BarLine] || pChip[EChannel.BeatLine])// 小節線
3116                                 {
3117                                         this.t進行描画_チップ_小節線_拍線(ref pChip);
3118                                 }
3119                                 else if (pChip[EChannel.MIDIChorus] && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0))
3120                                 {
3121                                         pChip.bHit = true;
3122                                 }
3123                                 else if (pChip[EChannel.FillIn])
3124                                 {
3125                                         this.t進行描画_チップ_フィルイン(ref pChip);
3126                                 }
3127                                 else if (pChip.bMovie && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0))            // 動画全般
3128                                 {
3129                                         pChip.bHit = true;
3130                                         if (CDTXMania.Instance.ConfigIni.bAVI)
3131                                         {
3132                                                 if (CDTXMania.Instance.DTX.bチップがある.BGA)
3133                                                 {
3134                                                         this.actAVI.bHasBGA = true;
3135                                                 }
3136                                                 //this.actAVI.bFullScreenMovieCentering = (pChip.eチャンネル番号 == EChannel.MovieFull) ? true : CDTXMania.Instance.ConfigIni.bForceFullMovieCentering.Both;
3137                                                 //this.actAVI.bFullScreenMovieCentering = true;
3138                                                 //if (CDTXMania.Instance.ConfigIni.bForceScalingAVI)
3139                                                 //{
3140                                                 //      //if (!this.actAVI.bFullScreenMovieCentering)
3141                                                 //      //{
3142                                                 //              this.actAVI.nFullScreenMovieX = CDTXMania.Instance.ConfigIni.cdForceScaledMovieX.Both;
3143                                                 //              this.actAVI.nFullScreenMovieY = CDTXMania.Instance.ConfigIni.cdForceScaledMovieY.Both;
3144                                                 //      //}
3145                                                 //}
3146                                                 //if (pChip.eチャンネル番号 == EChannel.MovieFull || CDTXMania.Instance.ConfigIni.bForceScalingAVI)
3147                                                 if (pChip.eチャンネル番号 == EChannel.MovieFull)
3148                                                 {
3149                                                         this.actAVI.bFullScreenMovie = true;
3150                                                 }
3151                                                 else
3152                                                 {
3153                                                         this.actAVI.bFullScreenMovie = false;
3154                                                 }
3155
3156                                                 this.actAVI.SetXYWH();
3157
3158                                                 int startWidth = !this.actAVI.bFullScreenMovie ? 278 : SampleFramework.GameWindowSize.Width;
3159                                                 int startHeight = !this.actAVI.bFullScreenMovie ? 355 : SampleFramework.GameWindowSize.Height;
3160
3161                                                 switch (pChip.eAVI種別)
3162                                                 {
3163                                                         case EAVIType.AVI:
3164                                                                 {
3165
3166                                                                         this.actAVI.Start(pChip.eチャンネル番号, pChip.rAVI, startWidth, startHeight, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, pChip.n発声時刻ms, true);
3167                                                                 }
3168                                                                 break;
3169
3170                                                         case EAVIType.AVIPAN:
3171                                                                 if (pChip.rAVIPan != null)
3172                                                                 {
3173                                                                         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, true);
3174                                                                 }
3175                                                                 break;
3176                                                 }
3177                                         }
3178                                 }
3179                                 else if (pChip.bSE && !pChip.bOverrideSE && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0))
3180                                 {
3181                                         pChip.bHit = true;
3182                                         if (CDTXMania.Instance.ConfigIni.bBGMPlay)
3183                                         {
3184                                                 CDTXMania.Instance.DTX.tWavの再生停止(this.n最後に再生したBGMの実WAV番号[pChip.eチャンネル番号 - EChannel.SE01]);
3185                                                 CDTXMania.Instance.DTX.tチップの再生(pChip, CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻 + pChip.n発声時刻ms, CDTXMania.Instance.DTX.nモニタを考慮した音量(EPart.Unknown));
3186                                                 this.n最後に再生したBGMの実WAV番号[pChip.eチャンネル番号 - EChannel.SE01] = pChip.n整数値_内部番号;
3187                                         }
3188                                 }
3189                                 else if (pChip.bOverrideSE && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0))
3190                                 {
3191                                         // override sound
3192                                         // mute sound (auto)
3193                                         // 4A: 84: HH (HO/HC)
3194                                         // 4B: 85: CY
3195                                         // 4C: 86: RD
3196                                         // 4D: 87: LC
3197                                         // 2A: 88: Gt
3198                                         // AA: 89: Bs
3199
3200                                         //      CDTXMania.Instance.DTX.tWavの再生停止( this.n最後に再生した実WAV番号.Guitar );
3201                                         //      CDTXMania.Instance.DTX.tチップの再生( pChip, n再生開始システム時刻ms, 8, n音量, bモニタ, b音程をずらして再生 );
3202                                         //      this.n最後に再生した実WAV番号.Guitar = pChip.n整数値_内部番号;
3203
3204                                         //      protected void tサウンド再生( CDTX.CChip pChip, long n再生開始システム時刻ms, E楽器パート part, int n音量, bool bモニタ, bool b音程をずらして再生 )
3205                                         pChip.bHit = true;
3206                                         EPart[] p = { EPart.Drums, EPart.Drums, EPart.Drums, EPart.Drums, EPart.Guitar, EPart.Bass };
3207
3208                                         EPart pp = p[pChip.eチャンネル番号 - EChannel.SE24];
3209
3210                                         //                                                      if ( pp == E楽器パート.DRUMS ) {                   // pChip.nチャンネル番号= ..... HHとか、ドラムの場合は変える。
3211                                         //                                                              //            HC    CY    RD    LC
3212                                         //                                                              int[] ch = { 0x11, 0x16, 0x19, 0x1A };
3213                                         //                                                              pChip.nチャンネル番号 = ch[ pChip.nチャンネル番号 - 0x84 ];
3214                                         //                                                      }
3215                                         this.tサウンド再生(pChip, CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻 + pChip.n発声時刻ms, pp, CDTXMania.Instance.DTX.nモニタを考慮した音量(pp));
3216                                 }
3217
3218                                 else if (pChip.bBass可視チップ)
3219                                 {
3220                                         this.t進行描画_チップ_ギターベース(ref pChip, EPart.Bass);
3221                                 }
3222                                 else if (pChip[EChannel.Bass_Wailing])
3223                                 {
3224                                         this.t進行描画_チップ_ウェイリング(ref pChip);
3225                                 }
3226                                 else if (pChip[EChannel.Bass_WailingSound] && !pChip.bHit && (pChip.nバーからの距離dot.Bass < 0))
3227                                 {
3228                                         pChip.bHit = true;
3229                                         this.r現在の歓声Chip.Bass = pChip;
3230                                 }
3231                                 else if (pChip[EChannel.Guitar_NoChip] && !pChip.bHit && (pChip.nバーからの距離dot.Guitar < 0))
3232                                 {
3233                                         pChip.bHit = true;
3234                                         this.r現在の空うちギターChip = pChip;
3235                                         pChip.ConvertGBNoChip();
3236                                 }
3237                                 else if (pChip[EChannel.Bass_NoChip] && !pChip.bHit && (pChip.nバーからの距離dot.Bass < 0))
3238                                 {
3239                                         pChip.bHit = true;
3240                                         this.r現在の空うちベースChip = pChip;
3241                                         pChip.ConvertGBNoChip();
3242                                 }
3243                                 else if (pChip.bBGALayerSwap && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0))
3244                                 {
3245                                         pChip.bHit = true;
3246                                         if ((CDTXMania.Instance.ConfigIni.bBGA && (pChip.eBGA種別 == EBGAType.BMP)) || (pChip.eBGA種別 == EBGAType.BMPTEX))
3247                                         {
3248                                                 this.actBGA.ChangeScope(pChip);
3249                                         }
3250                                 }
3251                                 else if (pChip[EChannel.MixerAdd] && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0))
3252                                 {
3253                                         //Debug.WriteLine( "[DA(AddMixer)] BAR=" + pChip.n発声位置 / 384 + " ch=" + pChip.nチャンネル番号.ToString( "x2" ) + ", wav=" + pChip.n整数値.ToString( "x2" ) + ", time=" + pChip.n発声時刻ms );
3254                                         pChip.bHit = true;
3255                                         if (CDTXMania.Instance.DTX.listWAV.ContainsKey(pChip.n整数値_内部番号))    // 参照が遠いので後日最適化する
3256                                         {
3257                                                 CDTX.CWAV wc = CDTXMania.Instance.DTX.listWAV[pChip.n整数値_内部番号];
3258                                                 //Debug.Write( "[AddMixer] BAR=" + pChip.n発声位置 / 384 + ", wav=" + Path.GetFileName( wc.strファイル名 ) + ", time=" + pChip.n発声時刻ms );
3259
3260                                                 for (int i = 0; i < Math.Max(CDTXMania.Instance.ConfigIni.nPolyphonicSounds, CDTXMania.Instance.ConfigIni.nPolyphonicSoundsGB); i++)
3261                                                 {
3262                                                         if (wc.rSound[i] != null)
3263                                                         {
3264                                                                 //CDTXMania.Instance.Sound管理.AddMixer( wc.rSound[ i ] );
3265                                                                 AddMixer(wc.rSound[i], pChip.b演奏終了後も再生が続くチップである);
3266                                                         }
3267                                                         //else
3268                                                         //{
3269                                                         //    Debug.WriteLine( ", nPoly=" + i + ", Mix=" + CDTXMania.Instance.Sound管理.GetMixingStreams() );
3270                                                         //    break;
3271                                                         //}
3272                                                         //if ( i == nPolyphonicSounds - 1 )
3273                                                         //{
3274                                                         //    Debug.WriteLine( ", nPoly=" + nPolyphonicSounds + ", Mix=" + CDTXMania.Instance.Sound管理.GetMixingStreams() );
3275                                                         //}
3276                                                 }
3277                                         }
3278                                 }
3279                                 else if (pChip[EChannel.MixerRemove] && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0))
3280                                 {
3281                                         //Debug.WriteLine( "[DB(RemoveMixer)] BAR=" + pChip.n発声位置 / 384 + " ch=" + pChip.nチャンネル番号.ToString( "x2" ) + ", wav=" + pChip.n整数値.ToString( "x2" ) + ", time=" + pChip.n発声時刻ms );
3282                                         pChip.bHit = true;
3283                                         if (CDTXMania.Instance.DTX.listWAV.ContainsKey(pChip.n整数値_内部番号))    // 参照が遠いので後日最適化する
3284                                         {
3285                                                 CDTX.CWAV wc = CDTXMania.Instance.DTX.listWAV[pChip.n整数値_内部番号];
3286                                                 //Debug.Write( "[DelMixer] BAR=" + pChip.n発声位置 / 384 +  ", wav=" + Path.GetFileName( wc.strファイル名 ) + ", time=" + pChip.n発声時刻ms );
3287                                                 for (int i = 0; i < Math.Max(CDTXMania.Instance.ConfigIni.nPolyphonicSounds, CDTXMania.Instance.ConfigIni.nPolyphonicSoundsGB); i++)
3288                                                 {
3289                                                         if (wc.rSound[i] != null)
3290                                                         {
3291                                                                 //CDTXMania.Instance.Sound管理.RemoveMixer( wc.rSound[ i ] );
3292                                                                 if (!wc.rSound[i].b演奏終了後も再生が続くチップである)   // #32248 2013.10.16 yyagi
3293                                                                 {                                                           // DTX終了後も再生が続くチップの0xDB登録をなくすことはできず。
3294                                                                         RemoveMixer(wc.rSound[i]);                          // (ミキサー解除のタイミングが遅延する場合の対応が面倒なので。)
3295                                                                 }                                                           // そこで、代わりにフラグをチェックしてミキサー削除ロジックへの遷移をカットする。
3296                                                         }
3297                                                         //else
3298                                                         //{
3299                                                         //    Debug.WriteLine( ", nPoly=" + i + ", Mix=" + CDTXMania.Instance.Sound管理.GetMixingStreams() );
3300                                                         //    break;
3301                                                         //}
3302                                                         //if ( i == nPolyphonicSounds - 1 )
3303                                                         //{
3304                                                         //    Debug.WriteLine( ", nPoly=" + nPolyphonicSounds + ", Mix=" + CDTXMania.Instance.Sound管理.GetMixingStreams() );
3305                                                         //}
3306                                                 }
3307                                         }
3308                                 }
3309                                 else if ( pChip[ EChannel.Click ] && !pChip.bHit && ( pChip.nバーからの距離dot.Drums < 0 ) )
3310                                 {
3311                                         pChip.bHit = true;
3312                                         if ( CDTXMania.Instance.ConfigIni.eClickType != EClickType.Off )
3313                                         {
3314                                                 switch (pChip.n整数値)
3315                                                 {
3316                                                         case (int)EClickSoundType.High:
3317                                                                 CDTXMania.Instance.Skin.soundClickHigh.t再生する();
3318                                                                 break;
3319                                                         case (int)EClickSoundType.Low:
3320                                                                 CDTXMania.Instance.Skin.soundClickLow.t再生する();
3321                                                                 break;
3322                                                         case (int)EClickSoundType.Bottom:
3323                                                                 CDTXMania.Instance.Skin.soundClickBottom.t再生する();
3324                                                                 break;
3325                                                 }
3326                                         }
3327                                 }
3328                                 else if (pChip[EChannel.FirstSoundChip] && !pChip.bHit && (pChip.nバーからの距離dot.Drums < 0))
3329                                 {
3330                                         pChip.bHit = true;
3331                                         if (CDTXMania.Instance.DTX2WAVmode.Enabled)
3332                                         {
3333                                                 FDK.CSound管理.t録音開始();
3334                                                 Trace.TraceInformation("録音を開始しました。");
3335                                         }
3336                                 }
3337                                 else if ( !pChip.bHit && ( pChip.nバーからの距離dot.Drums < 0 ) )
3338                                 {
3339                                         // other chips
3340                                         pChip.bHit = true;
3341                                 }
3342                         }
3343                         return false;
3344                 }
3345
3346
3347                 public void t再読込()
3348                 {
3349                         CDTXMania.Instance.DTX.t全チップの再生停止とミキサーからの削除();
3350                         this.eフェードアウト完了時の戻り値 = E演奏画面の戻り値.再読込_再演奏;
3351                         base.eフェーズID = CStage.Eフェーズ.演奏_再読込;
3352                         this.bPAUSE = false;
3353
3354                         // #34048 2014.7.16 yyagi
3355                         #region [ 読み込み画面に遷移する前に、設定変更した可能性があるパラメータをConfigIniクラスに書き戻す ]
3356                         for (EPart i = EPart.Drums; i <= EPart.Bass; i++)
3357                         {
3358                                 CDTXMania.Instance.ConfigIni.nViewerScrollSpeed[i] = CDTXMania.Instance.ConfigIni.nScrollSpeed[i];
3359                         }
3360                         CDTXMania.Instance.ConfigIni.bDebugInfo = CDTXMania.Instance.ConfigIni.bViewerShowDebugStatus;
3361                         #endregion
3362                 }
3363
3364                 public void t停止()
3365                 {
3366                         CDTXMania.Instance.DTX.t全チップの再生停止とミキサーからの削除();
3367                         this.actAVI.Stop();
3368                         this.actBGA.Stop();
3369                         this.actPanel.Stop();               // PANEL表示停止
3370                         CDTXMania.Instance.Timer.t一時停止();       // 再生時刻カウンタ停止
3371
3372                         this.n現在のトップChip = CDTXMania.Instance.DTX.listChip.Count - 1;   // 終端にシーク
3373
3374                         // 自分自身のOn活性化()相当の処理もすべき。
3375                 }
3376
3377                 /// <summary>
3378                 /// 演奏位置を変更する。
3379                 /// </summary>
3380                 /// <param name="nStartBar">演奏開始小節番号</param>
3381                 /// <param name="bResetHitStatus">演奏済み情報(bHit)をクリアするかどうか</param>
3382                 public void t演奏位置の変更(int nStartBar)
3383                 {
3384                         // まず全サウンドオフにする
3385                         CDTXMania.Instance.DTX.t全チップの再生停止();
3386                         this.actAVI.Stop();
3387                         this.actBGA.Stop();
3388
3389                         #region [ 再生開始小節の変更 ]
3390                         // +1が必要
3391                         nStartBar++;
3392
3393                         #region [ 演奏済みフラグのついたChipをリセットする ]
3394                         for (int i = 0; i < CDTXMania.Instance.DTX.listChip.Count; i++)
3395                         {
3396                                 CChip pChip = CDTXMania.Instance.DTX.listChip[i];
3397                                 if (pChip.bHit)
3398                                 {
3399                                         CChip p = (CChip)pChip.Clone();
3400                                         p.bHit = false;
3401                                         CDTXMania.Instance.DTX.listChip[i] = p;
3402                                 }
3403                         }
3404                         #endregion
3405
3406                         #region [ 処理を開始するチップの特定 ]
3407                         //for ( int i = this.n現在のトップChip; i < CDTXMania.Instance.DTX.listChip.Count; i++ )
3408                         bool bSuccessSeek = false;
3409                         for (int i = 0; i < CDTXMania.Instance.DTX.listChip.Count; i++)
3410                         {
3411                                 CChip pChip = CDTXMania.Instance.DTX.listChip[i];
3412                                 if (pChip.n発声位置 < 384 * nStartBar)
3413                                 {
3414                                         continue;
3415                                 }
3416                                 else
3417                                 {
3418                                         bSuccessSeek = true;
3419                                         this.n現在のトップChip = i;
3420                                         break;
3421                                 }
3422                         }
3423                         if (!bSuccessSeek)
3424                         {
3425                                 // this.n現在のトップChip = CDTXMania.Instance.DTX.listChip.Count - 1;
3426                                 this.n現在のトップChip = 0;       // 対象小節が存在しないなら、最初から再生
3427                         }
3428                         #endregion
3429
3430                         #region [ 演奏開始の発声時刻msを取得し、タイマに設定 ]
3431                         int nStartTime = CDTXMania.Instance.DTX.listChip[this.n現在のトップChip].n発声時刻ms;
3432
3433                         CSound管理.rc演奏用タイマ.tリセット();  // これでPAUSE解除されるので、次のPAUSEチェックは不要
3434                                                                                                                                         //if ( !this.bPAUSE )
3435                                                                                                                                         //{
3436                         CSound管理.rc演奏用タイマ.t一時停止();
3437                         //}
3438                         CSound管理.rc演奏用タイマ.n現在時刻 = nStartTime;
3439                         #endregion
3440
3441                         List<CSound> pausedCSound = new List<CSound>();
3442
3443                         #region [ BGMやギターなど、演奏開始のタイミングで再生がかかっているサウンドのの途中再生開始 ] // (CDTXのt入力・行解析・チップ配置()で小節番号が+1されているのを削っておくこと)
3444                         for (int i = this.n現在のトップChip; i >= 0; i--)
3445                         {
3446                                 CChip pChip = CDTXMania.Instance.DTX.listChip[i];
3447                                 int nDuration = pChip.GetDuration();
3448
3449                                 if ((pChip.n発声時刻ms + nDuration > 0) && (pChip.n発声時刻ms <= nStartTime) && (nStartTime <= pChip.n発声時刻ms + nDuration))
3450                                 {
3451                                         if (pChip.bWAVを使うチャンネルである && !pChip.b空打ちチップである) // wav系チャンネル、且つ、空打ちチップではない
3452                                         {
3453                                                 CDTX.CWAV wc;
3454                                                 bool b = CDTXMania.Instance.DTX.listWAV.TryGetValue(pChip.n整数値_内部番号, out wc);
3455                                                 if (!b) continue;
3456
3457                                                 if ((wc.bIsBGMSound && CDTXMania.Instance.ConfigIni.bBGMPlay) || (!wc.bIsBGMSound))
3458                                                 {
3459                                                         CDTXMania.Instance.DTX.tチップの再生(pChip, CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻 + pChip.n発声時刻ms, CDTXMania.Instance.DTX.nモニタを考慮した音量(EPart.Unknown));
3460                                                         #region [ PAUSEする ]
3461                                                         int j = wc.n現在再生中のサウンド番号;
3462                                                         if (wc.rSound[j] != null)
3463                                                         {
3464                                                                 wc.rSound[j].t再生を一時停止する();
3465                                                                 wc.rSound[j].t再生位置を変更する(nStartTime - pChip.n発声時刻ms);
3466                                                                 pausedCSound.Add(wc.rSound[j]);
3467                                                         }
3468                                                         #endregion
3469                                                 }
3470                                         }
3471                                 }
3472                         }
3473                         #endregion
3474                         #region [ 演奏開始時点で既に表示されているBGAとAVIの、シークと再生 ]
3475                         this.actBGA.SkipStart(nStartTime);
3476                         this.actAVI.SkipStart(nStartTime);
3477                         #endregion
3478                         #region [ PAUSEしていたサウンドを一斉に再生再開する(ただしタイマを止めているので、ここではまだ再生開始しない) ]
3479                         foreach (CSound cs in pausedCSound)
3480                         {
3481                                 cs.tサウンドを再生する();
3482                         }
3483                         pausedCSound.Clear();
3484                         pausedCSound = null;
3485                         #endregion
3486                         #region [ タイマを再開して、PAUSEから復帰する ]
3487                         CSound管理.rc演奏用タイマ.n現在時刻 = nStartTime;
3488                         CDTXMania.Instance.Timer.tリセット();                       // これでPAUSE解除されるので、3行先の再開()は不要
3489                         CDTXMania.Instance.Timer.n現在時刻 = nStartTime;                // Debug表示のTime: 表記を正しくするために必要
3490                         CSound管理.rc演奏用タイマ.t再開();
3491                         //CDTXMania.Instance.Timer.t再開();
3492                         this.bPAUSE = false;                                // システムがPAUSE状態だったら、強制解除
3493                         this.actPanel.Start();
3494                         #endregion
3495                         #endregion
3496                 }
3497
3498
3499                 /// <summary>
3500                 /// DTXV用の設定をする。(全AUTOなど)
3501                 /// 元の設定のバックアップなどはしないので、あとでConfig.iniを上書き保存しないこと。
3502                 /// </summary>
3503                 protected void tDTXV用の設定()
3504                 {
3505                         for (EPad i = EPad.Min; i < EPad.Max; ++i)
3506                         {
3507                                 CDTXMania.Instance.ConfigIni.bAutoPlay[i].Value = true;
3508                         }
3509                         CDTXMania.Instance.ConfigIni.bAVI.Value = true;
3510                         CDTXMania.Instance.ConfigIni.bBGA.Value = true;
3511                         for (EPart i = EPart.Drums; i <= EPart.Bass; i++)
3512                         {
3513                                 CDTXMania.Instance.ConfigIni.bGraph[i].Value = false;
3514                                 CDTXMania.Instance.ConfigIni.eSudHidInv[i].Value = ESudHidInv.Off;
3515                                 CDTXMania.Instance.ConfigIni.bLight[i].Value = false;
3516                                 CDTXMania.Instance.ConfigIni.bReverse[i].Value = false;
3517                                 CDTXMania.Instance.ConfigIni.eRandom[i].Value = ERandom.Off;
3518                                 CDTXMania.Instance.ConfigIni.nMinComboDisp[i].Value = 65535;
3519                                 CDTXMania.Instance.ConfigIni.bDisplayJudge[i].Value = false;
3520                                 CDTXMania.Instance.ConfigIni.bDisplayCombo[i].Value = false;
3521                         }
3522                         CDTXMania.Instance.ConfigIni.eDark.Value = EDark.Off;
3523                         CDTXMania.Instance.ConfigIni.bDebugInfo.Value = CDTXMania.Instance.ConfigIni.bViewerShowDebugStatus;
3524                         CDTXMania.Instance.ConfigIni.bFillin.Value = true;
3525                         CDTXMania.Instance.ConfigIni.bScoreIni.Value = false;
3526                         CDTXMania.Instance.ConfigIni.bStageFailed.Value = false;
3527                         CDTXMania.Instance.ConfigIni.bTight.Value = false;
3528                         CDTXMania.Instance.ConfigIni.bStoicMode.Value = false;
3529                         CDTXMania.Instance.ConfigIni.bDrumsHitSound.Value = true;
3530                         CDTXMania.Instance.ConfigIni.bBGMPlay.Value = true;
3531                         CDTXMania.Instance.ConfigIni.nRisky.Value = 0;
3532                         CDTXMania.Instance.ConfigIni.nShowLagType.Value = EShowLagType.Off;
3533                         //CDTXMania.Instance.ConfigIni.bForceScalingAVI.Value = false;          // DTXVモード時の各種表示要素の表示座標を「譜面制作者のカスタマイズ状態」にするか「DTXMania初期状態」にするかで
3534                                                                                                                                                                 // 悩みました。
3535                 }
3536
3537                 private void t進行描画_チップ_ウェイリング(ref CChip pChip)
3538                 {
3539                         if (CDTXMania.Instance.ConfigIni.bGuitar有効 && (!CDTXMania.Instance.DTX2WAVmode.Enabled))
3540                         {
3541                                 EPart indexInst = pChip.bGuitar可視チップ_Wailing含む ? EPart.Guitar : EPart.Bass;
3542                                 #region [ Sud Hid Inv 処理 ]
3543                                 if (
3544                                         CDTXMania.Instance.ConfigIni.eSudHidInv[indexInst] == ESudHidInv.FullInv ||
3545                                         CDTXMania.Instance.ConfigIni.eSudHidInv[indexInst] == ESudHidInv.SemiInv)
3546                                 {
3547                                         cInvisibleChip.SetInvisibleStatus(ref pChip);
3548                                 }
3549                                 else
3550                                 {
3551                                         if (CDTXMania.Instance.ConfigIni.eSudHidInv[indexInst] == ESudHidInv.Sudden ||
3552                                                 CDTXMania.Instance.ConfigIni.eSudHidInv[indexInst] == ESudHidInv.SudHid)
3553                                         {
3554                                                 pChip.b可視 = (pChip.nバーからの距離dot[indexInst] < CDTXMania.Instance.ConfigIni.nSuddenFrom[indexInst]);
3555                                         }
3556                                         if (CDTXMania.Instance.ConfigIni.eSudHidInv[indexInst] == ESudHidInv.Hidden ||
3557                                                 CDTXMania.Instance.ConfigIni.eSudHidInv[indexInst] == ESudHidInv.SudHid)
3558                                         {
3559                                                 pChip.b可視 = pChip.nバーからの距離dot[indexInst] >= CDTXMania.Instance.ConfigIni.nHiddenFrom[indexInst];
3560                                         }
3561                                 }
3562                                 #endregion
3563                                 cWailingChip[(int)indexInst].t進行描画_チップ_ウェイリング(ref pChip, ref txチップGB, ref ctWailingチップ模様アニメ);
3564
3565                                 if (!pChip.bHit && (pChip.nバーからの距離dot[indexInst] < 0))
3566                                 {
3567                                         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).
3568                                         {
3569                                                 pChip.bHit = true;
3570                                         }
3571                                         bool autoW = (indexInst == EPart.Guitar) ? CDTXMania.Instance.ConfigIni.bAutoPlay.GtWail : CDTXMania.Instance.ConfigIni.bAutoPlay.BsWail;
3572                                         if (autoW)
3573                                         {
3574                                                 // #25253 2011.5.29 yyagi: Set pChip.bHit=true if autoplay.
3575                                                 // pChip.bHit = true;
3576                                                 // this.actWailingBonus.Start( inst, this.r現在の歓声Chip[indexInst] );
3577                                                 // #23886 2012.5.22 yyagi; To support auto Wailing; Don't do wailing for ALL wailing chips. Do wailing for queued wailing chip.
3578                                                 // wailing chips are queued when 1) manually wailing and not missed at that time 2) AutoWailing=ON and not missed at that time
3579                                                 long nTimeStamp_Wailed = pChip.n発声時刻ms + CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻;
3580                                                 DoWailingFromQueue(indexInst, nTimeStamp_Wailed, autoW);
3581                                         }
3582                                         cInvisibleChip.StartSemiInvisible(indexInst);
3583                                 }
3584                                 return;
3585                         }
3586                         pChip.bHit = true;
3587                 }
3588
3589                 protected void t進行描画_チップアニメ()
3590                 {
3591                         for (EPart i = EPart.Drums; i <= EPart.Bass; i++)            // 0=drums, 1=guitar, 2=bass
3592                         {
3593                                 if (this.ctチップ模様アニメ[i] != null)
3594                                 {
3595                                         this.ctチップ模様アニメ[i].t進行Loop();
3596                                 }
3597                         }
3598                         if (this.ctWailingチップ模様アニメ != null)
3599                         {
3600                                 this.ctWailingチップ模様アニメ.t進行Loop();
3601                         }
3602                 }
3603
3604                 protected bool t進行描画_フェードイン_アウト()
3605                 {
3606                         switch (base.eフェーズID)
3607                         {
3608                                 case CStage.Eフェーズ.共通_フェードイン:
3609                                         if (this.actFI.On進行描画() != 0)
3610                                         {
3611                                                 base.eフェーズID = CStage.Eフェーズ.共通_通常状態;
3612                                         }
3613                                         break;
3614
3615                                 case CStage.Eフェーズ.共通_フェードアウト:
3616                                 case CStage.Eフェーズ.演奏_STAGE_FAILED_フェードアウト:
3617                                         if (this.actFO.On進行描画() != 0)
3618                                         {
3619                                                 return true;
3620                                         }
3621                                         break;
3622
3623                                 case CStage.Eフェーズ.演奏_STAGE_CLEAR_フェードアウト:
3624                                         if (this.actFOClear.On進行描画() == 0)
3625                                         {
3626                                                 break;
3627                                         }
3628                                         return true;
3629
3630                         }
3631                         return false;
3632                 }
3633
3634                 protected virtual void t入力処理_ギターベース(EPart inst)
3635                 {
3636                         #region [ スクロール速度変更 ]
3637                         int scrollSpeed = CDTXMania.Instance.ConfigIni.nScrollSpeed[inst];
3638                         bool scrollSpeedChanged = false;
3639                         float f = (float)CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset[inst] / (scrollSpeed + 1);
3640                         if (
3641                                 CDTXMania.Instance.Pad.b押されている(inst == EPart.Guitar ? EPad.GtDecide : EPad.BsDecide) &&
3642                                 CDTXMania.Instance.Pad.b押された(inst == EPart.Guitar ? EPad.GtB : EPad.BsB)
3643                                 )
3644                         {
3645                                 CDTXMania.Instance.ConfigIni.nScrollSpeed[inst].Value = scrollSpeed + 1;
3646                                 if (scrollSpeed < CDTXMania.Instance.ConfigIni.nScrollSpeed[inst])
3647                                 {
3648                                         scrollSpeedChanged = true;
3649                                 }
3650                         }
3651                         if (
3652                                 CDTXMania.Instance.Pad.b押されている(inst == EPart.Guitar ? EPad.GtDecide : EPad.BsDecide) &&
3653                                 CDTXMania.Instance.Pad.b押された(inst == EPart.Guitar ? EPad.GtR : EPad.BsR)
3654                                 )
3655                         {
3656                                 CDTXMania.Instance.ConfigIni.nScrollSpeed[inst].Value = scrollSpeed - 1;
3657                                 if (scrollSpeed > CDTXMania.Instance.ConfigIni.nScrollSpeed[inst])
3658                                 {
3659                                         scrollSpeedChanged = true;
3660                                 }
3661                         }
3662                         if (scrollSpeedChanged)
3663                         {
3664                                 // 判定ラインも付随
3665                                 CDTXMania.Instance.ConfigIni.nJudgeLinePosOffset[inst].Value = (int)(f * CDTXMania.Instance.ConfigIni.nScrollSpeed[inst] + 0.5);
3666                         }
3667                         #endregion
3668
3669                         if (!CDTXMania.Instance.ConfigIni.bGuitar有効 || !CDTXMania.Instance.DTX.bチップがある[inst])
3670                         {
3671                                 return;
3672                         }
3673
3674                         int R = (inst == EPart.Guitar) ? 0 : 3;
3675                         int G = R + 1;
3676                         int B = R + 2;
3677                         bool autoW = (inst == EPart.Guitar) ? CDTXMania.Instance.ConfigIni.bAutoPlay.GtWail : CDTXMania.Instance.ConfigIni.bAutoPlay.BsWail;
3678                         bool autoR = (inst == EPart.Guitar) ? CDTXMania.Instance.ConfigIni.bAutoPlay.GtR : CDTXMania.Instance.ConfigIni.bAutoPlay.BsR;
3679                         bool autoG = (inst == EPart.Guitar) ? CDTXMania.Instance.ConfigIni.bAutoPlay.GtG : CDTXMania.Instance.ConfigIni.bAutoPlay.BsG;
3680                         bool autoB = (inst == EPart.Guitar) ? CDTXMania.Instance.ConfigIni.bAutoPlay.GtB : CDTXMania.Instance.ConfigIni.bAutoPlay.BsB;
3681                         bool autoPick = (inst == EPart.Guitar) ? CDTXMania.Instance.ConfigIni.bAutoPlay.GtPick : CDTXMania.Instance.ConfigIni.bAutoPlay.BsPick;
3682                         int nAutoW = (autoW) ? 8 : 0;
3683                         int nAutoR = (autoR) ? 4 : 0;
3684                         int nAutoG = (autoG) ? 2 : 0;
3685                         int nAutoB = (autoB) ? 1 : 0;
3686                         int nAutoMask = nAutoW | nAutoR | nAutoG | nAutoB;
3687
3688                         CChip chip = this.r次に来る指定楽器Chipを更新して返す(inst);
3689                         if (chip != null)
3690                         {
3691                                 if ((chip.bGuitarBass_R) && autoR)
3692                                 {
3693                                         this.actLaneFlushGB.Start(R);
3694                                         this.actRGB.Push(R);
3695                                 }
3696                                 if ((chip.bGuitarBass_G) && autoG)
3697                                 {
3698                                         this.actLaneFlushGB.Start(G);
3699                                         this.actRGB.Push(G);
3700                                 }
3701                                 if ((chip.bGuitarBass_B) && autoB)
3702                                 {
3703                                         this.actLaneFlushGB.Start(B);
3704                                         this.actRGB.Push(B);
3705                                 }
3706                         }
3707
3708                         int pressingR = CDTXMania.Instance.Pad.b押されている(inst == EPart.Guitar ? EPad.GtR : EPad.BsR) ? 4 : 0;
3709                         this.t入力メソッド記憶(inst);
3710                         int pressingG = CDTXMania.Instance.Pad.b押されている(inst == EPart.Guitar ? EPad.GtG : EPad.BsG) ? 2 : 0;
3711                         this.t入力メソッド記憶(inst);
3712                         int pressingB = CDTXMania.Instance.Pad.b押されている(inst == EPart.Guitar ? EPad.GtB : EPad.BsB) ? 1 : 0;
3713                         this.t入力メソッド記憶(inst);
3714                         int pressingRGB = pressingR | pressingG | pressingB;
3715                         if (pressingR != 0)
3716                         {
3717                                 this.actLaneFlushGB.Start(R);
3718                                 this.actRGB.Push(R);
3719                         }
3720                         if (pressingG != 0)
3721                         {
3722                                 this.actLaneFlushGB.Start(G);
3723                                 this.actRGB.Push(G);
3724                         }
3725                         if (pressingB != 0)
3726                         {
3727                                 this.actLaneFlushGB.Start(B);
3728                                 this.actRGB.Push(B);
3729                         }
3730                         // auto pickだとここから先に行かないので注意
3731                         List<STInputEvent> events = CDTXMania.Instance.Pad.GetEvents(inst == EPart.Guitar ? EPad.GtPick : EPad.BsPick);
3732                         if ((events != null) && (events.Count > 0))
3733                         {
3734                                 foreach (STInputEvent eventPick in events)
3735                                 {
3736                                         if (!eventPick.b押された)
3737                                         {
3738                                                 continue;
3739                                         }
3740                                         this.t入力メソッド記憶(inst);
3741                                         long nTime = eventPick.nTimeStamp - CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻;
3742                                         EChannel chWailingSound = (inst == EPart.Guitar) ? EChannel.Guitar_WailingSound : EChannel.Bass_WailingSound;
3743
3744                                         // WailingSound チャンネルでE楽器パート.GUITARなチップ全てにヒットする
3745                                         CChip pChip = this.r指定時刻に一番近い未ヒットChip(
3746                                                         nTime, chWailingSound,
3747                                                         CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs[inst],
3748                                                         CDTXMania.Instance.nPoor範囲ms + 1);
3749
3750                                         EJudge e判定 = this.e指定時刻からChipのJUDGEを返す(nTime, pChip,
3751                                                         CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs[inst]);
3752                                         //Trace.TraceInformation("ch={0:x2}, mask1={1:x1}, mask2={2:x2}", pChip.nチャンネル番号,  ( pChip.nチャンネル番号 & ~nAutoMask ) & 0x0F, ( flagRGB & ~nAutoMask) & 0x0F );
3753                                         if (
3754                                                         (pChip != null) &&
3755                                                         ((((int)pChip.eチャンネル番号 & ~nAutoMask) & 0x0F) == ((pressingRGB & ~nAutoMask) & 0x0F)) &&
3756                                                         (e判定 != EJudge.Miss))
3757                                         {
3758                                                 bool bChipHasR = pChip.bGuitarBass_R;
3759                                                 bool bChipHasG = pChip.bGuitarBass_G;
3760                                                 bool bChipHasB = pChip.bGuitarBass_B;
3761                                                 bool bChipHasW = pChip.bGuitarBass_Wailing;
3762                                                 bool bChipIsO = pChip.bGuitarBass_Open;
3763                                                 bool bSuccessOPEN = bChipIsO && (autoR || pressingR == 0) && (autoG || pressingG == 0) && (autoB || pressingB == 0);
3764                                                 if ((bChipHasR && (autoR || pressingR != 0)) || bSuccessOPEN)
3765                                                 {
3766                                                         this.actChipFireGB.Start(R);
3767                                                 }
3768                                                 if ((bChipHasG && (autoG || pressingG != 0)) || bSuccessOPEN)
3769                                                 {
3770                                                         this.actChipFireGB.Start(G);
3771                                                 }
3772                                                 if ((bChipHasB && (autoB || pressingB != 0)) || bSuccessOPEN)
3773                                                 {
3774                                                         this.actChipFireGB.Start(B);
3775                                                 }
3776                                                 this.tチップのヒット処理(nTime, pChip);
3777                                                 this.tサウンド再生(pChip, CSound管理.rc演奏用タイマ.nシステム時刻, inst, CDTXMania.Instance.ConfigIni.nChipVolume, CDTXMania.Instance.ConfigIni.bEmphasizePlaySound[inst], e判定 == EJudge.Poor);
3778                                                 EChannel chWailingChip = (inst == EPart.Guitar) ? EChannel.Guitar_Wailing : EChannel.Bass_Wailing;
3779                                                 CChip item = this.r指定時刻に一番近い未ヒットChip(nTime, chWailingChip, CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs[inst], 140);
3780                                                 if (item != null)
3781                                                 {
3782                                                         this.queWailing[inst].Enqueue(item);
3783                                                 }
3784                                                 continue;
3785                                         }
3786
3787                                         // 以下、間違いレーンでのピック時
3788                                         CChip NoChipPicked = (inst == EPart.Guitar) ? this.r現在の空うちギターChip : this.r現在の空うちベースChip;
3789                                         if ((NoChipPicked != null) || ((NoChipPicked = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nTime, chWailingSound, CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs[inst])) != null))
3790                                         {
3791                                                 this.tサウンド再生(NoChipPicked, CSound管理.rc演奏用タイマ.nシステム時刻, inst, CDTXMania.Instance.ConfigIni.nChipVolume, CDTXMania.Instance.ConfigIni.bEmphasizePlaySound[inst], true);
3792                                         }
3793                                         if (!CDTXMania.Instance.ConfigIni.bLight[inst])
3794                                         {
3795                                                 this.tチップのヒット処理_BadならびにTight時のMiss(inst);
3796                                         }
3797                                 }
3798                         }
3799                         List<STInputEvent> list = CDTXMania.Instance.Pad.GetEvents(inst == EPart.Guitar ? EPad.GtWail : EPad.BsWail);
3800                         if ((list != null) && (list.Count > 0))
3801                         {
3802                                 foreach (STInputEvent eventWailed in list)
3803                                 {
3804                                         if (!eventWailed.b押された)
3805                                         {
3806                                                 continue;
3807                                         }
3808                                         DoWailingFromQueue(inst, eventWailed.nTimeStamp, autoW);
3809                                 }
3810                         }
3811                 }
3812
3813                 private void DoWailingFromQueue(EPart inst, long nTimeStamp_Wailed, bool autoW)
3814                 {
3815                         long nTimeWailed = nTimeStamp_Wailed - CSound管理.rc演奏用タイマ.n前回リセットした時のシステム時刻;
3816                         CChip chipWailing;
3817                         while ((this.queWailing[inst].Count > 0) && ((chipWailing = this.queWailing[inst].Dequeue()) != null))
3818                         {
3819                                 if ((nTimeWailed - chipWailing.n発声時刻ms) <= 1000)        // #24245 2011.1.26 yyagi: 800 -> 1000
3820                                 {
3821                                         chipWailing.bHit = true;
3822                                         this.actWailingBonus.Start(inst, this.r現在の歓声Chip[inst]);
3823                                         if (!autoW)
3824                                         {
3825                                                 int nCombo = (this.actCombo.dgbコンボ数[inst].n現在値 < 500) ? this.actCombo.dgbコンボ数[inst].n現在値 : 500;
3826                                                 // #24245 2011.1.26 yyagi changed DRUMS->BASS, add nCombo conditions
3827                                                 this.actScore.Add(inst, nCombo * 3000L);
3828                                         }
3829                                 }
3830                         }
3831                 }
3832
3833
3834
3835                 // t入力処理・ドラム()からメソッドを抽出したもの。
3836                 /// <summary>
3837                 /// chipArrayの中を, n発生位置の小さい順に並べる + nullを大きい方に退かす。セットでe判定Arrayも並べ直す。
3838                 /// </summary>
3839                 /// <param name="chipArray">ソート対象chip群</param>
3840                 /// <param name="e判定Array">ソート対象e判定群</param>
3841                 /// <param name="NumOfChips">チップ数</param>
3842                 private static void SortChipsByNTime(CChip[] chipArray, EJudge[] e判定Array, int NumOfChips)
3843                 {
3844                         for (int i = 0; i < NumOfChips - 1; i++)
3845                         {
3846                                 for (int j = NumOfChips - 1; j > i; j--)
3847                                 {
3848                                         if ((chipArray[j - 1] == null) || ((chipArray[j] != null) && (chipArray[j - 1].n発声位置 > chipArray[j].n発声位置)))
3849                                         {
3850                                                 // swap
3851                                                 CChip chipTemp = chipArray[j - 1];
3852                                                 chipArray[j - 1] = chipArray[j];
3853                                                 chipArray[j] = chipTemp;
3854                                                 EJudge e判定Temp = e判定Array[j - 1];
3855                                                 e判定Array[j - 1] = e判定Array[j];
3856                                                 e判定Array[j] = e判定Temp;
3857                                         }
3858                                 }
3859                         }
3860                 }
3861                 private bool tドラムヒット処理(long nHitTime, EPad type, CChip pChip, int n強弱度合い0to127)
3862                 {
3863                         if (pChip == null)
3864                         {
3865                                 return false;
3866                         }
3867                         // Ech定義 channel = pChip.eチャンネル番号;
3868                         int index = -1;
3869                         if (pChip.bDrums可視チップ_LP_LBD含まない)
3870                         {
3871                                 index = pChip.nDrumsIndex;
3872                         }
3873                         else if (pChip.bDrums不可視チップ_LP_LBD含まない)
3874                         {
3875                                 index = pChip.nDrumsIndexHidden;
3876                         }
3877                         ELane eLane = EnumConverter.LaneFromChannel(index + EChannel.HiHatClose);// nチャンネル0Atoレーン07[index];
3878                         EPad ePad = EnumConverter.PadFromChannel(index + EChannel.HiHatClose); //nチャンネル0Atoパッド08[index];
3879                         bool bPChipIsAutoPlay = CDTXMania.Instance.ConfigIni.bAutoPlay[ePad];
3880                         int nInputAdjustTime = bPChipIsAutoPlay ? 0 : CDTXMania.Instance.ConfigIni.nInputAdjustTimeMs.Drums;
3881                         EJudge e判定 = this.e指定時刻からChipのJUDGEを返す(nHitTime, pChip, nInputAdjustTime);
3882                         if (e判定 == EJudge.Miss)
3883                         {
3884                                 return false;
3885                         }
3886                         this.tチップのヒット処理(nHitTime, pChip);
3887                         this.actLaneFlushD.Start(eLane, ((float)n強弱度合い0to127) / 127f);
3888                         this.actPad.Hit(ePad);
3889                         if ((e判定 != EJudge.Poor) && (e判定 != EJudge.Miss))
3890                         {
3891                                 bool flag = this.bフィルイン中;
3892                                 bool flag2 = this.bフィルイン中 && this.bフィルイン区間の最後のChipである(pChip);
3893                                 // bool flag3 = flag2;
3894                                 // #31602 2013.6.24 yyagi 判定ラインの表示位置をずらしたら、チップのヒットエフェクトの表示もずらすために、nJudgeLine..を追加
3895                                 this.actChipFireD.Start(eLane, flag, flag2, flag2);
3896                         }
3897                         if (CDTXMania.Instance.ConfigIni.bDrumsHitSound)
3898                         {
3899                                 CChip rChip = null;
3900                                 bool bIsChipsoundPriorToPad = true;
3901                                 if (((type == EPad.HH) || (type == EPad.HHO)) || (type == EPad.LC))
3902                                 {
3903                                         bIsChipsoundPriorToPad = CDTXMania.Instance.ConfigIni.eHitSoundPriorityHH == EHitSoundPriority.Chip;
3904                                 }
3905                                 else if ((type == EPad.LT) || (type == EPad.FT))
3906                                 {
3907                                         bIsChipsoundPriorToPad = CDTXMania.Instance.ConfigIni.eHitSoundPriorityFT == EHitSoundPriority.Chip;
3908                                 }
3909                                 else if ((type == EPad.CY) || (type == EPad.RD))
3910                                 {
3911                                         bIsChipsoundPriorToPad = CDTXMania.Instance.ConfigIni.eHitSoundPriorityCY == EHitSoundPriority.Chip;
3912                                 }
3913                                 if (bIsChipsoundPriorToPad)
3914                                 {
3915                                         rChip = pChip;
3916                                 }
3917                                 else
3918                                 {
3919                                         EPad hH = type;
3920                                         if (!CDTXMania.Instance.DTX.bチップがある.HHOpen && (type == EPad.HHO))
3921                                         {
3922                                                 hH = EPad.HH;
3923                                         }
3924                                         if (!CDTXMania.Instance.DTX.bチップがある.Ride && (type == EPad.RD))
3925                                         {
3926                                                 hH = EPad.CY;
3927                                         }
3928                                         if (!CDTXMania.Instance.DTX.bチップがある.LeftCymbal && (type == EPad.LC))
3929                                         {
3930                                                 hH = EPad.HH;
3931                                         }
3932                                         rChip = this.r指定時刻に一番近いChip_ヒット未済問わず不可視考慮(nHitTime, EnumConverter.ChannelFromPad(hH), nInputAdjustTime);
3933                                         if (rChip == null)
3934                                         {
3935                                                 rChip = pChip;
3936                                         }
3937                                 }
3938                                 if (CDTXMania.Instance.ConfigIni.nStrictHitSoundRange == 0 ||
3939                                         (CDTXMania.Instance.ConfigIni.nStrictHitSoundRange >= Math.Abs(nHitTime + nInputAdjustTime - pChip.n発声時刻ms)))
3940                                 {
3941                                         this.tサウンド再生(rChip, CSound管理.rc演奏用タイマ.nシステム時刻, EPart.Drums, CDTXMania.Instance.ConfigIni.nChipVolume, CDTXMania.Instance.ConfigIni.bEmphasizePlaySound.Drums);
3942                                 }
3943                         }
3944                         return true;
3945                 }
3946
3947                 protected bool bフィルイン区間の最後のChipである(CChip pChip)
3948                 {
3949                         if (pChip == null)
3950                         {
3951                                 return false;
3952                         }
3953                         int num = pChip.n発声位置;
3954                         for (int i = CDTXMania.Instance.DTX.listChip.IndexOf(pChip) + 1; i < CDTXMania.Instance.DTX.listChip.Count; i++)
3955                         {
3956                                 pChip = CDTXMania.Instance.DTX.listChip[i];
3957                                 if ((pChip[EChannel.FillIn]) && (pChip.n整数値 == 2))
3958                                 {
3959                                         return true;
3960                                 }
3961                                 if ((pChip.bDrums可視チップ_LP_LBD含まない) && (pChip.n発声位置 - num) > 0x18)
3962                                 {
3963                                         return false;
3964                                 }
3965                         }
3966                         return true;
3967                 }
3968
3969                 private void t進行描画_チップ_フィルイン(ref CChip pChip)
3970                 {
3971                         if (!pChip.bHit && (pChip.nバーからの距離dot.Drums < 0))
3972                         {
3973                                 pChip.bHit = true;
3974
3975                                 if (CDTXMania.Instance.ConfigIni.bDrums有効)
3976                                 {
3977                                         switch (pChip.n整数値)
3978                                         {
3979                                                 case 0x01:  // フィルイン開始
3980                                                         if (CDTXMania.Instance.ConfigIni.bFillin)
3981                                                         {
3982                                                                 this.bフィルイン中 = true;
3983                                                         }
3984                                                         break;
3985
3986                                                 case 0x02:  // フィルイン終了
3987                                                         if (CDTXMania.Instance.ConfigIni.bFillin)
3988                                                         {
3989                                                                 this.bフィルイン中 = false;
3990                                                         }
3991                                                         if (((this.actCombo.dgbコンボ数.Drums.n現在値 > 0) || CDTXMania.Instance.ConfigIni.bIsAutoPlay(EPart.Drums)) && CDTXMania.Instance.ConfigIni.bAudience)
3992                                                         {
3993                                                                 if (this.r現在の歓声Chip.Drums != null)
3994                                                                 {
3995                                                                         CDTXMania.Instance.DTX.tチップの再生(this.r現在の歓声Chip.Drums, CSound管理.rc演奏用タイマ.nシステム時刻, CDTXMania.Instance.DTX.nモニタを考慮した音量(EPart.Unknown));
3996                                                                 }
3997                                                                 else
3998                                                                 {
3999                                                                         CDTXMania.Instance.Skin.sound歓声音.n位置_次に鳴るサウンド = 0;
4000                                                                         CDTXMania.Instance.Skin.sound歓声音.t再生する();
4001                                                                 }
4002                                                         }
4003                                                         break;
4004 #if TEST_NOTEOFFMODE  // 2011.1.1 yyagi TEST
4005                                                                 case 0x04:      // HH消音あり(従来同等)
4006                                                                         CDTXMania.Instance.DTX.b演奏で直前の音を消音する.HH = true;
4007                                                                         break;
4008                                                                 case 0x05:      // HH消音無し
4009                                                                         CDTXMania.Instance.DTX.b演奏で直前の音を消音する.HH = false;
4010                                                                         break;
4011                                                                 case 0x06:      // ギター消音あり(従来同等)
4012                                                                         CDTXMania.Instance.DTX.b演奏で直前の音を消音する.Gutiar = true;
4013                                                                         break;
4014                                                                 case 0x07:      // ギター消音無し
4015                                                                         CDTXMania.Instance.DTX.b演奏で直前の音を消音する.Gutiar = false;
4016                                                                         break;
4017                                                                 case 0x08:      // ベース消音あり(従来同等)
4018                                                                         CDTXMania.Instance.DTX.b演奏で直前の音を消音する.Bass = true;
4019                                                                         break;
4020                                                                 case 0x09:      // ベース消音無し
4021                                                                         CDTXMania.Instance.DTX.b演奏で直前の音を消音する.Bass = false;
4022                                                                         break;
4023 #endif
4024                                         }
4025                                 }
4026                         }
4027                 }
4028         }
4029 }