シューティングゲーム作成ノート

言語村　トップページ

作成ノートトップページ

シューティングゲーム全ソース

シューティングゲームで使っている全ソースです。
JavaAppletです。
ソースは好きに使って頂いて、一向に構いません。
解析するなり改造するなり好き勝手に使ってください。

ただし、自分でも解析するのにホネが折れるほど
ぐちゃぐちゃになってます。
特に、このころはまだポインタの概念を知らなかったので
変数がメモリをどう使っているか理解していませんでした。
Applet型の変数を多数宣言すればメモリが圧迫されると
勘違いしていたので、変数の使い方が変です。
特にgameクラス部分はStatic宣言を乱発しています。

このままでは見難いので、コピーして
テキストエディタやメモ帳などで見てください。

HTML部分

<html>
<head>
<title>Game</title>
<body>
<body bgcolor="#ffffff">
<applet code="game.class" width="300" height="400">
<!-- for non-Applet Browser -->
<p>このゲームはJavaが動くブラウザでお楽しみいただけます。</p>
</applet>
</body>
</html>

Java部分

import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.text.DecimalFormat;


//*******************************************************************************
//	gameクラス（メインルーチン）
//*******************************************************************************
public class game extends java.applet.Applet implements Runnable, KeyListener, MouseListener {
	
	static int score = 0;	// スコア
	int hi_score = 0;		// ハイスコア
	static int zan = 0;			// 残機数
	static int tuika = 0;		// １機増える点数
	static int syuu = 0;			// 周回
	int speed = 50;			// スレッドの停止時間
	boolean start = false;			// ゲーム中かどうかのフラグ
	
	Thread kicker = null;	// スレッド
	static Dimension d;		// 画面サイズ取得用
	DecimalFormat scFormat = new DecimalFormat("0000000000");	// スコア表示用数字フォーマット
	
	Image offscreen;		// オフスクリーン;
	Graphics off_g;
	
	MediaTracker mt;
	Image myShip[] = new Image[3];				// 自機の絵
	byte tekiPictNum = 8;						// 敵の絵の数
	Image tekiShip[] = new Image[tekiPictNum];	// 敵の絵
	static Image bakuhatu[] = new Image[2];		// 爆発の絵
	
	static AudioClip acShoot;	// 弾発射音
	static AudioClip acHit;		// ヒット音
	static AudioClip acBom;		// 爆発音
	static AudioClip acTuika;		// １機追加音
	
	Stars stars;		// 星オブジェクト
	Ship ship;			// 自機オブジェクト
	NowKey nowKey;		// キー入力管理オブジェクト
	Shoot shoot;		// 自機の弾管理クラス
	TekiControl tekiControl;	// 敵コントロールクラス
	Shoot_t shoot_t;			// 敵の弾管理クラス
	
	
	// -------------------------------------------------------------
	// 初期設定
	//--------------------------------------------------------------
	public void init() {
		
		int i;
		
		mt = new MediaTracker(this);
		// イメージファイルの読み込み
		for( i = 0; i < 3; i++ ){
			myShip[i] = getImage(getCodeBase(), "ship" + (i) + ".gif");
			mt.addImage(myShip[i], 0);
		}
		for( i = 0; i < 2; i ++ ) {
			bakuhatu[i] = getImage(getCodeBase(), "gekiha" + (i) + ".gif");
			mt.addImage(bakuhatu[i], 0);
		}
		for( i = 0; i < tekiPictNum; i++ ) {
			tekiShip[i] = getImage(getCodeBase(), "teki" + (i) + ".gif");
			mt.addImage(tekiShip[i], 1);
		}
		
		// オーディオファイルの読み込み
		acShoot = getAudioClip(getDocumentBase(), "shoot.wav");
		acHit = getAudioClip(getDocumentBase(), "hit.wav");
		acBom = getAudioClip(getDocumentBase(), "bom.wav");
		acTuika = getAudioClip(getDocumentBase(), "tuika.mid");
		
		// オフスクリーンの設定
		d = getSize(); // 画面サイズ取得
		offscreen = createImage( d.width, d.height );
		off_g = offscreen.getGraphics();
		off_g.setFont( new Font( "TimesRoman", Font.BOLD, 11 ) );
		
		// オブジェクト作成
		stars = new Stars( off_g );
		ship = new Ship( off_g, myShip );
		nowKey = new NowKey();
		shoot = new Shoot( off_g );
		tekiControl = new TekiControl( off_g, tekiShip, ship );
		shoot_t = new Shoot_t( off_g );
		
		addKeyListener(this); // キーリスナをアップレットに登録
		requestFocus(); // キー入力のフォーカスをセット
		addMouseListener(this); // マウスリスナをアプレットに登録
	}
	
	//-----------------------------------------------------
	// ゲーム開始時の初期設定
	//-----------------------------------------------------
	public void gameStart() {
		//変数の初期化
		if ( score > hi_score ) {
			hi_score = score;
		}
		score = 0;
		zan = 3;
		tuika = 100000;
		syuu = 0;
		start = true;
		Scenario.clearPointer(); // シナリオのクリア
		ship.setNew(); // 自機の初期化
	}
	
	//--------------------------------------------------------------
	// 描画関係
	//--------------------------------------------------------------
	public void paint(Graphics g) {
		update(g);
	}
	//---------------------------------------------------------------
	public void update(Graphics g) {
		
		// イメージ読み込み時のメッセージ表示
		if ( !mt.checkAll() ) {
			g.clearRect(0, 0, d.width, d.height);
				if ( !mt.checkID(0) ) {
					g.drawString("Now MyShip Loading....", d.width/4, d.height/2);
				} else if( !mt.checkID(1) ) {
					g.drawString("Now Enemy Loading.....", d.width/4, d.height/2);
				}
			return;
		}
		
		// 背景を黒くする
		off_g.setColor(Color.black);
		off_g.fillRect( 0, 0, d.width, d.height );
		
		// 星の描画
		stars.drawStars();
		
		if ( start ) {
			// ゲーム中の処理
			// 敵を動かし描画する
			tekiControl.move();
			// 敵の弾を動かし描画する
			shoot_t.move();
			// 自機の弾を動かし描画する
			shoot.move();
			// 自機の描画
			ship.drawShip();
			
		} else {
			// ゲームオーバーの表示
			gameOver();
		}
		// スコアの表示
		off_g.setColor(Color.white);
		off_g.drawString("HI_SCORE:" + scFormat.format( hi_score), 12, 12 );
		off_g.drawString("SCORE:" + scFormat.format( score), 160, 12 );
		off_g.setColor(Color.pink);
		off_g.drawString("SHIP:" + zan, 200,395);
		
		// オフスクリーンを表示
		g.drawImage( offscreen, 0, 0, this);
	}
	
	//------------------------------------------------------------------
	// スレッド関係
	//------------------------------------------------------------------
	public void start() {
		if ( kicker == null ) {
			// スレッドの実行
			kicker = new Thread(this);
			kicker.start();
		}
	}
	// ----------------------------------------------------------------
	public void stop() {
		// スレッドを止める
		kicker = null;
		// オーディオを止める
		if ( acShoot != null ){
			acShoot.stop();
		}
		if ( acHit != null ) {
			acHit.stop();
		}
		if ( acBom != null ) {
			acBom.stop();
		}
		if ( acTuika != null ) {
			acTuika.stop();
		}
	}
	// -----------------------------------------------------------------
	public void run() {
		
		// イメージがすべて読み込まれるまで待つ
		try {
			mt.waitForAll();
		} catch (InterruptedException e) {
			return;
		}
		
		
		// 実行中のスレッドをチェック
		Thread thisThread = Thread.currentThread();
		
		while ( kicker == thisThread ) {
			
			// 星を動かす
			stars.starMove();
			if ( start ) {
				// ゲーム中の処理
				if ( ship.getState() == 0 ) {
					// 準備画面
					ready();
				}
				// 自機を動かす
				ship.moveShip(nowKey);
				// 自機の弾を発射するかチェックする
				shoot.hassyaCheck( nowKey, ship );
				// 敵を出現させるかチェックする
				tekiControl.tekiCheck();
				// 敵の弾を出現させるかチェックする
				shoot_t.hassyaCheck();
				
				repaint();
				
				// 当たり判定
				hantei( ship, shoot, tekiControl, shoot_t );
				
			} else {
				repaint();
			}
			
			try {
				thisThread.sleep(speed);
			} catch (InterruptedException e) {
			}
		}
	}
	
