import com.nttdocomo.ui.*;
import com.nttdocomo.io.*;
//以下の２行はスクラッチパッドを使うときには書きます。
import java.io.*;
import javax.microedition.io.*;

//------------------------------------------------------------------  
// Rw class  
//  
// このclassは、スクラッチパッドへのアクセスをまとめたもの
//------------------------------------------------------------------  
class Rw{ 
       
      //スクラッチパッドに整数値を書き込む  
      // ｖ−　スクラッチパッド書き込む値  
      void write(int v){ 
            try{ 
            	  OutputStream out=Connector.openOutputStream("scratchpad:///0;pos=0");//スクラッチパッドをオープン  
                  out.write((v>>24)&0xff);//1byte目書き込み  
                  out.write((v>>16)&0xff);//2byte目書き込み  
                  out.write((v>> 8)&0xff);//3byte目書き込み  
                  out.write(v&0xff);//4バイト目書き込み  
                  out.flush();//flushを実施  
                  out.close();//closeを実施し、flushと合わせ、スクラッチパッドを閉じる  
                  }catch(IOException e){ 
                  System.out.println("Write Error " +e);//例外が発生したら内容をコンソールに表示  
            } 
      } 
       
      //スクラッチパッドから、整数を読み取る  
      // 戻り値　−　スクラッチパッドから読みこんだ値  
      int read(){ 
            int rv;//読み込み値を格納する変数rvを宣言  
            rv = -1;//rvの初期化  
            try{ 
                  InputStream in=Connector.openInputStream("scratchpad:///0;pos=0");//スクラッチパッドを開く  
                  rv=(in.read()<<24)|(in.read()<<16)|(in.read()<<8)|in.read();//整数を読み込む（４Bytesなので４回readを実施）  
                  in.close();//クローズ  
                  }catch(IOException e){ 
                  System.out.println("Read Error " +e);//例外が発生したら内容をコンソールに表示  
            } 
             
            return rv;//戻り値をセット  
      } 
} 

 
public class TestCanvas extends IApplication {
	// 初期化処理
	public void start(){	

		//Canvasオブジェクトを生成
		canvas screen = new canvas();
		//現在の画面に設定
		Display.setCurrent(screen);
	
	}
}



class canvas extends Canvas implements Runnable
{
	//Threadの宣言
	Thread m_gameLoop = null;
	
	//スクラッチパッド用クラスの呼び出し
	Rw rw = new Rw();
	
	//イメージの宣言
	Image m_imgTitle;	//開始画面
	Image m_imgTitlebg;	//開始画面BG
	Image m_imgBoard;	//8*8のマス
	Image m_imgFirst; 	//先手BG
	Image m_imgSecond;	//後手BG
	Image m_imgBlack;	//黒
	Image m_imgWhite;	//白
	Image m_imgRed;		//赤
	Image m_imgAllow;	//矢印
	Image m_imgTurn;	//ターン
	Image m_imgWin;		//勝ち
	Image m_imgLose;	//負け
	Image m_imgDraw;	//引き分け
	Image m_imgScore[] = new Image[10];//数字

	//画面モード
	private static final int SCREEN_TITLE     = 0;//タイトル画面
	private static final int SCREEN_NOMALGAME = 1;//ゲーム画面（通常）
	private static final int SCREEN_CPUGAME   = 2;//ゲーム画面（CPU同士）
	private static final int SCREEN_CLEAR     = 3;//クリア画面
	private static final int SCREEN_CREDIT    = 4;//クレジット画面
	private static final int SCREEN_VSGAME    = 5;//人VS人
	
	//オセロの状態
	private static final int REVERSI_WHITE  =  1;//オセロは白
	private static final int REVERSI_BLACK  =  0;//オセロは黒
	private static final int REVERSI_SPACE  = -1;//オセロが無い
	private static final int REVERSI_OK     =  2;//オセロ置ける
	private static final int REVERSI_CHOOSE =  3;//オセロ選ぶ
	
	//画面の状態変数
	private int m_screen;
	//押したキーの情報
	private int m_getKey = 0;//初期化
	//画面置き場サイズ
	private int m_reversiCnt = 8;//後で定義	
	//画面オセロ情報
	private Piece m_reversiPiece[][];
	//現在のカーソル位置
	private int m_i,m_j;//後で定義
	//オセロの手数　後でも定義
	private int m_reversiTurn = 0;
	//盤面のオセロの数
	private int m_blackReversi = 0;//黒の数
	private int m_whiteReversi = 0;//白の数
	//点滅の変数
	private int m_flash = 0;
	//優先度の設定
	private int m_priority[][] = new int[m_reversiCnt][m_reversiCnt];	
	//音状態の変数
	//0→×
	//1→○
	private int m_musicFlag = 0;
	//振動状態の変数
	//0→×
	//1→○
	private int m_vibrationFlag = 0;
	//設定保存用の変数
	private int m_memory = 0;
	
	//音楽を演奏させるオブジェクトを作る
	AudioPresenter m_music   = AudioPresenter.getAudioPresenter();//BGM
	AudioPresenter m_musicSE = AudioPresenter.getAudioPresenter();//SE
	
	private String str;
	private long size;
	

	
	public void paint(Graphics g) {
		
	}
	
