/*
■Quiet City Awaking -ver.TWM2-
　作成：ひかり( = さくらもどき )

　:-------------------------------------------------------------------------------:
 :::		霞がかった静寂の都市。朝日が差し込むと、世界が動き出します。	   :::
　:-------------------------------------------------------------------------------:

詳細
【推奨環境】ヘッドホン
【推奨音源】TWM2
【無断転用】不可
【　編曲　】可
【ジャンル】Easy Listening

作成環境
【   OS   】WindoowsXP HomeEdition
【　音源　】TWM2，MSGS
【出力環境】MDR-CD100	（ヘッドホン）
		UA-101	（オーディオI/O）

--------------------------------------------------------------------------------------------
◆ＭＥＭＯ
朝霞がかった街にはまもなく夜明けが訪れます。
深い蒼色にそまった空は朝の光でゆっくりと鮮やかな水色へと姿を変えます。
朝日が昇るまであともう少し。
街は静かに動き始めています。
切り抜きたかったのはそんな瞬間です。

DLありがとうございます。
この曲は「SAKURA New Generation」という企画へ参加させていただいた曲です。
他の参加者の曲がすごすぎて、投稿するタイミングを測りかねてたのだぜ・・・・

テーマとしてはこの間つくったLapis Lazuliと同じ『夜明け』です。
今回は『水色』がテーマでしたので、朝焼け直前のなんともいえない絶妙な水色をイメージしました。
Lapisとは対照的に静かで綺麗な「寝起きに聞ける四つ打ち」っていう感じにしてみました。


最後に、ソースコードについて。
色々と関数を大量に投入して新しい感じでドラムループとか作っているので、
宜しければドラムのあたりの記述だけでも見て頂ければ、と。

―――ですが如何せん汚すぎ、コンパイル重すぎ。
あとから読むときに死ぬんだろうなーという予想がプンプンしますｗ

--------------------------------------------------------------------------------------------
◆オーディオ版
鳥の鳴き声とかノイズとか色々と要素が追加されています。
でも基本的な楽器群に関してはMMLとほぼ互換ですので、ご安心ください。

では、「ほぼ」という誤差について
・各楽器のヴェロシティやコントロールがよりエフェクティブに調整されています
・一部フレーズの差し替え
・フィルタを差す関係で追加したノートとか

とはいえ、いつものMP3とMMLの誤差程度ではありますが・・・
視聴もできますので宜しければ以下のURLよりお聞きください〜
http://sng.xxxxxxxx.jp/
*/








曲名{"Quiet City Awaking -ver.TWM2-"}
作者{"SakuraModki = ひかり"}

ResetGS
拍子4,4
テンポ( 131 )
調#()
System.vMax=110
CH(11) SysEx$ = f0,41,10,42,12,{40,1a,15,02},f7;
Key= -5
Int I=1
//[16 TR=I CCMute=on I++]	/*　MP3作成用にCCを削ぎ落とす */

//===================================================================================================
//===================================================================================================
//===================================================================================================
//_汎用関数の定義
//===================================================================================================
//===================================================================================================
//===================================================================================================
Str PD={r32 y64,0 r32 y64,127 r-16}
Str PF={r32 y64,0 r-32}
Function L1(int){Result=(!1 * int)}		//数小節分の長さを返す
Function R1(int){[(int)r*1]}			//数小節分の休符
Function X(int){Sub{[(int)r-1]?  } }	//数小節戻ってから再生(デバッグ用)





//===================================================================================================
//===================================================================================================
//===================================================================================================
//_文字操作関数群 :: 行単位での処理が可能です
//===================================================================================================
//===================================================================================================
//===================================================================================================
Int _EXSTRING_ERROR_TYPE_SUCCESSED		=  0 //関数は正常に終了しました
Int _EXSTRING_ERROR_TYPE_INVALID_NUMBER	=  1 //不正な値が入力されています
Int _EXSTRING_ERROR_TYPE_NOT_EXIST		=  2 //存在しませんでした
Int _EXSTRING_CURRENT_ERROR = 0 ;

//---------------------------------------------------------------------------------------------------
//直前の文字列操作のエラーを取得する
//---------------------------------------------------------------------------------------------------
Function GetExStrError(){
	Result = _EXSTRING_CURRENT_ERROR
	_EXSTRING_CURRENT_ERROR = _EXSTRING_ERROR_TYPE_SUCCESSED
}

//---------------------------------------------------------------------------------------------------
//行数を取得する
//---------------------------------------------------------------------------------------------------
Function GetMaxLine(Str Data ){
	Data = Data+CHR($0D)+CHR($0A)+" ";
	Int It=0
	Int Cnt=0;

	For(Int It=0 ; It <= SizeOf(Data) ; It++){
		IF( ASC( MID(Data , It ,1 ) ) == $0D ){//CRならば改行を加算
			IF( ASC( MID(Data , It+1 ,1 ) ) == $0A ){//LFがあればとばす
				It++
			}
			Cnt++;
		}
	}
	Result = Cnt;
}

//---------------------------------------------------------------------------------------------------
//n行目を抜き出す。(n=0〜)
//---------------------------------------------------------------------------------------------------
Function GetLineByLineNum( Str Data , Int n ){
	Data = Data+CHR($0D)+CHR($0A)+"";

	Int It=0
	Int Cnt=0;
	Str Result_str="";
	Str Char;

	_EXSTRING_CURRENT_ERROR = _EXSTRING_ERROR_TYPE_NOT_EXIST;
	IF( n < 0){
		_EXSTRING_CURRENT_ERROR = _EXSTRING_ERROR_TYPE_INVALID_NUMBER;
	}Else{
		For(Int It=0 ; It < SizeOf(Data) ; It++){
			Char = MID( Data , It ,1 )
			IF( ASC( Char ) == $0D ){//CRならば改行を加算
				IF( ASC( MID(Data , It+1 ,1 ) ) == $0A ){//LFがあればとばす
					It++
				}
				Cnt++;
	
				IF( Cnt > n ){	//n行以上を読んだら終了
					_EXSTRING_CURRENT_ERROR = _EXSTRING_ERROR_TYPE_SUCCESSED;
					Result = Result_str;
					Exit;
				}
	
			}Else{
				IF( Cnt == n ){
					IF( Char != "" ){
						Result_str = Result_str + Char;
					}
				}
			}
		}
	}
}