	//-------------------------------------------------------
	// キー関係
	//-------------------------------------------------------
	public void keyPressed(KeyEvent e) {
		nowKey.keyPressed( e );
	}
	public void keyReleased(KeyEvent e) {
		nowKey.keyReleased( e );
	}
	public void keyTyped(KeyEvent e) {
	}
	
	//-------------------------------------------------------
	// マウス関係
	//-------------------------------------------------------
	public void mousePressed(MouseEvent e) {
		if ( !start ) {
			// ゲーム中で無いときにスタートボタンの位置だったらゲームスタート
			int mouseX = e.getX();
			int mouseY = e.getY();
			if ( mouseX > 100 && mouseX < 200 && mouseY > 260 && mouseY < 310 ) {
				gameStart();
			}
		}
	}
	public void mouseReleased(MouseEvent e) {
	}
	public void mouseClicked(MouseEvent e) {
	}
	public void mouseEntered(MouseEvent e) {
	}
	public void mouseExited(MouseEvent e) {
	}
	
	//------------------------------------------------------
	// 当たり判定関数
	//------------------------------------------------------
	public void hantei( Ship ship, Shoot shoot, TekiControl tekiControl, Shoot_t shoot_t ) {
		int i,j;
		int size; // 敵の大きさの取得用
		int ax,ay,bx,by; // 判定するX,Y座標
		
		// 敵をチェック
		for ( i = 0; i < tekiControl.maxTekisuu; i++ ) {
			if ( tekiControl.getState( i ) == 1 ) {
				// 敵の情報の取得
				size = tekiControl.teki[i].getSize();
				ax = tekiControl.teki[i].getX();
				ay = tekiControl.teki[i].getY();
				// 自機の弾とのチェック
				for ( j = 0; j < shoot.rensha; j++ ) {
					if ( shoot.getState( j ) ) {
						// 自機の弾のX,Y座標を取得
						bx = shoot.myMissile[j].getX();
						by = shoot.myMissile[j].getY();
						// 当たり判定
						if ( ax+size > bx && ax < bx+32 && ay+size > by && ay < by+32 ) {
							// 当たり処理
							tekiControl.setState( i, (byte)2 );
							shoot.setState( j, false );
							acHit.play();		// ヒット音を出す
							break;
						}
					}
				}
				// 自機とのチェック
				if ( ship.getState() == 1 && ax+size > ship.getX()+8 && ax < ship.getX()+24 && ay+size > ship.getY()+8 && ay < ship.getY()+24 ) {
					// 当たり処理
					ship.setState( (byte)2 );
					acBom.play();		// 爆発音を出す
					// シナリオを５つ巻き戻す
					Scenario.revPointer( 5 );
				}
			}
		}
		
		// 敵の弾をチェック
		for ( i =0; i < shoot_t.hassya; i++ ) {
			if ( shoot_t.getState( i ) ) {
				// 敵の弾のX,Y座標を取得
				ax = shoot_t.tekiMissile[i].getX();
				ay = shoot_t.tekiMissile[i].getY();
				// 自機とのチェック
				if ( ship.getState() == 1 && ax+8 > ship.getX()+8 && ax < ship.getX()+24 && ay+8 > ship.getY()+8 && ay < ship.getY()+24 ) {
					// 当たり処理
					ship.setState( (byte)2 );
					acBom.play();		// 爆発音を出す
					// シナリオを５つ巻き戻す
					Scenario.revPointer( 5 );
				}
			}
		}
	}
	
	//-------------------------------------------------------
	// 準備画面作成関数
	//-------------------------------------------------------
	public void ready() {
		// 残機を減らす
		zan--;
		
		int i;
		// 敵と弾を消して画面外に出す
		for ( i = 0; i < tekiControl.maxTekisuu; i++ ) {
			tekiControl.setState( i, (byte)0 );
			tekiControl.teki[i].setX(game.d.width + 32);
			tekiControl.teki[i].setY(game.d.height + 32);
		}
		for ( i = 0; i < shoot.rensha; i++ ) {
			shoot.setState( i, false );
			shoot.myMissile[i].setMissile(-32,-32);
		}
		for ( i = 0; i < shoot_t.hassya; i++ ) {
			shoot_t.setState( i, false );
			shoot_t.tekiMissile[i].setMissile(game.d.width + 32, game.d.height + 32 );
		}
		// 敵の出現を遅らす
		tekiControl.setWait( 0, 40 );
		if ( zan < 0 ) {
			// ゲームオーバー
			zan = 0;
			start = false;
			gameOver();
		} else {
			// 自機を初期状態にする
			ship.setState( (byte)1 );
			ship.setNew();
		}
	}
	
	//-------------------------------------------------------
	// ゲームオーバー表示関数
	//-------------------------------------------------------
	public void gameOver() {
		off_g.setColor(Color.white);
		off_g.drawString("G a m e   O v e r", 108, 200);
		if (score > hi_score) {
			// ハイスコア時の表示
			off_g.setColor(Color.orange);
			off_g.drawString("HighScore!!", 116, 215);
		}
		off_g.setColor(Color.white);
		off_g.drawString("Click  START  Button", 95, 250);
		// スタートボタン
		off_g.setColor(Color.gray);
		off_g.fillRoundRect( 100, 260, 100, 50, 20, 20);
		off_g.setColor(Color.black);
		off_g.drawString("START", 130, 290);
	}
}



//**********************************************************************
// Shipクラス（自機オブジェクト）
//**********************************************************************
class Ship {
	
	private int x,y;			// 自機のX,Y座標
	private int pictNo;			// 使用する自機の絵の番号
	private static int margin = 5;		// 余白
	private int step = 8;		// 自機の移動量
	private int maxX;			// 最大X座標
	private int maxY;			// 最大Y座標
	private Image myShip[];		// 自機の絵
	private byte state;			// 自機の状態(0準備中 1正常 2～撃破)
	
	private Graphics ship_g;// オフスクリーン
	
	//-------------------------------------------------------
	//コンストラクタ	g オフスクリーン
	//					image 自機の絵
	//-------------------------------------------------------
	Ship ( Graphics g, Image image[]  ) {
		
		maxX = game.d.width; // 画面の最大幅、高さの取得
		maxY = game.d.height;
		ship_g = g;
		myShip = image;
		
		// 初期位置＆初期イメージの設定
		x = (maxX / 2) - 16;
		y = maxY - (margin + 32 );
		state = 0;
		pictNo = 0;
	}
	
	
	//--------------------------------------------
	// 自機を表示する関数
	//--------------------------------------------
	void drawShip() {
		// 自機の状態をチェック
		if ( state <= 1 ) {
			// 通常表示
			ship_g.drawImage( myShip[pictNo], x, y, null );
		// 撃破
		} else {
			pictNo = state % 2;
			ship_g.drawImage( game.bakuhatu[pictNo], x, y, null );
		}
	}
	//---------------------------------------------
	// 自機を動かす関数　nowKey キー入力オブジェクト
	//---------------------------------------------
	void moveShip(NowKey nowKey) {
		
		// 自機の状態をチェック
		if ( state == 1 ) {
			pictNo = 0;
			
			// キー入力状態により、Shipの座標を変更する
			if ( nowKey.getKey(NowKey.up) ) {
				if ( y >= margin + step + 12 ) {
					y -= step;
				}
			}
			if ( nowKey.getKey(NowKey.down) ) {
				if ( y <= maxY - (margin + step + 32) ) {
					y += step;
				}
			}
			if ( nowKey.getKey(NowKey.right) ) {
				if ( x <= maxX - (margin + step + 32) ) {
					x += step;
				}
				pictNo = 2;
			}
			if ( nowKey.getKey(NowKey.left) ) {
				if ( x >= margin + step ) {
					x -= step;
				}
				pictNo = 1;
			}
		} else {
			state++;
			if ( state >= 10 ) {
				state = 0;
			}
		}
	}
	
	//----------------------------------------------------
	// 自機のX,Y座標、状態を取得する関数
	//----------------------------------------------------
	int getX() {
		return x;
	}
	int getY() {
		return y;
	}
	int getState() {
		return state;
	}
	//---------------------------------------------------
	// 自機の状態をセットする関数
	//---------------------------------------------------
	void setState(byte i) {
		state = i;
	}
	//---------------------------------------------------
	// 自機を初期状態にする関数
	//---------------------------------------------------
	void setNew() {
		x = (maxX / 2) - 16;
		y = maxY - (margin + 32 );
		pictNo = 0;
	}
}