	//コンストラクタ
	public canvas(){
		
//		 変数の宣言
		HttpConnection   http = null;
		InputStream      in   = null;
		//String url = TestCanvas.getCurrentApp().getSourceURL() + "xxx";
		String url = /*TestCanvas.getCurrentApp().getSourceURL() +*/ "xxx";
		byte[] buf;
		
		try {
			// 接続を設定
			http=(HttpConnection)(Connector.open(url, Connector.READ));
			// 要求メソッドを設定
			http.setRequestMethod(HttpConnection.GET);	
			//System.out.println(url);
			// 実際に接続
			http.connect();
			if(http.getResponseCode() == HttpConnection.HTTP_OK){
				// 入力ストリームを取得
				in = http.openInputStream();
				size = http.getLength();
				buf =   new byte[(int)size];
				in.read(buf);
				str = new String(buf);
				System.out.println(str);
				// 入力ストリームを閉じる
				in.close();
				// 接続を閉じる
				http.close();	
			}		
		}catch(Exception e){
			if(http != null)
			{
				try{ http.close(); }catch (Exception e2){}
			}
			if(in != null)
			{
				try{ in.close(); }catch (Exception e2){}
			}
		System.out.println("エラー："+e);
			str = "通信できませんでした";
		}
		
		
		//BGMを無限ループさせる
		m_music.setAttribute(AudioPresenter.LOOP_COUNT, -1);
		//BGMの優先度は効果音より低く設定する
		m_music.setAttribute(AudioPresenter.PRIORITY, 1);
		//BGMのボリュームを30に設定
		m_music.setAttribute(AudioPresenter.SET_VOLUME, 30); 
		//音源読み込み
		MediaSound ms = MediaManager.getSound("resource:///010.mld");
		
		try{
			MediaImage miTitle   = MediaManager.getImage("resource:///titlelogo.gif");//開始画面
			MediaImage miTitlebg = MediaManager.getImage("resource:///title_bg.gif");//開始画面BG
			MediaImage miAllow   = MediaManager.getImage("resource:///allow.gif");//矢印
			MediaImage miWin     = MediaManager.getImage("resource:///youwin.gif");//勝ち
			MediaImage miLose    = MediaManager.getImage("resource:///youlose.gif");//負け
			MediaImage miDraw    = MediaManager.getImage("resource:///draw.gif");//引き分け
			MediaImage miScore0  = MediaManager.getImage("resource:///score0.gif");//0
			MediaImage miScore1  = MediaManager.getImage("resource:///score1.gif");//1
			MediaImage miScore2  = MediaManager.getImage("resource:///score2.gif");//2
			MediaImage miScore3  = MediaManager.getImage("resource:///score3.gif");//3
			MediaImage miScore4  = MediaManager.getImage("resource:///score4.gif");//4
			MediaImage miScore5  = MediaManager.getImage("resource:///score5.gif");//5
			MediaImage miScore6  = MediaManager.getImage("resource:///score6.gif");//6
			MediaImage miScore7  = MediaManager.getImage("resource:///score7.gif");//7
			MediaImage miScore8  = MediaManager.getImage("resource:///score8.gif");//8
			MediaImage miScore9  = MediaManager.getImage("resource:///score9.gif");//9
			MediaImage miBoard   = MediaManager.getImage("resource:///table8x8.gif");//8*8のマス
			MediaImage miFirst   = MediaManager.getImage("resource:///bg_first.gif");//画像左
			MediaImage miSecond  = MediaManager.getImage("resource:///bg_second.gif");//画像右
			MediaImage miBlack   = MediaManager.getImage("resource:///black.gif");//黒
			MediaImage miWhite   = MediaManager.getImage("resource:///white.gif");//白
			MediaImage miRed     = MediaManager.getImage("resource:///red.gif");//赤
			MediaImage miTurn    = MediaManager.getImage("resource:///turn.gif");//ターン
			
			//使用宣言
			miTitle.use();
			miTitlebg.use();
			miAllow.use();
			miWin.use();
			miLose.use();
			miDraw.use();
			miScore0.use();
			miScore1.use();
			miScore2.use();
			miScore3.use();
			miScore4.use();
			miScore5.use();
			miScore6.use();
			miScore7.use();
			miScore8.use();
			miScore9.use();
			miBoard.use();
			miFirst.use();
			miSecond.use();
			miBlack.use();
			miWhite.use();
			miRed.use();
			miTurn.use();
			
			m_imgTitle    = miTitle.getImage();
			m_imgTitlebg  = miTitlebg.getImage();
			m_imgAllow    = miAllow.getImage();
			m_imgWin      = miWin.getImage();
			m_imgLose     = miLose.getImage();
			m_imgDraw     = miDraw.getImage();
			m_imgScore[0] = miScore0.getImage();
			m_imgScore[1] = miScore1.getImage();
			m_imgScore[2] = miScore2.getImage();
			m_imgScore[3] = miScore3.getImage();
			m_imgScore[4] = miScore4.getImage();
			m_imgScore[5] = miScore5.getImage();
			m_imgScore[6] = miScore6.getImage();
			m_imgScore[7] = miScore7.getImage();
			m_imgScore[8] = miScore8.getImage();
			m_imgScore[9] = miScore9.getImage();
			m_imgBoard    = miBoard.getImage();
			m_imgFirst    = miFirst.getImage();
			m_imgSecond   = miSecond.getImage();
			m_imgBlack    = miBlack.getImage();
			m_imgWhite    = miWhite.getImage();
			m_imgRed      = miRed.getImage();
			m_imgTurn = miTurn.getImage();
		}catch(Exception e)
		{
			//ここにエラー処理
		}
		
		//-------------------------------------------------------------------
		//スクラッチパッドからの設定反映
		//-------------------------------------------------------------------
		int v = rw.read();//Rw classの、read()メソッドを実行し結果をｖにセット
		//読み込んだサウンド設定反映
		if(v==2 || v==3)
		{
			m_musicFlag = 1; 
		}
		else
		{
			m_musicFlag = 0;
		}
		//読み込んだ振動設定反映
		if(v==1 || v==3)
		{
			m_vibrationFlag = 1;
		}
		else
		{
			m_vibrationFlag = 0;
		}
		//-------------------------------------------------------------------
		
		try{
			ms.use();//使用宣言
		} catch (ConnectionException e) 
		{
			//入力の例外処理
		}
		//音楽を演奏させるオブジェクトに読み込んだ音楽ファイルを設定
		m_music.setSound(ms);
		
		if(m_musicFlag != 1){
			m_music.play();
		}
		
		//優先度の設定
		int[] judgment = 
		{
			64,  9, 53, 26, 25, 60, 16, 61,
			10,  1, 17, 36, 35, 24,  4, 15,
			54, 18, 52, 47, 41, 49, 23, 59,
			27, 37, 45,  8,  7, 46, 40, 32,
			28, 38, 44,  6,  5, 43, 39, 31,
			55, 19, 51, 48, 42, 50, 22, 58,
			11,  2, 20, 33, 34, 21,  3, 14,
			63, 12, 56, 29, 30, 57, 13, 62
		};
		
		for(int x=0; x<m_reversiCnt; x++)
		{
			for(int y=0; y<m_reversiCnt; y++)
			{
				m_priority[x][y] = judgment[m_flash];
				m_flash++;
			}
		}
		//優先度の設定終わり
		 	
		//画面モードを「タイトル」に設定
		m_screen = SCREEN_TITLE;
		
				
		m_gameLoop = new Thread(this);//スレッドを生成する
		m_gameLoop.start();//スレッドを起動する
	}
	