//---------------------------------------------------------------------------------------------------
//特定文字を含まない行を削除する
//---------------------------------------------------------------------------------------------------
Function DeleteLineNotExistString(Str Data , Str Check ){
	Str Result_str="";
	Int Count = 0;
	Str Buf = "";
	GetExStrError();	//エラー初期化

	While( 1 ){
		Buf = GetLineByLineNum( Data , Count );
		IF( GetExStrError()  !=  _EXSTRING_ERROR_TYPE_SUCCESSED){
			Exit
		}

		Count++;

		
		If( POS( Check , Buf ) != 0){
			IF( Result_str == "" ){
				Result_str = Buf;
			}Else{
				Result_str = Result_str + CHR($0D) + CHR($0A) + Buf;
			}
		}
	}
	_EXSTRING_CURRENT_ERROR = _EXSTRING_ERROR_TYPE_SUCCESSED;
	Result = Result_str;
}




//===================================================================================================
//===================================================================================================
//===================================================================================================
//_TrackChange関数
//===================================================================================================
//===================================================================================================
//===================================================================================================
//他のトラックに対して、自分の今いるトラックから別のトラックを操作する
//		　書込先,情報　　,UseKeyShift
Function TRC(Int TTR,Str TSUB,Int UKS=on){
	Int BTR=TR;					//情報取得と復元ポイント設定
	Int BTime=Time
	Int DUKS=UseKeyShift			//UseKeyShiftの保存

	TR=TTR;					//情報設定と復元ポイント設定
	Int DTime=Time;
	Time=BTime

	UseKeyShift=UKS				//UseKeyShiftを適用
		Sub{TSUB};Time=DTime		//演奏とトラック初期化
	UseKeyShift=DUKS				//UseKeyShiftの復元

 	TR=BTR;Time=BTime				//元トラック情報初期化
}

//===================================================================================================
//===================================================================================================
//===================================================================================================
//_ドラム用ライブラリ :: 
//===================================================================================================
//===================================================================================================
//===================================================================================================
//---------------------------------------------------------------------------------------------------
//シーケンサ型記述用関数
//---------------------------------------------------------------------------------------------------
Function DrumPlay(Str Playlist , Str Note ){
	Str Buf = Replace( Replace( Playlist, "x" , Note  , on ) , "-", "r" , on);
	Buf;
}

//---------------------------------------------------------------------------------------------------
//複数記述用
//---------------------------------------------------------------------------------------------------
Function MML_DRUM(Str Drum_Play_data){

	Str Data = DeleteLineNotExistString( Drum_Play_data+CHR($0D) ,  CHR($3A) );		//:を含まない行を削除
	Str Cmd = Replace( Data , CHR($3A) , CHR($28) , on );						//:を(へ置換
//	Print(Cmd)

	Int Cnt=0;
	Str Buf=""
	Str LastBuf=""
	Int Flag = 0;
	Int Er=0;
	Str Result_Str=""
	
	For( Cnt=0; Flag == 0  ; Cnt++){
		Buf = GetLineByLineNum( Cmd , Cnt );
//		Print(Buf)
		Er=GetExStrError();

		IF(Er != _EXSTRING_ERROR_TYPE_SUCCESSED ){
			Flag=1
		}Else{
			IF( Buf != ""){
				Buf = Buf + " " + CHR($29);
			}Else{
				Buf = CHR($29);
			}

			IF( LastBuf != ""){
				Result_Str = Result_Str + {" Sub "}+ CHR($7b) + LastBuf+ CHR($7d)
			}
			LastBuf = Buf
		}
	}
	Result_Str = Result_Str + LastBuf
	Result = Result_Str
}