//*******************************************************************************
//Shootクラス（自機の弾を管理するオブジェクト）
//*******************************************************************************
class Shoot {
	
	static final int rensha = 5;	// 弾の最大連射数
	private boolean state[];		// 弾の使用状態 true = 使用中
	private int count;				// 使用する弾の順番
	private boolean spaceFlag;		// スペースキー連打を制御するフラグ
	Missile myMissile[];	// Missileオブジェクト
	
	private Graphics off_g;			// オフスクリーン
	
	//----------------------------------------------
	//コンストラクタ　g オフスクリーン
	//----------------------------------------------
	Shoot(Graphics g) {
		state = new boolean[rensha];
		myMissile = new Missile[rensha];
		
		for( int i = 0; i < rensha; i++ ) {
			state[i] = false;
			myMissile[i] = new Missile();
		}
		
		count = 0;
		spaceFlag = false;
		off_g = g;
	}
	
	//-----------------------------------------------
	// 弾を発射させる関数　nowKey キー入力オブジェクト
	//								ship 自機	acShoot 発射音
	//-----------------------------------------------
	void hassyaCheck(NowKey nowKey, Ship ship) {
		// 連打のチェック
		if (spaceFlag) {
				// 前回ボタンが押されていた
			if ( !nowKey.getKey( NowKey.space ) ) {
				// 今は押されていない場合はボタン入力を許可する
				spaceFlag = false;
				return;
			} else {
				return;
			}
		}
		if ( nowKey.getKey( NowKey.space ) ) {
			// 連打を禁止
			spaceFlag = true;
			
			// 弾が使用可能かどうかのチェック
			for( int i = 0; i < rensha; i++ ) {
				count++;
				if ( count >= rensha ) {
					count = 0;
				}
				if ( !state[count] ) {
					break;
				}
			}
			
			if ( state[count] ) {
				// 全弾使用中だった時
				return;
			}
			// 弾を発射させる
			state[count] = true;
			myMissile[count].setMissile( ship.getX(), ship.getY() );
			game.acShoot.play();	// 弾発射音を鳴らす
		}
	}
	
	//----------------------------------------------------
	// 使用中の弾を動かし、描画する
	//----------------------------------------------------
	void move() {
		for( int i = 0; i < rensha; i++ ) {
			if ( state[i] ) {
				// 弾が使用中の処理
				if ( myMissile[i].getY() <= 32 ) {
					// 弾が一番上まで行った時の処理
					state[i] = false;
				} else {
					// 弾を上に動かす
					myMissile[i].setMissile( myMissile[i].getY() - 32 );
					myMissile[i].drawMissile( off_g );
				}
			}
		}
	}
	
	//---------------------------------------------------
	// 弾の状態を取得、セットする関数
	//---------------------------------------------------
	boolean getState( int i ) {
		return state[i];
	}
	void setState( int i, boolean j ) {
		state[i] = j;
	}
}



//***************************************************
//Missileクラス(自機の弾を描画するオブジェクト）
//***************************************************
class Missile {
	
	private int x, y;			// 弾のX,Y座標
	
	//--------------------------------------------
	// コンストラクタ
	//--------------------------------------------
	Missile() {
	}
	
	//--------------------------------------------
	// 弾をセットする関数
	//--------------------------------------------
	void setMissile(int mx, int my) {
		x = mx;
		y = my;
	}
	void setMissile(int my) {
		y = my;
	}
	
	//-------------------------------------------
	// 弾のX,Y座標を取得する関数
	//-------------------------------------------
	int getX() {
		return x;
	}
	int getY() {
		return y;
	}
	
	//-------------------------------------------
	// 弾を描画する関数　g オフスクリーン
	//-------------------------------------------
	void drawMissile(Graphics g) {
		g.setColor(Color.yellow);
		g.fillRect( x + 8, y, 2, 16 );
		g.fillRect( x + 24,y, 2, 16 );
	}
	
}




//***************************************************
//	Starsクラス（星関係オブジェクト）30個の星を描く
//***************************************************
class Stars {
	
	
	private int x[] = new int[30]; // 星のX座標
	private int y[] = new int[30]; // 星のY座標
	private int starSpeed[] = new int[30]; // 星の移動量
	private int starColorFlag[] = new int[30]; // 星の点滅状態
	private int maxX; // 最大X座標
	private int maxY; // 最大Y座標
	
	private Graphics star_g; // オフスクリーン
	
	//----------------------------------------------------------
	//コンストラクタ	 g オフスクリーン
	//----------------------------------------------------------
	Stars( Graphics g ) {
		
		maxX = game.d.width;
		maxY = game.d.height;
		
		for( int i = 0; i < 30; i++ ) {
			// 星の初期設定
			x[i] = (int)(Math.random() * maxX);
			y[i] = (int)(Math.random() * maxY);
			starColorFlag[i] = (int)(Math.random() * 30 );
			
			switch ( i % 4 ) {
				case 0:
					starSpeed[i] = 1;
					break;
				case 1:
					starSpeed[i] = 2;
					break;
				case 2:
					starSpeed[i] = 3;
					break;
				case 3:
					starSpeed[i] = 4;
					break;
			}
			
		}
		star_g = g;
	}
	
	
	//------------------------------------------
	//	星を動かす関数
	//------------------------------------------
	void starMove() {
		
		for ( int i = 0; i < 30; i++ ) {
			
			y[i] += starSpeed[i];
			
			if ( y[i] > maxY ) {
				y[i] = 0;
				x[i] = (int)(Math.random() * maxX);
			}
		}
	}
	
	
	//----------------------------------------
	//星をオフスクリーンに描画する関数
	//----------------------------------------
	void drawStars() {
		
		for ( int i = 0; i < 30; i++ ) {
			
			starColorFlag[i]++;
			if ( starColorFlag[i] >= 30 ) {
				starColorFlag[i] = 0;
			}
			
			if ( starColorFlag[i] == 28 || starColorFlag[i] == 29 ) {
				star_g.setColor(Color.black);
			} else {
				star_g.setColor(Color.white);
			}
			
			star_g.fillRect( x[i], y[i], 2, 2 );
		}
	}
}



//*******************************************************
// NowKeyクラス（アプレットのキーイベント情報を管理）
//*******************************************************
class NowKey {
	
	// 各キーの入力判定変数
	private boolean upKey;
	private boolean downKey;
	private boolean rightKey;
	private boolean leftKey;
	private boolean spaceKey;
	
	// 定数の設定
	static final int up		= 0;
	static final int down	= 1;
	static final int right	= 2;
	static final int left	= 3;
	static final int space	= 4;
	
	//----------------------------------------------------
	//　コンストラクタ
	//----------------------------------------------------
	NowKey() {
		upKey		= false;
		downKey		= false;
		rightKey	= false;
		leftKey		= false;
		spaceKey	= false;
	}
	
	//----------------------------------------------------
	// keyPressed関数（どのキーが押されたかチェックする）
	//						e アプレットのキーイベント
	//----------------------------------------------------
	void keyPressed(KeyEvent e) {
		
		int key = e.getKeyCode(); // 押されたキーコードを取得
		
		if ( key == KeyEvent.VK_UP || key == KeyEvent.VK_NUMPAD8 ) {
			upKey = true;
		}
		if ( key == KeyEvent.VK_DOWN || key == KeyEvent.VK_NUMPAD2 ) {
			downKey = true;
		}
		if ( key == KeyEvent.VK_RIGHT || key == KeyEvent.VK_NUMPAD6 ) {
			rightKey = true;
		}
		if ( key == KeyEvent.VK_LEFT || key == KeyEvent.VK_NUMPAD4 ) {
			leftKey = true;
		}
		if ( key == KeyEvent.VK_SPACE ) {
			spaceKey = true;
		}
	}
	