	/*public void tuusin(Graphics g)
	{

		g.lock();
		g.setColor( g.getColorOfName(Graphics. RED) );//赤を定義
		g.drawString("通信："+str, 20, 238);
		g.unlock(true);
	}*/

	
//	------------------------------------------------------------------  
//	 run()  
//	  
//	 スレッド実行部分
//	------------------------------------------------------------------
	public void run()
	{
		// オフスクリーンバッファの作成
		Graphics g = getGraphics();
		// タイマ-の初期設定
		long tm = System.currentTimeMillis();
		int titleCount = 1;//カーソルの位置
		
		
		
		while(null != m_gameLoop){
			try{
				//待機処理
				tm -= System.currentTimeMillis();
				if(tm > -40) 
				{
					m_gameLoop.sleep(40 + tm);
				}
				tm =  System.currentTimeMillis();
				//ソフトキーでのON/OFF
				//ソフトキー1に文字表示
				if(m_musicFlag == 0){
					setSoftLabel(Frame.SOFT_KEY_1, "♪○");
				}
				else
				{
					setSoftLabel(Frame.SOFT_KEY_1, "♪×");
				}
				//ソフトキー２に文字表示
				if(m_vibrationFlag == 0)
				{
					setSoftLabel(Frame.SOFT_KEY_2, "振動×");
				}
				else
				{
					setSoftLabel(Frame.SOFT_KEY_2, "振動○");
				}
				
				if(m_getKey == 7)//ソフトキー１
				{
					m_musicFlag++;//音フラグ＋
					if(m_musicFlag > 1){
						m_musicFlag = 0;
					}
				}
				if(m_getKey == 6)
				{//ソフトキー２
					m_vibrationFlag++;//振動フラグ+
					if(m_vibrationFlag > 1){
						m_vibrationFlag = 0;
					}
				}//ソフトキーでのON/OFF終了
				
				PhoneSystem.setAttribute(
					    PhoneSystem.DEV_VIBRATOR , PhoneSystem.ATTR_VIBRATOR_OFF);
				
				if(m_musicFlag ==0 && m_vibrationFlag==0)
				{
					m_memory = 0;
				}
				else if(m_musicFlag ==0 && m_vibrationFlag==1){
					m_memory = 1;
				}
				else if(m_musicFlag ==1 && m_vibrationFlag==0){
					m_memory = 2;
				}
				else if(m_musicFlag ==1 && m_vibrationFlag==1){
					m_memory = 3;
				}
				
				
				switch(m_screen)
				{
				//プレイヤーVS CPU
				case SCREEN_NOMALGAME:
				{
					//先手
					if(m_reversiTurn%2 == 0)
					{
					}
					//後手
					else if(m_reversiTurn%2 != 0)
					{
						//待機処理
						tm -= System.currentTimeMillis();
						if(tm > -400) 
						{
							m_gameLoop.sleep(400 + tm);
						}
						tm =  System.currentTimeMillis();
						//CPUセット
						cpuAI(g);
					}
					gamekeyAction(m_getKey, g);
					reversiPaint(g);//盤上描画
					reversiScore(g);//スコア表示
					break;
				}//CPUゲーム終わり
				
				//CPU VS CPU
				case SCREEN_CPUGAME:
				{
					//先手
					if(m_reversiTurn%2 == 0)
					{
						//待機処理
						tm -= System.currentTimeMillis();
						if(tm>-400)
						{
							m_gameLoop.sleep(200 + tm);
						}
						tm =  System.currentTimeMillis();
						//CPUセット
						cpuAI(g);
					}
					//後手
					else if(m_reversiTurn%2 != 0)
					{
						//待機処理
						tm -= System.currentTimeMillis();
						if(tm>-400)
						{
							m_gameLoop.sleep(200 + tm);
						}
						tm =  System.currentTimeMillis();
						//CPUセット
						cpuAI(g);
					}
					gamekeyAction(m_getKey, g);
					reversiPaint(g);//盤上描画
					reversiScore(g);//スコア表示
					break;
				}//HUMANゲーム終わり
				
				//タイトル画面
				case SCREEN_TITLE:
				{
					if(m_getKey == 1)
					{
						titleCount = titleCount-1;
						if(titleCount < 1)
						{
							titleCount = 5;
						}
					}
					if(m_getKey == 2)
					{
						titleCount = titleCount+1;
						if(titleCount > 5)
						{
							titleCount = 1;
						}
					}
					drawTitle(g,titleCount);//タイトル画面描画処理
					//tuusin(g);
					g.setColor( g.getColorOfName(Graphics. RED) );//赤を定義
					g.drawString("通信："+str, 20, 238);
					if(m_getKey == 5)
					{
						if(titleCount == 1)
						{//ＶＳ　ＣＰＵ
							//ゲームモードへ移行
							reversiReset(g);//盤上リセット
							m_screen = SCREEN_NOMALGAME;//プレイヤー　VS　CPUへ
							
						}
						else if(titleCount == 2)
						{//ＶＳ　ＨＵＭＡＮ
							//ゲームモードへ移行
							reversiReset(g);//盤上リセット
							m_screen = SCREEN_CPUGAME;//CPU VS CPUへ
						}
						else if(titleCount == 3)
						{//人VS人
							//ゲームモードへ移行
							reversiReset(g);//盤上リセット
							m_screen = SCREEN_VSGAME;//人VS人へ
							
						}
						else if(titleCount == 4)
						{//未実装
							rw.write(m_memory);
							endGame();//ゲーム終了
						}
						else if(titleCount == 5)
						{//未実装
							rw.write(m_memory);
							endGame();//ゲーム終了
						}	
					}
					break;
				}//タイトル終わり
				
				//人VS人
				case SCREEN_VSGAME:
				{
					//先手
					if(m_reversiTurn%2 == 0)
					{
					}
					//後手
					else if(m_reversiTurn%2 != 0)
					{
					}
					gamekeyAction(m_getKey, g);
					reversiPaint(g);//盤上描画
					reversiScore(g);//スコア表示
					break;
				}
				//ゲーム判定（勝敗）表示
				case SCREEN_CLEAR:
				{
					drawClear(g);//画像表示
					if(m_getKey == 5)//なにか押されたらタイトルへ
					{
						m_screen = SCREEN_TITLE;
					}
					break;
				}//クリア終わり
				
				//仮
				case SCREEN_CREDIT:
				{
					//drawCredit(g);//クレジットを表示
					if(m_getKey != 0)//なにか押されたらタイトルへ
					{
						m_screen = SCREEN_TITLE;
					}
					break;
				}//クレジット終わり
			}//スイッチ文終わり
				
		}catch (Exception e)//例外処理
		{
			m_gameLoop = null;//プログラム終了
			e.printStackTrace();
			break;//プログラム終了
		}
		
		m_getKey = 0;//何もしてない状態
		}
		
	}

	
//	------------------------------------------------------------------  
//	 endGame  
//	  
//	 終了処理
//	------------------------------------------------------------------
	public void endGame()
	{
		try
		{
		}catch(Exception e)
		{
			e.printStackTrace();
		}
		m_gameLoop = null;//アプリケーションの終了
		IApplication.getCurrentApp().terminate();
		return;
	}

//	------------------------------------------------------------------  
//	 drawTitle  
//	  
//	 タイトル画面描画処理
//	------------------------------------------------------------------
	public void drawTitle(Graphics g, int chose){
		g.lock();//鍵をかける
		//基本画面表示
		g.drawImage(m_imgTitlebg, 0, 0);//背景表示
		g.drawImage(m_imgTitle, 0, 0);//開始画面表示
		
		if(chose == 1)//通常対戦選択時
		{
			g.drawImage(m_imgAllow, 75, 90);
		}
		else if(chose == 2)//CPU対戦
		{
			g.drawImage(m_imgAllow, 51, 114);
		}
		else if(chose == 3)//ハンデモード
		{
			g.drawImage(m_imgAllow, 63, 138);
		}
		else if(chose == 4)//成績表示
		{
			g.drawImage(m_imgAllow, 75, 162);
		}
		else if(chose == 5)//ヘルプ
		{
			g.drawImage(m_imgAllow, 81, 186);
		}
		g.unlock(true);//鍵解除
	}

	
//	------------------------------------------------------------------  
//	 drawClear  
//	  
//	 勝敗判定描画処理
//	------------------------------------------------------------------
	public void drawClear(Graphics g){
		g.lock();//鍵をかける
		
		

		
		if(m_blackReversi > m_whiteReversi)//黒が白より多ければ
		{
			g.drawImage(m_imgWin, 56, 106);//勝利
		}
		else if(m_blackReversi < m_whiteReversi)//白が黒より多ければ
		{
			g.drawImage(m_imgLose, 56, 106);//負け
		}
		else//それ以外（白黒同数）
		{
			g.drawImage(m_imgDraw, 86, 106);//引き分け
		}
		
		g.unlock(true);//鍵解除
	}

	
//	------------------------------------------------------------------  
//	 reversiScore  
//	  
//	 スコア描画処理
//	------------------------------------------------------------------
	public void reversiScore(Graphics g){


			
		g.lock();//鍵をかける
		
		//黒スコア
		//1桁目
		for(int i=0; i<10; i++)
		{
			if(m_blackReversi%10 == i)
			{
				g.drawImage(m_imgScore[i], 25, 205);
			//	g.unlock(true);
			}
		}
		//2桁目
		for(int i=1; i<10; i++){
			if(m_blackReversi<(i*10) && m_blackReversi>=((i-1)*10)){
				g.drawImage(m_imgScore[i-1], 15, 205);
				//g.unlock(true);
			}
		}

		//白スコア
		//1桁目
		for(int i=0; i<10; i++)
		{
			if(m_whiteReversi%10 == i)
			{
				g.drawImage(m_imgScore[i], 230, 205);
				//g.unlock(true);
			}
		}
		//2桁目
		for(int i=1; i<10; i++){
			if(m_whiteReversi<(i*10) && m_whiteReversi>=((i-1)*10)){
				g.drawImage(m_imgScore[i-1], 220, 205);
				//g.unlock(true);
			}
		}

		g.unlock(true);//鍵解除
	}
	

//	------------------------------------------------------------------  
//	 reversiPaint  
//	  
//	 パネルを描画する
//	------------------------------------------------------------------
	public void reversiPaint(Graphics g) {
		g.lock();//鍵をかける
		
		g.drawImage(m_imgBoard,   36, 58);//マス表示
		g.drawImage(m_imgFirst,    0, 55);  //先手表示
		g.drawImage(m_imgSecond, 204, 55);//後手表示
		
		//画面ピース描画処理
		for(int i=0; i<m_reversiCnt ;i++)
		{
			for(int j=0; j<m_reversiCnt ;j++)
			{
				//ピース描画処理
				m_reversiPiece[i][j].paint(g);
			}
		}
		
		g.unlock(true);//鍵解除
	}

	
//	------------------------------------------------------------------  
//	 reversiReset  
//	  
//	 パネルをリセットする
//	------------------------------------------------------------------
	public void reversiReset(Graphics g) 
	{
		g.lock();//鍵をかける
		m_reversiPiece = new Piece[m_reversiCnt][m_reversiCnt];//まずセットする
		for(int i=0; i<m_reversiCnt; i++){
			for(int j=0; j<m_reversiCnt; j++){
				
				if(i+1==m_reversiCnt/2 && j+1==m_reversiCnt/2)//３　３
				{
					m_reversiPiece[i][j] = new Piece(REVERSI_CHOOSE,REVERSI_WHITE, 19, 19, i, j);
				}
				else if(i==m_reversiCnt/2 && j==m_reversiCnt/2)//４　４
				{
					m_reversiPiece[i][j] = new Piece(REVERSI_SPACE,REVERSI_WHITE, 19, 19, i, j);
				}
				else if(i==m_reversiCnt/2 && j+1==m_reversiCnt/2)//４　３
				{
					m_reversiPiece[i][j] = new Piece(REVERSI_SPACE,REVERSI_BLACK, 19, 19, i, j);
				}
				else if(i+1==m_reversiCnt/2 && j==m_reversiCnt/2)//３　４
				{
					m_reversiPiece[i][j] = new Piece(REVERSI_SPACE,REVERSI_BLACK, 19, 19, i, j);
				}
				else 
				{
				m_reversiPiece[i][j] = new Piece(REVERSI_SPACE,REVERSI_SPACE, 19, 19, i, j);
				}
			}
		}
		m_i = 3;//初期位置
		m_j = 3;
		m_reversiTurn = 0;//オセロ色を直す
		judgment(g, 0);
		g.unlock(true);//鍵解除

	}

	
//	------------------------------------------------------------------  
//	 processEvent  
//	  
//	 キー入力処理
//	------------------------------------------------------------------
	public void processEvent(int type, int param)
	{//キーを離した時に処理を行う
		if(type == Display.KEY_RELEASED_EVENT)
		{
			if(param==Display.KEY_UP     || param==Display.KEY_2)//上＆2
			{
				m_getKey = 1;
				System.out.println("上");
			}
			if(param==Display.KEY_DOWN   || param==Display.KEY_8)//下＆8
			{
				m_getKey = 2;
				System.out.println("下");
			}
			if(param==Display.KEY_LEFT   || param==Display.KEY_4)//左＆3
			{
				m_getKey = 3;
				System.out.println("左");
			}
			if(param==Display.KEY_RIGHT  || param==Display.KEY_6)//右＆6
			{
				m_getKey = 4;
				System.out.println("右");
			}
			if(param==Display.KEY_SELECT || param==Display.KEY_5)//決定＆5
			{
				m_getKey = 5;
				System.out.println("選択");
				if(m_vibrationFlag == 1)
				{
					PhoneSystem.setAttribute(
						    PhoneSystem.DEV_VIBRATOR , PhoneSystem.ATTR_VIBRATOR_ON);
				}
			}
			if(param==Display.KEY_SOFT2)//ソフトキー右
			{
				m_getKey = 6;
				System.out.println("");
			}
			if(param==Display.KEY_SOFT1)//ソフトキー左
			{
				m_getKey = 7;
				//ソフトキー(左)が押されたかどうか調べる
				if(m_musicFlag == 0){
					m_music.stop();//演奏ストップ
				} else {
					m_music.play();//演奏開始
				}
			}
		}
	}
	
//	------------------------------------------------------------------  
//	 gamekeyAction  
//	  
//	 オセロを動かすにあたって弾く処理
//	------------------------------------------------------------------
	public void gamekeyAction(int k, Graphics g)
	{
		g.lock();//鍵をかける
		if(k == 1)//上押したら
		{
			if(m_j == 0)//パネルの最上段は弾く
			{
				g.unlock(true);//鍵解除
				return;
			}
			else if(m_j != 0)
			{
				changeEria(m_reversiPiece[m_i][m_j], m_reversiPiece[m_i][m_j-1], g);
				m_j = m_j-1;//カーソルの位置を把握
				g.unlock(true);//鍵解除
				return;
			}
		}
		else if(k == 2)//下押したら
		{
			if(m_j == m_reversiCnt-1)//パネルの最下段は弾く
			{
				g.unlock(true);//鍵解除
				return;
			}
			else if(m_j != m_reversiCnt-1)
			{
				changeEria(m_reversiPiece[m_i][m_j], m_reversiPiece[m_i][m_j+1], g);
				m_j = m_j+1;//白の位置を把握する
				g.unlock(true);//鍵解除
				return;
			}
		}
		else if(k == 3)//左押したら
		{
			if(m_i == 0)//パネルの一番右は弾く
			{
				g.unlock(true);//鍵解除
				return;
			}
			else if(m_i != 0)
			{
				changeEria(m_reversiPiece[m_i][m_j], m_reversiPiece[m_i-1][m_j], g);
				m_i = m_i-1;//白の位置を把握する
				g.unlock(true);//鍵解除
				return;
			}
		}
		else if(k == 4)//右押したら
		{
			if(m_i == m_reversiCnt-1)//パネルの一番右は弾く
			{
				g.unlock(true);//鍵解除
				return;
			}
			else if(m_i != m_reversiCnt-1)
			{
				changeEria(m_reversiPiece[m_i][m_j], m_reversiPiece[m_i+1][m_j], g);
				m_i = m_i+1;//白の位置を把握する
				g.unlock(true);//鍵解除
				return;
			}
		}
		else if(k == 0)//何もしてないなら
		{
			g.unlock(true);//鍵解除
			return;
		}
		else if(k == 5)//オセロを置く
		{
			if(m_reversiPiece[m_i][m_j].reversiSet == REVERSI_OK)//置ける場所しか置けない
			{
				//SE鳴らす
				se(g);

				if(m_reversiTurn%2 == 0)//黒のパターン
				{
					m_reversiPiece[m_i][m_j].reversiSet = REVERSI_BLACK;
					setReversiColor(m_i, m_j, REVERSI_BLACK, g);
					m_reversiTurn++;
					judgment(g, 0);
				}
				else if(m_reversiTurn%2 != 0)//白パターン
				{
					m_reversiPiece[m_i][m_j].reversiSet = REVERSI_WHITE;
					setReversiColor(m_i, m_j, REVERSI_WHITE, g);
					m_reversiTurn++;
					judgment(g, 0);
				}
			}else
			//置けない場合
			
			g.unlock(true);//鍵解除
			return;
		}
		g.unlock(true);//鍵解除
		return;
	}
	
	
//	------------------------------------------------------------------  
//	 changeEria  
//	  
//	 現在位置を入れ替える処理
//	------------------------------------------------------------------
	public void changeEria(Piece one, Piece two, Graphics g){
		int tmp;
		g.lock();//鍵をかける
		
		tmp = one.id;
		one.id = two.id;
		two.id = tmp;
		
		//oneとtwoの表示位置を全て入れ替えた
		g.unlock(true);//鍵解除
	}//changeEria(終わり

	
//	------------------------------------------------------------------  
//	 cpuAI  
//	  
//	 CPUの思考処理
//	------------------------------------------------------------------	
	public boolean cpuAI(Graphics g){
		g.lock();//鍵をかける
		
		int partly = 0;//初期化
		int xi = 0;//初期化
		int yj = 0;//初期化
		
		for(int i=0; i<m_reversiCnt; i++)
		{
			for (int j=0; j<m_reversiCnt; j++)
			{
				if(m_reversiPiece[i][j].reversiSet == REVERSI_OK)
				{//置けるスペース発見
					if(partly < m_priority[i][j])
					{
						partly = m_priority[i][j];
						xi = i;
						yj = j;
					}
				}
			}
		}
		
		if(partly != 0)
		{	
			if(m_reversiTurn%2 == 0)
			{//黒のパターン
				m_reversiPiece[xi][yj].reversiSet = REVERSI_BLACK;
				setReversiColor(xi, yj, REVERSI_BLACK, g);
				m_reversiTurn++;
				judgment(g, 0);
			}
			else if(m_reversiTurn%2 != 0)
			{//白パターン
				m_reversiPiece[xi][yj].reversiSet = REVERSI_WHITE;
				setReversiColor(xi, yj, REVERSI_WHITE, g);
				m_reversiTurn++;
				judgment(g, 0);
			}
		}
		
		g.unlock(true);//鍵解除	
		return true;//おいたと返す
	}//CPU終わり
	

//	------------------------------------------------------------------  
//	 judgment 
//	  
//	 オセロが置けるか判定
//	------------------------------------------------------------------
	public boolean judgment(Graphics g, int passScore){
		g.lock();//鍵をかける
		int x = 0;//置ける箇所がいくつか判定
		
		//盤面のオセロの数をリセット
		m_blackReversi = 0;
		m_whiteReversi = 0;
		
		for(int i=0; i<m_reversiCnt; i++){
			for (int j=0; j<m_reversiCnt; j++){
				if(m_reversiPiece[i][j].reversiSet == REVERSI_OK)
				{//置ける場所リセット
					m_reversiPiece[i][j].reversiSet = REVERSI_SPACE;
				}
				if(m_reversiPiece[i][j].reversiSet == REVERSI_SPACE)
				{//何も置いてなければ
					if(sixway(i, j, m_reversiTurn%2, g) == true)
					{//６方向探索開始
						m_reversiPiece[i][j].reversiSet = REVERSI_OK;
						x++;//一個置けたら追加
					}
				}
				if(m_reversiPiece[i][j].reversiSet == REVERSI_BLACK)
				{
					m_blackReversi++;
				}
				else if (m_reversiPiece[i][j].reversiSet == REVERSI_WHITE)
				{
					m_whiteReversi++;
				}
			}
		}
		
		if(x==0 && passScore==0)
		{//もし一つも置けなかったら、盤面が全部埋まっているかもしれない
			//盤面のオセロの数をリセット
			m_blackReversi = 0;
			m_whiteReversi = 0;
			
			for(int i=0; i<m_reversiCnt; i++)
			{
				for (int j=0; j<m_reversiCnt; j++)
				{
					if(m_reversiPiece[i][j].reversiSet == REVERSI_SPACE)
					{//置けるスペース発見
						m_reversiTurn++;//パスする
						judgment(g, 1);//もう一度判定する
						g.unlock(true);//鍵解除		
						return true;//まだ試合続行
					}
					else if(m_reversiPiece[i][j].reversiSet == REVERSI_BLACK)
					{
						m_blackReversi++;
					}
					else
					{
						m_whiteReversi++;
					}
				}
			}
			g.unlock(true);//鍵解除	
			m_screen = SCREEN_CLEAR;//盤面全部埋まって試合終了
		}
		else if(x==0 && passScore==1)
		{//さっきのターンもおけずに、今回も置けない場合
			g.unlock(true);//鍵解除	
			m_screen = SCREEN_CLEAR;//盤面は埋まってないが、置く場所がなくて試合終了
		}
		
		g.unlock(true);//鍵解除		
		return true;//置けると返す
	}//judgment終わり
	
	
//	------------------------------------------------------------------  
//	 sixway 
//	  
//	 オセロが置けるか判定する6方向処理
//	------------------------------------------------------------------
	public boolean sixway(int geni, int genj, int color,Graphics g){
		g.lock();//鍵をかける
		int otherColor;

		if(color == REVERSI_WHITE)
		{
			otherColor = REVERSI_BLACK;
		}
		else 
		{
			otherColor = REVERSI_WHITE;
		}
		
		for(int x=-1; x<=1; x++)
		{
			for(int y=-1; y<=1; y++)
			{
				if((x==0 && y==0) || (x+geni < 0) || (x+geni >= m_reversiCnt) || (y+genj < 0) || (y+genj >= m_reversiCnt))
				{//壁外に出たら弾く	
				}
				else if(m_reversiPiece[x+geni][y+genj].reversiSet == otherColor)
				{//一個目の色が対色か
					if(bearing(x, y, 2, geni, genj, color, g) == true)
					{//探索
						g.unlock(true);//鍵解除		
						return true;//置けると返す
					}
				}
			}
		}//６方向探索
		g.unlock(true);//鍵解除		
		return false;//置けないと返す
	}//judgment終わり
	
//	------------------------------------------------------------------  
//	 bearing 
//	  
//	 オセロが置けるか判定する再帰用関数
//	------------------------------------------------------------------
	public boolean bearing(int mi, int mj, int kaisuu, int geni, int genj, int color, Graphics g){
		g.lock();//鍵をかける
		int x = (mi*kaisuu)+geni;
		int y = (mj*kaisuu)+genj;
		
		if((x<0) || (y<0) || (x>=m_reversiCnt) || (y>=m_reversiCnt) || (m_reversiPiece[x][y].reversiSet==REVERSI_OK) 
				|| (m_reversiPiece[x][y].reversiSet==REVERSI_SPACE))
		{//壁にあたった　置けない
			g.unlock(true);//鍵解除		
			return false;//置けないと返す
		}
		else if(m_reversiPiece[x][y].reversiSet == color)
		{//自分が置く色と同じ色　発見　置ける
			g.unlock(true);//鍵解除		
			return true;//置けると返す
		}
		else
		{//さらに深く探索
			if(bearing(mi, mj, kaisuu+1, geni, genj, color, g) == true)
			{
				g.unlock(true);//鍵解除		
				return true;//置けると返す
			}
		}
		g.unlock(true);//鍵解除		
		return false;//置けないと返す
	}//
    
	
//	------------------------------------------------------------------  
//	 setReversiColor 
//	  
//	 オセロを置いたときの色変え処理
//	------------------------------------------------------------------
	public boolean setReversiColor(int geni, int genj, int color, Graphics g){
		g.lock();//鍵をかける
		int otherColor;

		if(color == REVERSI_WHITE)
		{
			otherColor = REVERSI_BLACK;
		}
		else
		{
			otherColor = REVERSI_WHITE;
		}
		
		for(int x=-1; x<=1; x++)
		{
			for(int y=-1; y<=1; y++)
			{
				if((x==0 && y==0) || (x+geni<0) || (x+geni>=m_reversiCnt) || (y+genj<0) || (y+genj>=m_reversiCnt))
				{//壁外に出たら弾く	
				}
				else if(m_reversiPiece[x+geni][y+genj].reversiSet == otherColor)
				{//一個目の色が対色か
					revaseway(x, y, 2, geni, genj, color, g);
				}
			}
		}//８方向探索
		g.unlock(true);//鍵解除		
		return false;//置けないと返す
	}//judgment終わり
	

//	------------------------------------------------------------------  
//	 revaseway 
//	  
//	 オセロを置いたときの反転再帰用関数
//	------------------------------------------------------------------
	public boolean revaseway(int mi, int mj, int kaisuu, int geni, int genj, int color, Graphics g){
		g.lock();//鍵をかける
		int x = (mi*kaisuu)+geni;
		int y = (mj*kaisuu)+genj;
		if((x<0) || (y<0) || (x>=m_reversiCnt) || (y>=m_reversiCnt) || (m_reversiPiece[x][y].reversiSet==REVERSI_OK) || (m_reversiPiece[x][y].reversiSet==REVERSI_SPACE))
		{//壁にあたった　外れ
			g.unlock(true);//鍵解除		
			return false;//置けないと返す
		}
		else if(m_reversiPiece[x][y].reversiSet == color)
		{//自分が置く色と同じ色　発見　置ける
			for(int q=1; q<kaisuu; q++)
			{
				for(int p=1; p<kaisuu; p++)
				{
					if(q == p)
					{//ｐとｑが同じときのみ
						m_reversiPiece[geni+(q*mi)][genj+(p*mj)].reversiSet = color;
					}
				}
			}
			g.unlock(true);//鍵解除
			return true;//置けると返す
		}
		else{//さらに深く探索
			if(revaseway(mi, mj, kaisuu+1, geni, genj, color, g) == true)
			{
				g.unlock(true);//鍵解除		
				return true;//置けると返す
			}
		}	
		g.unlock(true);//鍵解除
		return false;//置けないと返す
	}//反転再帰用関数終わり
    
	
//	------------------------------------------------------------------  
//	 Piece 
//	  
//	 パネル画像のオブジェクトクラス
//	------------------------------------------------------------------
	class Piece extends Object 
	{
		//オセロ　の指定位置
		private int id;
		//オセロの色
		private int reversiSet;
		//ピースのサイズ
		private int lPiceXSize;
		private int lPiceYSize;
		//現在の位置
		private int prei;
		private int prej;
		