//======================================================================================
//	Arpeggiator											(09/08/28)
//--------------------------------------------------------------------------------------
/*
■アルペジエーター関数仕様
			    ここまでは必ず入力  |  ここからは任意に省略可能
-関数名　Arpeggiator( Code , Len , Paturn , lPaturn , Pmode , Range , Rmode , Phase , Shift)
-引数
  Code  : 構成音
  Len   : 長さ
Paturn  : アルペジオパターン
lPaturn : ノートの長さのパターン（省略時はその時点でのlを使用する）
 Pmode  : パターンの再生方法(0:Normal 1:Revers)
 Range  : オクターブのシフト幅（省略時は入力されたパターンによる）
 Rmode  : オクターブのシフト方法(0:No 1:Note 2:Paturn 3:Revers Note 4:Revers Paturn)
 Phase  : 位相
 Shift  : ノートシフト
 
●解説
 -Code
  構成音を記述します。
  構成音は{a,c,e}のように{ }で括って , で区切ってください。
  入力は内部で自動的にソートされるので記述する順番は任意です。
  
 -Len
  アルペジオを適応する長さを指定します。
  この長さにわたってアルペジエーターは実行されます。
  動作終了後はLenだけ進んだ位置にTimeが指定されなおします。
  パターンとLenがちょうど一致しない場合はLenに収まるように最後のノート短く切ります。
  
 -Paturn
  アルペジオのノートのパターンを指定します。
  パターンは数字で指定します。
  0を基準として、数字が大きくなるほど高い音、小さくなるほど低い音になります。
  これも和音と同様に{ }で括って , で区切らなくてはいけません。
　通常のabcdefgの音符のように`や"の記号を用いて音階を上下することができます。
  
 -lPaturn
  省略可能な引数です。
  アルペジオのノートの長さのパターンを指定します。
  パターンはステップ数で指定します。
  !付きのステップ数でも自動的に変換されます。
  省略された場合はその時点でのlを使用します。
  これも和音と同様に{ }で括って , で区切らなくてはいけません。
  例）l8が指定されてこの引数が省略されれば8分音符のアルペジオになる。
  　　{!8,!16}が指定されていれば8分と16分を交互に繰り返すのアルペジオになる。
  
 -Pmode
  省略可能な引数です。
  パターンの再生方法を指定します。
  0:パターンを通常の再生方法で再生します。
  1:パターンを上下反転させて再生します。
  省略時は0になります。
  
 -Range
  省略可能な引数です。
  オクターブのシフト幅を決定します。
  省略時にはパターンのシフト幅に依存します。
  
 -Rmode
  省略可能な引数です。
  オクターブの変更方法を選択します。
  0:オクターブを変更しません。
  1:高いノートほど、高いオクターブで演奏します。
  2:パターンの1ループごとに1オクターブを上げます。
  3:高いノートほど、低いオクターブで演奏します。
  4:パターンの1ループごとに1オクターブを下げます。
  省略時には0になります。
  
 -Phase
  省略可能な引数です。
  アルペジオパターンの位相をずらします。
  lPaturnを指定している場合はその位相も同時にずれます。
  省略時は0です。
  例)パターン{1,2,3}の位相を1ずらすと{2,3,1}となる。
  例)パターン{1,2,3}の位相を2ずらすと{3,1,2}となる。
  
 -Shift
  省略可能な引数です。
  和音とパターンの対応をシフトします。
  省略時は0です。
  例）{c,d,e}に1,2,3が対応している場合 1シフトすると{d,e,`c}に1,2,3が対応する。
  例）{c,d,e}に1,2,3が対応している場合-1シフトすると{"e,c,d}に1,2,3が対応する。

■更新履歴
　2009/08/28 : 関数実行後に音符の長さの指定がおかしくなる現象に対応
　2009/08/27 : 仮公開
*/