	//----------------------------------------------------
	// keyReleased関数（どのキーが離されたかチェックする）
	//						e アプレットのキーイベント
	//----------------------------------------------------
	void keyReleased(KeyEvent e) {
		
		int key = e.getKeyCode(); // 離されたキーコードを取得
		
		if ( key == KeyEvent.VK_UP || key == KeyEvent.VK_NUMPAD8 ) {
			upKey = false;
		}
		if ( key == KeyEvent.VK_DOWN || key == KeyEvent.VK_NUMPAD2 ) {
			downKey = false;
		}
		if ( key == KeyEvent.VK_RIGHT || key == KeyEvent.VK_NUMPAD6 ) {
			rightKey = false;
		}
		if ( key == KeyEvent.VK_LEFT || key == KeyEvent.VK_NUMPAD4 ) {
			leftKey = false;
		}
		if ( key == KeyEvent.VK_SPACE ) {
			spaceKey = false;
		}
	}
	
	//---------------------------------------------------------
	// キーの入力状態を返す関数　key 入力状態を返すキーに
	//									対応した定数
	//---------------------------------------------------------
	boolean getKey(int key) {
		boolean ret = false;
		
		switch( key ) {
			case up:
				ret = upKey;
				break;
			case down:
				ret = downKey;
				break;
			case right:
				ret = rightKey;
				break;
			case left:
				ret = leftKey;
				break;
			case space:
				ret = spaceKey;
				break;
		}
		return ret;
	}
}


//----------------------------------------------------
// 敵コントロールクラス（敵全体を統括するクラス）
//----------------------------------------------------
class TekiControl {
	
	static final int maxTekisuu = 12; // 総敵数
	Teki teki[] = new Teki[maxTekisuu]; // 敵オブジェクト
	private byte state[] = new byte[maxTekisuu]; // 敵の状態(0未使用 1使用中 2攻撃を受けた 3撃破)
	static private int waitCount; // 待ち時間カウント
	private int tekiCount[] = new int[maxTekisuu]; // 敵の動いた回数
	private int obj;	// 使用するオブジェクト
	
	private Graphics off_g; // オフスクリーン
	private Image tekiShip[]; // 敵のイメージ
	
	
	static private int dataTeki, dataWait; // シナリオデータ取得用
	
	//--------------------------------------------------
	// コンストラクタ
	//--------------------------------------------------
	TekiControl(Graphics g, Image image[], Ship ship ) {
		for( int i = 0; i < maxTekisuu; i++ ) {
			teki[i] = new Teki(ship);
			state[i] = 0;
			tekiCount[i] = 0;
		}
		waitCount = 0;
		dataWait = 40;
		obj = 0;
		off_g = g;
		tekiShip = image;
	}
	
	//-------------------------------------------------
	// 敵の状態をチェックする関数
	//-------------------------------------------------
	void tekiCheck() {
		
		// シナリオから敵の種類と待ち時間を取得する
		if ( waitCount > dataWait ) {
			waitCount = -1;
			dataTeki	= Scenario.getScenario();
			dataWait	= Scenario.getScenario();
		}
		if ( waitCount == -1 ) {
			for( int i = 0; i < maxTekisuu; i++ ) {
				// 使用可能な敵オブジェクトがあるかチェック
				if ( state[obj] == 0 ) {
				 break;
				}
				obj++;
				if( obj >= maxTekisuu ) {
					obj = 0;
				}
			}
			if( state[obj] == 0 ) {
				// 敵の初期設定
				teki[obj].setTeki( dataTeki );
				state[obj] = 1;
				waitCount = 0;
				tekiCount[obj] = 0;
			} else {
				// 使えるオブジェクトが無かったときは、抜ける
				return;
			}
		} else {
			waitCount++;
		}
	}
	
	//--------------------------------------------
	// 敵を動かす関数
	//--------------------------------------------
	void move() {
	
		for( int i = 0; i < maxTekisuu; i++ ) {
			// 撃たれたかどうかの判定
			if ( state[i] == 2 ) {
				// 撃たれたので硬さを減らす
				teki[i].decreTough();
				if ( teki[i].getTough() <=0 ) {
					// 撃破
					state[i] = 3;
					// スコアを入れる（週回数が多いほど増加）
					game.score += ( teki[i].getValue() * (game.syuu + 1 ) );
					// scoreがtuika以上の場合、残機を一機増やす
					if ( game.score >= game.tuika ) {
						game.zan++;
						game.tuika += 100000;		// 次の追加点数を設定
						game.acTuika.play();		// 追加音を鳴らす
					}
				} else {
					state[i] = 1;
				}
			}
			if ( state[i] == 1 ) {
				// 使用中の敵を動かして描画する
				state[i] = teki[i].move( tekiCount[i] );
				drawTeki( i );
				tekiCount[i]++;
				// 念のためint型からあふれないようにする処理
				if ( tekiCount[i] > 100000000 ) {
					tekiCount[i] = 1000;
				}
			} else if ( state[i] != (byte)0 ) {
				// 撃破処理
				gekiha( i );
			}
		}
	}
	
	//-------------------------------------------
	// 敵を描画する関数
	//-------------------------------------------
	void drawTeki( int i ) {
		off_g.drawImage( tekiShip[teki[i].getImageNo()], teki[i].getX(), teki[i].getY(), null );
	}
	
	//-------------------------------------------
	// 撃破処理
	//-------------------------------------------
	void gekiha(int i) {
		int imageNo = 1; // 爆発のパターン
		int size = teki[i].getSize(); // 敵の大きさを取得
		if ( size < 40 ) {
			// 小さい敵の爆発
			if ( state[i] == 3 ) {
				imageNo = 0;
				state[i] = 4;
			} else {
				// 敵を画面外に出して使用可能にする
				teki[i].setX(game.d.width + 32);
				teki[i].setY(game.d.height + 32);
				state[i] = 0;
			}
			off_g.drawImage( game.bakuhatu[imageNo], teki[i].getX(), teki[i].getY(), null );
		} else {
			// 大きい敵の爆発
			if ( state[i] < 50 ) {
				if ( state[i] == 3 ) {
					// 爆発音を出す
					game.acBom.play();
				}
				// 爆発の絵の切り替え
				imageNo = state[i] % 2;
				state[i]++;
			} else {
				// 敵を画面外に出して使用可能にする
				teki[i].setX(game.d.width + 32);
				teki[i].setY(game.d.height + 32);
				state[i] = 0;
			}
			// 敵の絵全体を爆発で埋める
			for ( int j = 0; j < (size / 32); j++ ) {
				for ( int k = 0; k < (size / 32); k++ ) {
					off_g.drawImage( game.bakuhatu[imageNo], teki[i].getX() + (k * 32), teki[i].getY() + (j * 32), null );
				}
			}
		}			
	}
	
	//-------------------------------------------
	// 敵の状態を取得する関数
	//-------------------------------------------
	byte getState( int i ) {
		return state[i];
	}
	//-------------------------------------------
	// 敵の状態をセットする関数
	//-------------------------------------------
	void setState( int i, byte j ) {
		state[i] = j;
	}
	//-------------------------------------------
	// 敵の出現時間を設定する関数
	//-------------------------------------------
	static void setWait( int from, int to ) {
		waitCount = from;
		dataWait = to;
	}
}



//----------------------------------------------------
//　敵クラス(敵オブジェクト）
//----------------------------------------------------
class Teki {
	
	private int syurui;					// 敵の種類
	private int x, y;					// 敵のX,Y座標
	private static int shokiX, shokiY;	// 敵の初期X,Y座標
	private int moveX, moveY;			// 敵を動かす量
	private int xx, yy;					// 敵の弾の移動量作成用
	private int imageNo;				// 敵の絵の種類
	private int value;					// 敵の点数
	private int size;					// 敵の大きさ
	private int tough;					// 敵の固さ
	private static int maxX = game.d.width;	// 画面の最大X,Y座標
	private static int maxY = game.d.height;
	private Ship myShip;				// 自機オブジェクト
	private int data1, data2, data3;	// 汎用データ確保用
	
	//-------------------------------------------------
	// コンストラクタ
	//-------------------------------------------------
	Teki(Ship ship) {
		imageNo = 0;
		value = 0;
		size = 32;
		tough = 1;
		myShip = ship;
		data1 = 0;
		data2 = 0;
		data3 = 0;
	}
	