		//コンストラクタ
		public Piece(int iD, int reversi, int intXSize, int intYSize, int pi, int pj){
			this.id = iD;
			this.reversiSet = reversi;
			this.lPiceXSize = intXSize;
			this.lPiceYSize = intYSize;
			this.prei = pi;
			this.prej = pj;
		}
		
		public void paint(Graphics g){
			g.lock();
			if(reversiSet == REVERSI_WHITE)
			{//白
				g.drawImage(m_imgWhite, 35+prei*lPiceXSize+(19/2), 48+prej*lPiceYSize+(lPiceYSize/2)+(19/2));
			}
			else if(reversiSet == REVERSI_BLACK)
			{//黒
				g.drawImage(m_imgBlack, 35+prei*lPiceXSize+(19/2), 48+prej*lPiceYSize+(lPiceYSize/2)+(19/2));
			}
			else if(reversiSet == REVERSI_OK)
			{//置ける
				if(m_screen != SCREEN_CPUGAME)
				{
					if(m_screen == SCREEN_NOMALGAME)
					{
						if(m_reversiTurn%2 == 0)
						{
							g.drawImage(m_imgRed, 35+prei*lPiceXSize+(19/2), 48+prej*lPiceYSize+(lPiceYSize/2)+(19/2));
						}		
					}
					else if(m_screen == SCREEN_VSGAME)
					{
						g.drawImage(m_imgRed, 35+prei*lPiceXSize+(19/2), 48+prej*lPiceYSize+(lPiceYSize/2)+(19/2));	
					}
				}
			}
			
			if(id == REVERSI_CHOOSE)
			{//オセロの指定座標位置に居る場合
				if(m_screen == SCREEN_NOMALGAME)
				{
					if(m_reversiTurn%2 == 0)
					{
						g.setColor( g.getColorOfName(Graphics. RED) );//赤を定義
						g.drawRect(prei*lPiceXSize+43, prej*lPiceYSize+65, lPiceXSize,lPiceYSize);//赤のふちを描画
					}
				}
				else if(m_screen == SCREEN_VSGAME)
				{
					g.setColor( g.getColorOfName(Graphics. RED) );//赤を定義
					g.drawRect(prei*lPiceXSize+43,prej*lPiceYSize+65, lPiceXSize, lPiceYSize);//赤のふちを描画
				}
			}
			
			//どちらのターン中かを表示

			if(m_reversiTurn%2 == 0)
			{//黒（先手）
				g.drawImage(m_imgTurn, 6, 140);
			}
			else
			{//白（後手）
				g.drawImage(m_imgTurn, 210, 140);
			}
		}//paint終わり
		
	}
	
//	------------------------------------------------------------------  
//	 se 
//	  
//	 効果音の処理
//	------------------------------------------------------------------
	public void se(Graphics g){
		g.lock();
		//効果音のファイル読み込み
		MediaSound se = MediaManager.getSound("resource:///SE_01.mld");
		//効果音の優先度はBGMよりも高い値に設定しておく
		m_musicSE.setAttribute(AudioPresenter.PRIORITY, 10);
		try{
			se.use();
		} catch (ConnectionException ce) 
		{
			//入力の例外処理
			se = null;
		} catch (UIException uie) 
		{
			//ＵＩの例外処理
			se = null;
		}

		//音楽を演奏させるオブジェクトに読み込んだ音楽ファイルを設定
		m_musicSE.setSound(se);
		//SEの音量を設定(BGMより高い値にする）
		m_musicSE.setAttribute(AudioPresenter.SET_VOLUME, 100); 
		//演奏の開始
		if(m_musicFlag == 0)
		{//音フラグがオンになっていれば
			m_musicSE.play();
		}
		g.unlock(true);
	}//効果音終わり
}