Function Arpeggiator(Array Argv){
//-----------------------------------------
//	変数宣言
//-----------------------------------------
	Array NoteList=();
	Array NoteNumList=();
	Array PaturnNumList=();
	Array LenNumList=();
	Array OctNumList=();
	Int Notenum = 0;
	Int Patunum = 0;
	Int PaturnMax = -128;
	
	Int Default_Len = MML(l);
	Int Default_Time = Time;
	
	Int Len = 0;
	
	Int Pmode = Argv(4); //パターンの再生方法(0:Normal 1:Revers)
	Int Range = Argv(5); //オクターブのシフト幅（省略時は入力されたノート数による）
 	Int Rmode = Argv(6); //オクターブのシフト方法(0:Note 1:Paturn 2:Revers Note 3:Revers Paturn)
 	Int Phase = Argv(7); //位相
 	Int Shift = Argv(8); //ノートシフト
	
//汎用変数
	Int Counter = 0;
	Int Buf = 0;
	Int Buf2 = 0;
	Int Flag = 0;
	Str Stbuf = "";
	Str Stbuf2 = "";

//-----------------------------------------
//	0:和音分析
//-----------------------------------------
//渡された和音を読み込む
	Counter = 0
	While(Flag == 0){
		Flag = 1;
		Buf = POS( {","} , Argv(0) );
		If(Buf != 0){
			NoteList( Counter ) = MID( Argv(0) , 0 , Buf );
			Stbuf = Argv(0);
			Argv(0) = MID(Argv(0) , Buf+1 , SizeOf(Stbuf) );
			Flag = 0;
			IF(Counter == 128){
				Flag = 1;
			}
		}Else{
			Flag = 1;
			NoteList( Counter ) = Argv(0);
		}
		Counter++;
	}
	Notenum = Counter;
	Counter = 0;

//読み込み完了。
//ノートをノートナンバーへ変換
	[(Notenum)
		Flag = 0;
		Buf = 0;
		Stbuf = NoteList(Counter);
		
		While( POS({`},Stbuf) != 0){
			Stbuf = Replace( Stbuf , {`} , {} , off)
			Buf++;
		}
		While( POS(CHR(34),Stbuf) != 0){
			Stbuf = Replace( Stbuf , CHR(34) , {} , off)
			Buf--;
		}
		Stbuf = "NoteNumList(Counter) = NoteNo( "+Stbuf+" );"
		Stbuf;
		NoteNumList(Counter) = NoteNumList(Counter) + Buf*12;
		Counter++;
	]
	IF(CodeMode == 1){
		Phase += SizeOf(NoteNumList);
	}
	NoteNumList = ArraySortNum( NoteNumList );


//-----------------------------------------
//	1:Len
//-----------------------------------------
	IF( Argv(1) != "" ){
		Buf = Argv(1);
		Len = Buf;
	}Else{
		Print("[==関数内不正==]")
		Print({"[Arrpeggiator]: 第2引数: 引数の省略はできません。"});
		Print({"[Arrpeggiator]: コンパイルは中断されます。"});
		End;
	}

//-----------------------------------------
//	2:アルペジオパターン
//-----------------------------------------
	Counter = 0;
	Flag = 0;
	While(Flag == 0){
		Buf = POS( {","} , Argv(2) );
		If(Buf = 0){
			Flag = 1;
			Stbuf2 = Argv(2);
		}Else{
			Stbuf2 = MID( Argv(2) , 0 , Buf );
		}
		IF( POS({"r"} , Stbuf2) = 0 ){
			Buf2 = 0;
			Stbuf2 = Replace(Stbuf2,{" "},{""},on);
			While( POS({`},Stbuf2) != 0){
				Stbuf2 = Replace( Stbuf2 , {`} , {} , off)
				Buf2++;
			}
			While( POS(CHR(34),Stbuf2) != 0){
				Stbuf2 = Replace( Stbuf2 , CHR(34) , {} , off)
				Buf2--;
			}
			PaturnNumList( Counter ) = StrToNum(Stbuf2);
			OctNumList( Counter ) = Buf2;
			IF(PaturnMax < PaturnNumList(Counter) ){
				PaturnMax = PaturnNumList(Counter);
			}
		}Else{
			Stbuf2 = Replace(Stbuf2,{" "},{""},on);
			PaturnNumList( Counter ) = Stbuf2;
		}
		Stbuf = Argv(2);
		Argv(2) = MID(Argv(2) , Buf+1 , SizeOf(Stbuf) );
		Counter++;
		IF(Counter == 128){
			Flag = 1;
		}
	}

	If( SizeOf( PaturnNumList ) == 0){
		Print("[==関数内不正==]")
		Print({"[Arrpeggiator]: 第3引数: 引数の省略はできません。もしくは不正です。"});
		Print({"[Arrpeggiator]: コンパイルは中断されます。"});
		End;
	}
//-----------------------------------------
//	3:ノート長パターン
//-----------------------------------------
	IF(Argv(3) != "" ){
		Stbuf = "LenNumList = ("+Argv(3)+")";
		Stbuf;
	}Else{
		LenNumList(0) = Default_Len;
	}
//-----------------------------------------
//	4:Phase(範囲内に収める処理)
//-----------------------------------------
	While(Phase < 0 ){
		Phase += Notenum;
	}
	While(Phase >= SizeOf(PaturnNumList)){
		Phase -= SizeOf(PaturnNumList);
	}

//-----------------------------------------
//	5:Range(範囲内に収める処理)
//-----------------------------------------
	IF(Range <=0 ){
		Range = PaturnMax;
	}


//-----------------------------------------
//	Arpeggiate
//-----------------------------------------
	Counter = Phase;
	Flag = 0;
	Buf2 = 0; //オクターブの保持
	
	While(Flag == 0){
		Buf = Default_Time + Len - Time;	//残り時間
		IF( Buf <= LenNumList(Counter % SizeOf(LenNumList) ) ){
			Flag == 1;
			l%(Buf);
		}Else{
			l%(LenNumList(Counter % SizeOf(LenNumList)));
		}
		//休符かどうか確認。
		//数字と文字列を比較できないのでASCIIに変換(数字はすべて文字になる。)
		IF(ASC( PaturnNumList(Counter) ) <= 57 ){
			Stbuf = "Buf = "+PaturnNumList(Counter) + " + "+Shift;
			Stbuf	//Buf=PaturnNumList(Counter)+Shift;
			IF(Pmode == 1){
				Buf =Buf*-1 + PaturnMax;
			}

			//発音をノートリストの範囲内に抑える。
			While(Buf<0){
				Buf+=Notenum
			}
			Buf = Buf % Notenum

			//実際に発音する。
			n(NoteNumList(Buf) + 12*Buf2 + 12*OctNumList(Counter) );
		}Else{
			Stbuf = PaturnNumList(Counter);
			Stbuf;
		}

		Buf=Counter;//オクターブのためにバックアップ

		//パターンのサイクル
		Counter++;
		If(Counter == SizeOf(PaturnNumList)){
			Counter = 0;
		}
		//オクターブを状態に応じて変更
		Switch(Rmode){
			Case(0){
				Buf2 = 0;
			}
			Case(1){
				Buf2 = PaturnNumList(Counter);
				IF(Buf2 >= Range){
					Buf2 = Range;
				}
			}
			Case(2){
				IF(Counter == 0){
					Buf2++;
				}
				IF(Buf2 >= Range){
					Buf2 = 0
				}
			}
			Case(3){
				Buf2 = Range - PaturnNumList(Counter);
				IF(Buf2<0){
					Buf2=0;
				}
			}
			Case(4){
				IF(Counter == 0){
					Buf2--;
				}
				IF(Buf2 < 0){
					Buf2 = Range;
				}
			}
			Default{
				Buf2 = 0;
			}
		
		}
	}
//-------------------------------------------------------------------
//	初期化
//-------------------------------------------------------------------
	Time = Default_Time + Len;
//	l%(Default_Len)
	// l%を使うと以降のノート長の指定が不正になるらしいのでlを使うために
	// ステップを!付きに変換している。
	Stbuf=""
	Buf = 1;
	Buf2 = !1;
	While(Default_Len > 0){
		While( Default_Len / Buf2 > 0 ){
			Default_Len -=Buf2
			Stbuf = ""+Stbuf+"^"+(Buf)+""
		}
		Buf++;
		Buf2=!1/Buf
	}
	Stbuf=Replace(Stbuf,{"^"},{""},off)
	Stbuf2 ="l"+Stbuf+ ""
	Stbuf2
}

//アルペジオ種
Str Arp ={0  ,r  ,0  ,2  ,r  ,0  ,0  ,r  ,1  ,0  ,r  ,0  ,r  ,2  ,r  ,0  ,r  ,0  ,1  ,r  ,0  ,r  ,0  ,r  ,2  ,0  ,r}
Str lArp={!32,!32,!16,!32,!32,!16,!32,!32,!16,!32,!32,!32,!32,!32,!32,!32,!32,!16,!32,!32,!32,!32,!32,!32,!16,!32,!32}