	//-------------------------------------------------
	// 硬さを減らす関数
	//-------------------------------------------------
	void decreTough() {
		tough--;
	}
	//-------------------------------------------------
	// 硬さをセットする関数 
	// (週回数が上がるごとに硬くなる）
	//-------------------------------------------------
	void setTough( int i ) {
		tough = i + game.syuu;
	}
	//-------------------------------------------------
	// 敵をセットする関数
	//-------------------------------------------------
	void setTeki( int num ) {
		syurui = num;
	}
	//-------------------------------------------------
	// 敵の絵の種類、X,Y座標をセットする関数
	//-------------------------------------------------
	void setImageNo(int i) {
		imageNo = i;
	}
	void setX( int i ) {
		x = i;
	}
	void setY( int i ) {
		y = i;
	}
	//-------------------------------------------------
	// 敵の絵の種類、X,Y座標、大きさ、硬さ
	//		敵の点数を取得する関数
	//-------------------------------------------------
	int getImageNo() {
		return imageNo;
	}
	int getX() {
		return x;
	}
	int getY() {
		return y;
	}
	int getSize() {
		return size;
	}
	int getTough() {
		return tough;
	}
	int getValue() {
		return value;
	}
	
	//---------------------------------------------------
	// 弾を自機に飛ばす関数
	//---------------------------------------------------
	void setMissileMove() {
		setMissileMove( myShip.getX(), myShip.getY() );
	}
	//---------------------------------------------------
	// 弾を一定の座標に向けて飛ばす関数
	//		hx,hy 飛ばす方向のX,Y座標
	//---------------------------------------------------
	void setMissileMove( int hx, int hy ) {
		// 弾の移動量を決める
		xx = hx - x;
		yy = hy - y;
		if ( Math.abs(xx) >= Math.abs(yy) ) {
			yy = Math.round( ( (float)yy/(float)Math.abs(xx) ) * 4 ); 
			xx = xx < 0 ? -4 : 4;
		} else {
			xx = Math.round( ( (float)xx/(float)Math.abs(yy) ) * 4 );
			yy = yy < 0 ? -4 : 4;
		}
		// 弾のデータをセット
		Shoot_t.setData( x + (size/2) - 4, y + (size/2) -4, xx, yy );
		//data2++;
	}
	//---------------------------------------------------
	// 敵を一定の座標に向かって動かす関数
	//		hx,hy 飛ばす方向のX,Y座標　mv 移動量
	//---------------------------------------------------
	void setTekiMoveTo( int hx, int hy, int mv ) {
		// 敵の移動量を決める
		moveX = hx - x;
		moveY = hy - y;
		if ( Math.abs(moveX) >= Math.abs(moveY) ) {
			moveY = Math.round( ( (float)moveY/(float)Math.abs(moveX) ) * mv ); 
			moveX = moveX < 0 ? -mv : mv;
		} else {
			moveX = Math.round( ( (float)moveX/(float)Math.abs(moveY) ) * mv );
			moveY = moveY < 0 ? -mv : mv;
		}
	}
	
	//---------------------------------------------
	// 敵を動かす関数
	//---------------------------------------------
	byte move(int tekiCount) {
		byte ret = 1;
		switch( syurui ) {
			case 0:
				ret = (byte)teki0(tekiCount);
				x += moveX;
				y += moveY;
				break;
			case 1:
				ret = (byte)teki1(tekiCount);
				x += moveX;
				y += moveY;
				break;
			case 2:
				ret = (byte)teki2(tekiCount);
				x += moveX;
				y += moveY;
				break;
			case 3:
				ret = (byte)teki3(tekiCount);
				x += moveX;
				y += moveY;
				break;
			case 4:
				ret = (byte)teki4(tekiCount);
				x += moveX;
				y += moveY;
				break;
			case 5:
				ret = (byte)teki5(tekiCount);
				x += moveX;
				y += moveY;
				break;
			case 6:
				ret = (byte)teki6(tekiCount);
				x += moveX;
				y += moveY;
				break;
			case 7:
				ret = (byte)teki7(tekiCount);
				x += moveX;
				y += moveY;
				break;
			case 8:
				ret = (byte)teki8(tekiCount);
				x += moveX;
				y += moveY;
				break;
			case 9:
				ret = (byte)teki9(tekiCount);
				x += moveX;
				y += moveY;
				break;
			case 10:
				ret = (byte)teki10(tekiCount);
				x += moveX;
				y += moveY;
				break;
			case 11:
				ret = (byte)teki11(tekiCount);
				x += moveX;
				y += moveY;
				break;
			case 12:
				ret = (byte)teki12(tekiCount);
				break;
			case 13:
				ret = (byte)teki13(tekiCount);
				x += moveX;
				y += moveY;
				break;
		}
		return ret;
	}
	
	//----------------------------------------------
	// 敵の種類ごとの動きの関数
	//----------------------------------------------
	// 敵０
	int teki0(int tekiCount) {
		if ( tekiCount == 0 ) {
			// 初期位置の確保
			shokiX = (int)( Math.random() * (float)(maxX -64) ) + 32;
			shokiY = -32;
		}
		// 以下、敵１と同じ
		return teki1( tekiCount );
	}
	// 敵１
	int teki1(int tekiCount) {
		
		if ( tekiCount == 0 ) {
			// 初期設定
			data1 = ( shokiX + 16 ) > ( maxX / 2 ) ? 1: -1; // 敵の進む向き
			imageNo = 0;
			size = 32;
			value = 200;
			setTough( 1 );
			x = shokiX;
			y = shokiY;
			moveX = 8 * data1;
			moveY = 4;
		} else if ( x > maxX - 64 ) {
			// 右端へ行った時の処理
			data1 = -1;
			moveX += data1;
		} else if ( x < 32 ) {
			// 左端へ行った時の処理
			data1 = 1;
			moveX += data1;
		} else if ( Math.abs(moveX) < 8 ) {
			// 滑らかにターンさせる処理
			moveX += data1;
		}
		if ( moveX == 0 ) {
			// 弾を発射
			setMissileMove();
		}
		if ( y > maxY ) {
			// 画面外に行った処理
			return 0;
		}
		return 1;
	}
	// 敵２
	int teki2(int tekiCount) {
		if ( tekiCount == 0 ) {
			// 初期位置の確保
			shokiX = ( myShip.getX() + 16 ) > ( maxX / 2 ) ? 0: maxX;
			shokiY = -32;
		}
		// 以下、敵３と同じ
		return teki3( tekiCount );
	}
	// 敵３
	int teki3(int tekiCount) {
		
		if ( tekiCount == 0 ) {
			// 初期設定
			imageNo = 4;
			size = 32;
			value = 100;
			setTough( 1 );
			data1 = 0;	// 自機に近づくか逃げるかのフラグ
			x = shokiX;
			y = shokiY;
			moveX = 2 * ( shokiX > myShip.getX() ? -1: 1 );
			moveY = 2;
		} else if ( x+32 < 0 || x > maxX || y+32 < 0 || y > maxY ) {
			// 画面外に行った処理
			return 0;
		} else if ( data1 == 0 && ( (moveX > 0 && x > myShip.getX()) || (moveX < 0 && x < myShip.getX()) ) ) {
			// 自機に近づいたので、逃げる処理
			data1 = 1;
			moveX *= -1;
			// 弾を発射
			setMissileMove();
		} else if ( data1 == 1 && moveY > -4 ) {
			// 滑らかにターンさせる処理
			moveY--;
		}
		return 1;
	}
	// 敵４
	int teki4(int tekiCount) {
		
		if ( tekiCount == 0 ) {
			// 初期設定
			imageNo = 1;
			size = 32;
			value = 500;
			setTough( 2 );
			data1 = (int)(Math.random() * (float)maxY/2) + 30; // 敵が降下するY座標
			data2 = 0; // 停止時間カウント用
			x = (int)( Math.random() * (float)(maxX -64) ) + 32;
			y = -32;
			moveX = 0;
			moveY = 4;
		} else if ( y < -32 ) {
			// 画面外に行った処理
			return 0;
		} else if ( y >= data1 && data2 < 5 && data2 != 3 ) {
			// 停止
			moveY = 0;
			imageNo = 2;
			data2++;
		} else if ( data2 == 3 ) {
			// 弾を発射
			setMissileMove();
		} else if ( data2 >=5 ) {
			// 上へ移動
			moveY = -4;
		}
		return 1;
	}
	// 敵５(ボス)
	int teki5(int tekiCount) {
		
		if ( tekiCount == 0 ) {
			// 初期設定
			imageNo = 3;
			size = 94;
			value = 10000;
			tough = 200;
			data1 = 0; // 停止時間カウント用
			x = maxX/2 - 16;
			y = -94;
			moveX = 0;
			moveY = 1;
		} else if ( data1 < 10 && y == 50 ) {
			// 停止
			moveY = 0;
			data1++;
		} else if ( data1 == 10 ) {
			// 横移動開始
			moveX = -1;
			data1++;
		} else if ( data1 == 11 && tough >= 120 ) {
			// 攻撃
			if ( tekiCount % 20 == 0 ) {
				// 弾を発射
				setMissileMove();
			}
			// 左右移動
			if ( x < 10 ) {
				moveX = 1;
			} else if ( x > maxX - 100 ) {
				moveX = -1;
			}
		} else if ( tough < 120 && tough >= 50 ) {
			if (tekiCount % 25 == 0 ) {
				// 	弾を発射
				setMissileMove( x, maxY );
				setMissileMove( 0, maxY );
				setMissileMove( maxX,maxY );
			}
			// 左右移動
			if ( x < 10 ) {
				moveX = 4;
			} else if ( x > maxX - 100 ) {
				moveX = -4;
			}
		} else if ( tough < 50 ) {
			if (tekiCount % 20 == 0 ) {
				// 	弾を発射
				setMissileMove( x, maxY );
				setMissileMove( 0, maxY );
				setMissileMove( maxX,maxY );
				setMissileMove();
			}
			// 左右移動
			if ( x < 10 ) {
				moveX = 8;
			} else if ( x > maxX - 100 ) {
				moveX = -8;
			}
		}
		// 次の敵を出現させない
		TekiControl.setWait( 0, 100 );
		return 1;
	}
	// 敵６
	int teki6(int tekiCount) {
		
		if ( tekiCount == 0 ) {
			// 初期設定
			imageNo = 5;
			size = 32;
			value = 1000;
			setTough( 1 );
			x = (int)( Math.random() * (float)(maxX -64) ) + 32;
			y = -32;
			setTekiMoveTo( (int)( Math.random() * (float)(maxX -64) ) + 32, maxY, 16 );
		} else {
			if ( tekiCount % 10 == 0 ) {
				// 弾を発射
				setMissileMove();
			}
		}
		// 画面外に出た時の処理
		if ( y > maxY )  {
			return 0;
		}
		
		return 1;
	}
	
	// 敵７
	int teki7(int tekiCount) {
		
		if ( tekiCount == 0 ) {
			// 初期設定
			imageNo = 1;
			size = 32;
			value = 700;
			setTough( 2 );
			data1 = (int)(Math.random() * (float)maxY/2) + 30; // 敵が降下するY座標
			data2 = 0; // 停止時間カウント用
			x = (int)( Math.random() * (float)(maxX -64) ) + 32;
			y = -32;
			setTekiMoveTo( (int)( Math.random() * (float)(maxX -64) ) + 32, data1, 8 );
		} else if ( y < -32 ) {
			// 画面外に行った処理
			return 0;
		} else if ( y >= data1 && data2 < 3 ) {
			// 停止
			moveX = 0;
			moveY = 0;
			imageNo = 2;
			data2++;
		} else if ( data2 >= 3 && data2 < 20 ) {
			// 弾を発射
			if ( data2 % 3 == 0 ) {
				setMissileMove();
			}
			data2++;
		} else if ( data2 >=20 && data2 < 25 ) {
			// 停止
			imageNo = 1;
			data2++;
		} else if ( data2 >=25 ) {
			// 上へ移動
			moveY = -16;
		}
		return 1;
	}
	// 敵８
	int teki8(int tekiCount) {
		
		if ( tekiCount == 0 ) {
			// 初期設定
			imageNo = 1;
			size = 32;
			value = 700;
			setTough( 2 );
			data1 = (int)(Math.random() * (float)maxY/2) + 30; // 敵が降下するY座標
			data2 = 0; // 停止時間カウント用
			x = (int)( Math.random() * (float)(maxX -64) ) + 32;
			y = -32;
			setTekiMoveTo( (int)( Math.random() * (float)(maxX -64) ) + 32, data1, 8 );
		} else if ( y < -32 ) {
			// 画面外に行った処理
			return 0;
		} else if ( y >= data1 && data2 < 3 ) {
			// 停止
			moveX = 0;
			moveY = 0;
			imageNo = 2;
			data2++;
		} else if ( data2 == 3 ) {
			// 弾を発射
			setMissileMove( x, y - 32 );
			setMissileMove( x, y + 32 );
			setMissileMove( x - 32, y );
			setMissileMove( x + 32, y );
			setMissileMove( x + 32, y + 32 );
			setMissileMove( x + 32, y - 32 );
			setMissileMove( x - 32, y + 32 );
			setMissileMove( x - 32, y - 32 );
			data2++;
		} else if ( data2 >=4 && data2 < 6 ) {
			// 停止
			imageNo = 1;
			data2++;
		} else if ( data2 >= 6 ) {
			// 上へ移動
			moveY = -16;
		}
		return 1;
	}
	// 敵９
	int teki9(int tekiCount) {
		if ( tekiCount == 0 ) {
			// 初期位置の確保
			shokiX = ( myShip.getX() + 16 ) > ( maxX / 2 ) ? 0: maxX;
			shokiY = maxY;
		}
		// 以下、敵１０と同じ
		return teki10( tekiCount );
	}
	// 敵１０
	int teki10(int tekiCount) {
		
		if ( tekiCount == 0 ) {
			// 初期設定
			imageNo = 0;
			size = 32;
			value = 1000;
			setTough( 1 );
			data1 = 0;	// 上へ行くか下へ行くかのフラグ
			x = shokiX;
			y = shokiY;
			moveX = 4 * ( shokiX > myShip.getX() ? -1: 1 );
			moveY = -16;
		} else {
			if ( tekiCount % 10 == 0 ) {
				// 弾を発射
				setMissileMove();
			}
			if ( data1 == 0 ) {
				// 上へ移動
				if ( y < 120 ) {
				moveY += 1;
				if ( moveY == 0 ) {
					data1 = 1;
				}
			}
			// 下へ移動
			} else {
				if ( moveY < 16 ) {
					moveY += 1;
				} else {
					if ( y > maxY ) {
						return 0;
					}
				}
			}
		}
		return 1;
	}
	// 敵11(ボス)
	int teki11(int tekiCount) {
		
		if ( tekiCount == 0 ) {
			// 初期設定
			imageNo = 3;
			size = 94;
			value = 12000;
			tough = 200;
			data1 = 0;	// 停止時間カウント用
			data2 = 0;	// 正負の切り替え用
			x = maxX/2 - 40;
			y = -94;
			moveX = 0;
			moveY = 1;
		} else if ( data1 < 10 && y == 40 ) {
			// 停止
			moveY = 0;
			moveX = 0;
			data1++;
			data2 = 13;
		} else if ( data1 == 10 ) {
			// 移動開始
			moveX += data2;
			if ( y > 150 ) {
				moveY = -2;
			} else if ( y < 50 ) {
				moveY = 2;
			}
			if ( moveX > 12 && x > maxX/2 - 40 ) {
				moveX = 12;
				data2 = -1;
			} else if ( moveX < -12 && x < maxX/2 -40 ) {
				moveX = -12;
				data2 = 1;
			}
			// 	弾を発射
			if (  moveX == 0 ) {
				setMissileMove( 0, maxY );
				setMissileMove( maxX, maxY );
				setMissileMove();
			}
			if ( tough < 100 && tekiCount % 20 == 5 ) {
				setMissileMove();
			}
			if ( tough < 50 && tekiCount % 20 == 0 ) {
				setMissileMove( 0, maxY );
				setMissileMove( maxX, maxY );
				setMissileMove();
			}
		}
		// 次の敵を出現させない
		TekiControl.setWait( 0, 100 );
		return 1;
	}
	// 敵12
	int teki12(int tekiCount) {
		if ( tekiCount == 0 ) {
			// 初期設定
			imageNo = 6;
			size = 32;
			value = 1200;
			setTough( 3 );
			data1 = 0;	// 動きのモード切替
			data2 = 0;	// 画像点滅用フラグ
			data3 = 0;	// X座標保管用
			// 敵出現位置を決める
			do {
				data3 = (int)( Math.random() * (float)(maxX - 64) ) + 32;
				y = (int)( Math.random() * (float)(maxY -64) ) + 32;
				// 自機と出現位置が近いときは、出現場所を変更
			} while( data3 + 64 > myShip.getX() && data3 - 64 < myShip.getX() && y + 64 > myShip.getY() && y - 64 < myShip.getY() );
		} else if ( data1 == 0 ) {
			// 点滅
			x = ( tekiCount % 2 == 0 ? data3: -40 );
			if ( tekiCount == 20 ) {
				x = data3;
				data1 = 1;
			}
		} else if ( data1 == 1 ) {
			// 停止
			if ( tekiCount == 25 ) {
				// 敵グラフィック変更
				imageNo = 7;
			} else if ( tekiCount == 30 ){
				data1 = 2;
			}
		} else if ( data1 == 2 ) {
			if ( tekiCount % 15 == 0 ) {
				// 弾を発射
				setMissileMove();
			}
			if ( tekiCount == 200 ) {
				data1 = 3;
			}
		} else if ( data1 == 3 ) {
			// 点滅
			x = ( tekiCount % 2 == 0 ? data3: -40 );
			if ( tekiCount == 220 ) {
				return 0;
			}
		}
		return 1;
	}	
	// 敵13(ボス)
	int teki13(int tekiCount) {
		
		if ( tekiCount == 0 ) {
			// 初期設定
			imageNo = 3;
			size = 94;
			value = 15000;
			tough = 200;
			data1 = 0; // 停止時間カウント用
			data2 = 0; // 移動場所X座標
			data3 = 0; // 移動場所Y座標
			x = maxX/2 - 16;
			y = -94;
			moveX = 0;
			moveY = 1;
		} else if ( data1 < 10 && y == 50 ) {
			// 停止
			moveY = 0;
			data1++;
		} else if ( data1 == 10 ) {
			// 移動開始
			data1++;
			// 移動先をランダムに決める
			data2 = (int)( Math.random() * (float)(maxX - 94) );
			data3 = (int)( Math.random() * (float)(maxY - 94) );
			setTekiMoveTo( data2, data3, 4 );
		} else if ( data1 >= 11 && data1 < 40 ) {
			// 移動先に到着したかチェック
			if ( ( x > data2 - 12 && x < data2 + 12 && y > data3 - 12 && y < data3 + 12 ) || x < 8 || x > maxX - 102 || y < 16 || y > maxY - 102 ) {
				// 停止へ
				data1 = 39;
			}
			data1++;
		} else if ( data1 == 40 ) {
			// 停止
			moveX = 0;
			moveY = 0;
			data1++;
		} else if ( data1 >= 41 && data1 < 60 ) {
			// 停止中
			data1++;
		} else if ( data1 >= 60 && data1 < 100 ) {
			// 攻撃
			if ( tekiCount % 4 == 0 ) {
				// 弾を発射
				setMissileMove();
			}
			data1++;
		} else if ( data1 >= 100 ) {
			// 停止中
			data1++;
			if ( data1 > 105 ) {
				// 停止終了
				data1 = 10;
			}
		}
		// toughが少なくなると、弾を発射
		if ( tough < 150 && tekiCount % 15 == 0 ) {
			setMissileMove( x + 32, y + 32 );
			setMissileMove( x + 32, y - 32 );
			setMissileMove( x - 32, y + 32 );
			setMissileMove( x - 32, y - 32 );
		}
		if ( tough < 50 && ( tekiCount % 15 ) == 12 ) {
			setMissileMove( x, y - 32 );
			setMissileMove( x, y + 32 );
			setMissileMove( x - 32, y );
			setMissileMove( x + 32, y );
		}
		// 次の敵を出現させない
		TekiControl.setWait( 0, 100 );
		return 1;
	}
}