Str Arp1={0,`0}
Str Arp3={0,1,2}










/*　関数定義＋駄文で600行とかアホじゃないかと思うｗ　*/










//===================================================================================================
//===================================================================================================
//===================================================================================================
//_曲データ
//===================================================================================================
//===================================================================================================
//===================================================================================================

//_TR1 Heaven's Piano =======================================================================================================
Str Pv = { v.N(0,110,90 ,80,84 ,90,80,70 ,80,50,70)}
//Pv={v100 }
Int Upper = 2;
Str Pu={" [(Upper)>] "}
Str Pd={" [(Upper)<] "}
#PianoIntro1_1={
//gをペダルポイント

Sub{Pv Pu	r.g.d 	c^ d^	g.d.c	g.d.c	Pd}
    PD v80	f`c`f`g 	^`a^^	f^^^	^^^^

Sub{Pv Pu	r.g.d 	c^ d^	g.d.c	g.d.c	Pd}
    PD v80	e`c`e`f 	^`g^^ e^^^	^^^^

Sub{Pv Pu	r.g.d 	c^ d^	g.d.c	g.d.g	Pd}
    PD v80	da`d`e 	^`f^^ d^^^  ^^^^

Sub{Pv Pu	r.`c.d	c^ d^	g.d.c	^^^^	Pd}
    PD v80	g`d`g`a 	^`b^^ g^^^  ^v50t.N(0,5,9)>>g0b0`d^^<< t0
}


#PianoIntro1_2={
//------------------------------------------------
Sub{Pv Pu	r.g.d 	c^ d^	g.d.c	g.d.c	Pd}
    PD v80	f`c`f`g 	^`a^^	f^^^	^^^^

Sub{Pv Pu	r.g.d 	c^ d^	g.d.c	g.d.c	Pd}
    PD v80	e`c`e`f 	^`g^^ e^^^	^^^^

Sub{Pv Pu	r.g.d 	c^ d^	g.d.`c ^bgd	Pd}
    PD v80	da`d`e 	^`f^^ d^^^   ^^^^

Sub{Pv Pu	r.d. c	^ d^g	g^d`c	^bgd	Pd}
    PD v80	cegb		`c`d`g`b	`c^^^ ^"c^^
}

#PianoIntro2_1={
//gをペダルポイント

Sub{Pv Pu	r.g.d 	c^ d^	g.d.c	g.d.c	Pd}
    PD v80	f`c`f`g 	^`a^^	f^^^	^^^^

Sub{Pv Pu	r.g.d 	c^ d^	g.d.c	g.d.c	Pd}
    PD v80	a`e`a`b 	^`a^^a^^^	^^^^

Sub{Pv Pu	r.g.d 	c^ d^	g.d.c	g.d.g	Pd}
    PD v80	da`d`e 	^`f^^ d^^^  ^^^^

Sub{Pv Pu	r.`c.d	c^ d^	g.d.c	^^^^	Pd}
    PD v80	g`d`g`a 	^`b^^ g^^^  ^v50t.N(0,5,9)>>g0b0`d^^<< t0
}


#PianoIntro2_2={
//------------------------------------------------
Sub{Pv Pu	r.g.d 	c^ d^	g.d.c	g.d.c	Pd}
    PD v80	da`d`e 	^`f^^	d^^^	^^^^

Sub{Pv Pu	r.g.d 	c^ d^	g.d.c	g.d.c	Pd}
    PD v80	e`c`e`f 	^`g^^ e^^^	^^^^

Sub{Pv Pu	r.g.d 	c^ d^	g.d.`c ^bgd	Pd}
    PD v80	f`c`f`g 	^`a^^	f^^^	^^^^

Sub{Pv Pu	r.d. c	^ d^g	g^d`c	^bgd	Pd}
    PD v80	cegb		`c`d`g`b	`c^^^ ^"c^^
}


TR=1 q100  o4 l8 V=127 @1,16 REV=30 CHO=30
//イントロ
 #PianoIntro1_1
 
//メインA
 #PianoIntro1_1	#PianoIntro1_2
 #PianoIntro1_1	#PianoIntro1_2

//間奏・換装
 R1(8)		#PianoIntro1_2

//メインB
 #PianoIntro2_1	#PianoIntro2_2
 #PianoIntro2_1	#PianoIntro2_2 

//アウトロ(リフレイン)
 #PianoIntro2_1	#PianoIntro2_2 



//_TR2 Bass=============================================================================================

#Bass2={l8
[16 f][16 e]
[16 d][16 g]

[16 f][16 e]
[16 d][16 c]
}

#Bass1_1={
q100
f1^1e1^1
d1^1g1^1
}

#Bass3_1={l16
[f^"f32c32f `ffr"f fr"ff `ffrf]
[e^^e `eer"e er"ee `eere]
[d^^d `ddr"d dr"dd `ddrd]
[g^^g `ggr"g gr"gg `ggrg]
}

#Bass3_2={l16
[f^"ff `ffr"f fr"ff `ffrf]
[e^^e `eer"e er"ee `eere]
[d^^d `ddr"d dr"dd `ddrd]
[c^^c `ccr"c cr"cc `ccrc]
}

#BASS4_1={l8
[6 "ff]["ff]
[6 "aa]["aa]
[6 "dd]["dd]
[6 "gg]["aa]
}

#BASS4_2={l8
 [6 "dd]["dd]
 [6 "ee]["ee]
 [6 "ff]["ff]
 [6 "cc]["dd]
}


TR=2 q100 o3 l8 V=110 @82,8 v90
//イントロ
R1(8)

//メインA
#Bass1_1 q55 #Bass3_2
#Bass3_1	 #Bass3_2

//間奏
R1(8)		 R1(8)

//メインB
v100 q100
>
#BASS4_1	#BASS4_2
#BASS4_1	#BASS4_2 
<

//_TR3 PAD=============================================================================================
#Code={
Sub{> v-10 c."b2	c."b2 "a"b cd v+10<}
"" c0 c0 e0g1^1
"""a0"a0 c0e1^1
"""f0"f0"a0c1^1
"""g0"g0"b0d1^1
}

#Pad={
EP.T(60,97,L1(4) , 97,60,L1(3),60,127,L1(1) )
#Code
}

#PadSet={
//イントロ
 R1(8)

//メインA
[ #Pad ]
[ #Pad ]

//間奏
[ #Pad ]

//メインB
[ #Pad ]
[ #Pad ]
}

TR=3 q100 o6 l1 @51 v40 REV=127 V=127
#PadSet





//_TR4 BASS BOOSTER=============================================================================================
#Under1_1={
 f1^1e1^1
 d1^1g1^1
}
#Under1_2={
 f1^1e1^1
 d1^1c1^1
}

#Under2_1={
 f1^1a1^1
 d1^1g1^1
}
#Under2_2={
 d1^1e1^1
 f1^1c1^1
}

TR=4 q100 o3 l1 @80 v60 V=127 REV=0
  R1(8)
#Under1_1	#Under1_2
#Under1_1	#Under1_2

#Under1_1	#Under1_2

#Under2_1	#Under2_2
#Under2_1	#Under2_2

//_TR5 みょん=============================================================================================
#SynAlp1_1={
Arpeggiator( { "f,f,a,`c} , !1^1 , Arp,lArp)
Arpeggiator( { "e,e,g,`d} , !1^1 , Arp,lArp)
Arpeggiator( { "d,d,f,`c} , !1^1 , Arp,lArp)
Arpeggiator( { "g,g,b,`f} , !1^1 , Arp,lArp)
}

#SynAlp1_2={
Arpeggiator( { "f,f,a,`e} , !1^1 , Arp,lArp)
Arpeggiator( { "e,e,g,`d} , !1^1 , Arp,lArp)
Arpeggiator( { "d,d,f,`c} , !1^1 , Arp,lArp)
Arpeggiator( { "c,c,e, b} , !1^1 , Arp,lArp)
}

#SynAlp2_1={
Arpeggiator( { "f,f,a,`c} , !1^1 , Arp,lArp)
Arpeggiator( { "a,a,`c,`e}, !1^1 , Arp,lArp)
Arpeggiator( { "d,d,f,`c} , !1^1 , Arp,lArp)
Arpeggiator( { "g,g,b,`f} , !1^1 , Arp,lArp)
}

#SynAlp2_2={
Arpeggiator( { "d,d,f, a} , !1^1 , Arp,lArp)
Arpeggiator( { "e,e,g,`d} , !1^1 , Arp,lArp)
Arpeggiator( { "f,f,a,`c} , !1^1 , Arp,lArp)
Arpeggiator( { "c,c,e, b} , !1^1 , Arp,lArp)
}

TR=5 @39 q40 o5 V=127 v30 REV=120 CHO=30
//イントロ
R1(8)

//メインA
#SynAlp1_1	#SynAlp1_2
#SynAlp1_1	#SynAlp1_2

//間奏
R1(8)		R1(8)

//メインB
#SynAlp2_1	#SynAlp2_2
#SynAlp2_1	#SynAlp2_2

//アウトロ


//_TR6 Mellody Piano=============================================================================================
#Mellody={
 PD c^^^	^^^^	g.f.e	e.f.c		
 PD c^^^	^^""b16"e16"b16e16	g.f.e	e.f.c
 PD c^^^	^^""a16"d16"a16d16	g.f.e e.f.`c
 PD `c^^^	^^"c16"g16c16g16		`c.b.g e.d.c
}

TR=6 q100 o7 l8 V=127 v100 REV=20 @1
//イントロ
R1(8)

//メインA
R1(8)		R1(8)	Sub{ r-2 "g-32,,60 "g2-32}
#Mellody	#Mellody

//間奏
#Mellody	#Mellody

//メインB
#Mellody	#Mellody 
#Mellody	#Mellody


//_TR7 すーぱーそー=============================================================================================
#SuperSaw1_1={
 [3 "f c g"f  c g"f g][ "f c a]"f b		//F	:face g
 [3 "e"b`c"e "b`c"e`c][ "e"b b]"b g		//E	:egbd f
 [3 "d"a`c"d "a`c"d`c][ "d"a`c]"d`d		//D	:dfac e
 [  "g"b g"g:"b g"g g]
 [  		 "b b"g b:"g"b b"g][ "g"bb]"g`c	//G	:------
}
	
#SuperSaw1_2={
 [3 "f c`c"f  c`c"f`c][ "f c`d]"f`d		//F	:face g
 [3 "e"b`c"e "b`c"e`c][ "e"b`d]"e`d		//E	:egbd f
 [3 "d"a`c"d "a`c"d`c][ "d"a`d]"d`e		//D	:dfac e
 [  "c"g g"c:"g g"c g]
 [  		 "g b"c b:"c"g b"c][ "c"g`c]"c`d		//C	:cegb d
}


#SuperSaw2_1={
 [3 "f c g"f  c g"f g][ "f c a]"f b		//F
 [3 "a"b`c"a "b`c"a`c][ "a"b b]"a g		//A
 [3 "d"a`c"d "a`c"d`c][ "d"a`c]"d`d		//D
 [  "g"b g"g:"b g"g g]
 [  		 "b b"g b:"g"b b"g][ "g"bb]"g`c//G
}
	
#SuperSaw2_2={
 [3 "d c`c"d  c`c"d`c][ "d c`d]"d`d			//D
 [3 "e"b`c"e "b`c"e`c][ "e"b`d]"e`d			//E
 [3 "f"a`c"d "a`c"f`c][ "f"a`d]"f`e			//F
 [  "c"g g"c:"g g"c g]
 [  		 "g b"c b:"c"g b"c][ "c"g`c]"c`d 	//C
}


TR=7 q60 o6 l16 V=127 @82,90,1 v50 REV=20
//イントロ
R1(8)

//メインA
R1(8)		R1(8)
//R1(8)		R1(8)
//R1(8)		EP.T(0,127,L1(8))	#SuperSaw1_2
R1(8)	V.T(0,127,L1(8)) #SuperSaw1_2

//間奏
#SuperSaw1_1	#SuperSaw1_2

//メインB
#SuperSaw2_1	#SuperSaw2_2
#SuperSaw2_1	#SuperSaw2_2



//_TR8 すーぱーそー2=============================================================================================
#SYNTH1={ l8 q100
g^^g ^c^"b	^"g"bg ^c"bc
g^gg ^`c^b	^`cbg  ^c"bc
g^^c ^"bcd  g.f.e	 e.f.c
g^gg ^`c^b	^`cbg  ^c"bc 
}
/*
 PD c^^^	^^^^	g.f.e	e.f.c		
 PD c^^^	^^""b16"e16"b16e16	g.f.e	e.f.c
 PD c^^^	^^""a16"d16"a16d16	g.f.e e.f.`c
 PD `c^^^	^^"c16"g16c16g16		`c.b.g e.d.c
*/

#SYNTH1={ l8 q100
g^^g ^c^"b	"g."b.g c."b.c
g^gg ^`c^b	`c.b.g  c."b.c
g^^c ^"bcd  g.f.e	 e.f.c
g^gg ^`c^b	`c.b.g  c."b.c 
}



#SYNTH2={ l16 q20
grrr rrg^	^^c^	^^"b^
^^"g^	"b^g^	^^c^	"b^c^

g^^^	g^g^	^^`c^	^^b^
^^`c^	b^g^	^^c^	"b^c^

//g^^g ^c^"b	^"g"bg ^c"bc
//g^gg ^`c^b	^`cbg  ^c"bc
//g^^c ^"bcd  g.f.e	 e.f.c
//g^gg ^`c^b	^`cbg  ^c"bc 
}

#SYNTH = { Sub{>#SYNTH1<}
 #SYNTH1 }

TR=8 q100 o6 l8 V=127 @82,90,1 v80 REV=20
//イントロ
R1(8)

//メインA
R1(8)		R1(8)
R1(8)		R1(8)

//間奏
R1(8)		R1(8)

//メロB
V.T(0,127,L1(8))
#SYNTH	#SYNTH
#SYNTH	#SYNTH

Sub{r V.T(127,0,!1)}
g^^^ ^^^^



//_DrumTrack and SideChainComp=============================================================================================
//サイドチェーンの種類
Str SideChain1="EP.T(64,127,!8.)"			//柔らかいアタックのコンプ
Str SideChain2="EP.T(0,0,!16,0,127,!16)"		//完全に音の消えるホールドの長い鋭いコンプ
Str SideChain3="EP.T(0,127,!16)"			//完全に音の消えるホールドの短い鋭いコンプ
Str SideChain4="EP.T(0,127,!32)"			//さらに鋭いコンプ


//サイドチェーンのアサイン
Str Add=""
	Add = Add + {" TRC( 3 , SideChain2 ) "}	//パッドにサイドチェーンをアサイン
	Add = Add + {" TRC( 4 , SideChain3 ) "}	//低音　にサイドチェーンをアサイン

//各ノートへの関数のアサイン
Function KICK (Str Playlist ){DrumPlay( Playlist , Add+"c") }	//Kick Asigned "SideChainComp."
Function KICK2(Str Playlist ){DrumPlay( Playlist , "c") }		//Kick unAsigned

Function CLAP (Str Playlist ){DrumPlay( Playlist , "d+")}
Function STICK(Str Playlist ){DrumPlay( Playlist , "a") }
Function EXP  (Str Playlist ){DrumPlay( Playlist , "`e")}

//別チャンネルにアサインする場合は予め文字列を作っておくと楽。もしくは関数を作るべし。
Str _Hat = "v(Hatvel) o3 f+"
Str _OHH = "v(Hatvel) o3 a+"
Function OHH (Str Playlist ){Int Hatvel;  DrumPlay( Playlist ," Hatvel=MML(v) TRC(11,_OHH) "+"r") }
Function HAT1(Str Playlist ){Int Hatvel; DrumPlay( Playlist , " Hatvel=MML(v) TRC(11,_Hat) "+"r") }
Function HAT2(Str Playlist ){ DrumPlay( Playlist , "g+") }

Function RIDE(Str Playlist ){ DrumPlay( Playlist , "`d+") }


//シーケンサ型記述法 :: FL Studioのリズムシーケンサ入力が便利だったので作りました
//				リズムをより視覚的に作れるかと思います。
//				でも、入力支援のリズムボックスで作っても良かったような気がしてる（笑

//-------------------------------------------------------------------------------------------------------
/*	このバスドラ(KICK2)にはサウドチェーンが付いてません。					
	基本的なリズムはお決まりの4つ打ちバス＋偶数拍のクラップ、裏打ちのハットです。	*/
Str Drum0_1 = MML_DRUM({"
	//	vol	1	2	3	4	5	6	7	8	
	HAT2 :v80	--x-	--x-	--x-	--x-	--x-	--x-	--x-	--x-	
	STICK:v50	----	x---	----	x---	----	x---	----	x---	
	CLAP :v50	----	x---	----	x---	----	x---	----	x---	
	EXP  :v10	----	x---	----	x---	----	x---	----	x---	
	KICK2:v120	x---	x---	x---	x---	x---	x---	x---	x-x-	
"})


Str Drum0_2 = MML_DRUM({"
	//	vol	1	2	3	4	5	6	7	8	
	HAT2 :v80	--x-	--x-	--x-	--x-	--x-	--x-	-x-x	--x-	
	STICK:v50	----	x---	----	x---	----	x---	----	x---	
	CLAP :v50	----	x---	----	x---	----	x---	----	x---	
	EXP  :v10	----	x---	----	x---	----	x---	----	x---	
	KICK2:v100	x---	x---	x---	x---	x---	x--x	-x-x	x-x-	
"})

//-------------------------------------------------------------------------------------------------------
/*	サイドチェーンの付いたバスドラ(KICK)を投入。	*/
Str Drum1_1 = MML_DRUM({"
	//	vol	1	2	3	4	5	6	7	8	
	HAT2 :v80	--x-	--x-	--x-	--x-	--x-	--x-	--x-	--x-	
	STICK:v50	----	x---	----	x---	----	x---	----	x---	
	CLAP :v50	----	x---	----	x---	----	x---	----	x---	
	EXP  :v10	----	x---	----	x---	----	x---	----	x---	
	KICK :v120	x---	x---	x---	x---	x---	x---	x---	x-x-	
"})


Str Drum1_2 = MML_DRUM({"
	//	vol	1	2	3	4	5	6	7	8	
	HAT2 :v80	--x-	--x-	--x-	--x-	--x-	--x-	-x-x	--x-	
	STICK:v50	----	x---	----	x---	----	x---	----	x---	
	CLAP :v50	----	x---	----	x---	----	x---	----	x---	
	EXP  :v10	----	x---	----	x---	----	x---	----	x---	
	KICK :v100	x---	x---	x---	x---	x---	x--x	-x-x	x-x-	
"})


//-------------------------------------------------------------------------------------------------------
/*	@27,90のHAT1(f+)の音はキツいので、CH11をつかって@1の音を使ってます。	
	隙間を縫うようにハットで間を詰めます。						*/

Str Drum2_1 = MML_DRUM({"
	//	vol	1	2	3	4	5	6	7	8	
	OHH  :v30	x---	x---	x---	x---	x---	x---	x---	x---	
	HAT1 :v30	---x	-x-x	-x--	x--x	-x-x	-x-x	--x-	-x-x	
	HAT2 :v80	--x-	--x-	--x-	--x-	--x-	--x-	--x-	--x-	
	STICK:v50	----	x---	----	x---	----	x---	----	x---	
	CLAP :v50	----	x---	----	x---	----	x---	----	x---	
	EXP  :v10	----	x---	----	x---	----	x---	----	x---	
	KICK :v120	x---	x---	x---	x---	x---	x---	x---	x-x-	
"})


Str Drum2_2 = MML_DRUM({"
	//	vol	1	2	3	4	5	6	7	8	
	OHH  :v30	x---	x---	x---	x---	x---	x---	x---	x---	
	HAT1 :v30	---x	-x-x	-x--	x--x	-x-x	-x-x	--x-	-x-x	
	HAT2 :v80	--x-	--x-	--x-	--x-	--x-	--x-	-x-x	--x-	
	STICK:v50	----	x---	----	x---	----	x---	----	x---	
	CLAP :v50	----	x---	----	x---	----	x---	----	x---	
	EXP  :v10	----	x---	----	x---	----	x---	----	x---	
	KICK :v100	x---	x---	x---	x---	x---	x--x	-x-x	x-x-	
"})

//-------------------------------------------------------------------------------------------------------
//今まで通りの小ネタ
Int Cnt;
Str EP0 = {EP=0}		//音量ON
Str EP127 = {EP=127}	//音量OFF
Str AllOff = { Cnt=1 MetaText={"AllExpression:Off"} [16 TRC(Cnt , EP0 )Cnt++]}
Str AllOn  = { Cnt=1 MetaText={"AllExpression:On"}  [16 TRC(Cnt , EP127 )Cnt++] }

Str SnareFill = {" Sub{[8 r-1]v30 [7  [8 [e16]v+1]][ [[ AllOn c0e32 AllOff r32]  r]AllOn c0e AllOff r AllOn ]  }"}


//_DrumPlay=============================================================================================
UseKeyShift=off 調-()
TR=11 o3 l16 q40 V=100 @1		//TRCを使って書き込むためのトラック
TR=10 o3 l16 q40 V=100 @27,90
/* intro */
R1(8)

/* メインA */
MetaText={"All start , DrumAsign:off"}
[3 Drum0_1 ]  Drum0_2
MetaText={"DrumAsign : on"}
[3 Drum1_1 ]  Drum1_2

/* 間奏 */
[3 Drum2_1 ]  Drum2_2
MetaText={"Drum:off"}
R1(8)

/* 換装 */
R1(8);MetaText={"Drum:Snare"}
R1(8);SnareFill;
Sub{v127 `c+0`e TRC(11,"o3v127`e")}

/* メインB */
[3 Drum1_1 ]  Drum1_2
[3 Drum1_1 ]  Drum1_2
Sub{v80 `c+0`e }

[3 Drum2_1 ]  Drum2_2
[3 Drum2_1 ]  Drum2_2 ;SnareFill;
Sub{v127 `c+0`e TRC(11,"o3v127`e")}

//_TR16 Bird=============================================================================================
#BirdAlp={
	Arpeggiator( { f,a,`c} , !1^1 , Arp)
	Arpeggiator( { e,g,`d} , !1^1 , Arp)
	Arpeggiator( { d,f,`c} , !1^1 , Arp)
	Arpeggiator( { g,b,`f} , !1^1 , Arp)
}


TR=16 @124 o5  l4. v10 REV=127  V=127 CHO=127
v.N(10,15,7, 9,15,10,12)
Sub{o5 l4. #BirdAlp }
Sub{o4 l5. #BirdAlp }



I=0
[TR=I r1^1 I++]