//*******************************************************************************
//Shoot_tクラス（敵の弾を管理するオブジェクト）
//*******************************************************************************
class Shoot_t {
	
	static final int hassya = 32;			// 弾の最大発射数
	private static boolean hassyaFlag[];	// 弾を撃ったかどうかのフラグ
	private static int shokiX[];			// 弾を撃った場所のX,Y座標
	private static int shokiY[];
	private static int moveX[];			// 弾のX,Y座標の移動量
	private static int moveY[];
	private static boolean state[];		// 弾の使用状態 true = 使用中
	private static int count;			// 使用するオブジェクトの順番
	private static int objCount;		// オブジェクトをチェックする順番
	Missile_t tekiMissile[];	// Missile_tオブジェクト
	
	private static int maxX = game.d.width;	// 画面の最大X,Y座標
	private static int maxY = game.d.height;
	private Graphics off_g;			// オフスクリーン
	
	//----------------------------------------------
	//コンストラクタ　g オフスクリーン
	//----------------------------------------------
	Shoot_t(Graphics g) {
		hassyaFlag = new boolean[hassya];
		shokiX = new int[hassya];
		shokiY = new int[hassya];
		moveX = new int[hassya];
		moveY = new int[hassya];
		state = new boolean[hassya];
		tekiMissile = new Missile_t[hassya];
		
		for( int i = 0; i < hassya; i++ ) {
			hassyaFlag[i] = false;
			shokiX[i] = 0;
			shokiY[i] = 0;
			moveX[i] = 0;
			moveY[i] = 0;
			state[i] = false;
			tekiMissile[i] = new Missile_t();
		}
		
		count = 0;
		objCount = 0;
		off_g = g;
	}
	
	//-----------------------------------------------
	// 弾を発射させる関数　ship 自機オブジェクト
	//-----------------------------------------------
	void hassyaCheck() {
		for ( int i = 0; i < hassya; i++ ) {
			
			// 弾を撃ったかチェック
			if (hassyaFlag[i]) {
				hassyaFlag[i] = false;
				// 弾が使用可能かどうかのチェック
				for( int j = 0; j < hassya; j++ ) {
					objCount++;
					if ( objCount >= hassya ) {
						objCount = 0;
					}
					if ( !state[objCount] ) {
						break;
					}
				}
				
				if ( state[objCount] ) {
					// 全弾使用中だった時
					return;
				}
				// 弾を発射させる
				state[objCount] = true;
				tekiMissile[objCount].setMissile( shokiX[i], shokiY[i], moveX[i], moveY[i] );
			}
		}
	}
	
	//----------------------------------------------------
	// 使用中の弾を動かし、描画する
	//----------------------------------------------------
	void move() {
		for( int i = 0; i < hassya; i++ ) {
			if ( state[i] ) {
				// 弾が使用中の時の処理
				if ( tekiMissile[i].getX() <= -8 || tekiMissile[i].getX() > maxX || tekiMissile[i].getY() <= -8 || tekiMissile[i].getY() > maxY ) {
					// 弾が画面外に行った時の処理
					state[i] = false;
				} else {
					// 弾を動かす
					tekiMissile[i].setMissile();
					tekiMissile[i].drawMissile( off_g );
				}
			}
		}
	}
	
	//----------------------------------------------
	// 弾を発射するデータをセットする関数
	// 		x,y 初期X,Y座標　mx,my 移動量
	//----------------------------------------------
	static void setData( int x, int y, int mx, int my ) {
		hassyaFlag[count]	= true;
		shokiX[count]		= x;
		shokiY[count]		= y;
		moveX[count]		= mx;
		moveY[count]		= my;
		count++;
		if ( count >= hassya ) {
			count = 0;
		}
	}
	//-----------------------------------------------
	// 弾の状態をセットする関数
	//-----------------------------------------------
	void setState( int i, boolean j ) {
		state[i] = j;
	}
	//-----------------------------------------------
	// 弾の状態を取得する関数
	//-----------------------------------------------
	boolean getState( int i ) {
		return state[i];
	}
}



//***************************************************
//Missile_tクラス(敵の弾を描画するオブジェクト）
//***************************************************
class Missile_t {
	
	private int x, y;			// 弾のX,Y座標
	private int moveX, moveY;	// 弾のX,Yの移動量
	
	//--------------------------------------------
	// コンストラクタ
	//--------------------------------------------
	Missile_t() {
	}
	
	//--------------------------------------------
	// 弾をセットする関数
	//		xx,yy 初期X,Y座標　mx,my 移動量
	//--------------------------------------------
	void setMissile(int xx, int yy, int mx, int my) {
		x = xx;
		y = yy;
		moveX = mx;
		moveY = my;
	}
	void setMissile( int xx, int yy ) {
		setMissile( xx, yy, 0, 0);
	}
	void setMissile() {
		x += moveX;
		y += moveY;
	}
	
	//-------------------------------------------
	// 弾のX,Y座標を取得する関数
	//-------------------------------------------
	int getX() {
		return x;
	}
	int getY() {
		return y;
	}
	
	//-------------------------------------------
	// 弾を描画する関数　g オフスクリーン
	//-------------------------------------------
	void drawMissile(Graphics g) {
		g.setColor(Color.cyan);
		g.fillOval( x, y, 8, 8 );
	}
}




//----------------------------------------------------
// シナリオクラス（敵の出現パターン管理クラス）
//----------------------------------------------------
class Scenario {
	
	private static int pointer = 0; // 現在シナリオのポインタ
	
	// シナリオデータ
	//	敵の種類	待ち時間
	private static int scenarioData[] = {
		// 1面 
		2,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			50,
		
		2,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			50,
		
		2,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			50,
		
		2,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			50,
		
		0,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			50,
		
		0,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			50,
		
		0,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			50,
		
		0,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			50,
		
		4,			40,
		4,			30,
		4,			20,
		4,			10,
		4,			6,
		4,			6,
		4,			6,
		4,			6,
		4,			6,
		4,			6,
		4,			6,
		4,			6,
		4,			50,
		
		2,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			50,
		
		0,			3,
		4,			3,
		1,			3,
		4,			3,
		1,			3,
		4,			3,
		1,			3,
		4,			3,
		1,			3,
		4,			3,
		4,			3,
		4,			3,
		4,			3,
		4,			50,
		
		0,			3,
		4,			3,
		1,			3,
		4,			3,
		1,			3,
		4,			3,
		1,			3,
		4,			3,
		1,			3,
		4,			3,
		4,			3,
		4,			3,
		4,			3,
		4,			50,
		
		2,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			50,

		0,			6,
		4,			6,
		0,			6,
		4,			6,
		0,			6,
		4,			6,
		0,			6,
		4,			6,
		0,			6,
		4,			6,
		0,			6,
		4,			6,
		0,			6,
		4,			6,
		0,			6,
		4,			6,
		0,			6,
		4,			6,
		0,			6,
		4,			5,
		4,			4,
		4,			3,
		4,			2,
		4,			1,
		4,			1,
		4,			1,
		4,			1,
		4,			1,
		4,			50,
		
		2,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			50,
		
		2,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			50,
		
		7,			40,
		7,			30,
		7,			20,
		7,			10,
		7,			6,
		7,			6,
		7,			5,
		7,			4,
		7,			3,
		7,			2,
		7,			50,
		
		6,			6,
		6,			6,
		6,			6,
		6,			6,
		6,			100,
		// ボス1
		5,			100,
		
		// ２面
		2,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			50,
		
		2,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			50,
		
		0,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		0,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		0,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		0,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			50,
		
		2,			3,
		1,			3,
		2,			3,
		1,			3,
		2,			3,
		1,			3,
		2,			3,
		1,			3,
		2,			3,
		1,			3,
		2,			3,
		1,			3,
		2,			3,
		1,			3,
		2,			3,
		1,			3,
		2,			3,
		1,			3,
		2,			3,
		1,			3,
		2,			3,
		1,			3,
		2,			3,
		1,			3,
		2,			3,
		1,			3,
		2,			3,
		1,			3,
		2,			3,
		1,			3,
		2,			3,
		1,			3,
		2,			3,
		1,			3,
		2,			3,
		1,			50,
		
		2,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			50,
		
		2,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			50,
		
		8,			40,
		8,			30,
		8,			20,
		8,			10,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			50,
		
		9,			6,
		10,			6,
		10,			6,
		10,			6,
		10,			50,
		
		9,			6,
		10,			6,
		10,			6,
		10,			6,
		10,			50,
		
		9,			6,
		10,			6,
		10,			6,
		10,			6,
		10,			50,
		
		9,			6,
		10,			6,
		10,			6,
		10,			6,
		10,			50,
		
		0,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			50,
		
		0,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			50,
		
		0,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			50,
		
		0,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			50,
		
		2,			6,
		3,			6,
		3,			6,
		3,			6,
		3,			50,
		
		7,			40,
		7,			35,
		7,			30,
		7,			25,
		7,			20,
		7,			15,
		7,			10,
		7,			9,
		7,			8,
		7,			7,
		7,			6,
		7,			5,
		7,			5,
		7,			5,
		7,			5,
		7,			5,
		7,			5,
		7,			50,
		
		0,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			50,
		
		8,			40,
		8,			30,
		8,			20,
		8,			10,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			6,
		8,			50,
		
		0,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		0,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			6,
		1,			50,
		
		6,			6,
		6,			6,
		6,			6,
		6,			6,
		6,			6,
		6,			6,
		6,			6,
		6,			6,
		6,			6,
		6,			6,
		6,			6,
		6,			100,
		// ボス2
		11,			100,
		
		// ３面
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			50,
		
		0,			6,
		0,			6,
		0,			6,
		0,			6,
		0,			6,
		0,			6,
		0,			6,
		0,			6,
		0,			6,
		0,			6,
		0,			50,
		
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			50,
		
		4,			40,
		7,			30,
		8,			20,
		4,			10,
		7,			8,
		8,			6,
		4,			1,
		7,			1,
		8,			1,
		7,			1,
		8,			1,
		7,			1,
		8,			1,
		7,			1,
		8,			1,
		7,			1,
		8,			1,
		7,			1,
		8,			1,
		7,			1,
		8,			1,
		7,			1,
		7,			1,
		8,			1,
		7,			1,
		8,			1,
		7,			1,
		8,			1,
		7,			1,
		8,			1,
		7,			1,
		8,			1,
		7,			1,
		8,			1,
		7,			1,
		8,			1,
		7,			1,
		8,			1,
		8,			1,
		7,			50,
		
		9,			6,
		10,			6,
		10,			6,
		10,			6,
		10,			50,
		
		9,			6,
		10,			6,
		10,			6,
		10,			6,
		10,			50,
		
		9,			6,
		10,			6,
		10,			6,
		10,			6,
		10,			50,
		
		9,			6,
		10,			6,
		10,			6,
		10,			6,
		10,			50,
		
		9,			6,
		10,			6,
		10,			6,
		10,			6,
		10,			50,
		
		9,			6,
		10,			6,
		10,			6,
		10,			6,
		10,			50,
		
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		6,			6,
		2,			6,
		6,			6,
		2,			6,
		6,			6,
		2,			6,
		6,			6,
		2,			6,
		6,			6,
		2,			6,
		6,			6,
		2,			6,
		6,			6,
		2,			6,
		6,			6,
		2,			6,
		6,			6,
		2,			6,
		6,			6,
		2,			6,
		6,			6,
		2,			6,
		6,			6,
		2,			6,
		6,			6,
		2,			6,
		6,			6,
		2,			6,
		6,			6,
		2,			6,
		6,			6,
		2,			50,
		
		12,			50,
		12,			50,
		12,			40,
		12,			40,
		12,			30,
		12,			30,
		12,			30,
		12,			20,
		12,			20,
		12,			20,
		12,			20,
		12,			20,
		12,			20,
		12,			20,
		12,			20,
		12,			20,
		12,			20,
		12,			20,
		12,			20,
		12,			20,
		12,			50,
		
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			10,
		2,			50,
		
		0,			6,
		6,			6,
		1,			6,
		6,			6,
		1,			6,
		6,			6,
		1,			6,
		6,			6,
		1,			6,
		6,			6,
		1,			6,
		6,			6,
		0,			6,
		6,			6,
		1,			6,
		6,			6,
		1,			6,
		6,			6,
		1,			6,
		6,			6,
		1,			6,
		6,			6,
		1,			50,
		
		// ボス3
		13,			100
	};
	private static int maxStep = scenarioData.length; // 総シナリオデータ数
	
	//--------------------------------
	// コンストラクタ　(使っていない）
	//--------------------------------
	Scenario() {
	}
	
	//--------------------------------
	// シナリオの取得関数
	//--------------------------------
	static int getScenario() {
		if ( pointer >= maxStep || pointer < 0 ) {
			// シナリオが最後まで行ったときは、最初に戻る
			pointer = 0;
			game.syuu++;
		}
		return scenarioData[pointer++];
	}
	
	//--------------------------------
	// ポインターの初期化関数
	//--------------------------------
	static void clearPointer() {
		pointer = 0;
	}
	
	//-------------------------------------
	// ポインタの巻き戻し関数 i 巻き戻す数
	//-------------------------------------
	static void revPointer( int i ) {
		pointer -= ( i * 2 );
	}
}