Super Kenji Run

package jp.gr.java_conf.skr_1;

import java.io.IOException;
import java.util.ArrayList;

import javax.microedition.khronos.opengles.GL10;

import jp.gr.java_conf.skr_1.button.BaseButton;
import jp.gr.java_conf.skr_1.button.Datas;
import jp.gr.java_conf.skr_1.button.GameOvers;
import jp.gr.java_conf.skr_1.button.GamePauses;
import jp.gr.java_conf.skr_1.button.GamePlays;
import jp.gr.java_conf.skr_1.course.*;
import jp.gr.java_conf.skr_1.data.クレジットコインデータ;
import jp.gr.java_conf.skr_1.data.ゲームクリアデータ;
import jp.gr.java_conf.skr_1.data.コインデータ;
import jp.gr.java_conf.skr_1.data.コンチデータ;
import jp.gr.java_conf.skr_1.data.コースデータ;
import jp.gr.java_conf.skr_1.data.スコアデータ;
import jp.gr.java_conf.skr_1.data.パワーアップデータ;
import jp.gr.java_conf.skr_1.data.パワーメーターデータ;
import jp.gr.java_conf.skr_1.data.ボス戦前データ;
import jp.gr.java_conf.skr_1.data.ボールデータ;
import jp.gr.java_conf.skr_1.data.ボール最大値データ;
import jp.gr.java_conf.skr_1.data.ライフデータ;
import jp.gr.java_conf.skr_1.data.一位コースデータ;
import jp.gr.java_conf.skr_1.data.三位コースデータ;
import jp.gr.java_conf.skr_1.data.三位スコアデータ;
import jp.gr.java_conf.skr_1.data.中断セーブデータ;
import jp.gr.java_conf.skr_1.data.二位コースデータ;
import jp.gr.java_conf.skr_1.data.二位スコアデータ;
import jp.gr.java_conf.skr_1.data.五位コースデータ;
import jp.gr.java_conf.skr_1.data.五位スコアデータ;
import jp.gr.java_conf.skr_1.data.合計のクリスタルデータ;
import jp.gr.java_conf.skr_1.data.四位コースデータ;
import jp.gr.java_conf.skr_1.data.四位スコアデータ;
import jp.gr.java_conf.skr_1.data.現在のクリスタルデータ;
import jp.gr.java_conf.skr_1.effect.BlockCoins;
import jp.gr.java_conf.skr_1.effect.Bombs;
import jp.gr.java_conf.skr_1.effect.EmptyBlock;
import jp.gr.java_conf.skr_1.effect.EnemyAttacks;
import jp.gr.java_conf.skr_1.effect.EnemyDefeats;
import jp.gr.java_conf.skr_1.effect.Fonts;
import jp.gr.java_conf.skr_1.effect.ItemBreaks;
import jp.gr.java_conf.skr_1.effect.Marios;
import jp.gr.java_conf.skr_1.effect.TileBreaks;
import jp.gr.java_conf.skr_1.enemy.*;
import jp.gr.java_conf.skr_1.font.BaseFont;
import jp.gr.java_conf.skr_1.font.Scores;
import jp.gr.java_conf.skr_1.item.*;
import jp.gr.java_conf.skr_1.option.攻撃ボタン位置記憶;
import jp.gr.java_conf.skr_1.player.BasePlayer;
import jp.gr.java_conf.skr_1.player.ContactLines;
import jp.gr.java_conf.skr_1.player.Fireballs;
import jp.gr.java_conf.skr_1.player.Hands;
import jp.gr.java_conf.skr_1.player.MarioSets;
import jp.gr.java_conf.skr_1.sound.*;
import jp.gr.java_conf.skr_1.tile.*;

import org.andengine.audio.music.MusicFactory;
import org.andengine.engine.handler.timer.ITimerCallback;
import org.andengine.engine.handler.timer.TimerHandler;
import org.andengine.entity.modifier.AlphaModifier;
import org.andengine.entity.modifier.DelayModifier;
import org.andengine.entity.modifier.FadeInModifier;
import org.andengine.entity.modifier.FadeOutModifier;
import org.andengine.entity.modifier.LoopEntityModifier;
import org.andengine.entity.modifier.MoveModifier;
import org.andengine.entity.modifier.ScaleModifier;
import org.andengine.entity.modifier.SequenceEntityModifier;
import org.andengine.entity.primitive.Rectangle;
import org.andengine.entity.scene.IOnSceneTouchListener;
import org.andengine.entity.scene.Scene;
import org.andengine.entity.sprite.AnimatedSprite;
import org.andengine.entity.sprite.ButtonSprite;
import org.andengine.entity.sprite.Sprite;
import org.andengine.entity.text.Text;
import org.andengine.entity.text.TextOptions;
import org.andengine.input.touch.TouchEvent;
import org.andengine.opengl.font.Font;
import org.andengine.opengl.texture.Texture;
import org.andengine.opengl.texture.TextureOptions;
import org.andengine.opengl.texture.atlas.bitmap.BitmapTextureAtlas;
import org.andengine.opengl.texture.region.TextureRegion;
import org.andengine.util.HorizontalAlign;
import org.andengine.util.color.Color;
import org.andengine.util.debug.Debug;
import org.andengine.util.modifier.ease.EaseBackInOut;
import org.andengine.util.modifier.ease.EaseQuadOut;

import android.content.Intent;
import android.graphics.Typeface;
import android.view.KeyEvent;

public class MainScene extends KeyListenScene
implements IOnSceneTouchListener, ButtonSprite.OnClickListener {
	
	// ===========================================================
	// コンストラクター
	// ===========================================================
	
	public MainScene(MultiSceneActivity baseActivity) {
		super(baseActivity);
		// スコアとかの初期化
		スコアデータ.getInstance(getBaseActivity()).setスコアデータ(
				現在のスコア = スコアデータ.getInstance(getBaseActivity()).getスコアデータ());
		コインデータ.getInstance(getBaseActivity()).setコインデータ(
				現在のコイン = コインデータ.getInstance(getBaseActivity()).getコインデータ());
		コインの最大値		= 100;
		ライフデータ.getInstance(getBaseActivity()).setライフデータ(
				現在のライフ = ライフデータ.getInstance(getBaseActivity()).getライフデータ());
		ボールデータ.getInstance(getBaseActivity()).setボールデータ(
				現在のボール = ボールデータ.getInstance(getBaseActivity()).getボールデータ());
		ボール最大値データ.getInstance(getBaseActivity()).setボール最大値データ(
				ボール最大値 = ボール最大値データ.getInstance(getBaseActivity()).getボール最大値データ());
		パワーメーターデータ.getInstance(getBaseActivity()).setパワーメーターデータ(
				現在のノーマルメーター = パワーメーターデータ.getInstance(getBaseActivity()).getパワーメーターデータ());
		現在のクリスタルデータ.getInstance(getBaseActivity()).set現在のクリスタルデータ(
				現在のクリスタル = 現在のクリスタルデータ.getInstance(getBaseActivity()).get現在のクリスタルデータ());
		合計のクリスタルデータ.getInstance(getBaseActivity()).set合計のクリスタルデータ(
				合計のクリスタル = 合計のクリスタルデータ.getInstance(getBaseActivity()).get合計のクリスタルデータ());
		コンチデータ.getInstance(getBaseActivity()).setコンチデータ(
				現在のコンチニュー = コンチデータ.getInstance(getBaseActivity()).getコンチデータ());
		コースデータ.getInstance(getBaseActivity()).setコースデータ(
				コースカウンター = コースデータ.getInstance(getBaseActivity()).getコースデータ());
		// スタッフクレジットじゃないときの処理
		if (コースカウンター != 22) {
			remainingView();
			// スタッフクレジット時の処理
		} else {
			init();
		}
	}
	
	// ===========================================================
	// クラス
	// ===========================================================
	
	// エフェクト
	BlockCoins			blockCoins			= new BlockCoins			(getBaseActivity());
	Bombs				bombs				= new Bombs					(getBaseActivity());
	Fonts				fonts				= new Fonts					(getBaseActivity());
	EmptyBlock			emptyBlock			= new EmptyBlock			(getBaseActivity());
	TileBreaks			tileBreaks			= new TileBreaks			(getBaseActivity());
	ItemBreaks			itemBreaks			= new ItemBreaks			(getBaseActivity());
	EnemyDefeats		enemyDefeats		= new EnemyDefeats			(getBaseActivity());
	EnemyAttacks		enemyAttacks		= new EnemyAttacks			(getBaseActivity());
	Marios				marios				= new Marios				(getBaseActivity());
	// ボタン
	BaseButton			baseButton			= new BaseButton			(getBaseActivity());
	Datas				datas				= new Datas					(getBaseActivity());
	GamePauses			gamePauses			= new GamePauses			(getBaseActivity());
	GameOvers			gameOvers			= new GameOvers				(getBaseActivity());
	GamePlays			gamePlays			= new GamePlays				(getBaseActivity());
	// フォント
	BaseFont			baseFont			= new BaseFont				(getBaseActivity());
	Scores				scores				= new Scores				(getBaseActivity());
	// タイル
	BaseTile			baseTile			= new BaseTile				(getBaseActivity());
	Grasss				grasss				= new Grasss				(getBaseActivity());
	Mounts				mounts				= new Mounts				(getBaseActivity());
	TreeParts			treeParts			= new TreeParts				(getBaseActivity());
	Fences				fences				= new Fences				(getBaseActivity());
	GroundBlocks		groundBlocks		= new GroundBlocks			(getBaseActivity());
	PipeParts			pipeParts			= new PipeParts				(getBaseActivity());
	MushroomBlockParts	mushroomBlockParts	= new MushroomBlockParts	(getBaseActivity());
	PierceBlocks		pierceBlocks		= new PierceBlocks			(getBaseActivity());
	BrickBlocks			brickBlocks			= new BrickBlocks			(getBaseActivity());
	HardBlocks			hardBlocks			= new HardBlocks			(getBaseActivity());
	CastleBlocks		castleBlocks		= new CastleBlocks			(getBaseActivity());
	CandyBlocks			candyBlocks			= new CandyBlocks			(getBaseActivity());
	HiddenBlocks		hiddenBlocks		= new HiddenBlocks			(getBaseActivity());
	QuestionBlockShorts	questionBlockShorts	= new QuestionBlockShorts	(getBaseActivity());
	QuestionBlockLongs	questionBlockLongs	= new QuestionBlockLongs	(getBaseActivity());
	JumpingBoards		jumpingBoards		= new JumpingBoards			(getBaseActivity());
	Chocolates			chocolates			= new Chocolates			(getBaseActivity());
	LiftReds			liftReds			= new LiftReds				(getBaseActivity());
	LiftBlues			liftBlues			= new LiftBlues				(getBaseActivity());
	ChangeBlocks		changeBlocks		= new ChangeBlocks			(getBaseActivity());
	Needles				needles				= new Needles				(getBaseActivity());
	GoalRings			goalRings			= new GoalRings				(getBaseActivity());
	// アイテム
	BaseItem			baseItem			= new BaseItem				(getBaseActivity());
	Coins				coins				= new Coins					(getBaseActivity());
	PowerUpItems		powerUpItems		= new PowerUpItems			(getBaseActivity());
	OneUpMushroom		oneUpMushroom		= new OneUpMushroom			(getBaseActivity());
	FireFlowers			fireFlowers			= new FireFlowers			(getBaseActivity());
	PowerCrystal		powerCrystal		= new PowerCrystal			(getBaseActivity());
	// 敵キャラ
	BaseEnemy			baseEnemy			= new BaseEnemy				(getBaseActivity());
	Goomba				goomba				= new Goomba				(getBaseActivity());
	KoopaParatroopas	koopaParatroopas	= new KoopaParatroopas		(getBaseActivity());
	BulletBills			bulletBills			= new BulletBills			(getBaseActivity());
	PiranhaPlants		piranhaPlants		= new PiranhaPlants			(getBaseActivity());
	BuzzyBeetle			buzzyBeetle			= new BuzzyBeetle			(getBaseActivity());
	Spinys				spinys				= new Spinys				(getBaseActivity());
	CheepCheep			cheepCheep			= new CheepCheep			(getBaseActivity());
	Balloons			balloons			= new Balloons				(getBaseActivity());
	Bowsers				bowsers				= new Bowsers				(getBaseActivity());
	// プレイヤー
	BasePlayer			basePlayer			= new BasePlayer			(getBaseActivity());
	MarioSets			marioSets			= new MarioSets				(getBaseActivity());
	Fireballs			fireballs			= new Fireballs				(getBaseActivity());
	Hands				hands				= new Hands					(getBaseActivity());
	ContactLines		contactLines		= new ContactLines			(getBaseActivity());
	// コース
	NormalCourse01		normalCourse01		= new NormalCourse01		(getBaseActivity());
	NormalCourse02		normalCourse02		= new NormalCourse02		(getBaseActivity());
	NormalCourse03		normalCourse03		= new NormalCourse03		(getBaseActivity());
	NormalCourse04		normalCourse04		= new NormalCourse04		(getBaseActivity());
	NormalCourse05		normalCourse05		= new NormalCourse05		(getBaseActivity());
	NormalCourse06		normalCourse06		= new NormalCourse06		(getBaseActivity());
	NormalCourse07		normalCourse07		= new NormalCourse07		(getBaseActivity());
	NormalCourse08		normalCourse08		= new NormalCourse08		(getBaseActivity());
	NormalCourse09		normalCourse09		= new NormalCourse09		(getBaseActivity());
	NormalCourse10		normalCourse10		= new NormalCourse10		(getBaseActivity());
	NormalCourse11		normalCourse11		= new NormalCourse11		(getBaseActivity());
	NormalCourse12		normalCourse12		= new NormalCourse12		(getBaseActivity());
	NormalCourse13		normalCourse13		= new NormalCourse13		(getBaseActivity());
	NormalCourse14		normalCourse14		= new NormalCourse14		(getBaseActivity());
	NormalCourse15		normalCourse15		= new NormalCourse15		(getBaseActivity());
	NormalCourse16		normalCourse16		= new NormalCourse16		(getBaseActivity());
	NormalCourse17		normalCourse17		= new NormalCourse17		(getBaseActivity());
	NormalCourse18		normalCourse18		= new NormalCourse18		(getBaseActivity());
	NormalCourse19		normalCourse19		= new NormalCourse19		(getBaseActivity());
	NormalCourse20		normalCourse20		= new NormalCourse20		(getBaseActivity());
	NormalCourse21		normalCourse21		= new NormalCourse21		(getBaseActivity());
	NormalCourse22		normalCourse22		= new NormalCourse22		(getBaseActivity());
	BossCourse00		bossCourse00		= new BossCourse00			(getBaseActivity());
	BossCourse01		bossCourse01		= new BossCourse01			(getBaseActivity());
	BossCourse02		bossCourse02		= new BossCourse02			(getBaseActivity());
	BossCourse03		bossCourse03		= new BossCourse03			(getBaseActivity());
	BossCourse04		bossCourse04		= new BossCourse04			(getBaseActivity());
	BossCourse05		bossCourse05		= new BossCourse05			(getBaseActivity());
	BossCourse06		bossCourse06		= new BossCourse06			(getBaseActivity());
	BossCourse07		bossCourse07		= new BossCourse07			(getBaseActivity());
	BossCourse08		bossCourse08		= new BossCourse08			(getBaseActivity());
	BossCourse09		bossCourse09		= new BossCourse09			(getBaseActivity());
	BossCourse10		bossCourse10		= new BossCourse10			(getBaseActivity());
	BossCourse31		bossCourse31		= new BossCourse31			(getBaseActivity());
	// サウンド
	MusicPlay			musicPlay			= new MusicPlay				(getBaseActivity());
	SoundPlay			soundPlay			= new SoundPlay				(getBaseActivity());
	VoicePlay			voicePlay			= new VoicePlay				(getBaseActivity());
	
	// ===========================================================
	// 他クラス共通変数
	// ===========================================================
	
	// 記憶関係
	private int								攻撃ボタン位置;
//	private boolean							開いてるフラグ;
	// 背景関係
//	private AnimatedSprite					タイトル画面背景;
//	private Sprite							データ画面背景;
	private Sprite							オプション画面背景1;
//	private Sprite							オプション画面背景2;
//	private Sprite							オプション画面背景3;
//	private Sprite							オプション画面背景4;
//	private Sprite							メール画面背景;
//	private Rectangle						オプション四角形1;
//	private Rectangle						オプション四角形2;
//	private Rectangle						オプション四角形3;
	// スプライト関係
//	private AnimatedSprite					タイトルロゴ;
//	private Sprite							ウインドウ;
//	private AnimatedSprite					一位レコード1;
//	private AnimatedSprite					二位レコード1;
//	private AnimatedSprite					三位レコード1;
//	private AnimatedSprite					四位レコード1;
//	private AnimatedSprite					五位レコード1;
//	private AnimatedSprite					一位レコード2;
//	private AnimatedSprite					二位レコード2;
//	private AnimatedSprite					三位レコード2;
//	private AnimatedSprite					四位レコード2;
//	private AnimatedSprite					五位レコード2;
	private AnimatedSprite					オプションカーソル;
	private Sprite							オプションFフラワー1;
	private Sprite							オプションFフラワー2;
	private Sprite							警告マーク1;
	private Sprite							警告マーク2;
//	private Sprite							警告マーク3;
//	private Sprite							警告マーク4;
//	private Sprite							警告マーク5;
//	private Sprite							警告マーク6;
//	private Sprite							警告マーク7;
//	private Sprite							警告マーク8;
//	private Sprite							手紙マーク1;
//	private Sprite							手紙マーク2;
//	private Sprite							オンラン文字;
	private Sprite							ボタポジ文字;
	private Sprite							サウスイ文字;
	private Sprite							オルリセ文字;
//	private Sprite							デタリセ文字;
//	private Sprite							重要文字;
	private Sprite							オプリセ文字;
	// テキスト関係
//	private Text							ヴァージョンアップ用テキスト;
//	private Text							データ削除用テキスト1;
//	private Text							データ削除用テキスト2;
	private Text							オプ削除用テキスト;
	// ボタン関係
//	private ButtonSprite					ランキングボタン;
//	private ButtonSprite					データ閉じボタン;
	private ButtonSprite					攻撃左ボタン;
	private ButtonSprite					攻撃中ボタン;
	private ButtonSprite					攻撃右ボタン;
	private ButtonSprite					ミュージックボタン;
	private ButtonSprite					サウンドボタン;
//	private ButtonSprite					データ削除ボタン;
//	private ButtonSprite					データ削除Yesボタン1;
//	private ButtonSprite					データ削除Yesボタン2;
//	private ButtonSprite					データ削除Noボタン1;
//	private ButtonSprite					データ削除Noボタン2;
//	private ButtonSprite					オプ削除ボタン;
	private ButtonSprite					オプ削除Yesボタン;
	private ButtonSprite					オプ削除Noボタン;
	private ButtonSprite					オプ閉じボタン;
//	private ButtonSprite					サウテスボタン;
//	private ButtonSprite					サウテス閉じボタン;
//	private ButtonSprite					メール送信Yesボタン;
//	private ButtonSprite					メール送信Noボタン;
	
	// ===========================================================
	// このクラスのみの変数
	// ===========================================================
	
	// 記録関係
	private Text							テキスト1;
	private Text							スコアテキスト;
	private int								現在のスコア;
	private Text							テキスト2;
	private Text							コインテキスト;
	private int								現在のコイン;
	private int								コインの最大値;
	private Text							テキスト3;
	private Text							テキスト4;
	private Text							ライフテキスト一時;
	private Text							ライフテキスト常時;
	private int								現在のライフ;
	private Text							テキスト5;
	private Text							ボールテキスト;
	private int								現在のボール;
	private int								ボール最大値;
	private Text							テキスト6;
	private Text							テキスト7;
	private Text							ワールドテキスト一時;
	private Text							ワールドテキスト常時;
	private char							現在のワールド;
	private Text							テキスト8;
	private Text							テキスト9;
	private Text							コーステキスト一時;
	private Text							コーステキスト常時;
	private char							現在のコース;
	private Text							テキスト10;
	private Text							距離テキスト;
	private int								現在の距離;
	private int								距離の最大値;
	private int								現在のノーマルメーター;
//	private int								現在のファイナルメーター;
	private int								現在のクリスタル					= 0;
	private int								合計のクリスタル;
	private Text							テキスト11;
	private Text							コンチテキスト1;
	private Text							コンチテキスト2;
	private int								現在のコンチニュー;
	private Text							カウントダウンテキスト;
	private int								ハイスコア変数;
	// クレジット関係
	private Text							SCテキスト1;
	private Text							クレジットコインテキスト;
	private int								現在のクレジットコイン;
	private Text							SCテキスト2;
	private Text							ハイスコアコインテキスト;
//	// デバッグ関係※リリースの際には必ずコメントアウト！
//	private Text							デバッグデータ1テキスト;
//	private Text							デバッグデータ2テキスト;
//	private Text							デバッグデータ3テキスト;
//	private Text							デバッグデータ4テキスト;
//	private Text							デバッグデータ5テキスト;
//	private Text							デバッグデータ6テキスト;
//	private Text							デバッグデータ7テキスト;
//	private Text							デバッグデータ8テキスト;
	// アイコン関係
	private AnimatedSprite					アイコンマリオ;
	private Sprite							アイコン用ウインドウ;
	private Sprite							クレジット用ウインドウ;
	private AnimatedSprite					アイコイン;
	private Sprite							アイパンツ;
	private AnimatedSprite					アイコンボール;
	private AnimatedSprite					アイコンクリス;
	private Sprite							アイコンクリスMAX1;
	private Sprite							アイコンクリスMAX2;
	private Sprite							アイコンクリスMAX3;
	private Sprite							アイコンメット;
	private Sprite							アイコンシャツ;
	private Sprite							アイコンズボン;
	private AnimatedSprite					アイコンカーソル;
	private AnimatedSprite					アイコンノークリ1;
	private AnimatedSprite					アイコンノークリ2;
	private AnimatedSprite					アイコンノークリ3;
//	private AnimatedSprite					アイコンスペクリ1;
//	private AnimatedSprite					アイコンスペクリ2;
//	private AnimatedSprite					アイコンスペクリ3;
//	private AnimatedSprite					アイコンスペクリ4;
//	private AnimatedSprite					アイコンスペクリ5;
	private AnimatedSprite					メーターチャージ;
	private AnimatedSprite					メーターフィーバー;
	private AnimatedSprite					メーターパーセン;
	private AnimatedSprite					ゲーポーズ文字;
	private Sprite							アイコンゲムオ1;
	private Sprite							アイコンゲムオ2;
	private Sprite							アイコンゲムオ3;
	private Sprite							アイコンゲムオ4;
	private Sprite							アイコンゲムオ5;
	private Sprite							アイコンゲムオ6;
	private Sprite							アイコンゲムオ7;
	private Sprite							アイコンゲムオ8;
	private Sprite							クリアイコン;
	private Sprite							ダミーデータ削除;
	private Sprite							ダミーオプ削除;
	private Sprite							ダミーサウテス;
	// ブロック関係
	private AnimatedSprite					ブロックメットアイテム;
	private AnimatedSprite					ブロックシャツアイテム;
	private AnimatedSprite					ブロックズボンアイテム;
	private AnimatedSprite					ブロックワンナップキノコ;
	private AnimatedSprite					ブロックファイアフラワー1;
	private AnimatedSprite					ブロックファイアフラワー2;
	// バルーン関係
	private AnimatedSprite					きいろコインバルーン;
	private AnimatedSprite					あかコインバルーン;
	private AnimatedSprite					あおコインバルーン;
	private AnimatedSprite					ワンナップキノコバルーン;
	private AnimatedSprite					ファイアフラワーバルーン;
	// フォー関係
	private int								通常スコア用フォー;
//	private int								倍率スコア用フォー;
	private int								Nボール用フォー;
	private int								Sボール用フォー;
	private int								衝撃波上用フォー;
	private int								衝撃波下用フォー;
	// レイヤー関係
	private int								レイヤー01背景用				= 1;
	private int								レイヤー02タイル用				= 2;
	private int								レイヤー03パックン用				= 3;
	private int								レイヤー04ドカン用				= 4;
	private int								レイヤー05ボール用				= 5;
	private int								レイヤー06アイテム用				= 6;
	private int								レイヤー07特殊タイル用				= 7;
	private int								レイヤー08敵キャラ用				= 8;
	private int								レイヤー09エフェクト用				= 9;
	private int								レイヤー10プレイヤー用				= 10;
	private int								レイヤー11特殊背景用				= 11;
	private int								レイヤー12アイコン用				= 12;
	private int								レイヤー13テキスト用				= 13;
	private int								レイヤー14ボタン用				= 14;
	private int								レイヤー15ロゴ用					= 15;
	private int								レイヤー16ポーズ用				= 16;
	private int								レイヤー17デバッグ用				= 17;
	// アニメスピード
	private int								aniスター						= 30;
	private int								ani速						= 60;
	private int								ani並						= 120;
	private int								ani遅						= 180;
	// スクロールスピード
	private float							画面のスピード					= 8;
	private float							敵キャラ速い					= 14;
	private float							敵キャラちょっと速い				= 13;
	private float							敵キャラ普通					= 12;
	private float							敵キャラちょっと遅い				= 11;
	private float							敵キャラ遅い					= 10;
	private float							ボールの移動速度				= 16;
	private float							衝撃波の移動速度				= 12;
	// コース
	private int								タテ							= 0;
	private int								ヨコ							= 0;
	private boolean							コース初期化中					= false;
	// 距離
	// ワールド1（序盤）
	private int								コース1の距離					= 700;
	private int								コース2の距離					= 600;
	private int								コース3の距離					= 800;
	private int								コース4の距離					= 900;
	// ワールド2（序盤）
	private int								コース5の距離					= 700;
	private int								コース6の距離					= 500;
	private int								コース7の距離					= 800;
	private int								コース8の距離					= 1000;
	// ワールド3（中盤）
	private int								コース9の距離					= 900;
	private int								コース10の距離					= 700;
	private int								コース11の距離					= 1000;
	private int								コース12の距離					= 800;
	// ワールド4（後半）
	private int								コース13の距離					= 900;
	private int								コース14の距離					= 1000;
	private int								コース15の距離					= 700;
	private int								コース16の距離					= 1200;
	// ワールドS（後半）
	private int								コース17の距離					= 1000;
	private int								コース18の距離					= 700;
	private int								コース19の距離					= 900;
	private int								コース20の距離					= 1200;
	private int								コース21の距離					= 200;
	// カウンター
	private int								ダッシュカウンター;
	private int								ジャンプカウンター;
	private int								くっつきカウンター;
	private int								ハンドラーカウンター;
	private int								メモリーカウンター;
	private int								タイル位置カウンター;
	private int								タイル位置バックアップ;
	private int								コースカウンター;
	private int								ボスエリアカウンター;
	private int								復活タイムカウンター				= 0;
	private int								復活タイムバックアップ				= 5;
	private int								連続ミスカウンター					= 0;
	private int								初期装着型カウンター				= 0;
	private int								Nボールカウンター					= 0;
	private int								Sボールカウンター					= 0;
	private int								敵キャラ連続ヒット					= 0;
	private int								キラー青色連続ヒット				= 0;
	private int								ボスレベル1体力					= 1;
	private int								ボスレベル2体力					= 30;
	private int								ボスレベル3体力					= 40;
	private int								ボスレベル4体力					= 40;
	private int								ボスレベルファイナル体力				= 50;
	private int								ノーマルボス行動パターン				= 0;
	private int								ノーマルボス行動ユニット				= 1;
//	private int								ファイナルボス行動パターン			= 0;
//	private int								ファイナルボス行動ユニット			= 0;
	// 背景
	private Sprite							ワールド1;
	private Sprite							ワールド2;
	private AnimatedSprite					ワールド3;
	private Sprite							ワールド4;
	private Sprite							地下エリア;
	private Sprite							お城エリア;
	private Sprite							地上雲1;
	private Sprite							地上雲2;
	private Sprite							アスレチック雲1;
	private Sprite							アスレチック雲2;
	private Sprite							水1;
	private Sprite							水2;
	private Sprite							溶岩1;
	private Sprite							溶岩2;
	private Sprite							ワールド1地下入り口;
	private Sprite							ワールド1地下中間;
	private Sprite							ワールド1お城入り口;
	private Sprite							ワールド1お城中間;
	private Sprite							ワールド2地下入り口;
	private Sprite							ワールド2地下中間;
	private Sprite							ワールド2お城入り口;
	private Sprite							ワールド2お城中間;
	private Sprite							ワールド3地下入り口;
	private Sprite							ワールド3地下中間;
	private Sprite							ワールド3お城入り口;
	private Sprite							ワールド3お城中間;
	private Sprite							ワールド4お城入り口;
	private Sprite							ワールド4お城中間;
	private Sprite							ブロック背景1;
	private Sprite							ブロック背景2;
	private Sprite							ブロック背景3;
	private Sprite							ブロック背景4;
	private Sprite							オプション用背景;
	private Sprite							クレジット用背景;
	// 移動処理値
	private float							待機ジャンプの上昇移動値			= 0;
	private float							待機ジャンプの下降移動値			= 9.6f;
	private float							普通ジャンプの上昇移動値			= 24;
	private float							普通ジャンプの下降移動値			= 4.8f;
	private float							踏み台ジャンプの上昇移動値			= 0;
	private float							踏み台ジャンプの下降移動値			= 0;
	private float							バック転ジャンプの上昇移動値			= 0;
	private float							バック転ジャンプの下降移動値			= 0;
	private float							プレイヤーのダッシュ値				= 352;
	private float							プレイヤーのジャンプ値				= 168;
	private boolean							プレイヤーの上昇移動フラグ			= false;
	private boolean							プレイヤーの下降移動フラグ			= false;
	private boolean							プレイヤーのダッシュフラグ				= false;
	private boolean							プレイヤーのジャンプフラグ			= false;
	private boolean							踏みジャン実行フラグ				= false;
	private boolean							バック転実行フラグ				= false;
	private boolean							バック転タイムフラグ				= false;
	private boolean							エエーイ実行フラグ					= false;
	private boolean							ボールハンド実行フラグ				= false;
	private boolean							ボールハンドタイムフラグ				= false;
	private boolean							パンチハンド実行フラグ				= false;
	private boolean							パンチハンドタイムフラグ				= false;
	private boolean							判定中1フラグ					= false;
	private boolean							判定中2フラグ					= false;
	private boolean							左側移動フラグ					= false;
	private boolean							右側移動フラグ					= false;
	private boolean							リフト上昇フラグ					= false;
	private boolean							リフト下降フラグ					= false;
	private float							ボスキャラゆらゆら値左				= 0;
	private float							ボスキャラゆらゆら値右				= 0;
	// ブロックアイテム
	private float							ブロックコイン黄色上昇移動時の値		= 24;
	private float							ブロックコイン黄色下降移動時の値		= 4.8f;
	private float							ブロックコイン赤色上昇移動時の値		= 24;
	private float							ブロックコイン赤色下降移動時の値		= 4.8f;
	private float							ブロックコイン青色上昇移動時の値		= 24;
	private float							ブロックコイン青色下降移動時の値		= 4.8f;
	private float							ブロックメットアイテム上昇移動時の値	= 12;
	private float							ブロックメットアイテム下降移動時の値	= 2.4f;
	private float							ブロックシャツアイテム上昇移動時の値	= 12;
	private float							ブロックシャツアイテム下降移動時の値	= 2.4f;
	private float							ブロックズボンアイテム上昇移動時の値	= 12;
	private float							ブロックズボンアイテム下降移動時の値	= 2.4f;
	private float							ブロックワンナップキノコ上昇移動時の値	= 12;
	private float							ブロックワンナップキノコ下降移動時の値	= 2.4f;
	private float							ブロックファイアフラワー1上昇移動時の値	= 12;
	private float							ブロックファイアフラワー1下降移動時の値	= 2.4f;
	private float							ブロックファイアフラワー2上昇移動時の値	= 12;
	private float							ブロックファイアフラワー2下降移動時の値	= 2.4f;
	// システムフラグ
	private boolean							ゲーム待機中かどうか				= true;
	private boolean							ミュージック待機中かどうか			= false;
	private boolean							イントロ中かどうか					= false;
	private boolean							ここからスタートかどうか				= true;
	private boolean							タッチ中かどうか					= false;
	private boolean							ポーズ中かどうか					= false;
	private boolean							ポーズオプション中かどうか			= false;
	private boolean							ポーズタイトル中かどうか				= false;
	private boolean							ポーズプレイ押したかどうか			= false;
	private boolean							ゲームオーバーかどうか				= false;
	private boolean							ボスエリアかどうか					= false;
	private boolean							ボスリトライ時かどうか				= false;
	private boolean							コースの端っこかどうか				= false;
	private boolean							クレジットスキップしたかどうか			= false;
	private boolean							ゲームを終了したかどうか			= false;
	private boolean							メモリーの開放をしたかどうか			= false;
	private boolean							フラグタイル接触					= false;
	private boolean							フラグバルーン掴み				= false;
	private boolean							フラグバルーン放したい				= false;
	private boolean							フラグバル放メッセージ				= false;
	private boolean							フラグチェンジブロック				= false;
	private boolean							フラグキラー青色					= false;
	private boolean							フラグボスキャラ出現				= false;
	private boolean							フラグボスキャラ生存				= false;
	private boolean							フラグボスキャラダメージ				= false;
	private boolean							フラグボスキャラゆらゆら				= false;
	private boolean							フラグボスキャラバーン				= false;
	// ボタン
	private AnimatedSprite					ボール攻撃ボタンプッシュ;
	private Sprite							ボール攻撃ボタン;
	private AnimatedSprite					パンチ攻撃ボタンプッシュ;
	private Sprite							パンチ攻撃ボタン;
	// 出現フラグ
	private boolean							出現フラグワールド1地下入り口		= false;
	private boolean							出現フラグワールド1お城入り口		= false;
	private boolean							出現フラグワールド2地下入り口		= false;
	private boolean							出現フラグワールド2お城入り口		= false;
	private boolean							出現フラグワールド3地下入り口		= false;
	private boolean							出現フラグワールド3お城入り口		= false;
	private boolean							出現フラグワールド4お城入り口		= false;
	private boolean							出現フラグブロック背景1				= false;
	private boolean							出現フラグブロック背景2				= false;
	private boolean							出現フラグブロック背景3				= false;
	private boolean							出現フラグブロック背景4				= false;
	private boolean							出現フラグきいろコインバルーン			= false;
	private boolean							出現フラグあかコインバルーン			= false;
	private boolean							出現フラグあおコインバルーン			= false;
	private boolean							出現フラグワンナップキノコバルーン		= false;
	private boolean							出現フラグファイアフラワーバルーン		= false;
	private boolean							出現フラグブロックコイン黄色			= false;
	private boolean							出現フラグブロックコイン赤色			= false;
	private boolean							出現フラグブロックコイン青色			= false;
	private boolean							出現フラグブロックメットアイテム			= false;
	private boolean							出現フラグブロックシャツアイテム		= false;
	private boolean							出現フラグブロックズボンアイテム		= false;
	private boolean							出現フラグブロックワンナップキノコ		= false;
	private boolean							出現フラグブロックファイアフラワー1		= false;
	private boolean							出現フラグブロックファイアフラワー2		= false;
	// 状態フラグ
	private boolean							グラチェンジフラグ					= false;
	private boolean							メット取得フラグ					= false;
	private boolean							シャツ取得フラグ					= false;
	private boolean							ズボン取得フラグ					= false;
	private boolean							状態フラグ生存					= true;
	private boolean							状態フラグ無敵					= false;
	private boolean							状態フラグ点滅					= false;
	private boolean							状態フラグ復活中					= false;
	private boolean							状態フラグ中断中					= false;
	// 収納用アレイ
	private ArrayList<Sprite>				収納用タイル
	= new ArrayList<Sprite>();
	private ArrayList<Sprite>				収納用アイテム
	= new ArrayList<Sprite>();
	private ArrayList<Sprite>				収納用敵キャラ
	= new ArrayList<Sprite>();
	private ArrayList<Sprite>				収納用プレイヤー
	= new ArrayList<Sprite>();
	private ArrayList<Sprite>				収納用エフェクト
	= new ArrayList<Sprite>();
	private ArrayList<Sprite>				収納用フォント
	= new ArrayList<Sprite>();
	private ArrayList<CustomTimerHandler>	収納用ハンドラー
	= new ArrayList<CustomTimerHandler>();
	// スプライト用アレイ
	private ArrayList<Sprite>				収納用通常スコア
	= new ArrayList<Sprite>();
//	private ArrayList<AnimatedSprite>		収納用倍率スコア
//	= new ArrayList<AnimatedSprite>();
	private ArrayList<AnimatedSprite>		収納用Nボール
	= new ArrayList<AnimatedSprite>();
	private ArrayList<AnimatedSprite>		収納用Sボール
	= new ArrayList<AnimatedSprite>();
	private ArrayList<AnimatedSprite>		収納用衝撃波上
	= new ArrayList<AnimatedSprite>();
	private ArrayList<AnimatedSprite>		収納用衝撃波下
	= new ArrayList<AnimatedSprite>();
	// アレイ用変数
	private int								タイル;
	private int								アイテム;
	private int								敵キャラ;
	private int								プレイヤー;
	private int								エフェクト;
	private int								フォント;
	// マニュアル関係
	private Sprite							マニュアル画面;
	private ButtonSprite					マニュアルボタン;
	// 四角形
	private Rectangle						オプション四角形;
	private Rectangle						残り人数四角形;
	private Rectangle						ゲームポーズ四角形;
	private Rectangle						ゲームオーバー四角形;
	// バルーン
	private boolean							出現フラグバルーン				= false;
	private boolean							移動フラグバルーン				= false;
	private int								バルーンの出現ポイント				= 0;
	private float							バルーンの上昇移動値1			= 5;
	private float							バルーンの上昇移動値2			= 10;
	private float							バルーンの下降移動値1			= 5;
	private float							バルーンの下降移動値2			= 10;
	
	// ===========================================================
	// 初期化系
	// ===========================================================
	
	// テキストの初期化
	public void textInit() {
		if (コースカウンター == 1) {
			現在のワールド		= '1';
			現在のコース		= '1';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース1の距離;
		} else if (コースカウンター == 2) {
			現在のワールド		= '1';
			現在のコース		= '2';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース2の距離;
		} else if (コースカウンター == 3) {
			現在のワールド		= '1';
			現在のコース		= '3';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース3の距離;
		} else if (コースカウンター == 4) {
			現在のワールド		= '1';
			現在のコース		= '4';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース4の距離;
		} else if (コースカウンター == 5) {
			現在のワールド		= '2';
			現在のコース		= '1';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース5の距離;
		} else if (コースカウンター == 6) {
			現在のワールド		= '2';
			現在のコース		= '2';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース6の距離;
		} else if (コースカウンター == 7) {
			現在のワールド		= '2';
			現在のコース		= '3';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース7の距離;
		} else if (コースカウンター == 8) {
			現在のワールド		= '2';
			現在のコース		= '4';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース8の距離;
		} else if (コースカウンター == 9) {
			現在のワールド		= '3';
			現在のコース		= '1';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース9の距離;
		} else if (コースカウンター == 10) {
			現在のワールド		= '3';
			現在のコース		= '2';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース10の距離;
		} else if (コースカウンター == 11) {
			現在のワールド		= '3';
			現在のコース		= '3';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース11の距離;
		} else if (コースカウンター == 12) {
			現在のワールド		= '3';
			現在のコース		= '4';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース12の距離;
		} else if (コースカウンター == 13) {
			現在のワールド		= '4';
			現在のコース		= '1';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース13の距離;
		} else if (コースカウンター == 14) {
			現在のワールド		= '4';
			現在のコース		= '2';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース14の距離;
		} else if (コースカウンター == 15) {
			現在のワールド		= '4';
			現在のコース		= '3';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース15の距離;
		} else if (コースカウンター == 16) {
			現在のワールド		= '4';
			現在のコース		= '4';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース16の距離;
		} else if (コースカウンター == 17) {
			現在のワールド		= 'S';
			現在のコース		= '1';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース17の距離;
		} else if (コースカウンター == 18) {
			現在のワールド		= 'S';
			現在のコース		= '2';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース18の距離;
		} else if (コースカウンター == 19) {
			現在のワールド		= 'S';
			現在のコース		= '3';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース19の距離;
		} else if (コースカウンター == 20) {
			現在のワールド		= 'S';
			現在のコース		= '4';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース20の距離;
		} else if (コースカウンター == 21) {
			現在のワールド		= 'S';
			現在のコース		= 'S';
			ワールドテキスト一時.setText("" + 現在のワールド);
			ワールドテキスト常時.setText("" + 現在のワールド);
			コーステキスト常時.setText("" + 現在のコース);
			コーステキスト一時.setText("" + 現在のコース);
			距離の最大値		= コース21の距離;
		}
	}
	// 背景の初期化
	public void backInit() {
		// 空とか…
		// 草原
		if (コースカウンター == 1 || コースカウンター == 3
				|| コースカウンター == 17 || コースカウンター == 21) {
			ワールド1 = getBaseActivity().getResourceUtil()
					.getSprite("back_01_grassland.png");
			ワールド1.setPosition(0, 0);
			attachChild(ワールド1);
			ワールド1.registerEntityModifier(new FadeInModifier(3));
			// 荒野
		} else if (コースカウンター == 5 || コースカウンター == 6
				|| コースカウンター == 8 || コースカウンター == 18) {
			ワールド2 = getBaseActivity().getResourceUtil()
					.getSprite("back_02_wasteland.png");
			ワールド2.setPosition(0, 0);
			attachChild(ワールド2);
			ワールド2.registerEntityModifier(new FadeInModifier(3));
			// 雪原
		} else if (コースカウンター == 9 || コースカウンター == 11
				|| コースカウンター == 19) {
			ワールド3 = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("back_03_snowfalls.png", 1, 4);
			ワールド3.setPosition(0, 0);
			ワールド3.animate(ani遅);
			attachChild(ワールド3);
			ワールド3.registerEntityModifier(new FadeInModifier(3));
			// 火山
		} else if (コースカウンター == 13 || コースカウンター == 14
				|| コースカウンター == 20) {
			ワールド4 = getBaseActivity().getResourceUtil()
					.getSprite("back_04_volcano.png");
			ワールド4.setPosition(0, 0);
			attachChild(ワールド4);
			ワールド4.registerEntityModifier(new FadeInModifier(3));
			// 地下
		} else if (コースカウンター == 2 || コースカウンター == 7
				|| コースカウンター == 10) {
			地下エリア = getBaseActivity().getResourceUtil()
					.getSprite("back_05_underground.png");
			地下エリア.setPosition(0, 0);
			attachChild(地下エリア);
			地下エリア.registerEntityModifier(new FadeInModifier(3));
			// お城
		} else if (コースカウンター == 4 || コースカウンター == 12
				|| コースカウンター == 15 || コースカウンター == 16) {
			お城エリア = getBaseActivity().getResourceUtil()
					.getSprite("back_06_castle.png");
			お城エリア.setPosition(0, 0);
			attachChild(お城エリア);
			お城エリア.registerEntityModifier(new FadeInModifier(3));
		} else if (コースカウンター == 22) {
			ワールド1 = getBaseActivity().getResourceUtil()
					.getSprite("back_01_grassland.png");
			ワールド1.setPosition(0, 0);
			attachChild(ワールド1);
			ワールド1.registerEntityModifier(new FadeInModifier(3));
			クレジット用背景 = getBaseActivity().getResourceUtil()
					.getSprite("credit_01_back.png");
			クレジット用背景.setPosition(0, 0);
			クレジット用背景.setAlpha(0);
			attachChild(クレジット用背景);
			クレジット用背景.registerEntityModifier(new FadeInModifier(150));
		}
		// 雲とか…
		// 地上雲
		if (コースカウンター == 1 || コースカウンター == 5
				|| コースカウンター == 6 || コースカウンター == 9
				|| コースカウンター == 13 || コースカウンター == 14
				|| コースカウンター == 18 || コースカウンター == 21
				|| コースカウンター == 22) {
			地上雲1 = getBaseActivity().getResourceUtil()
					.getSprite("back_07_cloud_overworld.png");
			地上雲1.setPosition(0, 0);
			attachChild(地上雲1);
			地上雲1.registerEntityModifier(new FadeInModifier(3));
			地上雲2 = getBaseActivity().getResourceUtil()
					.getSprite("back_07_cloud_overworld.png");
			// 画面幅*2分右へ配置する
			地上雲2.setPosition(getBaseActivity().getEngine().getCamera()
					.getWidth() * 2, 0);
			attachChild(地上雲2);
			地上雲2.registerEntityModifier(new FadeInModifier(3));
		}
		// アスレチック雲
		if (コースカウンター == 3 || コースカウンター == 8
				|| コースカウンター == 11 || コースカウンター == 15
				|| コースカウンター == 17 || コースカウンター == 20) {
			アスレチック雲1 = getBaseActivity().getResourceUtil()
					.getSprite("back_08_cloud_athletic.png");
			アスレチック雲1.setPosition(0, 0);
			attachChild(アスレチック雲1);
			アスレチック雲1.registerEntityModifier(new FadeInModifier(3));
			アスレチック雲2 = getBaseActivity().getResourceUtil()
					.getSprite("back_08_cloud_athletic.png");
			// 画面幅*2分右へ配置する
			アスレチック雲2.setPosition(getBaseActivity().getEngine().getCamera()
					.getWidth() * 2, 0);
			attachChild(アスレチック雲2);
			アスレチック雲2.registerEntityModifier(new FadeInModifier(3));
		}
		// 水
		if (コースカウンター == 7 || コースカウンター == 10
				|| コースカウンター == 17 || コースカウンター == 19) {
			水1 = getBaseActivity().getResourceUtil()
					.getSprite("back_09_water.png");
			水1.setPosition(0, 0);
			attachChild(水1);
			水1.registerEntityModifier(new FadeInModifier(3));
			水2 = getBaseActivity().getResourceUtil()
					.getSprite("back_09_water.png");
			// 画面幅*2分右へ配置する
			水2.setPosition(getBaseActivity().getEngine().getCamera()
					.getWidth() * 2, 0);
			attachChild(水2);
			水2.registerEntityModifier(new FadeInModifier(3));
		}
		// 溶岩
		if (コースカウンター == 4 || コースカウンター == 13
				|| コースカウンター == 14 || コースカウンター == 16
				|| コースカウンター == 20) {
			溶岩1 = getBaseActivity().getResourceUtil()
					.getSprite("back_10_lava.png");
			溶岩1.setPosition(0, 0);
			attachChild(溶岩1);
			溶岩1.registerEntityModifier(new FadeInModifier(3));
			溶岩2 = getBaseActivity().getResourceUtil()
					.getSprite("back_10_lava.png");
			// 画面幅*2分右へ配置する
			溶岩2.setPosition(getBaseActivity().getEngine().getCamera()
					.getWidth() * 2, 0);
			attachChild(溶岩2);
			溶岩2.registerEntityModifier(new FadeInModifier(3));
		}
	}
	// コースの初期化
	public void courseInit() {
		// 読み込みフラグ：ON
		コース初期化中 = true;
		// 1-1の読み込み
		if (コースカウンター == 1) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign01();
				}
			}
			// 1-2の読み込み
		} else if (コースカウンター == 2) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign02();
				}
			}
			// 1-3の読み込み
		} else if (コースカウンター == 3) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign03();
				}
			}
			// 1-4の読み込み（通常）
		} else if (コースカウンター == 4
				&& ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() != 1) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign04();
				}
			}
			// 1-4の読み込み（ボス戦前）
		} else if (コースカウンター == 4
				&& ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 1) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					ボスエリアカウンター = 0;
					ボスリトライ時かどうか = true;
					bossCourseDataAssign00();
				}
			}
			// 2-1の読み込み
		} else if (コースカウンター == 5) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign05();
				}
			}
			// 2-2の読み込み
		} else if (コースカウンター == 6) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// キラー青フラグをオン！
					フラグキラー青色 = true;
					// スプライトの割り振り
					normalCourseDataAssign06();
				}
			}
			// 2-3の読み込み
		} else if (コースカウンター == 7) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign07();
				}
			}
			// 2-4の読み込み（通常）
		} else if (コースカウンター == 8
				&& ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() != 2) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign08();
				}
			}
			// 2-4の読み込み（ボス戦前）
		} else if (コースカウンター == 8
				&& ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 2) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					ボスエリアカウンター = 0;
					ボスリトライ時かどうか = true;
					bossCourseDataAssign00();
				}
			}
			// 3-1の読み込み
		} else if (コースカウンター == 9) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign09();
				}
			}
			// 3-2の読み込み
		} else if (コースカウンター == 10) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign10();
				}
			}
			// 3-3の読み込み
		} else if (コースカウンター == 11) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign11();
				}
			}
			// 3-4の読み込み（通常）
		} else if (コースカウンター == 12
				&& ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() != 3) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign12();
				}
			}
			// 3-4の読み込み（ボス戦前）
		} else if (コースカウンター == 12
				&& ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 3) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					ボスエリアカウンター = 0;
					ボスリトライ時かどうか = true;
					bossCourseDataAssign00();
				}
			}
			// 4-1の読み込み
		} else if (コースカウンター == 13) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign13();
				}
			}
			// 4-2の読み込み
		} else if (コースカウンター == 14) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// キラー青フラグをオン！
					フラグキラー青色 = true;
					// スプライトの割り振り
					normalCourseDataAssign14();
				}
			}
			// 4-3の読み込み
		} else if (コースカウンター == 15) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign15();
				}
			}
			// 4-4の読み込み（通常）
		} else if (コースカウンター == 16
				&& ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() != 4) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign16();
				}
			}
			// 4-4の読み込み（ボス戦前）
		} else if (コースカウンター == 16
				&& ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 4) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					ボスエリアカウンター = 0;
					ボスリトライ時かどうか = true;
					bossCourseDataAssign00();
				}
			}
			// S-1の読み込み
		} else if (コースカウンター == 17) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign17();
				}
			}
			// S-2の読み込み
		} else if (コースカウンター == 18) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign18();
				}
			}
			// S-3の読み込み
		} else if (コースカウンター == 19) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign19();
				}
			}
			// S-4の読み込み
		} else if (コースカウンター == 20) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign20();
				}
			}
			// S-Sの読み込み
		} else if (コースカウンター == 21) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign21();
				}
			}
			// S-Rの読み込み
		} else if (コースカウンター == 22) {
			// コースデータ上下の読み込み。（初回時）
			for (タテ = 0; タテ < 15; タテ++) {
				// コースデータ左右の読み込み。（画面幅+1ブロック）
				for (ヨコ = 0; ヨコ < 26; ヨコ++) {
					// スプライトの割り振り
					normalCourseDataAssign22();
				}
			}
		}
		
		// 読み込みフラグ：OFF
		コース初期化中 = false;
	}
	// 初期化メイン
	public void init() {
		// 背景の初期化
		backInit();
		// コースの読み込み
		courseInit();
		// プレイヤーの追加
		// マリオの状態をフラグ化
		if (メット取得フラグ == false && シャツ取得フラグ == false
				&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
			グラチェンジフラグ = false;
		} else if (メット取得フラグ == true && シャツ取得フラグ == true
				&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
			グラチェンジフラグ = false;
		} else if (状態フラグ無敵 == true) {
			グラチェンジフラグ = false;
			// ※1
		} else if (メット取得フラグ == true && シャツ取得フラグ == false
				&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
			グラチェンジフラグ = true;
			// ※2
		} else if (メット取得フラグ == true && シャツ取得フラグ == true
				&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
			グラチェンジフラグ = true;
			// ※3
		} else if (メット取得フラグ == false && シャツ取得フラグ == true
				&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
			グラチェンジフラグ = true;
			// ※4
		} else if (メット取得フラグ == false && シャツ取得フラグ == true
				&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
			グラチェンジフラグ = true;
			// ※5
		} else if (メット取得フラグ == false && シャツ取得フラグ == false
				&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
			グラチェンジフラグ = true;
			// ※6
		} else if (メット取得フラグ == true && シャツ取得フラグ == false
				&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
			グラチェンジフラグ = true;
		}
		// 判定ラインの追加
		// 上の当たり判定
		contactLines.playerContactLineAbove = getBaseActivity().getResourceUtil()
				.getSprite("player_16_contact_line_above.png");
		attachChild(contactLines.playerContactLineAbove);
		contactLines.playerContactLineAbove.setAlpha(0.5f);
		contactLines.playerContactLineAbove.setZIndex(レイヤー17デバッグ用);
		sortChildren();
		// 下の当たり判定
		contactLines.playerContactLineBelow = getBaseActivity().getResourceUtil()
				.getSprite("player_17_contact_line_below.png");
		attachChild(contactLines.playerContactLineBelow);
		contactLines.playerContactLineBelow.setAlpha(0.5f);
		contactLines.playerContactLineBelow.setZIndex(レイヤー17デバッグ用);
		sortChildren();
		// 中の当たり判定（1つ目）
		contactLines.playerContactLineCenter1 = getBaseActivity().getResourceUtil()
				.getSprite("player_18_contact_line_center_1.png");
		attachChild(contactLines.playerContactLineCenter1);
		contactLines.playerContactLineCenter1.setAlpha(0.5f);
		contactLines.playerContactLineCenter1.setZIndex(レイヤー17デバッグ用);
		sortChildren();
		// 中の当たり判定（2つ目）
		contactLines.playerContactLineCenter2 = getBaseActivity().getResourceUtil()
				.getSprite("player_19_contact_line_center_2.png");
		attachChild(contactLines.playerContactLineCenter2);
		contactLines.playerContactLineCenter2.setAlpha(0.5f);
		contactLines.playerContactLineCenter2.setZIndex(レイヤー17デバッグ用);
		sortChildren();
		// 核の当たり判定
		contactLines.playerContactLineCore = getBaseActivity().getResourceUtil()
				.getSprite("player_20_contact_line_core.png");
		attachChild(contactLines.playerContactLineCore);
		contactLines.playerContactLineCore.setAlpha(0.5f);
		contactLines.playerContactLineCore.setZIndex(レイヤー17デバッグ用);
		sortChildren();
		// スタッフクレジットじゃないときの処理
		if (コースカウンター != 22) {
			// まず、攻撃ボタンの位置を変数に代入
			攻撃ボタン位置 = 攻撃ボタン位置記憶.getInstance(getBaseActivity()).get攻撃ボタン位置記憶();
			// 攻撃ボタン
			if (現在のボール == 0) {
				// ボタンダミーをアニマテッドで描画
				ボール攻撃ボタンプッシュ = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("button_23_game_play_attack_fireball_push.png", 1, 2);
				placeToCenterX(ボール攻撃ボタンプッシュ, 352);
				ボール攻撃ボタンプッシュ.setY(ボール攻撃ボタンプッシュ.getY() + 400);
				ボール攻撃ボタンプッシュ.setCurrentTileIndex(0);
				ボール攻撃ボタンプッシュ.setAlpha(0.5f);
				attachChild(ボール攻撃ボタンプッシュ);
				ボール攻撃ボタンプッシュ.setZIndex(レイヤー14ボタン用);
				sortChildren();
				// 手持ちのボールがない場合、パンチ攻撃ボタンを優先的に表示
				// "押した瞬間に反応する"攻撃ボタン（ボールあり）の追加
				ボール攻撃ボタン = new Sprite(0, 0, (TextureRegion)
						getBaseActivity().getResourceUtil()
						.getSprite("button_23_game_play_attack_fireball.png").getTextureRegion(),
						this.getBaseActivity().getVertexBufferObjectManager()){
					@Override
					public boolean onAreaTouched(final TouchEvent pSceneTouchEvent,
							final float pTouchAreaLocalX, final float pTouchAreaLocalY) {
						switch (pSceneTouchEvent.getAction()) {
						case TouchEvent.ACTION_DOWN:
							if (!ゲーム待機中かどうか && !ポーズ中かどうか
									&& !ゲームオーバーかどうか && !パンチハンド実行フラグ) {
								ボール攻撃ボタンプッシュ.setCurrentTileIndex(1);
								// 0.25秒ストップ！
								registerUpdateHandler(new TimerHandler(0.25f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										ボール攻撃ボタンプッシュ.setCurrentTileIndex(0);
									}
								}));
								ballAttackSprite();
							}
							break;
						case TouchEvent.ACTION_UP:
							break;
						case TouchEvent.ACTION_CANCEL:
							break;
						}
						return true;
					}
				};
				placeToCenterX(ボール攻撃ボタン, 352);
				ボール攻撃ボタン.setY(ボール攻撃ボタン.getY() + 400);
				registerTouchArea(ボール攻撃ボタン);
				attachChild(ボール攻撃ボタン);
				ボール攻撃ボタン.setZIndex(レイヤー14ボタン用);
				sortChildren();
				// ボタンダミーをアニマテッドで描画
				パンチ攻撃ボタンプッシュ = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("button_24_game_play_attack_punch_push.png", 1, 2);
				placeToCenterX(パンチ攻撃ボタンプッシュ, 352);
				パンチ攻撃ボタンプッシュ.setY(パンチ攻撃ボタンプッシュ.getY() + 400);
				パンチ攻撃ボタンプッシュ.setCurrentTileIndex(0);
				パンチ攻撃ボタンプッシュ.setAlpha(0.5f);
				attachChild(パンチ攻撃ボタンプッシュ);
				パンチ攻撃ボタンプッシュ.setZIndex(レイヤー14ボタン用);
				sortChildren();
				// "押した瞬間に反応する"攻撃ボタン（ボールなし）の追加
				パンチ攻撃ボタン = new Sprite(0, 0, (TextureRegion)
						getBaseActivity().getResourceUtil()
						.getSprite("button_24_game_play_attack_punch.png").getTextureRegion(),
						this.getBaseActivity().getVertexBufferObjectManager()){
					@Override
					public boolean onAreaTouched(final TouchEvent pSceneTouchEvent,
							final float pTouchAreaLocalX, final float pTouchAreaLocalY) {
						switch (pSceneTouchEvent.getAction()) {
						case TouchEvent.ACTION_DOWN:
							if (!ゲーム待機中かどうか && !ポーズ中かどうか
									&& !ゲームオーバーかどうか && !バック転実行フラグ) {
								パンチ攻撃ボタンプッシュ.setCurrentTileIndex(1);
								// 0.25秒ストップ！
								registerUpdateHandler(new TimerHandler(0.25f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										パンチ攻撃ボタンプッシュ.setCurrentTileIndex(0);
									}
								}));
								punchAttackSprite();
							}
							break;
						case TouchEvent.ACTION_UP:
							break;
						case TouchEvent.ACTION_CANCEL:
							break;
						}
						return true;
					}
				};
				placeToCenterX(パンチ攻撃ボタン, 352);
				パンチ攻撃ボタン.setY(パンチ攻撃ボタン.getY() + 400);
				registerTouchArea(パンチ攻撃ボタン);
				attachChild(パンチ攻撃ボタン);
				パンチ攻撃ボタン.setZIndex(レイヤー14ボタン用);
				sortChildren();
				// NGボタンのY座を動かす。（OKはそのまま）
				if (攻撃ボタン位置 == 0) {
					パンチ攻撃ボタンプッシュ.registerEntityModifier(new SequenceEntityModifier(
							new DelayModifier(3), new MoveModifier(0.5f, 0, 0,
									パンチ攻撃ボタンプッシュ.getY(), パンチ攻撃ボタンプッシュ.getY() - 400,
									EaseBackInOut.getInstance())));
					パンチ攻撃ボタン.registerEntityModifier(new SequenceEntityModifier(
							new DelayModifier(3), new MoveModifier(0.5f, 0, 0,
									パンチ攻撃ボタン.getY(), パンチ攻撃ボタン.getY() - 400,
									EaseBackInOut.getInstance())));
				} else if (攻撃ボタン位置 == 1) {
					パンチ攻撃ボタンプッシュ.registerEntityModifier(new SequenceEntityModifier(
							new DelayModifier(3), new MoveModifier(0.5f, 336, 336,
									パンチ攻撃ボタンプッシュ.getY(), パンチ攻撃ボタンプッシュ.getY() - 400,
									EaseBackInOut.getInstance())));
					パンチ攻撃ボタン.registerEntityModifier(new SequenceEntityModifier(
							new DelayModifier(3), new MoveModifier(0.5f, 336, 336,
									パンチ攻撃ボタン.getY(), パンチ攻撃ボタン.getY() - 400,
									EaseBackInOut.getInstance())));
				} else if (攻撃ボタン位置 == 2) {
					パンチ攻撃ボタンプッシュ.registerEntityModifier(new SequenceEntityModifier(
							new DelayModifier(3), new MoveModifier(0.5f, 672, 672,
									パンチ攻撃ボタンプッシュ.getY(), パンチ攻撃ボタンプッシュ.getY() - 400,
									EaseBackInOut.getInstance())));
					パンチ攻撃ボタン.registerEntityModifier(new SequenceEntityModifier(
							new DelayModifier(3), new MoveModifier(0.5f, 672, 672,
									パンチ攻撃ボタン.getY(), パンチ攻撃ボタン.getY() - 400,
									EaseBackInOut.getInstance())));
				}
			} else {
				// ボタンダミーをアニマテッドで描画
				ボール攻撃ボタンプッシュ = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("button_23_game_play_attack_fireball_push.png", 1, 2);
				placeToCenterX(ボール攻撃ボタンプッシュ, 352);
				ボール攻撃ボタンプッシュ.setY(ボール攻撃ボタンプッシュ.getY() + 400);
				ボール攻撃ボタンプッシュ.setCurrentTileIndex(0);
				ボール攻撃ボタンプッシュ.setAlpha(0.5f);
				attachChild(ボール攻撃ボタンプッシュ);
				ボール攻撃ボタンプッシュ.setZIndex(レイヤー14ボタン用);
				sortChildren();
				// 手持ちのボールがある場合、ボール攻撃ボタンを優先的に表示
				// "押した瞬間に反応する"攻撃ボタン（ボールあり）の追加
				ボール攻撃ボタン = new Sprite(0, 0, (TextureRegion)
						getBaseActivity().getResourceUtil()
						.getSprite("button_23_game_play_attack_fireball.png").getTextureRegion(),
						this.getBaseActivity().getVertexBufferObjectManager()){
					@Override
					public boolean onAreaTouched(final TouchEvent pSceneTouchEvent,
							final float pTouchAreaLocalX, final float pTouchAreaLocalY) {
						switch (pSceneTouchEvent.getAction()) {
						case TouchEvent.ACTION_DOWN:
							if (!ゲーム待機中かどうか && !ポーズ中かどうか
									&& !ゲームオーバーかどうか && !パンチハンド実行フラグ) {
								ボール攻撃ボタンプッシュ.setCurrentTileIndex(1);
								// 0.25秒ストップ！
								registerUpdateHandler(new TimerHandler(0.25f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										ボール攻撃ボタンプッシュ.setCurrentTileIndex(0);
									}
								}));
								ballAttackSprite();
							}
							break;
						case TouchEvent.ACTION_UP:
							break;
						case TouchEvent.ACTION_CANCEL:
							break;
						}
						return true;
					}
				};
				placeToCenterX(ボール攻撃ボタン, 352);
				ボール攻撃ボタン.setY(ボール攻撃ボタン.getY() + 400);
				registerTouchArea(ボール攻撃ボタン);
				attachChild(ボール攻撃ボタン);
				ボール攻撃ボタン.setZIndex(レイヤー14ボタン用);
				sortChildren();
				// OKボタンのY座を動かす。（NGはそのまま）
				if (攻撃ボタン位置 == 0) {
					ボール攻撃ボタンプッシュ.registerEntityModifier(new SequenceEntityModifier(
							new DelayModifier(3), new MoveModifier(0.5f, 0, 0,
									ボール攻撃ボタンプッシュ.getY(), ボール攻撃ボタンプッシュ.getY() - 400,
									EaseBackInOut.getInstance())));
					ボール攻撃ボタン.registerEntityModifier(new SequenceEntityModifier(
							new DelayModifier(3), new MoveModifier(0.5f, 0, 0,
									ボール攻撃ボタン.getY(), ボール攻撃ボタン.getY() - 400,
									EaseBackInOut.getInstance())));
				} else if (攻撃ボタン位置 == 1) {
					ボール攻撃ボタンプッシュ.registerEntityModifier(new SequenceEntityModifier(
							new DelayModifier(3), new MoveModifier(0.5f, 336, 336,
									ボール攻撃ボタンプッシュ.getY(), ボール攻撃ボタンプッシュ.getY() - 400,
									EaseBackInOut.getInstance())));
					ボール攻撃ボタン.registerEntityModifier(new SequenceEntityModifier(
							new DelayModifier(3), new MoveModifier(0.5f, 336, 336,
									ボール攻撃ボタン.getY(), ボール攻撃ボタン.getY() - 400,
									EaseBackInOut.getInstance())));
				} else if (攻撃ボタン位置 == 2) {
					ボール攻撃ボタンプッシュ.registerEntityModifier(new SequenceEntityModifier(
							new DelayModifier(3), new MoveModifier(0.5f, 672, 672,
									ボール攻撃ボタンプッシュ.getY(), ボール攻撃ボタンプッシュ.getY() - 400,
									EaseBackInOut.getInstance())));
					ボール攻撃ボタン.registerEntityModifier(new SequenceEntityModifier(
							new DelayModifier(3), new MoveModifier(0.5f, 672, 672,
									ボール攻撃ボタン.getY(), ボール攻撃ボタン.getY() - 400,
									EaseBackInOut.getInstance())));
				}
				// ボタンダミーをアニマテッドで描画
				パンチ攻撃ボタンプッシュ = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("button_24_game_play_attack_punch_push.png", 1, 2);
				placeToCenterX(パンチ攻撃ボタンプッシュ, 352);
				パンチ攻撃ボタンプッシュ.setY(パンチ攻撃ボタンプッシュ.getY() + 400);
				パンチ攻撃ボタンプッシュ.setCurrentTileIndex(0);
				パンチ攻撃ボタンプッシュ.setAlpha(0.5f);
				attachChild(パンチ攻撃ボタンプッシュ);
				パンチ攻撃ボタンプッシュ.setZIndex(レイヤー14ボタン用);
				sortChildren();
				// "押した瞬間に反応する"攻撃ボタン（ボールなし）の追加
				パンチ攻撃ボタン = new Sprite(0, 0, (TextureRegion)
						getBaseActivity().getResourceUtil()
						.getSprite("button_24_game_play_attack_punch.png").getTextureRegion(),
						this.getBaseActivity().getVertexBufferObjectManager()){
					@Override
					public boolean onAreaTouched(final TouchEvent pSceneTouchEvent,
							final float pTouchAreaLocalX, final float pTouchAreaLocalY) {
						switch (pSceneTouchEvent.getAction()) {
						case TouchEvent.ACTION_DOWN:
							if (!ゲーム待機中かどうか && !ポーズ中かどうか
									&& !ゲームオーバーかどうか && !バック転実行フラグ) {
								パンチ攻撃ボタンプッシュ.setCurrentTileIndex(1);
								// 0.25秒ストップ！
								registerUpdateHandler(new TimerHandler(0.25f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										パンチ攻撃ボタンプッシュ.setCurrentTileIndex(0);
									}
								}));
								punchAttackSprite();
							}
							break;
						case TouchEvent.ACTION_UP:
							break;
						case TouchEvent.ACTION_CANCEL:
							break;
						}
						return true;
					}
				};
				placeToCenterX(パンチ攻撃ボタン, 352);
				パンチ攻撃ボタン.setY(パンチ攻撃ボタン.getY() + 400);
				registerTouchArea(パンチ攻撃ボタン);
				attachChild(パンチ攻撃ボタン);
				パンチ攻撃ボタン.setZIndex(レイヤー14ボタン用);
				sortChildren();
			}
			// 色々デタッチ！
			テキスト3.detachSelf();
			ライフテキスト一時.detachSelf();
			テキスト6.detachSelf();
			ワールドテキスト一時.detachSelf();
			テキスト8.detachSelf();
			コーステキスト一時.detachSelf();
			アイコンマリオ.detachSelf();
			// コンチ時は専用テキストを削除
			if (現在のコンチニュー >= 1) {
				テキスト11.detachSelf();
				コンチテキスト1.detachSelf();
				コンチテキスト2.detachSelf();
			}
			// マリオのグラセット1
			if (グラチェンジフラグ == false) {
				marioSets.playerMarioSet1 = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("player_01_mario_set_1.png", 1, 30);
				marioSets.playerMarioSet1.setPosition(64, 480);
				attachChild(marioSets.playerMarioSet1);
				marioSets.playerMarioSet1.setZIndex(レイヤー10プレイヤー用);
				sortChildren();
			} else {
				// マリオのグラセット2
				marioSets.playerMarioSet2 = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("player_02_mario_set_2.png", 1, 30);
				marioSets.playerMarioSet2.setPosition(64, 480);
				attachChild(marioSets.playerMarioSet2);
				marioSets.playerMarioSet2.setZIndex(レイヤー10プレイヤー用);
				sortChildren();
			}
			// ジャンプ時のグラ
			playerJumpAnimation();
			// ゲームスタート！
			// 1秒ストップ！
			registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					SoundPlay.seJump.stop();
					SoundPlay.seJump.play();
					VoicePlay.voicePlayerAppear.stop();
					VoicePlay.voicePlayerAppear.play();
					registerUpdateHandler(スタート時レート);
				}
			}));
			// スタッフクレジット時の処理
		} else {
			// 端末に搭載されたフォントを利用する
			Texture texture = new BitmapTextureAtlas(getBaseActivity()
					.getTextureManager(), 512, 512,
					TextureOptions.BILINEAR_PREMULTIPLYALPHA);
			Font font = new Font(getBaseActivity().getFontManager(), texture,
					Typeface.DEFAULT_BOLD, 21, true, Color.WHITE);
			getBaseActivity().getTextureManager().loadTexture(texture);
			getBaseActivity().getFontManager().loadFont(font);
			// 1.読み込んだフォントを利用してクレジットコインを表示
			SCテキスト1				= new Text(208, 436, font, "×",
					42, new TextOptions(HorizontalAlign.LEFT),
					getBaseActivity().getVertexBufferObjectManager());
			attachChild(SCテキスト1);
			SCテキスト1.setZIndex(レイヤー13テキスト用);
			sortChildren();
			クレジットコインテキスト			= new Text(224, 436, font, ""
					+ 現在のクレジットコイン, 42, new TextOptions(HorizontalAlign.LEFT),
					getBaseActivity().getVertexBufferObjectManager());
			attachChild(クレジットコインテキスト);
			クレジットコインテキスト.setZIndex(レイヤー13テキスト用);
			sortChildren();
			// 2.読み込んだフォントを利用してハイスコアコインを表示
			SCテキスト2				= new Text(16, 420, font, "High",
					42, new TextOptions(HorizontalAlign.LEFT),
					getBaseActivity().getVertexBufferObjectManager());
			attachChild(SCテキスト2);
			SCテキスト2.setZIndex(レイヤー13テキスト用);
			sortChildren();
			ハイスコアコインテキスト			= new Text(16, 452, font, ""
					+ クレジットコインデータ.getInstance(getBaseActivity()).getクレジットコインデータ(),
					42, new TextOptions(HorizontalAlign.LEFT),
					getBaseActivity().getVertexBufferObjectManager());
			attachChild(ハイスコアコインテキスト);
			ハイスコアコインテキスト.setZIndex(レイヤー13テキスト用);
			sortChildren();
			// クレジット用ウインドウをアニマテッドで描画
			クレジット用ウインドウ = getBaseActivity().getResourceUtil()
					.getSprite("credit_02_window.png");
			クレジット用ウインドウ.setPosition(0, 0);
			クレジット用ウインドウ.setAlpha(0.5f);
			attachChild(クレジット用ウインドウ);
			クレジット用ウインドウ.setZIndex(レイヤー12アイコン用);
			sortChildren();
			// アイコインをアニマテッドで描画
			アイコイン = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("icon_02_coin.png", 1, 4);
			アイコイン.setPosition(184, 440);
			アイコイン.animate(ani遅);
			attachChild(アイコイン);
			アイコイン.setZIndex(レイヤー12アイコン用);
			sortChildren();
			// マリオのグラセット1
			if (グラチェンジフラグ == false) {
				marioSets.playerMarioSet1 = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("player_01_mario_set_1.png", 1, 30);
				marioSets.playerMarioSet1.setPosition(-160, 480);
				attachChild(marioSets.playerMarioSet1);
				marioSets.playerMarioSet1.setZIndex(レイヤー10プレイヤー用);
				sortChildren();
			} else {
				// マリオのグラセット2
				marioSets.playerMarioSet2 = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("player_02_mario_set_2.png", 1, 30);
				marioSets.playerMarioSet2.setPosition(-160, 480);
				attachChild(marioSets.playerMarioSet2);
				marioSets.playerMarioSet2.setZIndex(レイヤー10プレイヤー用);
				sortChildren();
			}
			// スキップボタンの定義と処理をインスタンスで！
			final ButtonSprite スキップボタン = ResourceUtil.getInstance(getBaseActivity())
					.getButtonSprite("credit_58_button_skip.png",
							"credit_58_button_skip_push.png");
			スキップボタン.setPosition(704, 432);
			registerTouchArea(スキップボタン);
			attachChild(スキップボタン);
			スキップボタン.setZIndex(レイヤー14ボタン用);
			sortChildren();
			スキップボタン.setOnClickListener(new ButtonSprite.OnClickListener() {
				public void onClick(ButtonSprite pButtonSprite,
						float pTouchAreaLocalX, float pTouchAreaLocalY) {
					クレジットスキップしたかどうか = true;
					// 色々デタッチ！
					スキップボタン.detachSelf();
					unregisterTouchArea(スキップボタン);
					// 6秒ストップ！
					registerUpdateHandler(new TimerHandler(6, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							コースの端っこかどうか = true;
							// 「センキュー」ボイス！
							VoicePlay.voiceGameClear.stop();
							VoicePlay.voiceGameClear.play();
							// THE ENDロゴ
							// エンドロゴ1
							Sprite アイコンエンド1 = ResourceUtil.getInstance(getBaseActivity())
									.getSprite("credit_04_t_character.png");
							アイコンエンド1.setPosition(224, -256);
							attachChild(アイコンエンド1);
							アイコンエンド1.setZIndex(レイヤー12アイコン用);
							sortChildren();
							アイコンエンド1.registerEntityModifier(new SequenceEntityModifier(
									new DelayModifier(1), new MoveModifier(1.25f,
											アイコンエンド1.getX(), アイコンエンド1.getX(),
											アイコンエンド1.getY() - 2400, アイコンエンド1.getY() + 320,
											EaseBackInOut.getInstance())));
							// エンドロゴ2
							Sprite アイコンエンド2 = ResourceUtil.getInstance(getBaseActivity())
									.getSprite("credit_05_h_character.png");
							アイコンエンド2.setPosition(272, -256);
							attachChild(アイコンエンド2);
							アイコンエンド2.setZIndex(レイヤー12アイコン用);
							sortChildren();
							アイコンエンド2.registerEntityModifier(new SequenceEntityModifier(
									new DelayModifier(1), new MoveModifier(1.50f,
											アイコンエンド2.getX(), アイコンエンド2.getX(),
											アイコンエンド2.getY() - 2400, アイコンエンド2.getY() + 320,
											EaseBackInOut.getInstance())));
							// エンドロゴ3
							Sprite アイコンエンド3 = ResourceUtil.getInstance(getBaseActivity())
									.getSprite("credit_06_e_character.png");
							アイコンエンド3.setPosition(320, -256);
							attachChild(アイコンエンド3);
							アイコンエンド3.setZIndex(レイヤー12アイコン用);
							sortChildren();
							アイコンエンド3.registerEntityModifier(new SequenceEntityModifier(
									new DelayModifier(1), new MoveModifier(1.75f,
											アイコンエンド3.getX(), アイコンエンド3.getX(),
											アイコンエンド3.getY() - 2400, アイコンエンド3.getY() + 320,
											EaseBackInOut.getInstance())));
							// エンドロゴ4
							Sprite アイコンエンド4 = ResourceUtil.getInstance(getBaseActivity())
									.getSprite("credit_07_e_character.png");
							アイコンエンド4.setPosition(416, -256);
							attachChild(アイコンエンド4);
							アイコンエンド4.setZIndex(レイヤー12アイコン用);
							sortChildren();
							アイコンエンド4.registerEntityModifier(new SequenceEntityModifier(
									new DelayModifier(1), new MoveModifier(2.00f,
											アイコンエンド4.getX(), アイコンエンド4.getX(),
											アイコンエンド4.getY() - 2400, アイコンエンド4.getY() + 320,
											EaseBackInOut.getInstance())));
							// エンドロゴ5
							Sprite アイコンエンド5 = ResourceUtil.getInstance(getBaseActivity())
									.getSprite("credit_08_n_character.png");
							アイコンエンド5.setPosition(464, -256);
							attachChild(アイコンエンド5);
							アイコンエンド5.setZIndex(レイヤー12アイコン用);
							sortChildren();
							アイコンエンド5.registerEntityModifier(new SequenceEntityModifier(
									new DelayModifier(1), new MoveModifier(2.25f,
											アイコンエンド5.getX(), アイコンエンド5.getX(),
											アイコンエンド5.getY() - 2400, アイコンエンド5.getY() + 320,
											EaseBackInOut.getInstance())));
							// エンドロゴ6
							Sprite アイコンエンド6 = ResourceUtil.getInstance(getBaseActivity())
									.getSprite("credit_09_d_character.png");
							アイコンエンド6.setPosition(512, -256);
							attachChild(アイコンエンド6);
							アイコンエンド6.setZIndex(レイヤー12アイコン用);
							sortChildren();
							アイコンエンド6.registerEntityModifier(new SequenceEntityModifier(
									new DelayModifier(1), new MoveModifier(2.50f,
											アイコンエンド6.getX(), アイコンエンド6.getX(),
											アイコンエンド6.getY() - 2400, アイコンエンド6.getY() + 320,
											EaseBackInOut.getInstance())));
							// エンドロゴ7
							Sprite アイコンエンド7 = ResourceUtil.getInstance(getBaseActivity())
									.getSprite("credit_10_!_character.png");
							アイコンエンド7.setPosition(560, -256);
							attachChild(アイコンエンド7);
							アイコンエンド7.setZIndex(レイヤー12アイコン用);
							sortChildren();
							アイコンエンド7.registerEntityModifier(new SequenceEntityModifier(
									new DelayModifier(1), new MoveModifier(2.75f,
											アイコンエンド7.getX(), アイコンエンド7.getX(),
											アイコンエンド7.getY() - 2400, アイコンエンド7.getY() + 320,
											EaseBackInOut.getInstance())));
							// ゲームクリア
							gameClear();
						}
					}));
				}
			});
			// ダッシュ時のグラ
			playerDashAnimation();
			// スタッフクレジットスタート！
			// 3秒ストップ！（「レッツゴー」ボイス）
			registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					VoicePlay.voiceGameStart.stop();
					VoicePlay.voiceGameStart.play();
					registerUpdateHandler(スタート時レート);
				}
			}));
			// 6秒ストップ！（スーパーけんじラン_スタッフクレジット）
			registerUpdateHandler(new TimerHandler(6, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					final Sprite スーパーけんじラン_スタッフクレジット = getBaseActivity().getResourceUtil()
							.getSprite("credit_03_super_kenji_run_staff_credit_character.png");
					placeToCenterX(スーパーけんじラン_スタッフクレジット, 64);
					スーパーけんじラン_スタッフクレジット.setAlpha(0);
					attachChild(スーパーけんじラン_スタッフクレジット);
					スーパーけんじラン_スタッフクレジット.setZIndex(レイヤー12アイコン用);
					sortChildren();
					スーパーけんじラン_スタッフクレジット.registerEntityModifier(new FadeInModifier(1.5f));
					// 4.5秒ストップ！（ジャンル名削除）
					registerUpdateHandler(new TimerHandler(4.5f, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							スーパーけんじラン_スタッフクレジット.registerEntityModifier(new FadeOutModifier(1.5f));
							// 1.5秒ストップ！
							registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
								public void onTimePassed(TimerHandler pTimeHandler) {
									スーパーけんじラン_スタッフクレジット.detachSelf();
								}
							}));
						}
					}));
				}
			}));
			// 12秒ストップ！（ゲームシステム）
			registerUpdateHandler(new TimerHandler(12, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					if (クレジットスキップしたかどうか == false) {
						final Sprite ゲームシステム = getBaseActivity().getResourceUtil()
								.getSprite("credit_11_name_game_system.png");
						placeToCenterX(ゲームシステム, 16);
						ゲームシステム.setAlpha(0);
						ゲームシステム.setScale(0.75f);
						attachChild(ゲームシステム);
						ゲームシステム.setZIndex(レイヤー12アイコン用);
						sortChildren();
						ゲームシステム.registerEntityModifier(new FadeInModifier(1.5f));
						// 1.5秒ストップ！（スタッフ名表示）
						registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								final Sprite おかもと_けんじ = getBaseActivity().getResourceUtil()
										.getSprite("credit_12_name_okamoto_kenji.png");
								おかもと_けんじ.setPosition(32, 80);
								おかもと_けんじ.setAlpha(0);
								おかもと_けんじ.setScale(0.75f);
								attachChild(おかもと_けんじ);
								おかもと_けんじ.setZIndex(レイヤー12アイコン用);
								sortChildren();
								おかもと_けんじ.registerEntityModifier(new FadeInModifier(1.5f));
								final Sprite さとう_じんご = getBaseActivity().getResourceUtil()
										.getSprite("credit_13_name_satou_jingo.png");
								さとう_じんご.setPosition(448, 80);
								さとう_じんご.setAlpha(0);
								さとう_じんご.setScale(0.75f);
								attachChild(さとう_じんご);
								さとう_じんご.setZIndex(レイヤー12アイコン用);
								sortChildren();
								さとう_じんご.registerEntityModifier(new FadeInModifier(1.5f));
								// 3秒ストップ！
								registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										おかもと_けんじ.registerEntityModifier(new FadeOutModifier(1.5f));
										さとう_じんご.registerEntityModifier(new FadeOutModifier(1.5f));
										// 1.5秒ストップ！
										registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
											public void onTimePassed(TimerHandler pTimeHandler) {
												おかもと_けんじ.detachSelf();
												さとう_じんご.detachSelf();
											}
										}));
									}
								}));
							}
						}));
						// 4.5秒ストップ！（ジャンル名削除）
						registerUpdateHandler(new TimerHandler(4.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								ゲームシステム.registerEntityModifier(new FadeOutModifier(1.5f));
								// 1.5秒ストップ！
								registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										ゲームシステム.detachSelf();
									}
								}));
							}
						}));
					}
				}
			}));
			// 18秒ストップ！（プログラム）
			registerUpdateHandler(new TimerHandler(18, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					if (クレジットスキップしたかどうか == false) {
						final Sprite プログラム = getBaseActivity().getResourceUtil()
								.getSprite("credit_14_name_program.png");
						placeToCenterX(プログラム, 16);
						プログラム.setAlpha(0);
						プログラム.setScale(0.75f);
						attachChild(プログラム);
						プログラム.setZIndex(レイヤー12アイコン用);
						sortChildren();
						プログラム.registerEntityModifier(new FadeInModifier(1.5f));
						// 1.5秒ストップ！（スタッフ名表示）
						registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								final Sprite おかもと_けんじ = getBaseActivity().getResourceUtil()
										.getSprite("credit_15_name_okamoto_kenji.png");
								おかもと_けんじ.setPosition(32, 80);
								おかもと_けんじ.setAlpha(0);
								おかもと_けんじ.setScale(0.75f);
								attachChild(おかもと_けんじ);
								おかもと_けんじ.setZIndex(レイヤー12アイコン用);
								sortChildren();
								おかもと_けんじ.registerEntityModifier(new FadeInModifier(1.5f));
								final Sprite きょうごく_たけし = getBaseActivity().getResourceUtil()
										.getSprite("credit_16_name_kyougoku_takesi.png");
								きょうごく_たけし.setPosition(448, 80);
								きょうごく_たけし.setAlpha(0);
								きょうごく_たけし.setScale(0.75f);
								attachChild(きょうごく_たけし);
								きょうごく_たけし.setZIndex(レイヤー12アイコン用);
								sortChildren();
								きょうごく_たけし.registerEntityModifier(new FadeInModifier(1.5f));
								// 3秒ストップ！
								registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										おかもと_けんじ.registerEntityModifier(new FadeOutModifier(1.5f));
										きょうごく_たけし.registerEntityModifier(new FadeOutModifier(1.5f));
										// カットしたときの処理
										if (クレジットスキップしたかどうか == true) {
											プログラム.registerEntityModifier(new FadeOutModifier(1.5f));
										}
										// 1.5秒ストップ！（第二スタッフ名表示）
										registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
											public void onTimePassed(TimerHandler pTimeHandler) {
												おかもと_けんじ.detachSelf();
												きょうごく_たけし.detachSelf();
												// カットしたときの処理
												if (クレジットスキップしたかどうか == true) {
													プログラム.detachSelf();
												}
												if (クレジットスキップしたかどうか == false) {
													final Sprite たねむら_こうじ = getBaseActivity().getResourceUtil()
															.getSprite("credit_17_name_tanemura_kouji.png");
													placeToCenterX(たねむら_こうじ, 80);
													たねむら_こうじ.setAlpha(0);
													たねむら_こうじ.setScale(0.75f);
													attachChild(たねむら_こうじ);
													たねむら_こうじ.setZIndex(レイヤー12アイコン用);
													sortChildren();
													たねむら_こうじ.registerEntityModifier(new FadeInModifier(1.5f));
													// 4.5秒ストップ！
													registerUpdateHandler(new TimerHandler(4.5f, new ITimerCallback() {
														public void onTimePassed(TimerHandler pTimeHandler) {
															たねむら_こうじ.registerEntityModifier(new FadeOutModifier(1.5f));
															// 1.5秒ストップ！
															registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
																public void onTimePassed(TimerHandler pTimeHandler) {
																	たねむら_こうじ.detachSelf();
																}
															}));
														}
													}));
												}
											}
										}));
									}
								}));
							}
						}));
						// 10.5秒ストップ！（ジャンル名削除）
						registerUpdateHandler(new TimerHandler(10.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								プログラム.registerEntityModifier(new FadeOutModifier(1.5f));
								// 1.5秒ストップ！
								registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										プログラム.detachSelf();
									}
								}));
							}
						}));
					}
				}
			}));
			// 30秒ストップ！（レベルデザイン）
			registerUpdateHandler(new TimerHandler(30, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					if (クレジットスキップしたかどうか == false) {
						final Sprite レベルデザイン = getBaseActivity().getResourceUtil()
								.getSprite("credit_18_name_level_design.png");
						placeToCenterX(レベルデザイン, 16);
						レベルデザイン.setAlpha(0);
						レベルデザイン.setScale(0.75f);
						attachChild(レベルデザイン);
						レベルデザイン.setZIndex(レイヤー12アイコン用);
						sortChildren();
						レベルデザイン.registerEntityModifier(new FadeInModifier(1.5f));
						// 1.5秒ストップ！（スタッフ名表示）
						registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								final Sprite おかもと_けんじ = getBaseActivity().getResourceUtil()
										.getSprite("credit_19_name_okamoto_kenji.png");
								placeToCenterX(おかもと_けんじ, 80);
								おかもと_けんじ.setAlpha(0);
								おかもと_けんじ.setScale(0.75f);
								attachChild(おかもと_けんじ);
								おかもと_けんじ.setZIndex(レイヤー12アイコン用);
								sortChildren();
								おかもと_けんじ.registerEntityModifier(new FadeInModifier(1.5f));
								// 3秒ストップ！
								registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										おかもと_けんじ.registerEntityModifier(new FadeOutModifier(1.5f));
										// 1.5秒ストップ！
										registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
											public void onTimePassed(TimerHandler pTimeHandler) {
												おかもと_けんじ.detachSelf();
											}
										}));
									}
								}));
							}
						}));
						// 4.5秒ストップ！（ジャンル名削除）
						registerUpdateHandler(new TimerHandler(4.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								レベルデザイン.registerEntityModifier(new FadeOutModifier(1.5f));
								// 1.5秒ストップ！
								registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										レベルデザイン.detachSelf();
									}
								}));
							}
						}));
					}
				}
			}));
			// 36秒ストップ！（イラスト）
			registerUpdateHandler(new TimerHandler(36, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					if (クレジットスキップしたかどうか == false) {
						final Sprite イラスト = getBaseActivity().getResourceUtil()
								.getSprite("credit_20_name_illustration.png");
						placeToCenterX(イラスト, 16);
						イラスト.setAlpha(0);
						イラスト.setScale(0.75f);
						attachChild(イラスト);
						イラスト.setZIndex(レイヤー12アイコン用);
						sortChildren();
						イラスト.registerEntityModifier(new FadeInModifier(1.5f));
						// 1.5秒ストップ！（スタッフ名表示）
						registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								final Sprite たがみ_けんすけ = getBaseActivity().getResourceUtil()
										.getSprite("credit_21_name_tagami_kensuke.png");
								たがみ_けんすけ.setPosition(32, 80);
								たがみ_けんすけ.setAlpha(0);
								たがみ_けんすけ.setScale(0.75f);
								attachChild(たがみ_けんすけ);
								たがみ_けんすけ.setZIndex(レイヤー12アイコン用);
								sortChildren();
								たがみ_けんすけ.registerEntityModifier(new FadeInModifier(1.5f));
								final Sprite はりた_じょう = getBaseActivity().getResourceUtil()
										.getSprite("credit_22_name_harita_jou.png");
								はりた_じょう.setPosition(448, 80);
								はりた_じょう.setAlpha(0);
								はりた_じょう.setScale(0.75f);
								attachChild(はりた_じょう);
								はりた_じょう.setZIndex(レイヤー12アイコン用);
								sortChildren();
								はりた_じょう.registerEntityModifier(new FadeInModifier(1.5f));
								// 3秒ストップ！
								registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										たがみ_けんすけ.registerEntityModifier(new FadeOutModifier(1.5f));
										はりた_じょう.registerEntityModifier(new FadeOutModifier(1.5f));
										// 1.5秒ストップ！
										registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
											public void onTimePassed(TimerHandler pTimeHandler) {
												たがみ_けんすけ.detachSelf();
												はりた_じょう.detachSelf();
											}
										}));
									}
								}));
							}
						}));
						// 4.5秒ストップ！（ジャンル名削除）
						registerUpdateHandler(new TimerHandler(4.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								イラスト.registerEntityModifier(new FadeOutModifier(1.5f));
								// 1.5秒ストップ！
								registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										イラスト.detachSelf();
									}
								}));
							}
						}));
					}
				}
			}));
			// 42秒ストップ！（キャラクターデザイン）
			registerUpdateHandler(new TimerHandler(42, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					if (クレジットスキップしたかどうか == false) {
						final Sprite キャラクターデザイン = getBaseActivity().getResourceUtil()
								.getSprite("credit_23_name_character_design.png");
						placeToCenterX(キャラクターデザイン, 16);
						キャラクターデザイン.setAlpha(0);
						キャラクターデザイン.setScale(0.75f);
						attachChild(キャラクターデザイン);
						キャラクターデザイン.setZIndex(レイヤー12アイコン用);
						sortChildren();
						キャラクターデザイン.registerEntityModifier(new FadeInModifier(1.5f));
						// 1.5秒ストップ！（スタッフ名表示）
						registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								final Sprite おかもと_けんじ = getBaseActivity().getResourceUtil()
										.getSprite("credit_24_name_okamoto_kenji.png");
								おかもと_けんじ.setPosition(32, 80);
								おかもと_けんじ.setAlpha(0);
								おかもと_けんじ.setScale(0.75f);
								attachChild(おかもと_けんじ);
								おかもと_けんじ.setZIndex(レイヤー12アイコン用);
								sortChildren();
								おかもと_けんじ.registerEntityModifier(new FadeInModifier(1.5f));
								final Sprite たがみ_けんすけ = getBaseActivity().getResourceUtil()
										.getSprite("credit_25_name_tagami_kensuke.png");
								たがみ_けんすけ.setPosition(448, 80);
								たがみ_けんすけ.setAlpha(0);
								たがみ_けんすけ.setScale(0.75f);
								attachChild(たがみ_けんすけ);
								たがみ_けんすけ.setZIndex(レイヤー12アイコン用);
								sortChildren();
								たがみ_けんすけ.registerEntityModifier(new FadeInModifier(1.5f));
								// 3秒ストップ！
								registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										おかもと_けんじ.registerEntityModifier(new FadeOutModifier(1.5f));
										たがみ_けんすけ.registerEntityModifier(new FadeOutModifier(1.5f));
										// カットしたときの処理
										if (クレジットスキップしたかどうか == true) {
											キャラクターデザイン.registerEntityModifier(new FadeOutModifier(1.5f));
										}
										// 1.5秒ストップ！（第二スタッフ名表示）
										registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
											public void onTimePassed(TimerHandler pTimeHandler) {
												おかもと_けんじ.detachSelf();
												たがみ_けんすけ.detachSelf();
												// カットしたときの処理
												if (クレジットスキップしたかどうか == true) {
													キャラクターデザイン.detachSelf();
												}
												if (クレジットスキップしたかどうか == false) {
													final Sprite やまだ_たかし = getBaseActivity().getResourceUtil()
															.getSprite("credit_26_name_yamada_takasi.png");
													placeToCenterX(やまだ_たかし, 80);
													やまだ_たかし.setAlpha(0);
													やまだ_たかし.setScale(0.75f);
													attachChild(やまだ_たかし);
													やまだ_たかし.setZIndex(レイヤー12アイコン用);
													sortChildren();
													やまだ_たかし.registerEntityModifier(new FadeInModifier(1.5f));
													// 4.5秒ストップ！
													registerUpdateHandler(new TimerHandler(4.5f, new ITimerCallback() {
														public void onTimePassed(TimerHandler pTimeHandler) {
															やまだ_たかし.registerEntityModifier(new FadeOutModifier(1.5f));
															// 1.5秒ストップ！
															registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
																public void onTimePassed(TimerHandler pTimeHandler) {
																	やまだ_たかし.detachSelf();
																}
															}));
														}
													}));
												}
											}
										}));
									}
								}));
							}
						}));
						// 10.5秒ストップ！（ジャンル名削除）
						registerUpdateHandler(new TimerHandler(10.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								キャラクターデザイン.registerEntityModifier(new FadeOutModifier(1.5f));
								// 1.5秒ストップ！
								registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										キャラクターデザイン.detachSelf();
									}
								}));
							}
						}));
					}
				}
			}));
			// 54秒ストップ！（ミュージック）
			registerUpdateHandler(new TimerHandler(54, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					if (クレジットスキップしたかどうか == false) {
						final Sprite ミュージック = getBaseActivity().getResourceUtil()
								.getSprite("credit_27_name_music.png");
						placeToCenterX(ミュージック, 16);
						ミュージック.setAlpha(0);
						ミュージック.setScale(0.75f);
						attachChild(ミュージック);
						ミュージック.setZIndex(レイヤー12アイコン用);
						sortChildren();
						ミュージック.registerEntityModifier(new FadeInModifier(1.5f));
						// 1.5秒ストップ！（スタッフ名表示）
						registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								final Sprite おかもと_けんじ = getBaseActivity().getResourceUtil()
										.getSprite("credit_28_name_okamoto_kenji.png");
								おかもと_けんじ.setPosition(32, 80);
								おかもと_けんじ.setAlpha(0);
								おかもと_けんじ.setScale(0.75f);
								attachChild(おかもと_けんじ);
								おかもと_けんじ.setZIndex(レイヤー12アイコン用);
								sortChildren();
								おかもと_けんじ.registerEntityModifier(new FadeInModifier(1.5f));
								final Sprite やまだ_たかし = getBaseActivity().getResourceUtil()
										.getSprite("credit_29_name_yamada_takasi.png");
								やまだ_たかし.setPosition(448, 80);
								やまだ_たかし.setAlpha(0);
								やまだ_たかし.setScale(0.75f);
								attachChild(やまだ_たかし);
								やまだ_たかし.setZIndex(レイヤー12アイコン用);
								sortChildren();
								やまだ_たかし.registerEntityModifier(new FadeInModifier(1.5f));
								// 3秒ストップ！
								registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										おかもと_けんじ.registerEntityModifier(new FadeOutModifier(1.5f));
										やまだ_たかし.registerEntityModifier(new FadeOutModifier(1.5f));
										// 1.5秒ストップ！
										registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
											public void onTimePassed(TimerHandler pTimeHandler) {
												おかもと_けんじ.detachSelf();
												やまだ_たかし.detachSelf();
											}
										}));
									}
								}));
							}
						}));
						// 4.5秒ストップ！（ジャンル名削除）
						registerUpdateHandler(new TimerHandler(4.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								ミュージック.registerEntityModifier(new FadeOutModifier(1.5f));
								// 1.5秒ストップ！
								registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										ミュージック.detachSelf();
									}
								}));
							}
						}));
					}
				}
			}));
			// 60秒ストップ！（こうかおん）
			registerUpdateHandler(new TimerHandler(60, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					if (クレジットスキップしたかどうか == false) {
						final Sprite こうかおん = getBaseActivity().getResourceUtil()
								.getSprite("credit_30_name_sound.png");
						placeToCenterX(こうかおん, 16);
						こうかおん.setAlpha(0);
						こうかおん.setScale(0.75f);
						attachChild(こうかおん);
						こうかおん.setZIndex(レイヤー12アイコン用);
						sortChildren();
						こうかおん.registerEntityModifier(new FadeInModifier(1.5f));
						// 1.5秒ストップ！（スタッフ名表示）
						registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								final Sprite おかもと_けんじ = getBaseActivity().getResourceUtil()
										.getSprite("credit_31_name_okamoto_kenji.png");
								placeToCenterX(おかもと_けんじ, 80);
								おかもと_けんじ.setAlpha(0);
								おかもと_けんじ.setScale(0.75f);
								attachChild(おかもと_けんじ);
								おかもと_けんじ.setZIndex(レイヤー12アイコン用);
								sortChildren();
								おかもと_けんじ.registerEntityModifier(new FadeInModifier(1.5f));
								// 3秒ストップ！
								registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										おかもと_けんじ.registerEntityModifier(new FadeOutModifier(1.5f));
										// 1.5秒ストップ！
										registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
											public void onTimePassed(TimerHandler pTimeHandler) {
												おかもと_けんじ.detachSelf();
											}
										}));
									}
								}));
							}
						}));
						// 4.5秒ストップ！（ジャンル名削除）
						registerUpdateHandler(new TimerHandler(4.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								こうかおん.registerEntityModifier(new FadeOutModifier(1.5f));
								// 1.5秒ストップ！
								registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										こうかおん.detachSelf();
									}
								}));
							}
						}));
					}
				}
			}));
			// 66秒ストップ！（ボイス）
			registerUpdateHandler(new TimerHandler(66, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					if (クレジットスキップしたかどうか == false) {
						final Sprite ボイス = getBaseActivity().getResourceUtil()
								.getSprite("credit_32_name_voice.png");
						placeToCenterX(ボイス, 16);
						ボイス.setAlpha(0);
						ボイス.setScale(0.75f);
						attachChild(ボイス);
						ボイス.setZIndex(レイヤー12アイコン用);
						sortChildren();
						ボイス.registerEntityModifier(new FadeInModifier(1.5f));
						// 1.5秒ストップ！（スタッフ名表示）
						registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								final Sprite おかもと_けんじ = getBaseActivity().getResourceUtil()
										.getSprite("credit_33_name_okamoto_kenji.png");
								おかもと_けんじ.setPosition(32, 80);
								おかもと_けんじ.setAlpha(0);
								おかもと_けんじ.setScale(0.75f);
								attachChild(おかもと_けんじ);
								おかもと_けんじ.setZIndex(レイヤー12アイコン用);
								sortChildren();
								おかもと_けんじ.registerEntityModifier(new FadeInModifier(1.5f));
								final Sprite のせ_みさ = getBaseActivity().getResourceUtil()
										.getSprite("credit_34_name_nose_misa.png");
								のせ_みさ.setPosition(448, 80);
								のせ_みさ.setAlpha(0);
								のせ_みさ.setScale(0.75f);
								attachChild(のせ_みさ);
								のせ_みさ.setZIndex(レイヤー12アイコン用);
								sortChildren();
								のせ_みさ.registerEntityModifier(new FadeInModifier(1.5f));
								// 3秒ストップ！
								registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										おかもと_けんじ.registerEntityModifier(new FadeOutModifier(1.5f));
										のせ_みさ.registerEntityModifier(new FadeOutModifier(1.5f));
										// 1.5秒ストップ！
										registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
											public void onTimePassed(TimerHandler pTimeHandler) {
												おかもと_けんじ.detachSelf();
												のせ_みさ.detachSelf();
											}
										}));
									}
								}));
							}
						}));
						// 4.5秒ストップ！（ジャンル名削除）
						registerUpdateHandler(new TimerHandler(4.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								ボイス.registerEntityModifier(new FadeOutModifier(1.5f));
								// 1.5秒ストップ！
								registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										ボイス.detachSelf();
									}
								}));
							}
						}));
					}
				}
			}));
			// 72秒ストップ！（デバッグ）
			registerUpdateHandler(new TimerHandler(72, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					if (クレジットスキップしたかどうか == false) {
						final Sprite デバッグ = getBaseActivity().getResourceUtil()
								.getSprite("credit_35_name_debug.png");
						placeToCenterX(デバッグ, 16);
						デバッグ.setAlpha(0);
						デバッグ.setScale(0.75f);
						attachChild(デバッグ);
						デバッグ.setZIndex(レイヤー12アイコン用);
						sortChildren();
						デバッグ.registerEntityModifier(new FadeInModifier(1.5f));
						// 1.5秒ストップ！（スタッフ名表示）
						registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								final Sprite えのもと_まこと = getBaseActivity().getResourceUtil()
										.getSprite("credit_36_name_enomoto_makoto.png");
								えのもと_まこと.setPosition(32, 80);
								えのもと_まこと.setAlpha(0);
								えのもと_まこと.setScale(0.75f);
								attachChild(えのもと_まこと);
								えのもと_まこと.setZIndex(レイヤー12アイコン用);
								sortChildren();
								えのもと_まこと.registerEntityModifier(new FadeInModifier(1.5f));
								final Sprite けんじょう_あつし = getBaseActivity().getResourceUtil()
										.getSprite("credit_37_name_kenjou_atusi.png");
								けんじょう_あつし.setPosition(448, 80);
								けんじょう_あつし.setAlpha(0);
								けんじょう_あつし.setScale(0.75f);
								attachChild(けんじょう_あつし);
								けんじょう_あつし.setZIndex(レイヤー12アイコン用);
								sortChildren();
								けんじょう_あつし.registerEntityModifier(new FadeInModifier(1.5f));
								// 3秒ストップ！
								registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										えのもと_まこと.registerEntityModifier(new FadeOutModifier(1.5f));
										けんじょう_あつし.registerEntityModifier(new FadeOutModifier(1.5f));
										// カットしたときの処理
										if (クレジットスキップしたかどうか == true) {
											デバッグ.registerEntityModifier(new FadeOutModifier(1.5f));
										}
										// 1.5秒ストップ！（第二スタッフ名表示）
										registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
											public void onTimePassed(TimerHandler pTimeHandler) {
												えのもと_まこと.detachSelf();
												けんじょう_あつし.detachSelf();
												// カットしたときの処理
												if (クレジットスキップしたかどうか == true) {
													デバッグ.detachSelf();
												}
												if (クレジットスキップしたかどうか == false) {
													final Sprite ささき_とも = getBaseActivity().getResourceUtil()
															.getSprite("credit_38_name_sasaki_tomo.png");
													ささき_とも.setPosition(32, 80);
													ささき_とも.setAlpha(0);
													ささき_とも.setScale(0.75f);
													attachChild(ささき_とも);
													ささき_とも.setZIndex(レイヤー12アイコン用);
													sortChildren();
													ささき_とも.registerEntityModifier(new FadeInModifier(1.5f));
													final Sprite さとう_じんご = getBaseActivity().getResourceUtil()
															.getSprite("credit_39_name_satou_jingo.png");
													さとう_じんご.setPosition(448, 80);
													さとう_じんご.setAlpha(0);
													さとう_じんご.setScale(0.75f);
													attachChild(さとう_じんご);
													さとう_じんご.setZIndex(レイヤー12アイコン用);
													sortChildren();
													さとう_じんご.registerEntityModifier(new FadeInModifier(1.5f));
													// 4.5秒ストップ！
													registerUpdateHandler(new TimerHandler(4.5f, new ITimerCallback() {
														public void onTimePassed(TimerHandler pTimeHandler) {
															ささき_とも.registerEntityModifier(new FadeOutModifier(1.5f));
															さとう_じんご.registerEntityModifier(new FadeOutModifier(1.5f));
															// カットしたときの処理
															if (クレジットスキップしたかどうか == true) {
																デバッグ.registerEntityModifier(new FadeOutModifier(1.5f));
															}
															// 1.5秒ストップ！（第三スタッフ名表示）
															registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
																public void onTimePassed(TimerHandler pTimeHandler) {
																	ささき_とも.detachSelf();
																	さとう_じんご.detachSelf();
																	// カットしたときの処理
																	if (クレジットスキップしたかどうか == true) {
																		デバッグ.detachSelf();
																	}
																	if (クレジットスキップしたかどうか == false) {
																		final Sprite のせ_みさ = getBaseActivity().getResourceUtil()
																				.getSprite("credit_40_name_nose_misa.png");
																		のせ_みさ.setPosition(32, 80);
																		のせ_みさ.setAlpha(0);
																		のせ_みさ.setScale(0.75f);
																		attachChild(のせ_みさ);
																		のせ_みさ.setZIndex(レイヤー12アイコン用);
																		sortChildren();
																		のせ_みさ.registerEntityModifier(new FadeInModifier(1.5f));
																		final Sprite はりた_じょう = getBaseActivity().getResourceUtil()
																				.getSprite("credit_41_name_harita_jou.png");
																		はりた_じょう.setPosition(448, 80);
																		はりた_じょう.setAlpha(0);
																		はりた_じょう.setScale(0.75f);
																		attachChild(はりた_じょう);
																		はりた_じょう.setZIndex(レイヤー12アイコン用);
																		sortChildren();
																		はりた_じょう.registerEntityModifier(new FadeInModifier(1.5f));
																		// 4.5秒ストップ！
																		registerUpdateHandler(new TimerHandler(4.5f, new ITimerCallback() {
																			public void onTimePassed(TimerHandler pTimeHandler) {
																				のせ_みさ.registerEntityModifier(new FadeOutModifier(1.5f));
																				はりた_じょう.registerEntityModifier(new FadeOutModifier(1.5f));
																				// カットしたときの処理
																				if (クレジットスキップしたかどうか == true) {
																					デバッグ.registerEntityModifier(new FadeOutModifier(1.5f));
																				}
																				// 1.5秒ストップ！（第四スタッフ名表示）
																				registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
																					public void onTimePassed(TimerHandler pTimeHandler) {
																						のせ_みさ.detachSelf();
																						はりた_じょう.detachSelf();
																						// カットしたときの処理
																						if (クレジットスキップしたかどうか == true) {
																							デバッグ.detachSelf();
																						}
																						if (クレジットスキップしたかどうか == false) {
																							final Sprite ふじの_ゆうき = getBaseActivity().getResourceUtil()
																									.getSprite("credit_42_name_hujino_yuuki.png");
																							ふじの_ゆうき.setPosition(32, 80);
																							ふじの_ゆうき.setAlpha(0);
																							ふじの_ゆうき.setScale(0.75f);
																							attachChild(ふじの_ゆうき);
																							ふじの_ゆうき.setZIndex(レイヤー12アイコン用);
																							sortChildren();
																							ふじの_ゆうき.registerEntityModifier(new FadeInModifier(1.5f));
																							final Sprite やまだ_たかし = getBaseActivity().getResourceUtil()
																									.getSprite("credit_43_name_yamada_takasi.png");
																							やまだ_たかし.setPosition(448, 80);
																							やまだ_たかし.setAlpha(0);
																							やまだ_たかし.setScale(0.75f);
																							attachChild(やまだ_たかし);
																							やまだ_たかし.setZIndex(レイヤー12アイコン用);
																							sortChildren();
																							やまだ_たかし.registerEntityModifier(new FadeInModifier(1.5f));
																							// 4.5秒ストップ！
																							registerUpdateHandler(new TimerHandler(4.5f, new ITimerCallback() {
																								public void onTimePassed(TimerHandler pTimeHandler) {
																									ふじの_ゆうき.registerEntityModifier(new FadeOutModifier(1.5f));
																									やまだ_たかし.registerEntityModifier(new FadeOutModifier(1.5f));
																									// カットしたときの処理
																									if (クレジットスキップしたかどうか == true) {
																										デバッグ.registerEntityModifier(new FadeOutModifier(1.5f));
																									}
																									// 1.5秒ストップ！（第五スタッフ名表示）
																									registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
																										public void onTimePassed(TimerHandler pTimeHandler) {
																											ふじの_ゆうき.detachSelf();
																											やまだ_たかし.detachSelf();
																											// カットしたときの処理
																											if (クレジットスキップしたかどうか == true) {
																												デバッグ.detachSelf();
																											}
																											if (クレジットスキップしたかどうか == false) {
																												final Sprite このゲームを_あそんでくれたひと = getBaseActivity().getResourceUtil()
																														.getSprite("credit_44_name_(konoge-muwo_asondekuretahito).png");
																												placeToCenterX(このゲームを_あそんでくれたひと, 80);
																												このゲームを_あそんでくれたひと.setAlpha(0);
																												このゲームを_あそんでくれたひと.setScale(0.75f);
																												attachChild(このゲームを_あそんでくれたひと);
																												このゲームを_あそんでくれたひと.setZIndex(レイヤー12アイコン用);
																												sortChildren();
																												このゲームを_あそんでくれたひと.registerEntityModifier(new FadeInModifier(1.5f));
																												// 4.5秒ストップ！
																												registerUpdateHandler(new TimerHandler(4.5f, new ITimerCallback() {
																													public void onTimePassed(TimerHandler pTimeHandler) {
																														このゲームを_あそんでくれたひと.registerEntityModifier(new FadeOutModifier(1.5f));
																														// 1.5秒ストップ！（第三スタッフ名表示）
																														registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
																															public void onTimePassed(TimerHandler pTimeHandler) {
																																このゲームを_あそんでくれたひと.detachSelf();
																															}
																														}));
																													}
																												}));
																											}
																										}
																									}));
																								}
																							}));
																						}
																					}
																				}));
																			}
																		}));
																	}
																}
															}));
														}
													}));
												}
											}
										}));
									}
								}));
							}
						}));
						// 28.5秒ストップ！（ジャンル名削除）
						registerUpdateHandler(new TimerHandler(28.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								デバッグ.registerEntityModifier(new FadeOutModifier(1.5f));
								// 1.5秒ストップ！
								registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										デバッグ.detachSelf();
									}
								}));
							}
						}));
					}
				}
			}));
			// 102秒ストップ！（アドバイザー）
			registerUpdateHandler(new TimerHandler(102, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					if (クレジットスキップしたかどうか == false) {
						final Sprite アドバイザー = getBaseActivity().getResourceUtil()
								.getSprite("credit_45_name_adviser.png");
						placeToCenterX(アドバイザー, 16);
						アドバイザー.setAlpha(0);
						アドバイザー.setScale(0.75f);
						attachChild(アドバイザー);
						アドバイザー.setZIndex(レイヤー12アイコン用);
						sortChildren();
						アドバイザー.registerEntityModifier(new FadeInModifier(1.5f));
						// 1.5秒ストップ！（スタッフ名表示）
						registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								final Sprite ささき_とも = getBaseActivity().getResourceUtil()
										.getSprite("credit_46_name_sasaki_tomo.png");
								ささき_とも.setPosition(32, 80);
								ささき_とも.setAlpha(0);
								ささき_とも.setScale(0.75f);
								attachChild(ささき_とも);
								ささき_とも.setZIndex(レイヤー12アイコン用);
								sortChildren();
								ささき_とも.registerEntityModifier(new FadeInModifier(1.5f));
								final Sprite はやし_りゅうせい = getBaseActivity().getResourceUtil()
										.getSprite("credit_47_name_hayasi_ryuusei.png");
								はやし_りゅうせい.setPosition(448, 80);
								はやし_りゅうせい.setAlpha(0);
								はやし_りゅうせい.setScale(0.75f);
								attachChild(はやし_りゅうせい);
								はやし_りゅうせい.setZIndex(レイヤー12アイコン用);
								sortChildren();
								はやし_りゅうせい.registerEntityModifier(new FadeInModifier(1.5f));
								// 3秒ストップ！
								registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										ささき_とも.registerEntityModifier(new FadeOutModifier(1.5f));
										はやし_りゅうせい.registerEntityModifier(new FadeOutModifier(1.5f));
										// 1.5秒ストップ！
										registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
											public void onTimePassed(TimerHandler pTimeHandler) {
												ささき_とも.detachSelf();
												はやし_りゅうせい.detachSelf();
											}
										}));
									}
								}));
							}
						}));
						// 4.5秒ストップ！（ジャンル名削除）
						registerUpdateHandler(new TimerHandler(4.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								アドバイザー.registerEntityModifier(new FadeOutModifier(1.5f));
								// 1.5秒ストップ！
								registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										アドバイザー.detachSelf();
									}
								}));
							}
						}));
					}
				}
			}));
			// 108秒ストップ！（おせわになったかた）
			registerUpdateHandler(new TimerHandler(108, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					if (クレジットスキップしたかどうか == false) {
						final Sprite おせわになったかた = getBaseActivity().getResourceUtil()
								.getSprite("credit_48_name_osewaninattakata.png");
						placeToCenterX(おせわになったかた, 16);
						おせわになったかた.setAlpha(0);
						おせわになったかた.setScale(0.75f);
						attachChild(おせわになったかた);
						おせわになったかた.setZIndex(レイヤー12アイコン用);
						sortChildren();
						おせわになったかた.registerEntityModifier(new FadeInModifier(1.5f));
						// 1.5秒ストップ！（スタッフ名表示）
						registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								final Sprite けんじょう_あつし = getBaseActivity().getResourceUtil()
										.getSprite("credit_49_name_kenjou_atusi.png");
								けんじょう_あつし.setPosition(32, 80);
								けんじょう_あつし.setAlpha(0);
								けんじょう_あつし.setScale(0.75f);
								attachChild(けんじょう_あつし);
								けんじょう_あつし.setZIndex(レイヤー12アイコン用);
								sortChildren();
								けんじょう_あつし.registerEntityModifier(new FadeInModifier(1.5f));
								final Sprite さとう_じんご = getBaseActivity().getResourceUtil()
										.getSprite("credit_50_name_satou_jingo.png");
								さとう_じんご.setPosition(448, 80);
								さとう_じんご.setAlpha(0);
								さとう_じんご.setScale(0.75f);
								attachChild(さとう_じんご);
								さとう_じんご.setZIndex(レイヤー12アイコン用);
								sortChildren();
								さとう_じんご.registerEntityModifier(new FadeInModifier(1.5f));
								// 3秒ストップ！
								registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										けんじょう_あつし.registerEntityModifier(new FadeOutModifier(1.5f));
										さとう_じんご.registerEntityModifier(new FadeOutModifier(1.5f));
										// カットしたときの処理
										if (クレジットスキップしたかどうか == true) {
											おせわになったかた.registerEntityModifier(new FadeOutModifier(1.5f));
										}
										// 1.5秒ストップ！（第二スタッフ名表示）
										registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
											public void onTimePassed(TimerHandler pTimeHandler) {
												けんじょう_あつし.detachSelf();
												さとう_じんご.detachSelf();
												// カットしたときの処理
												if (クレジットスキップしたかどうか == true) {
													おせわになったかた.detachSelf();
												}
												if (クレジットスキップしたかどうか == false) {
													final Sprite ふくの_ようこ = getBaseActivity().getResourceUtil()
															.getSprite("credit_51_name_hukuno_youko.png");
													ふくの_ようこ.setPosition(32, 80);
													ふくの_ようこ.setAlpha(0);
													ふくの_ようこ.setScale(0.75f);
													attachChild(ふくの_ようこ);
													ふくの_ようこ.setZIndex(レイヤー12アイコン用);
													sortChildren();
													ふくの_ようこ.registerEntityModifier(new FadeInModifier(1.5f));
													final Sprite ふじの_ゆうき = getBaseActivity().getResourceUtil()
															.getSprite("credit_52_name_hujino_yuuki.png");
													ふじの_ゆうき.setPosition(448, 80);
													ふじの_ゆうき.setAlpha(0);
													ふじの_ゆうき.setScale(0.75f);
													attachChild(ふじの_ゆうき);
													ふじの_ゆうき.setZIndex(レイヤー12アイコン用);
													sortChildren();
													ふじの_ゆうき.registerEntityModifier(new FadeInModifier(1.5f));
													// 4.5秒ストップ！
													registerUpdateHandler(new TimerHandler(4.5f, new ITimerCallback() {
														public void onTimePassed(TimerHandler pTimeHandler) {
															ふくの_ようこ.registerEntityModifier(new FadeOutModifier(1.5f));
															ふじの_ゆうき.registerEntityModifier(new FadeOutModifier(1.5f));
															// 1.5秒ストップ！
															registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
																public void onTimePassed(TimerHandler pTimeHandler) {
																	ふくの_ようこ.detachSelf();
																	ふじの_ゆうき.detachSelf();
																}
															}));
														}
													}));
												}
											}
										}));
									}
								}));
							}
						}));
						// 10.5秒ストップ！（ジャンル名削除）
						registerUpdateHandler(new TimerHandler(10.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								おせわになったかた.registerEntityModifier(new FadeOutModifier(1.5f));
								// 1.5秒ストップ！
								registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										おせわになったかた.detachSelf();
									}
								}));
							}
						}));
					}
				}
			}));
			// 120秒ストップ！（おせわになったツール）
			registerUpdateHandler(new TimerHandler(120, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					if (クレジットスキップしたかどうか == false) {
						final Sprite おせわになったツール = getBaseActivity().getResourceUtil()
								.getSprite("credit_53_name_osewaninattatu-ru.png");
						placeToCenterX(おせわになったツール, 16);
						おせわになったツール.setAlpha(0);
						おせわになったツール.setScale(0.75f);
						attachChild(おせわになったツール);
						おせわになったツール.setZIndex(レイヤー12アイコン用);
						sortChildren();
						おせわになったツール.registerEntityModifier(new FadeInModifier(1.5f));
						// 1.5秒ストップ！（スタッフ名表示）
						registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								final Sprite アンドエンジン = getBaseActivity().getResourceUtil()
										.getSprite("credit_54_name_andengine.png");
								placeToCenterX(アンドエンジン, 80);
								アンドエンジン.setAlpha(0);
								アンドエンジン.setScale(0.75f);
								attachChild(アンドエンジン);
								アンドエンジン.setZIndex(レイヤー12アイコン用);
								sortChildren();
								アンドエンジン.registerEntityModifier(new FadeInModifier(1.5f));
								// 3秒ストップ！
								registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										アンドエンジン.registerEntityModifier(new FadeOutModifier(1.5f));
										// カットしたときの処理
										if (クレジットスキップしたかどうか == true) {
											おせわになったツール.registerEntityModifier(new FadeOutModifier(1.5f));
										}
										// 1.5秒ストップ！（第二スタッフ名表示）
										registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
											public void onTimePassed(TimerHandler pTimeHandler) {
												アンドエンジン.detachSelf();
												// カットしたときの処理
												if (クレジットスキップしたかどうか == true) {
													おせわになったツール.detachSelf();
												}
												if (クレジットスキップしたかどうか == false) {
													final Sprite バンブラP = getBaseActivity().getResourceUtil()
															.getSprite("credit_55_name_daigassou_banndoburaza-zu_p.png");
													placeToCenterX(バンブラP, 80);
													バンブラP.setAlpha(0);
													バンブラP.setScale(0.75f);
													attachChild(バンブラP);
													バンブラP.setZIndex(レイヤー12アイコン用);
													sortChildren();
													バンブラP.registerEntityModifier(new FadeInModifier(1.5f));
													// 4.5秒ストップ！
													registerUpdateHandler(new TimerHandler(4.5f, new ITimerCallback() {
														public void onTimePassed(TimerHandler pTimeHandler) {
															バンブラP.registerEntityModifier(new FadeOutModifier(1.5f));
															// カットしたときの処理
															if (クレジットスキップしたかどうか == true) {
																おせわになったツール.registerEntityModifier(new FadeOutModifier(1.5f));
															}
															// 1.5秒ストップ！（第三スタッフ名表示）
															registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
																public void onTimePassed(TimerHandler pTimeHandler) {
																	バンブラP.detachSelf();
																	// カットしたときの処理
																	if (クレジットスキップしたかどうか == true) {
																		おせわになったツール.detachSelf();
																	}
																	if (クレジットスキップしたかどうか == false) {
																		final Sprite 文字画メーカー = getBaseActivity().getResourceUtil()
																				.getSprite("credit_56_name_mojigame-ka-.png");
																		placeToCenterX(文字画メーカー, 80);
																		文字画メーカー.setAlpha(0);
																		文字画メーカー.setScale(0.75f);
																		attachChild(文字画メーカー);
																		文字画メーカー.setZIndex(レイヤー12アイコン用);
																		sortChildren();
																		文字画メーカー.registerEntityModifier(new FadeInModifier(1.5f));
																		// 4.5秒ストップ！
																		registerUpdateHandler(new TimerHandler(4.5f, new ITimerCallback() {
																			public void onTimePassed(TimerHandler pTimeHandler) {
																				文字画メーカー.registerEntityModifier(new FadeOutModifier(1.5f));
																				// 1.5秒ストップ！
																				registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
																					public void onTimePassed(TimerHandler pTimeHandler) {
																						文字画メーカー.detachSelf();
																					}
																				}));
																			}
																		}));
																	}
																}
															}));
														}
													}));
												}
											}
										}));
									}
								}));
							}
						}));
						// 16.5秒ストップ！（ジャンル名削除）
						registerUpdateHandler(new TimerHandler(16.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								おせわになったツール.registerEntityModifier(new FadeOutModifier(1.5f));
								// 1.5秒ストップ！
								registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										おせわになったツール.detachSelf();
									}
								}));
							}
						}));
					}
				}
			}));
			// 141秒ストップ！（岡本堂）
			registerUpdateHandler(new TimerHandler(141, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					if (クレジットスキップしたかどうか == false) {
						final Sprite 岡本堂 = getBaseActivity().getResourceUtil()
								.getSprite("credit_57_logo_okamotodo.png");
						placeToCenterX(岡本堂, 64);
						岡本堂.setAlpha(0);
						attachChild(岡本堂);
						岡本堂.setZIndex(レイヤー12アイコン用);
						sortChildren();
						岡本堂.registerEntityModifier(new FadeInModifier(1.5f));
						// 4.5秒ストップ！（ジャンル名削除）
						registerUpdateHandler(new TimerHandler(4.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								岡本堂.registerEntityModifier(new FadeOutModifier(1.5f));
								// 1.5秒ストップ！
								registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										岡本堂.detachSelf();
									}
								}));
							}
						}));
					}
				}
			}));
			// 147秒ストップ！（THE ENDロゴ）
			registerUpdateHandler(new TimerHandler(147, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					if (クレジットスキップしたかどうか == false) {
						// 一足先にスキップボタンを削除
						スキップボタン.detachSelf();
						unregisterTouchArea(スキップボタン);
						// エンドロゴ1
						Sprite アイコンエンド1 = ResourceUtil.getInstance(getBaseActivity())
								.getSprite("credit_04_t_character.png");
						アイコンエンド1.setPosition(224, -256);
						attachChild(アイコンエンド1);
						アイコンエンド1.setZIndex(レイヤー12アイコン用);
						sortChildren();
						アイコンエンド1.registerEntityModifier(new SequenceEntityModifier(
								new DelayModifier(1), new MoveModifier(1.25f,
										アイコンエンド1.getX(), アイコンエンド1.getX(),
										アイコンエンド1.getY() - 2400, アイコンエンド1.getY() + 320,
										EaseBackInOut.getInstance())));
						// エンドロゴ2
						Sprite アイコンエンド2 = ResourceUtil.getInstance(getBaseActivity())
								.getSprite("credit_05_h_character.png");
						アイコンエンド2.setPosition(272, -256);
						attachChild(アイコンエンド2);
						アイコンエンド2.setZIndex(レイヤー12アイコン用);
						sortChildren();
						アイコンエンド2.registerEntityModifier(new SequenceEntityModifier(
								new DelayModifier(1), new MoveModifier(1.50f,
										アイコンエンド2.getX(), アイコンエンド2.getX(),
										アイコンエンド2.getY() - 2400, アイコンエンド2.getY() + 320,
										EaseBackInOut.getInstance())));
						// エンドロゴ3
						Sprite アイコンエンド3 = ResourceUtil.getInstance(getBaseActivity())
								.getSprite("credit_06_e_character.png");
						アイコンエンド3.setPosition(320, -256);
						attachChild(アイコンエンド3);
						アイコンエンド3.setZIndex(レイヤー12アイコン用);
						sortChildren();
						アイコンエンド3.registerEntityModifier(new SequenceEntityModifier(
								new DelayModifier(1), new MoveModifier(1.75f,
										アイコンエンド3.getX(), アイコンエンド3.getX(),
										アイコンエンド3.getY() - 2400, アイコンエンド3.getY() + 320,
										EaseBackInOut.getInstance())));
						// エンドロゴ4
						Sprite アイコンエンド4 = ResourceUtil.getInstance(getBaseActivity())
								.getSprite("credit_07_e_character.png");
						アイコンエンド4.setPosition(416, -256);
						attachChild(アイコンエンド4);
						アイコンエンド4.setZIndex(レイヤー12アイコン用);
						sortChildren();
						アイコンエンド4.registerEntityModifier(new SequenceEntityModifier(
								new DelayModifier(1), new MoveModifier(2.00f,
										アイコンエンド4.getX(), アイコンエンド4.getX(),
										アイコンエンド4.getY() - 2400, アイコンエンド4.getY() + 320,
										EaseBackInOut.getInstance())));
						// エンドロゴ5
						Sprite アイコンエンド5 = ResourceUtil.getInstance(getBaseActivity())
								.getSprite("credit_08_n_character.png");
						アイコンエンド5.setPosition(464, -256);
						attachChild(アイコンエンド5);
						アイコンエンド5.setZIndex(レイヤー12アイコン用);
						sortChildren();
						アイコンエンド5.registerEntityModifier(new SequenceEntityModifier(
								new DelayModifier(1), new MoveModifier(2.25f,
										アイコンエンド5.getX(), アイコンエンド5.getX(),
										アイコンエンド5.getY() - 2400, アイコンエンド5.getY() + 320,
										EaseBackInOut.getInstance())));
						// エンドロゴ6
						Sprite アイコンエンド6 = ResourceUtil.getInstance(getBaseActivity())
								.getSprite("credit_09_d_character.png");
						アイコンエンド6.setPosition(512, -256);
						attachChild(アイコンエンド6);
						アイコンエンド6.setZIndex(レイヤー12アイコン用);
						sortChildren();
						アイコンエンド6.registerEntityModifier(new SequenceEntityModifier(
								new DelayModifier(1), new MoveModifier(2.50f,
										アイコンエンド6.getX(), アイコンエンド6.getX(),
										アイコンエンド6.getY() - 2400, アイコンエンド6.getY() + 320,
										EaseBackInOut.getInstance())));
						// エンドロゴ7
						Sprite アイコンエンド7 = ResourceUtil.getInstance(getBaseActivity())
								.getSprite("credit_10_!_character.png");
						アイコンエンド7.setPosition(560, -256);
						attachChild(アイコンエンド7);
						アイコンエンド7.setZIndex(レイヤー12アイコン用);
						sortChildren();
						アイコンエンド7.registerEntityModifier(new SequenceEntityModifier(
								new DelayModifier(1), new MoveModifier(2.75f,
										アイコンエンド7.getX(), アイコンエンド7.getX(),
										アイコンエンド7.getY() - 2400, アイコンエンド7.getY() + 320,
										EaseBackInOut.getInstance())));
					}
				}
			}));
			// 150秒ストップ！（「センキュー」ボイス！）
			registerUpdateHandler(new TimerHandler(150, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					if (クレジットスキップしたかどうか == false) {
						// コインゲームの記録を保存
						if (現在のクレジットコイン > クレジットコインデータ.getInstance(getBaseActivity()).getクレジットコインデータ()) {
							クレジットコインデータ.getInstance(getBaseActivity()).setクレジットコインデータ(現在のクレジットコイン);
							クレジットコインテキスト.registerEntityModifier(
									new LoopEntityModifier(new SequenceEntityModifier(
											new ScaleModifier(0.25f, 1.0f, 2),
											new ScaleModifier(0.25f, 2, 1.0f)), 4));
							// 2秒ストップ！
							registerUpdateHandler(new TimerHandler(2, new ITimerCallback() {
								public void onTimePassed(TimerHandler pTimeHandler) {
									// ハイスコアコインも忘れずにインクリ
									ハイスコアコインテキスト.setText("" + 現在のクレジットコイン);
									SCテキスト2.setColor(1, 1, 0);
									ハイスコアコインテキスト.setColor(1, 1, 0);
								}
							}));
						}
						VoicePlay.voiceGameClear.stop();
						VoicePlay.voiceGameClear.play();
					}
				}
			}));
			// 153秒ストップ！（ハイスコアとボタン）
			registerUpdateHandler(new TimerHandler(153, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					if (クレジットスキップしたかどうか == false) {
						gameClear();
					}
				}
			}));
		}
	}
	
	// ===========================================================
	// 描画系
	// ===========================================================
	
	// 残り人数画面の描画
	public void remainingView() {
		// ジャンプ位置を高さにあわせて変更
		// ボス戦前は強制レベ1
		if (ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 1 && コースカウンター == 4
				|| ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 2 && コースカウンター == 8
				|| ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 3 && コースカウンター == 12
				|| ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 4 && コースカウンター == 16) {
			待機ジャンプの上昇移動値 = 48;
			// 高さレベル1
		} else if (コースカウンター == 1 || コースカウンター == 2
				|| コースカウンター == 3 || コースカウンター == 5
				|| コースカウンター == 6 || コースカウンター == 7
				|| コースカウンター == 16 || コースカウンター == 21
				|| コースカウンター == 22 || コースカウンター == 0) {
			待機ジャンプの上昇移動値 = 48;
			// 高さレベル2
		} else if (コースカウンター == 8 || コースカウンター == 9
				|| コースカウンター == 12 || コースカウンター == 14
				|| コースカウンター == 18) {
			待機ジャンプの上昇移動値 = 54;
			// 高さレベル3
		} else if (コースカウンター == 10 || コースカウンター == 11
				|| コースカウンター == 13 || コースカウンター == 15
				|| コースカウンター == 20) {
			待機ジャンプの上昇移動値 = 60;
			// 高さレベル4
		} else if (コースカウンター == 4 || コースカウンター == 17) {
			待機ジャンプの上昇移動値 = 66;
			// 高さレベル5
		} else if (コースカウンター == 19) {
			待機ジャンプの上昇移動値 = 72;
		}
		// ワールドスタート時に服を着てるかどうかの設定
		if (パワーアップデータ.getInstance(getBaseActivity()).getパワーアップデータ() == 0) {
			// ノーコン時、運がよければ最初から服を装着
			if (現在のコンチニュー == 0) {
				int r = (int) (Math.random() * 50);
				if (r == 0) {
					初期装着型カウンター = (int) (Math.random() * 7);
					if (初期装着型カウンター == 0) {
						メット取得フラグ = true;
						シャツ取得フラグ = true;
						ズボン取得フラグ = true;
					} else if (初期装着型カウンター == 1) {
						メット取得フラグ = true;
					} else if (初期装着型カウンター == 2) {
						メット取得フラグ = true;
						シャツ取得フラグ = true;
					} else if (初期装着型カウンター == 3) {
						シャツ取得フラグ = true;
					} else if (初期装着型カウンター == 4) {
						シャツ取得フラグ = true;
						ズボン取得フラグ = true;
					} else if (初期装着型カウンター == 5) {
						ズボン取得フラグ = true;
					} else if (初期装着型カウンター == 6) {
						ズボン取得フラグ = true;
						メット取得フラグ = true;
					}
				}
				// コンチ時は回数に応じて服を装着
			} else if (現在のコンチニュー == 1 || 現在のコンチニュー == 2) {
				初期装着型カウンター = (int) (Math.random() * 2);
				if (初期装着型カウンター == 0) {
					メット取得フラグ = true;
				} else if (初期装着型カウンター == 1) {
					シャツ取得フラグ = true;
				} else if (初期装着型カウンター == 2) {
					ズボン取得フラグ = true;
				}
			} else if (現在のコンチニュー == 3 || 現在のコンチニュー == 4) {
				初期装着型カウンター = (int) (Math.random() * 2);
				if (初期装着型カウンター == 0) {
					メット取得フラグ = true;
					シャツ取得フラグ = true;
				} else if (初期装着型カウンター == 1) {
					シャツ取得フラグ = true;
					ズボン取得フラグ = true;
				} else if (初期装着型カウンター == 2) {
					ズボン取得フラグ = true;
					メット取得フラグ = true;
				}
			} else if (現在のコンチニュー >= 5) {
				メット取得フラグ = true;
				シャツ取得フラグ = true;
				ズボン取得フラグ = true;
			}
		} else if (パワーアップデータ.getInstance(getBaseActivity()).getパワーアップデータ() == 1) {
			メット取得フラグ = true;
		} else if (パワーアップデータ.getInstance(getBaseActivity()).getパワーアップデータ() == 2) {
			メット取得フラグ = true;
			シャツ取得フラグ = true;
		} else if (パワーアップデータ.getInstance(getBaseActivity()).getパワーアップデータ() == 3) {
			シャツ取得フラグ = true;
		} else if (パワーアップデータ.getInstance(getBaseActivity()).getパワーアップデータ() == 4) {
			シャツ取得フラグ = true;
			ズボン取得フラグ = true;
		} else if (パワーアップデータ.getInstance(getBaseActivity()).getパワーアップデータ() == 5) {
			ズボン取得フラグ = true;
		} else if (パワーアップデータ.getInstance(getBaseActivity()).getパワーアップデータ() == 6) {
			ズボン取得フラグ = true;
			メット取得フラグ = true;
		} else if (パワーアップデータ.getInstance(getBaseActivity()).getパワーアップデータ() == 7) {
			メット取得フラグ = true;
			シャツ取得フラグ = true;
			ズボン取得フラグ = true;
		} else if (パワーアップデータ.getInstance(getBaseActivity()).getパワーアップデータ() == 8) {
			// 服を着ていない状態を保存したい場合はこちらを選択
		}
		// テキスト
		// ノーマルテキストを描画
		normalTextView();
		// デバッグテキストを描画
		debugTextView();
		// テキストを初期化
		textInit();
		// 四角形
		// 四角形を描画
		残り人数四角形 = new Rectangle(0, 0, getBaseActivity().getEngine()
				.getCamera().getWidth(), getBaseActivity().getEngine()
				.getCamera().getHeight(), getBaseActivity()
				.getVertexBufferObjectManager());
		残り人数四角形.setBlendFunction(
				GL10.GL_ONE_MINUS_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);
		残り人数四角形.setColor(0, 0, 0);
		attachChild(残り人数四角形);
		// アイコン
		// アイコンマリオをアニマテッドで描画
		if (メット取得フラグ == true
				&& シャツ取得フラグ == false && ズボン取得フラグ == false) {
			アイコンマリオ = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("player_02_mario_set_2.png", 1, 30);
			アイコンマリオ.setPosition(320, 192);
			アイコンマリオ.setCurrentTileIndex(3);
			attachChild(アイコンマリオ);
			アイコンマリオ.setZIndex(レイヤー16ポーズ用);
			sortChildren();
		} else if (メット取得フラグ == true && シャツ取得フラグ == true
				&& ズボン取得フラグ == false) {
			アイコンマリオ = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("player_02_mario_set_2.png", 1, 30);
			アイコンマリオ.setPosition(320, 192);
			アイコンマリオ.setCurrentTileIndex(8);
			attachChild(アイコンマリオ);
			アイコンマリオ.setZIndex(レイヤー16ポーズ用);
			sortChildren();
		} else if (シャツ取得フラグ == true
				&& メット取得フラグ == false && ズボン取得フラグ == false) {
			アイコンマリオ = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("player_02_mario_set_2.png", 1, 30);
			アイコンマリオ.setPosition(320, 192);
			アイコンマリオ.setCurrentTileIndex(13);
			attachChild(アイコンマリオ);
			アイコンマリオ.setZIndex(レイヤー16ポーズ用);
			sortChildren();
		} else if (シャツ取得フラグ == true && ズボン取得フラグ == true
				&& メット取得フラグ == false) {
			アイコンマリオ = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("player_02_mario_set_2.png", 1, 30);
			アイコンマリオ.setPosition(320, 192);
			アイコンマリオ.setCurrentTileIndex(18);
			attachChild(アイコンマリオ);
			アイコンマリオ.setZIndex(レイヤー16ポーズ用);
			sortChildren();
		} else if (ズボン取得フラグ == true
				&& メット取得フラグ == false && シャツ取得フラグ == false) {
			アイコンマリオ = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("player_02_mario_set_2.png", 1, 30);
			アイコンマリオ.setPosition(320, 192);
			アイコンマリオ.setCurrentTileIndex(23);
			attachChild(アイコンマリオ);
			アイコンマリオ.setZIndex(レイヤー16ポーズ用);
			sortChildren();
		} else if (ズボン取得フラグ == true && メット取得フラグ == true
				&& シャツ取得フラグ == false) {
			アイコンマリオ = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("player_02_mario_set_2.png", 1, 30);
			アイコンマリオ.setPosition(320, 192);
			アイコンマリオ.setCurrentTileIndex(28);
			attachChild(アイコンマリオ);
			アイコンマリオ.setZIndex(レイヤー16ポーズ用);
			sortChildren();
		} else if (ズボン取得フラグ == true && メット取得フラグ == true && シャツ取得フラグ == true) {
			アイコンマリオ = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("player_01_mario_set_1.png", 1, 30);
			アイコンマリオ.setPosition(320, 192);
			アイコンマリオ.setCurrentTileIndex(8);
			attachChild(アイコンマリオ);
			アイコンマリオ.setZIndex(レイヤー16ポーズ用);
			sortChildren();
		} else if (ズボン取得フラグ == false && メット取得フラグ == false && シャツ取得フラグ == false) {
			アイコンマリオ = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("player_01_mario_set_1.png", 1, 30);
			アイコンマリオ.setPosition(320, 192);
			アイコンマリオ.setCurrentTileIndex(3);
			attachChild(アイコンマリオ);
			アイコンマリオ.setZIndex(レイヤー16ポーズ用);
			sortChildren();
		}
		// アイコン用ウインドウを普通のぷすらいとで描画
		アイコン用ウインドウ = getBaseActivity().getResourceUtil()
				.getSprite("icon_01_window.png");
		アイコン用ウインドウ.setPosition(0, 0);
		アイコン用ウインドウ.setAlpha(0.5f);
		attachChild(アイコン用ウインドウ);
		アイコン用ウインドウ.setZIndex(レイヤー12アイコン用);
		sortChildren();
		// アイコインをアニマテッドで描画
		アイコイン = getBaseActivity().getResourceUtil()
				.getAnimatedSprite("icon_02_coin.png", 1, 4);
		アイコイン.setPosition(184, 12);
		アイコイン.animate(ani遅);
		attachChild(アイコイン);
		アイコイン.setZIndex(レイヤー12アイコン用);
		sortChildren();
		// アイパンツをアニマテッドで描画
		アイパンツ = getBaseActivity().getResourceUtil()
				.getSprite("icon_03_pants.png");
		アイパンツ.setPosition(184, 36);
		attachChild(アイパンツ);
		アイパンツ.setZIndex(レイヤー12アイコン用);
		sortChildren();
		// アイコンボールをアニマテッドで描画
		アイコンボール = getBaseActivity().getResourceUtil()
				.getAnimatedSprite("icon_04_fireball.png", 1, 4);
		アイコンボール.setPosition(344, 12);
		アイコンボール.animate(ani速);
		attachChild(アイコンボール);
		アイコンボール.setZIndex(レイヤー12アイコン用);
		sortChildren();
		// アイコンクリスをアニマテッドで描画
		アイコンクリス = getBaseActivity().getResourceUtil()
				.getAnimatedSprite("icon_05_crystal_list_1.png", 1, 9);
		アイコンクリス.setPosition(344, 36);
		if (現在のクリスタル == 0) {
			アイコンクリス.setCurrentTileIndex(0);
		} else if (現在のクリスタル == 1) {
			アイコンクリス.animate(
					new long[] { ani遅, ani遅, ani遅, ani遅, }, 1, 4, true);
		} else if (現在のクリスタル == 2) {
			アイコンクリス.animate(
					new long[] { ani遅, ani遅, ani遅, ani遅, }, 5, 8, true);
		}
		attachChild(アイコンクリス);
		アイコンクリス.setZIndex(レイヤー12アイコン用);
		sortChildren();
		// アイコンメットを普通のぷすらいとで描画
		if (メット取得フラグ == true) {
			アイコンメット = getBaseActivity().getResourceUtil()
					.getSprite("icon_07_power-up_item_1.png");
			アイコンメット.setPosition(16 + 48 * 0, 80);
			アイコンメット.setScale(1.0f);
			attachChild(アイコンメット);
			アイコンメット.setZIndex(レイヤー12アイコン用);
			sortChildren();
		}
		// アイコンシャツを普通のぷすらいとで描画
		if (シャツ取得フラグ == true) {
			アイコンシャツ = getBaseActivity().getResourceUtil()
					.getSprite("icon_08_power-up_item_2.png");
			アイコンシャツ.setPosition(16 + 48 * 1, 80);
			アイコンシャツ.setScale(1.0f);
			attachChild(アイコンシャツ);
			アイコンシャツ.setZIndex(レイヤー12アイコン用);
			sortChildren();
		}
		// アイコンズボンを普通のぷすらいとで描画
		if (ズボン取得フラグ == true) {
			アイコンズボン = getBaseActivity().getResourceUtil()
					.getSprite("icon_09_power-up_item_3.png");
			アイコンズボン.setPosition(16 + 48 * 2, 80);
			アイコンズボン.setScale(1.0f);
			attachChild(アイコンズボン);
			アイコンズボン.setZIndex(レイヤー12アイコン用);
			sortChildren();
		}
		// アイコンカーソルをアニマテッドで描画
		アイコンカーソル = getBaseActivity().getResourceUtil()
				.getAnimatedSprite("icon_11_cursor_left.png", 1, 4);
		アイコンカーソル.setPosition(16, 368);
		アイコンカーソル.animate(ani並);
		// アイコンカーソルを完全に透明化
		アイコンカーソル.setAlpha(0);
		attachChild(アイコンカーソル);
		アイコンカーソル.setZIndex(レイヤー12アイコン用);
		sortChildren();
		// パワーメーターを画面右上部分に配置
		メーターチャージ = getBaseActivity().getResourceUtil()
				.getAnimatedSprite("icon_13_normal_meter_1.png", 1, 60);
		メーターチャージ.setPosition(640, 80);
		// パワーメーター値をインクリ
		if (現在のノーマルメーター < 2) {
			メーターチャージ.setCurrentTileIndex(0);
		} else if (現在のノーマルメーター < 4) {
			メーターチャージ.setCurrentTileIndex(1);
		} else if (現在のノーマルメーター < 6) {
			メーターチャージ.setCurrentTileIndex(2);
		} else if (現在のノーマルメーター < 8) {
			メーターチャージ.setCurrentTileIndex(3);
		} else if (現在のノーマルメーター < 10) {
			メーターチャージ.setCurrentTileIndex(4);
		} else if (現在のノーマルメーター < 12) {
			メーターチャージ.setCurrentTileIndex(5);
		} else if (現在のノーマルメーター < 14) {
			メーターチャージ.setCurrentTileIndex(6);
		} else if (現在のノーマルメーター < 16) {
			メーターチャージ.setCurrentTileIndex(7);
		} else if (現在のノーマルメーター < 18) {
			メーターチャージ.setCurrentTileIndex(8);
		} else if (現在のノーマルメーター < 20) {
			メーターチャージ.setCurrentTileIndex(9);
		} else if (現在のノーマルメーター < 22) {
			メーターチャージ.setCurrentTileIndex(10);
		} else if (現在のノーマルメーター < 24) {
			メーターチャージ.setCurrentTileIndex(11);
		} else if (現在のノーマルメーター < 26) {
			メーターチャージ.setCurrentTileIndex(12);
		} else if (現在のノーマルメーター < 28) {
			メーターチャージ.setCurrentTileIndex(13);
		} else if (現在のノーマルメーター < 30) {
			メーターチャージ.setCurrentTileIndex(14);
		} else if (現在のノーマルメーター < 32) {
			メーターチャージ.setCurrentTileIndex(15);
		} else if (現在のノーマルメーター < 34) {
			メーターチャージ.setCurrentTileIndex(16);
		} else if (現在のノーマルメーター < 36) {
			メーターチャージ.setCurrentTileIndex(17);
		} else if (現在のノーマルメーター < 38) {
			メーターチャージ.setCurrentTileIndex(18);
		} else if (現在のノーマルメーター < 40) {
			メーターチャージ.setCurrentTileIndex(19);
		} else if (現在のノーマルメーター < 42) {
			メーターチャージ.setCurrentTileIndex(20);
		} else if (現在のノーマルメーター < 44) {
			メーターチャージ.setCurrentTileIndex(21);
		} else if (現在のノーマルメーター < 46) {
			メーターチャージ.setCurrentTileIndex(22);
		} else if (現在のノーマルメーター < 48) {
			メーターチャージ.setCurrentTileIndex(23);
		} else if (現在のノーマルメーター < 50) {
			メーターチャージ.setCurrentTileIndex(24);
		} else if (現在のノーマルメーター < 52) {
			メーターチャージ.setCurrentTileIndex(25);
		} else if (現在のノーマルメーター < 54) {
			メーターチャージ.setCurrentTileIndex(26);
		} else if (現在のノーマルメーター < 56) {
			メーターチャージ.setCurrentTileIndex(27);
		} else if (現在のノーマルメーター < 58) {
			メーターチャージ.setCurrentTileIndex(28);
		} else if (現在のノーマルメーター < 60) {
			メーターチャージ.setCurrentTileIndex(29);
		} else if (現在のノーマルメーター < 62) {
			メーターチャージ.setCurrentTileIndex(30);
		} else if (現在のノーマルメーター < 64) {
			メーターチャージ.setCurrentTileIndex(31);
		} else if (現在のノーマルメーター < 66) {
			メーターチャージ.setCurrentTileIndex(32);
		} else if (現在のノーマルメーター < 68) {
			メーターチャージ.setCurrentTileIndex(33);
		} else if (現在のノーマルメーター < 70) {
			メーターチャージ.setCurrentTileIndex(34);
		} else if (現在のノーマルメーター < 72) {
			メーターチャージ.setCurrentTileIndex(35);
		} else if (現在のノーマルメーター < 74) {
			メーターチャージ.setCurrentTileIndex(36);
		} else if (現在のノーマルメーター < 76) {
			メーターチャージ.setCurrentTileIndex(37);
		} else if (現在のノーマルメーター < 78) {
			メーターチャージ.setCurrentTileIndex(38);
		} else if (現在のノーマルメーター < 80) {
			メーターチャージ.setCurrentTileIndex(39);
		} else if (現在のノーマルメーター < 82) {
			メーターチャージ.setCurrentTileIndex(40);
		} else if (現在のノーマルメーター < 84) {
			メーターチャージ.setCurrentTileIndex(41);
		} else if (現在のノーマルメーター < 86) {
			メーターチャージ.setCurrentTileIndex(42);
		} else if (現在のノーマルメーター < 88) {
			メーターチャージ.setCurrentTileIndex(43);
		} else if (現在のノーマルメーター < 90) {
			メーターチャージ.setCurrentTileIndex(44);
		} else if (現在のノーマルメーター < 92) {
			メーターチャージ.setCurrentTileIndex(45);
		} else if (現在のノーマルメーター < 94) {
			メーターチャージ.setCurrentTileIndex(46);
		} else if (現在のノーマルメーター < 96) {
			メーターチャージ.setCurrentTileIndex(47);
		} else if (現在のノーマルメーター < 98) {
			メーターチャージ.setCurrentTileIndex(48);
		} else if (現在のノーマルメーター < 100) {
			メーターチャージ.setCurrentTileIndex(49);
		} else if (現在のノーマルメーター < 102) {
			メーターチャージ.setCurrentTileIndex(50);
		} else if (現在のノーマルメーター < 104) {
			メーターチャージ.setCurrentTileIndex(51);
		} else if (現在のノーマルメーター < 106) {
			メーターチャージ.setCurrentTileIndex(52);
		} else if (現在のノーマルメーター < 108) {
			メーターチャージ.setCurrentTileIndex(53);
		} else if (現在のノーマルメーター < 110) {
			メーターチャージ.setCurrentTileIndex(54);
		} else if (現在のノーマルメーター < 112) {
			メーターチャージ.setCurrentTileIndex(55);
		} else if (現在のノーマルメーター < 114) {
			メーターチャージ.setCurrentTileIndex(56);
		} else if (現在のノーマルメーター < 116) {
			メーターチャージ.setCurrentTileIndex(57);
		} else if (現在のノーマルメーター < 118) {
			メーターチャージ.setCurrentTileIndex(58);
		} else if (現在のノーマルメーター < 120) {
			メーターチャージ.setCurrentTileIndex(59);
		} else if (現在のノーマルメーター >= 120) {
			normalStarmanSprite();
		}
		attachChild(メーターチャージ);
		メーターチャージ.setZIndex(レイヤー12アイコン用);
		sortChildren();
		// パーセントデータをパワーメーターに重ね配置
		メーターパーセン = getBaseActivity().getResourceUtil()
				.getAnimatedSprite("icon_19_meter_percent_1.png", 1, 120);
		メーターパーセン.setPosition(704, 88);
		// パーセントデータをインクリ
		for (int i = 0; i <= 現在のノーマルメーター; i++) {
			メーターパーセン.setCurrentTileIndex(i);
		}
		attachChild(メーターパーセン);
		メーターパーセン.setZIndex(レイヤー13テキスト用);
		sortChildren();
		// クリアイコンを普通のぷすらいとで描画
		クリアイコン = getBaseActivity().getResourceUtil()
				.getSprite("icon_30_world_clear_window.png");
		クリアイコン.setPosition(0, 128);
		クリアイコン.setAlpha(0);
		attachChild(クリアイコン);
		クリアイコン.setZIndex(レイヤー12アイコン用);
		sortChildren();
		// 5秒ストップ！
		registerUpdateHandler(new TimerHandler(5, new ITimerCallback() {
			public void onTimePassed(TimerHandler pTimeHandler) {
				init();
			}
		}));
	}
	// マニュアル画面の描画
	public void manualView() {
		SoundPlay.sePause.stop();
		SoundPlay.sePause.play();
		// プレイヤーの動きをストップ！
		if (グラチェンジフラグ == false) {
			marioSets.playerMarioSet1.stopAnimation();
		} else {
			marioSets.playerMarioSet2.stopAnimation();
		}
		// ハンドラーをストップ！
		unregisterUpdateHandler(スタート時レート);
		// 四角形
		final Rectangle manualBg = new Rectangle(0, 0, getBaseActivity().getEngine()
				.getCamera().getWidth(), getBaseActivity().getEngine()
				.getCamera().getHeight(), getBaseActivity()
				.getVertexBufferObjectManager());
		manualBg.setBlendFunction(
				GL10.GL_ONE_MINUS_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);
		manualBg.setAlpha(0.5f);
		manualBg.setColor(0, 0, 0);
		attachChild(manualBg);
		// 背景
		マニュアル画面 = ResourceUtil.getInstance(getBaseActivity())
				.getSprite("system_11_manual_back_1.png");
		placeToCenter(マニュアル画面);
		マニュアル画面.setScale(0.75f);
		attachChild(マニュアル画面);
		// マニュアルボタン（OK）の定義と処理をインスタンスで！
		マニュアルボタン = ResourceUtil.getInstance(getBaseActivity())
				.getButtonSprite("button_01_title_game_start.png",
						"button_01_title_game_start_push.png");
		placeToCenter(マニュアルボタン);
		registerTouchArea(マニュアルボタン);
		attachChild(マニュアルボタン);
		マニュアルボタン.setOnClickListener(new ButtonSprite.OnClickListener() {
			public void onClick(ButtonSprite pButtonSprite,
					float pTouchAreaLocalX, float pTouchAreaLocalY) {
				VoicePlay.voiceGameStart.stop();
				VoicePlay.voiceGameStart.play();
				// 色々デタッチ！
				manualBg.detachSelf();
				マニュアル画面.detachSelf();
				マニュアルボタン.detachSelf();
				unregisterTouchArea(マニュアルボタン);
				if (ゲーム待機中かどうか == true) {
					// 0.5秒ストップ！
					registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							SoundPlay.seJump.stop();
							SoundPlay.seJump.play();
							registerUpdateHandler(スタート時レート);
						}
					}));
				} else {
					// 1秒間に30回、フレームレートを呼び出し
					registerUpdateHandler(フレームレート);
					// 3秒毎にキラー出現時間を呼び出し
					registerUpdateHandler(キラー出現レート);
					// Sceneのタッチリスナーを登録
					setOnSceneTouchListener(MainScene.this);
				}
			}
		});
	}
	
	// ===========================================================
	// テキスト系
	// ===========================================================
	
	// ノーマルテキストを描画
	public void normalTextView() {
		// 端末に搭載されたフォントを利用する
		Texture texture = new BitmapTextureAtlas(getBaseActivity()
				.getTextureManager(), 512, 512,
				TextureOptions.BILINEAR_PREMULTIPLYALPHA);
		Font font = new Font(getBaseActivity().getFontManager(), texture,
				Typeface.DEFAULT_BOLD, 21, true, Color.WHITE);
		getBaseActivity().getTextureManager().loadTexture(texture);
		getBaseActivity().getFontManager().loadFont(font);
		// 1.読み込んだフォントを利用してスコアを表示
		テキスト1				= new Text(16, 4, font, "Score",
				42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		attachChild(テキスト1);
		テキスト1.setZIndex(レイヤー13テキスト用);
		sortChildren();
		スコアテキスト			= new Text(16, 36, font, ""
				+ 現在のスコア, 42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		attachChild(スコアテキスト);
		スコアテキスト.setZIndex(レイヤー13テキスト用);
		sortChildren();
		// 2.読み込んだフォントを利用してコインを表示
		テキスト2				= new Text(208, 8, font, "×",
				42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		attachChild(テキスト2);
		テキスト2.setZIndex(レイヤー13テキスト用);
		sortChildren();
		コインテキスト			= new Text(224, 8, font, ""
				+ 現在のコイン, 42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		attachChild(コインテキスト);
		コインテキスト.setZIndex(レイヤー13テキスト用);
		sortChildren();
		// 3.読み込んだフォントを利用して（※一時的に）残機を表示
		テキスト3				= new Text(394, 212, font, "×",
				42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		attachChild(テキスト3);
		テキスト3.setZIndex(レイヤー13テキスト用);
		sortChildren();
		ライフテキスト一時			= new Text(464, 212, font, ""
				+ 現在のライフ, 42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		attachChild(ライフテキスト一時);
		ライフテキスト一時.setZIndex(レイヤー13テキスト用);
		sortChildren();
		// 4.読み込んだフォントを利用して（※ず～と）残機を表示
		テキスト4				= new Text(208, 32, font, "×",
				42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		attachChild(テキスト4);
		テキスト4.setZIndex(レイヤー13テキスト用);
		sortChildren();
		ライフテキスト常時			= new Text(224, 32, font, ""
				+ 現在のライフ, 42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		attachChild(ライフテキスト常時);
		ライフテキスト常時.setZIndex(レイヤー13テキスト用);
		sortChildren();
		// 5.読み込んだフォントを利用してボールを表示
		テキスト5				= new Text(368, 8, font, "×",
				42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		if (現在のボール <= ((ボール最大値 / 2) / 2)) {
			テキスト5.setColor(1, 0, 0);
			attachChild(テキスト5);
			テキスト5.setZIndex(レイヤー13テキスト用);
			sortChildren();
		} else if (現在のボール <= (ボール最大値 / 2)) {
			テキスト5.setColor(1, 1, 0);
			attachChild(テキスト5);
			テキスト5.setZIndex(レイヤー13テキスト用);
			sortChildren();
		} else {
			テキスト5.setColor(1, 1, 1);
			attachChild(テキスト5);
			テキスト5.setZIndex(レイヤー13テキスト用);
			sortChildren();
		}
		ボールテキスト			= new Text(384, 8, font, ""
				+ 現在のボール + "/" + ボール最大値, 42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		if (現在のボール <= ((ボール最大値 / 2) / 2)) {
			ボールテキスト.setColor(1, 0, 0);
			attachChild(ボールテキスト);
			ボールテキスト.setZIndex(レイヤー13テキスト用);
			sortChildren();
		} else if (現在のボール <= (ボール最大値 / 2)) {
			ボールテキスト.setColor(1, 1, 0);
			attachChild(ボールテキスト);
			ボールテキスト.setZIndex(レイヤー13テキスト用);
			sortChildren();
		} else {
			ボールテキスト.setColor(1, 1, 1);
			attachChild(ボールテキスト);
			ボールテキスト.setZIndex(レイヤー13テキスト用);
			sortChildren();
		}
		// 6.読み込んだフォントを利用して（※一時的に）ワールドを表示
		テキスト6				= new Text(304, 148, font, "World",
				42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		attachChild(テキスト6);
		テキスト6.setZIndex(レイヤー13テキスト用);
		sortChildren();
		ワールドテキスト一時		= new Text(448, 148, font, ""
				+ 現在のワールド, 42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		attachChild(ワールドテキスト一時);
		ワールドテキスト一時.setZIndex(レイヤー13テキスト用);
		sortChildren();
		// 7.読み込んだフォントを利用して（※ず～と）ワールドを表示
		テキスト7				= new Text(496, 4, font, "World",
				42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		attachChild(テキスト7);
		テキスト7.setZIndex(レイヤー13テキスト用);
		sortChildren();
		ワールドテキスト常時		= new Text(496, 36, font, ""
				+ 現在のワールド, 42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		attachChild(ワールドテキスト常時);
		ワールドテキスト常時.setZIndex(レイヤー13テキスト用);
		sortChildren();
		// 8.読み込んだフォントを利用して（※一時的に）コースを表示
		テキスト8				= new Text(464, 148, font, "-",
				42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		attachChild(テキスト8);
		テキスト8.setZIndex(レイヤー13テキスト用);
		sortChildren();
		コーステキスト一時		= new Text(480, 148, font, ""
				+ 現在のコース, 42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		attachChild(コーステキスト一時);
		コーステキスト一時.setZIndex(レイヤー13テキスト用);
		sortChildren();
		// 9.読み込んだフォントを利用して（※ず～と）コースを表示
		テキスト9				= new Text(512, 36, font, "-",
				42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		attachChild(テキスト9);
		テキスト9.setZIndex(レイヤー13テキスト用);
		sortChildren();
		コーステキスト常時		= new Text(528, 36, font, ""
				+ 現在のコース, 42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		attachChild(コーステキスト常時);
		コーステキスト常時.setZIndex(レイヤー13テキスト用);
		sortChildren();
		// 10.読み込んだフォントを利用して距離を表示
		テキスト10				= new Text(656, 4, font, "Distance",
				42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		attachChild(テキスト10);
		テキスト10.setZIndex(レイヤー13テキスト用);
		sortChildren();
		距離テキスト			= new Text(656, 36, font, ""
				+ 現在の距離 + "/" + 距離の最大値 + "m", 42, new TextOptions(HorizontalAlign.LEFT),
				getBaseActivity().getVertexBufferObjectManager());
		attachChild(距離テキスト);
		距離テキスト.setZIndex(レイヤー13テキスト用);
		sortChildren();
		// 11.読み込んだフォントを利用してコンチ回数を表示（コンチ時のみ）
		if (現在のコンチニュー >= 1) {
			テキスト11 = new Text(288, 320, font, "Continue", 42,
					new TextOptions(HorizontalAlign.LEFT), getBaseActivity()
							.getVertexBufferObjectManager());
			テキスト11.setColor(1, 1, 0);
			attachChild(テキスト11);
			テキスト11.setZIndex(レイヤー13テキスト用);
			sortChildren();
			コンチテキスト1 = new Text(394, 320, font, "×", 42,
					new TextOptions(HorizontalAlign.LEFT), getBaseActivity()
							.getVertexBufferObjectManager());
			コンチテキスト1.setColor(1, 1, 0);
			attachChild(コンチテキスト1);
			コンチテキスト1.setZIndex(レイヤー13テキスト用);
			sortChildren();
			コンチテキスト2 = new Text(464, 320, font, "" + 現在のコンチニュー, 42,
					new TextOptions(HorizontalAlign.LEFT), getBaseActivity()
							.getVertexBufferObjectManager());
			コンチテキスト2.setColor(1, 1, 0);
			attachChild(コンチテキスト2);
			コンチテキスト2.setZIndex(レイヤー13テキスト用);
			sortChildren();
			コンチテキスト2.registerEntityModifier(
					new LoopEntityModifier(new SequenceEntityModifier(
							new ScaleModifier(0.25f, 1.0f, 1.5f),
							new ScaleModifier(0.25f, 1.5f, 1.0f)), 12));
		}
	}
	// デバッグテキストを描画
	public void debugTextView() {
//		// 端末に搭載されたフォントを利用する
//		Texture texture = new BitmapTextureAtlas(getBaseActivity()
//				.getTextureManager(), 512, 512,
//				TextureOptions.BILINEAR_PREMULTIPLYALPHA);
//		Font font = new Font(getBaseActivity().getFontManager(), texture,
//				Typeface.DEFAULT_BOLD, 24, true, Color.WHITE);
//		getBaseActivity().getTextureManager().loadTexture(texture);
//		getBaseActivity().getFontManager().loadFont(font);
//		// 1.読み込んだフォントを利用してデバッグデータ1を表示
//		デバッグデータ1テキスト			= new Text(-48, 132, font, "None..."
//				+ " : " + 0000, 42, new TextOptions(HorizontalAlign.LEFT),
//				getBaseActivity().getVertexBufferObjectManager());
//		デバッグデータ1テキスト.setColor(1, 0, 0);
//		デバッグデータ1テキスト.setScale(0.5f);
//		attachChild(デバッグデータ1テキスト);
//		デバッグデータ1テキスト.setZIndex(レイヤー17デバッグ用);
//		sortChildren();
//		// 2.読み込んだフォントを利用してデバッグデータ2を表示
//		デバッグデータ2テキスト			= new Text(-48, 148, font, "None..."
//				+ " : " + 0000, 42, new TextOptions(HorizontalAlign.LEFT),
//				getBaseActivity().getVertexBufferObjectManager());
//		デバッグデータ2テキスト.setColor(1, 0.5f, 0);	
//		デバッグデータ2テキスト.setScale(0.5f);
//		attachChild(デバッグデータ2テキスト);
//		デバッグデータ2テキスト.setZIndex(レイヤー17デバッグ用);
//		sortChildren();
//		// 3.読み込んだフォントを利用してデバッグデータ3を表示
//		デバッグデータ3テキスト			= new Text(-48, 164, font, "None..."
//				+ " : " + 0000, 42, new TextOptions(HorizontalAlign.LEFT),
//				getBaseActivity().getVertexBufferObjectManager());
//		デバッグデータ3テキスト.setColor(1, 1, 0);	
//		デバッグデータ3テキスト.setScale(0.5f);
//		attachChild(デバッグデータ3テキスト);
//		デバッグデータ3テキスト.setZIndex(レイヤー17デバッグ用);
//		sortChildren();
//		// 4.読み込んだフォントを利用してデバッグデータ4を表示
//		デバッグデータ4テキスト			= new Text(-48, 180, font, "None..."
//				+ " : " + 0000, 42, new TextOptions(HorizontalAlign.LEFT),
//				getBaseActivity().getVertexBufferObjectManager());
//		デバッグデータ4テキスト.setColor(0, 1, 0);	
//		デバッグデータ4テキスト.setScale(0.5f);
//		attachChild(デバッグデータ4テキスト);
//		デバッグデータ4テキスト.setZIndex(レイヤー17デバッグ用);
//		sortChildren();
//		// 5.読み込んだフォントを利用してデバッグデータ5を表示
//		デバッグデータ5テキスト			= new Text(-48, 196, font, "None..."
//				+ " : " + 0000, 42, new TextOptions(HorizontalAlign.LEFT),
//				getBaseActivity().getVertexBufferObjectManager());
//		デバッグデータ5テキスト.setColor(0, 1, 0.5f);	
//		デバッグデータ5テキスト.setScale(0.5f);
//		attachChild(デバッグデータ5テキスト);
//		デバッグデータ5テキスト.setZIndex(レイヤー17デバッグ用);
//		sortChildren();
//		// 6.読み込んだフォントを利用してデバッグデータ6を表示
//		デバッグデータ6テキスト			= new Text(-48, 212, font, "None..."
//				+ " : " + 0000, 42, new TextOptions(HorizontalAlign.LEFT),
//				getBaseActivity().getVertexBufferObjectManager());
//		デバッグデータ6テキスト.setColor(0, 1, 1);	
//		デバッグデータ6テキスト.setScale(0.5f);
//		attachChild(デバッグデータ6テキスト);
//		デバッグデータ6テキスト.setZIndex(レイヤー17デバッグ用);
//		sortChildren();
//		// 7.読み込んだフォントを利用してデバッグデータ7を表示
//		デバッグデータ7テキスト			= new Text(-48, 228, font, "None..."
//				+ " : " + 0000, 42, new TextOptions(HorizontalAlign.LEFT),
//				getBaseActivity().getVertexBufferObjectManager());
//		デバッグデータ7テキスト.setColor(0, 0, 1);	
//		デバッグデータ7テキスト.setScale(0.5f);
//		attachChild(デバッグデータ7テキスト);
//		デバッグデータ7テキスト.setZIndex(レイヤー17デバッグ用);
//		sortChildren();
//		// 8.読み込んだフォントを利用してデバッグデータ8を表示
//		デバッグデータ8テキスト			= new Text(-48, 244, font, "None..."
//				+ " : " + 0000, 42, new TextOptions(HorizontalAlign.LEFT),
//				getBaseActivity().getVertexBufferObjectManager());
//		デバッグデータ8テキスト.setColor(0.5f, 0, 1);	
//		デバッグデータ8テキスト.setScale(0.5f);
//		attachChild(デバッグデータ8テキスト);
//		デバッグデータ8テキスト.setZIndex(レイヤー17デバッグ用);
//		sortChildren();
	}
	
	// ===========================================================
	// アニメーション系
	// ===========================================================
	
	// デフォルトアニメ
	public void playerDefaultAnimation() {
		if (グラチェンジフラグ == false) {
			// ダッシュ時
			if (プレイヤーのダッシュフラグ == true && プレイヤーのジャンプフラグ == false) {
				if (メット取得フラグ == false && シャツ取得フラグ == false
						&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet1.animate(
							new long[] { ani並, ani並, ani並, }, 0, 2, true);
				} else if (メット取得フラグ == true && シャツ取得フラグ == true
						&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet1.animate(
							new long[] { ani並, ani並, ani並, }, 5, 7, true);
				} else if (状態フラグ無敵 == true) {
					marioSets.playerMarioSet1.animate(
							new long[] { aniスター, aniスター, aniスター, aniスター,
									aniスター, aniスター, aniスター, aniスター,
									aniスター, aniスター, aniスター, aniスター, }, 10, 21, true);
				}
			// ジャンプ時
			} else if (プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true) {
				if (メット取得フラグ == false && シャツ取得フラグ == false
						&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet1.setCurrentTileIndex(3);
				} else if (メット取得フラグ == true && シャツ取得フラグ == true
						&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet1.setCurrentTileIndex(8);
				} else if (状態フラグ無敵 == true) {
					marioSets.playerMarioSet1.animate(
							new long[] { aniスター, aniスター, aniスター, aniスター, }, 22, 25, true);
				}
			}
		} else {
			// ダッシュ時
			if (プレイヤーのダッシュフラグ == true && プレイヤーのジャンプフラグ == false) {
				// ※1
				if (メット取得フラグ == true && シャツ取得フラグ == false
						&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.animate(
							new long[] { ani並, ani並, ani並, }, 0, 2, true);
					// ※2
				} else if (メット取得フラグ == true && シャツ取得フラグ == true
						&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.animate(
							new long[] { ani並, ani並, ani並, }, 5, 7, true);
					// ※3
				} else if (メット取得フラグ == false && シャツ取得フラグ == true
						&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.animate(
							new long[] { ani並, ani並, ani並, }, 10, 12, true);
					// ※4
				} else if (メット取得フラグ == false && シャツ取得フラグ == true
						&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.animate(
							new long[] { ani並, ani並, ani並, }, 15, 17, true);
					// ※5
				} else if (メット取得フラグ == false && シャツ取得フラグ == false
						&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.animate(
							new long[] { ani並, ani並, ani並, }, 20, 22, true);
					// ※6
				} else if (メット取得フラグ == true && シャツ取得フラグ == false
						&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.animate(
							new long[] { ani並, ani並, ani並, }, 25, 27, true);
				}
				// ジャンプ時
			} else if (プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true) {
				if (メット取得フラグ == true && シャツ取得フラグ == false
						&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.setCurrentTileIndex(3);
					// ※2
				} else if (メット取得フラグ == true && シャツ取得フラグ == true
						&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.setCurrentTileIndex(8);
					// ※3
				} else if (メット取得フラグ == false && シャツ取得フラグ == true
						&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.setCurrentTileIndex(13);
					// ※4
				} else if (メット取得フラグ == false && シャツ取得フラグ == true
						&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.setCurrentTileIndex(18);
					// ※5
				} else if (メット取得フラグ == false && シャツ取得フラグ == false
						&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.setCurrentTileIndex(23);
					// ※6
				} else if (メット取得フラグ == true && シャツ取得フラグ == false
						&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.setCurrentTileIndex(28);
				}
			}
		}
	}
	// ダッシュアニメ
	public void playerDashAnimation() {
		if (バック転実行フラグ == false) {
			if (グラチェンジフラグ == false) {
				if (メット取得フラグ == false && シャツ取得フラグ == false
						&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet1.animate(
							new long[] { ani並, ani並, ani並, }, 0, 2, true);
				} else if (メット取得フラグ == true && シャツ取得フラグ == true
						&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet1.animate(
							new long[] { ani並, ani並, ani並, }, 5, 7, true);
				} else if (状態フラグ無敵 == true) {
					marioSets.playerMarioSet1.animate(
							new long[] { aniスター, aniスター, aniスター, aniスター,
									aniスター, aniスター, aniスター, aniスター,
									aniスター, aniスター, aniスター, aniスター, }, 10, 21, true);
				}
			} else {
				// ※1
				if (メット取得フラグ == true && シャツ取得フラグ == false
						&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.animate(
							new long[] { ani並, ani並, ani並, }, 0, 2, true);
					// ※2
				} else if (メット取得フラグ == true && シャツ取得フラグ == true
						&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.animate(
							new long[] { ani並, ani並, ani並, }, 5, 7, true);
					// ※3
				} else if (メット取得フラグ == false && シャツ取得フラグ == true
						&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.animate(
							new long[] { ani並, ani並, ani並, }, 10, 12, true);
					// ※4
				} else if (メット取得フラグ == false && シャツ取得フラグ == true
						&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.animate(
							new long[] { ani並, ani並, ani並, }, 15, 17, true);
					// ※5
				} else if (メット取得フラグ == false && シャツ取得フラグ == false
						&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.animate(
							new long[] { ani並, ani並, ani並, }, 20, 22, true);
					// ※6
				} else if (メット取得フラグ == true && シャツ取得フラグ == false
						&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.animate(
							new long[] { ani並, ani並, ani並, }, 25, 27, true);
				}
			}
		} else {
			if (グラチェンジフラグ == false) {
				if (メット取得フラグ == false && シャツ取得フラグ == false
						&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet1.animate(
							new long[] { 60, 60, 60, }, 0, 2, true);
				} else if (メット取得フラグ == true && シャツ取得フラグ == true
						&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet1.animate(
							new long[] { 60, 60, 60, }, 5, 7, true);
				} else if (状態フラグ無敵 == true) {
					marioSets.playerMarioSet1.animate(
							new long[] { 15, 15, 15, 15,
									15, 15, 15, 15,
									15, 15, 15, 15, }, 10, 21, true);
				}
			} else {
				// ※1
				if (メット取得フラグ == true && シャツ取得フラグ == false
						&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.animate(
							new long[] { 60, 60, 60, }, 0, 2, true);
					// ※2
				} else if (メット取得フラグ == true && シャツ取得フラグ == true
						&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.animate(
							new long[] { 60, 60, 60, }, 5, 7, true);
					// ※3
				} else if (メット取得フラグ == false && シャツ取得フラグ == true
						&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.animate(
							new long[] { 60, 60, 60, }, 10, 12, true);
					// ※4
				} else if (メット取得フラグ == false && シャツ取得フラグ == true
						&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.animate(
							new long[] { 60, 60, 60, }, 15, 17, true);
					// ※5
				} else if (メット取得フラグ == false && シャツ取得フラグ == false
						&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.animate(
							new long[] { 60, 60, 60, }, 20, 22, true);
					// ※6
				} else if (メット取得フラグ == true && シャツ取得フラグ == false
						&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
					marioSets.playerMarioSet2.animate(
							new long[] { 60, 60, 60, }, 25, 27, true);
				}
			}
		}
	}
	// ジャンプアニメ
	public void playerJumpAnimation() {
		if (グラチェンジフラグ == false) {
			if (メット取得フラグ == false && シャツ取得フラグ == false
					&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
				marioSets.playerMarioSet1.setCurrentTileIndex(3);
			} else if (メット取得フラグ == true && シャツ取得フラグ == true
					&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
				marioSets.playerMarioSet1.setCurrentTileIndex(8);
			} else if (状態フラグ無敵 == true) {
				marioSets.playerMarioSet1.animate(
						new long[] { aniスター, aniスター, aniスター, aniスター, }, 22, 25, true);
			}
		} else {
			// ※1
			if (メット取得フラグ == true && シャツ取得フラグ == false
					&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
				marioSets.playerMarioSet2.setCurrentTileIndex(3);
				// ※2
			} else if (メット取得フラグ == true && シャツ取得フラグ == true
					&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
				marioSets.playerMarioSet2.setCurrentTileIndex(8);
				// ※3
			} else if (メット取得フラグ == false && シャツ取得フラグ == true
					&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
				marioSets.playerMarioSet2.setCurrentTileIndex(13);
				// ※4
			} else if (メット取得フラグ == false && シャツ取得フラグ == true
					&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
				marioSets.playerMarioSet2.setCurrentTileIndex(18);
				// ※5
			} else if (メット取得フラグ == false && シャツ取得フラグ == false
					&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
				marioSets.playerMarioSet2.setCurrentTileIndex(23);
				// ※6
			} else if (メット取得フラグ == true && シャツ取得フラグ == false
					&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
				marioSets.playerMarioSet2.setCurrentTileIndex(28);
			}
		}
	}
	// 攻撃アニメ
	public void playerAttackAnimation() {
		if (グラチェンジフラグ == false) {
			if (メット取得フラグ == false && シャツ取得フラグ == false
					&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
				marioSets.playerMarioSet1.setCurrentTileIndex(4);
			} else if (メット取得フラグ == true && シャツ取得フラグ == true
					&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
				marioSets.playerMarioSet1.setCurrentTileIndex(9);
			} else if (状態フラグ無敵 == true) {
				marioSets.playerMarioSet1.animate(
						new long[] { aniスター, aniスター, aniスター, aniスター, }, 26, 29, true);
			}
		} else {
			// ※1
			if (メット取得フラグ == true && シャツ取得フラグ == false
					&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
				marioSets.playerMarioSet2.setCurrentTileIndex(4);
				// ※2
			} else if (メット取得フラグ == true && シャツ取得フラグ == true
					&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
				marioSets.playerMarioSet2.setCurrentTileIndex(9);
				// ※3
			} else if (メット取得フラグ == false && シャツ取得フラグ == true
					&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
				marioSets.playerMarioSet2.setCurrentTileIndex(14);
				// ※4
			} else if (メット取得フラグ == false && シャツ取得フラグ == true
					&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
				marioSets.playerMarioSet2.setCurrentTileIndex(19);
				// ※5
			} else if (メット取得フラグ == false && シャツ取得フラグ == false
					&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
				marioSets.playerMarioSet2.setCurrentTileIndex(24);
				// ※6
			} else if (メット取得フラグ == true && シャツ取得フラグ == false
					&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
				marioSets.playerMarioSet2.setCurrentTileIndex(29);
			}
		}
	}
	
	// ===========================================================
	// インクリ系
	// ===========================================================
	
	// ノーマルテキストをインクリ
	public void textIncrement() {
		// スタッフクレジットじゃないときの処理
		if (コースカウンター != 22 && メモリーの開放をしたかどうか == false) {
			スコアテキスト.setText("" + 現在のスコア);
			コインテキスト.setText("" + 現在のコイン);
			if (現在のライフ <= 1) {
				ライフテキスト常時.setText("" + 現在のライフ);
				テキスト4.setColor(1, 0, 0);
				ライフテキスト常時.setColor(1, 0, 0);
			} else if (現在のライフ == 10) {
				ライフテキスト常時.setText("" + 現在のライフ);
				テキスト4.setColor(1, 1, 0);
				ライフテキスト常時.setColor(1, 1, 0);
			} else {
				ライフテキスト常時.setText("" + 現在のライフ);
				テキスト4.setColor(1, 1, 1);
				ライフテキスト常時.setColor(1, 1, 1);
			}
			if (現在のボール <= ((ボール最大値 / 2) / 2)) {
				ボールテキスト.setText("" + 現在のボール + "/" + ボール最大値);
				テキスト5.setColor(1, 0, 0);
				ボールテキスト.setColor(1, 0, 0);
			} else if (現在のボール <= (ボール最大値 / 2)) {
				ボールテキスト.setText("" + 現在のボール + "/" + ボール最大値);
				テキスト5.setColor(1, 1, 0);
				ボールテキスト.setColor(1, 1, 0);
			} else {
				ボールテキスト.setText("" + 現在のボール + "/" + ボール最大値);
				テキスト5.setColor(1, 1, 1);
				ボールテキスト.setColor(1, 1, 1);
			}
			// 距離にタイル位置を代入
			if (現在の距離 < 距離の最大値) {
				現在の距離 = (ヨコ - 26);
				if (現在の距離 <= 0) {
					// 距離がマイナス表記にならないよう調整
					距離テキスト.setText("" + 0			+ "/" + 距離の最大値 + "m");
				} else {
					距離テキスト.setText("" + 現在の距離	+ "/" + 距離の最大値 + "m");
				}
				テキスト10.setColor(1, 1, 1);
				距離テキスト.setColor(1, 1, 1);
			} else {
				テキスト10.setColor(1, 1, 0);
				距離テキスト.setColor(1, 1, 0);
			}
			// スタッフクレジット時の処理
		} else if (コースカウンター == 22 && メモリーの開放をしたかどうか == false) {
			クレジットコインテキスト.setText("" + 現在のクレジットコイン);
			// ハイスコア時はテキストの色を黄色に
			if (現在のクレジットコイン > クレジットコインデータ.getInstance(getBaseActivity()).getクレジットコインデータ()) {
				SCテキスト1.setColor(1, 1, 0);
				クレジットコインテキスト.setColor(1, 1, 0);
			}
		}
	}
	// デバッグテキストをインクリ
	public void debugTextIncrement() {
		// スタッフクレジットじゃないときの処理
		if (コースカウンター != 22) {
//									// 1
//			デバッグデータ1テキスト	.setText("変数を入力"
//							+ " : " + 変数を入力);
//									// 2
//			デバッグデータ2テキスト	.setText("変数を入力"
//							+ " : " + 変数を入力);
//									// 3
//			デバッグデータ3テキスト	.setText("変数を入力"
//							+ " : " + 変数を入力);
//									// 4
//			デバッグデータ4テキスト	.setText("変数を入力"
//							+ " : " + 変数を入力);
//									// 5
//			デバッグデータ5テキスト	.setText("変数を入力"
//							+ " : " + 変数を入力);
//									// 6
//			デバッグデータ6テキスト	.setText("変数を入力"
//							+ " : " + 変数を入力);
//									// 7
//			デバッグデータ7テキスト	.setText("変数を入力"
//							+ " : " + 変数を入力);
//									// 8
//			デバッグデータ8テキスト	.setText("変数を入力"
//							+ " : " + 変数を入力);
		}
	}
	// 背景をインクリ
	public void backIncrement() {
		if (コースの端っこかどうか == false && メモリーの開放をしたかどうか == false) {
			// 地上雲
			if (コースカウンター == 1 && ゲームオーバーかどうか == false
					|| コースカウンター == 5 && ゲームオーバーかどうか == false
					|| コースカウンター == 6 && ゲームオーバーかどうか == false
					|| コースカウンター == 9 && ゲームオーバーかどうか == false
					|| コースカウンター == 13 && ゲームオーバーかどうか == false
					|| コースカウンター == 14 && ゲームオーバーかどうか == false
					|| コースカウンター == 18 && ゲームオーバーかどうか == false
					|| コースカウンター == 21 && ゲームオーバーかどうか == false
					|| コースカウンター == 22 && ゲームオーバーかどうか == false
					) {
				地上雲1.setX(地上雲1.getX() - 画面のスピード);
				if (地上雲1.getX() <= -getBaseActivity().getEngine()
						.getCamera().getWidth() * 2) {
					// 雲の右端が画面左端より左に移動した場合は画面幅*4分右へ移動
					地上雲1.setX(地上雲1.getX()
							+ getBaseActivity().getEngine().getCamera()
							.getWidth() * 4);
				}
				地上雲2.setX(地上雲2.getX() - 画面のスピード);
				if (地上雲2.getX() <= -getBaseActivity().getEngine()
						.getCamera().getWidth() * 2) {
					地上雲2.setX(地上雲2.getX()
							+ getBaseActivity().getEngine().getCamera()
							.getWidth() * 4);
				}
			}
			// アスレチック雲
			if (コースカウンター == 3 && ゲームオーバーかどうか == false
					|| コースカウンター == 8 && ゲームオーバーかどうか == false
					|| コースカウンター == 11 && ゲームオーバーかどうか == false
					|| コースカウンター == 15 && ゲームオーバーかどうか == false
					|| コースカウンター == 17 && ゲームオーバーかどうか == false
					|| コースカウンター == 20 && ゲームオーバーかどうか == false
					) {
				アスレチック雲1.setX(アスレチック雲1.getX() - 画面のスピード);
				if (アスレチック雲1.getX() <= -getBaseActivity().getEngine()
						.getCamera().getWidth() * 2) {
					// 雲の右端が画面左端より左に移動した場合は画面幅*4分右へ移動
					アスレチック雲1.setX(アスレチック雲1.getX()
							+ getBaseActivity().getEngine().getCamera()
							.getWidth() * 4);
				}
				アスレチック雲2.setX(アスレチック雲2.getX() - 画面のスピード);
				if (アスレチック雲2.getX() <= -getBaseActivity().getEngine()
						.getCamera().getWidth() * 2) {
					アスレチック雲2.setX(アスレチック雲2.getX()
							+ getBaseActivity().getEngine().getCamera()
							.getWidth() * 4);
				}
			}
			// 水
			if (コースカウンター == 7 && ゲームオーバーかどうか == false
					|| コースカウンター == 10 && ゲームオーバーかどうか == false
					|| コースカウンター == 17 && ゲームオーバーかどうか == false
					|| コースカウンター == 19 && ゲームオーバーかどうか == false
					) {
				水1.setX(水1.getX() - 画面のスピード);
				if (水1.getX() <= -getBaseActivity().getEngine()
						.getCamera().getWidth() * 2) {
					// 水の右端が画面左端より左に移動した場合は画面幅*4分右へ移動
					水1.setX(水1.getX()
							+ getBaseActivity().getEngine().getCamera()
							.getWidth() * 4);
				}
				水2.setX(水2.getX() - 画面のスピード);
				if (水2.getX() <= -getBaseActivity().getEngine()
						.getCamera().getWidth() * 2) {
					水2.setX(水2.getX()
							+ getBaseActivity().getEngine().getCamera()
							.getWidth() * 4);
				}
			}
			// 溶岩
			if (コースカウンター == 4 && ゲームオーバーかどうか == false
					|| コースカウンター == 13 && ゲームオーバーかどうか == false
					|| コースカウンター == 14 && ゲームオーバーかどうか == false
					|| コースカウンター == 16 && ゲームオーバーかどうか == false
					|| コースカウンター == 20 && ゲームオーバーかどうか == false
					) {
				溶岩1.setX(溶岩1.getX() - 画面のスピード);
				if (溶岩1.getX() <= -getBaseActivity().getEngine()
						.getCamera().getWidth() * 2) {
					// 溶岩の右端が画面左端より左に移動した場合は画面幅*4分右へ移動
					溶岩1.setX(溶岩1.getX()
							+ getBaseActivity().getEngine().getCamera()
							.getWidth() * 4);
				}
				溶岩2.setX(溶岩2.getX() - 画面のスピード);
				if (溶岩2.getX() <= -getBaseActivity().getEngine()
						.getCamera().getWidth() * 2) {
					溶岩2.setX(溶岩2.getX()
							+ getBaseActivity().getEngine().getCamera()
							.getWidth() * 4);
				}
			}
			if (出現フラグワールド1地下入り口 == true) {
				ワールド1地下入り口.setX(ワールド1地下入り口.getX() - 画面のスピード);
				ワールド1地下中間.setX(ワールド1地下中間.getX() - 画面のスピード);
			}
			if (出現フラグワールド1お城入り口 == true) {
				ワールド1お城入り口.setX(ワールド1お城入り口.getX() - 画面のスピード);
				ワールド1お城中間.setX(ワールド1お城中間.getX() - 画面のスピード);
			}
			if (出現フラグワールド2地下入り口 == true) {
				ワールド2地下入り口.setX(ワールド2地下入り口.getX() - 画面のスピード);
				ワールド2地下中間.setX(ワールド2地下中間.getX() - 画面のスピード);
			}
			if (出現フラグワールド2お城入り口 == true) {
				ワールド2お城入り口.setX(ワールド2お城入り口.getX() - 画面のスピード);
				ワールド2お城中間.setX(ワールド2お城中間.getX() - 画面のスピード);
			}
			if (出現フラグワールド3地下入り口 == true) {
				ワールド3地下入り口.setX(ワールド3地下入り口.getX() - 画面のスピード);
				ワールド3地下中間.setX(ワールド3地下中間.getX() - 画面のスピード);
			}
			if (出現フラグワールド3お城入り口 == true) {
				ワールド3お城入り口.setX(ワールド3お城入り口.getX() - 画面のスピード);
				ワールド3お城中間.setX(ワールド3お城中間.getX() - 画面のスピード);
			}
			if (出現フラグワールド4お城入り口 == true) {
				ワールド4お城入り口.setX(ワールド4お城入り口.getX() - 画面のスピード);
				ワールド4お城中間.setX(ワールド4お城中間.getX() - 画面のスピード);
			}
			if (出現フラグブロック背景1 == true) {
				ブロック背景1.setX(ブロック背景1.getX() - 画面のスピード);
			}
			if (出現フラグブロック背景2 == true) {
				ブロック背景2.setX(ブロック背景2.getX() - 画面のスピード);
			}
			if (出現フラグブロック背景3 == true) {
				ブロック背景3.setX(ブロック背景3.getX() - 画面のスピード);
			}
			if (出現フラグブロック背景4 == true) {
				ブロック背景4.setX(ブロック背景4.getX() - 画面のスピード);
			}
		}
	}
	// コースをインクリ
	public void courseIncrement() {
		if (コースカウンター == 1 || コースカウンター == 2
				|| コースカウンター == 3 || コースカウンター == 4) {
			world1Increment();
		} else if (コースカウンター == 5 || コースカウンター == 6
				|| コースカウンター == 7 || コースカウンター == 8) {
			world2Increment();
		} else if (コースカウンター == 9 || コースカウンター == 10
				|| コースカウンター == 11 || コースカウンター == 12) {
			world3Increment();
		} else if (コースカウンター == 13 || コースカウンター == 14
				|| コースカウンター == 15 || コースカウンター == 16) {
			world4Increment();
		} else if (コースカウンター == 17 || コースカウンター == 18
				|| コースカウンター == 19 || コースカウンター == 20
				|| コースカウンター == 21 || コースカウンター == 22) {
			worldSIncrement();
		}
	}
	// アイコンをインクリ
	public void iconIncrement() {
		// スタッフクレジットじゃないときの処理
		if (コースカウンター != 22 && メモリーの開放をしたかどうか == false) {
			// アイコンカーソル
			if (グラチェンジフラグ == false) {
				if (marioSets.playerMarioSet1.getX() <= 0) {
					アイコンカーソル.setPosition(
							16,
							contactLines.playerContactLineCenter1.getY() + 16);
					アイコンカーソル.setAlpha(1);
				} else {
					アイコンカーソル.setAlpha(0);
				}
			} else {
				if (marioSets.playerMarioSet2.getX() <= 0) {
					アイコンカーソル.setPosition(
							16,
							contactLines.playerContactLineCenter1.getY() + 16);
					アイコンカーソル.setAlpha(1);
				} else {
					アイコンカーソル.setAlpha(0);
				}
			}
			// パワーメーター
			if (現在のノーマルメーター < 2) {
				メーターチャージ.setCurrentTileIndex(0);
			} else if (現在のノーマルメーター < 4) {
				メーターチャージ.setCurrentTileIndex(1);
			} else if (現在のノーマルメーター < 6) {
				メーターチャージ.setCurrentTileIndex(2);
			} else if (現在のノーマルメーター < 8) {
				メーターチャージ.setCurrentTileIndex(3);
			} else if (現在のノーマルメーター < 10) {
				メーターチャージ.setCurrentTileIndex(4);
			} else if (現在のノーマルメーター < 12) {
				メーターチャージ.setCurrentTileIndex(5);
			} else if (現在のノーマルメーター < 14) {
				メーターチャージ.setCurrentTileIndex(6);
			} else if (現在のノーマルメーター < 16) {
				メーターチャージ.setCurrentTileIndex(7);
			} else if (現在のノーマルメーター < 18) {
				メーターチャージ.setCurrentTileIndex(8);
			} else if (現在のノーマルメーター < 20) {
				メーターチャージ.setCurrentTileIndex(9);
			} else if (現在のノーマルメーター < 22) {
				メーターチャージ.setCurrentTileIndex(10);
			} else if (現在のノーマルメーター < 24) {
				メーターチャージ.setCurrentTileIndex(11);
			} else if (現在のノーマルメーター < 26) {
				メーターチャージ.setCurrentTileIndex(12);
			} else if (現在のノーマルメーター < 28) {
				メーターチャージ.setCurrentTileIndex(13);
			} else if (現在のノーマルメーター < 30) {
				メーターチャージ.setCurrentTileIndex(14);
			} else if (現在のノーマルメーター < 32) {
				メーターチャージ.setCurrentTileIndex(15);
			} else if (現在のノーマルメーター < 34) {
				メーターチャージ.setCurrentTileIndex(16);
			} else if (現在のノーマルメーター < 36) {
				メーターチャージ.setCurrentTileIndex(17);
			} else if (現在のノーマルメーター < 38) {
				メーターチャージ.setCurrentTileIndex(18);
			} else if (現在のノーマルメーター < 40) {
				メーターチャージ.setCurrentTileIndex(19);
			} else if (現在のノーマルメーター < 42) {
				メーターチャージ.setCurrentTileIndex(20);
			} else if (現在のノーマルメーター < 44) {
				メーターチャージ.setCurrentTileIndex(21);
			} else if (現在のノーマルメーター < 46) {
				メーターチャージ.setCurrentTileIndex(22);
			} else if (現在のノーマルメーター < 48) {
				メーターチャージ.setCurrentTileIndex(23);
			} else if (現在のノーマルメーター < 50) {
				メーターチャージ.setCurrentTileIndex(24);
			} else if (現在のノーマルメーター < 52) {
				メーターチャージ.setCurrentTileIndex(25);
			} else if (現在のノーマルメーター < 54) {
				メーターチャージ.setCurrentTileIndex(26);
			} else if (現在のノーマルメーター < 56) {
				メーターチャージ.setCurrentTileIndex(27);
			} else if (現在のノーマルメーター < 58) {
				メーターチャージ.setCurrentTileIndex(28);
			} else if (現在のノーマルメーター < 60) {
				メーターチャージ.setCurrentTileIndex(29);
			} else if (現在のノーマルメーター < 62) {
				メーターチャージ.setCurrentTileIndex(30);
			} else if (現在のノーマルメーター < 64) {
				メーターチャージ.setCurrentTileIndex(31);
			} else if (現在のノーマルメーター < 66) {
				メーターチャージ.setCurrentTileIndex(32);
			} else if (現在のノーマルメーター < 68) {
				メーターチャージ.setCurrentTileIndex(33);
			} else if (現在のノーマルメーター < 70) {
				メーターチャージ.setCurrentTileIndex(34);
			} else if (現在のノーマルメーター < 72) {
				メーターチャージ.setCurrentTileIndex(35);
			} else if (現在のノーマルメーター < 74) {
				メーターチャージ.setCurrentTileIndex(36);
			} else if (現在のノーマルメーター < 76) {
				メーターチャージ.setCurrentTileIndex(37);
			} else if (現在のノーマルメーター < 78) {
				メーターチャージ.setCurrentTileIndex(38);
			} else if (現在のノーマルメーター < 80) {
				メーターチャージ.setCurrentTileIndex(39);
			} else if (現在のノーマルメーター < 82) {
				メーターチャージ.setCurrentTileIndex(40);
			} else if (現在のノーマルメーター < 84) {
				メーターチャージ.setCurrentTileIndex(41);
			} else if (現在のノーマルメーター < 86) {
				メーターチャージ.setCurrentTileIndex(42);
			} else if (現在のノーマルメーター < 88) {
				メーターチャージ.setCurrentTileIndex(43);
			} else if (現在のノーマルメーター < 90) {
				メーターチャージ.setCurrentTileIndex(44);
			} else if (現在のノーマルメーター < 92) {
				メーターチャージ.setCurrentTileIndex(45);
			} else if (現在のノーマルメーター < 94) {
				メーターチャージ.setCurrentTileIndex(46);
			} else if (現在のノーマルメーター < 96) {
				メーターチャージ.setCurrentTileIndex(47);
			} else if (現在のノーマルメーター < 98) {
				メーターチャージ.setCurrentTileIndex(48);
			} else if (現在のノーマルメーター < 100) {
				メーターチャージ.setCurrentTileIndex(49);
			} else if (現在のノーマルメーター < 102) {
				メーターチャージ.setCurrentTileIndex(50);
			} else if (現在のノーマルメーター < 104) {
				メーターチャージ.setCurrentTileIndex(51);
			} else if (現在のノーマルメーター < 106) {
				メーターチャージ.setCurrentTileIndex(52);
			} else if (現在のノーマルメーター < 108) {
				メーターチャージ.setCurrentTileIndex(53);
			} else if (現在のノーマルメーター < 110) {
				メーターチャージ.setCurrentTileIndex(54);
			} else if (現在のノーマルメーター < 112) {
				メーターチャージ.setCurrentTileIndex(55);
			} else if (現在のノーマルメーター < 114) {
				メーターチャージ.setCurrentTileIndex(56);
			} else if (現在のノーマルメーター < 116) {
				メーターチャージ.setCurrentTileIndex(57);
			} else if (現在のノーマルメーター < 118) {
				メーターチャージ.setCurrentTileIndex(58);
			} else if (現在のノーマルメーター < 120) {
				メーターチャージ.setCurrentTileIndex(59);
			} else if (現在のノーマルメーター >= 120) {
				normalStarmanSprite();
			}
			for (int i = 0; i <= 現在のノーマルメーター; i++) {
				メーターパーセン.setCurrentTileIndex(i);
			}
		}
	}
	// スコアをインクリ
	public void scoreIncrement() {
		
	}
	// アイテムをインクリ
	public void itemIncrement() {
		if (メモリーの開放をしたかどうか == false) {
			// ブロック系
			// ブロックコイン黄色を上へ
			if (出現フラグブロックコイン黄色 == true) {
				if (グラチェンジフラグ == false) {
					blockCoins.effectBlockCoinYellow.setX(
							marioSets.playerMarioSet1.getX());
				} else {
					blockCoins.effectBlockCoinYellow.setX(
							marioSets.playerMarioSet2.getX());
				}
				blockCoins.effectBlockCoinYellow.setY(
						blockCoins.effectBlockCoinYellow.getY() - ブロックコイン黄色上昇移動時の値);
				ブロックコイン黄色上昇移動時の値 *= 0.864f;
				// ブロックコイン黄色を下へ
				if (ブロックコイン黄色上昇移動時の値 >= 0) {
					blockCoins.effectBlockCoinYellow.setY(
							blockCoins.effectBlockCoinYellow.getY() + ブロックコイン黄色下降移動時の値);
					ブロックコイン黄色下降移動時の値 *= 1.086f;
					// ブロックコイン黄色がマリオに触れたらリセット
					if (グラチェンジフラグ == false) {
						if (marioSets.playerMarioSet1.getY()
								<= blockCoins.effectBlockCoinYellow.getY()) {
							// スタッフクレジットじゃないときの処理
							if (コースカウンター != 22) {
								// フォントを表示
								scores.fontScore100 = getBaseActivity().getResourceUtil()
										.getSprite("font_01_score_100.png");
								scores.fontScore100.setTag(
										Scores.TAG_FONT_01_SCORE_100);
								scores.fontScore100.setPosition(
										marioSets.playerMarioSet1.getX(),
										marioSets.playerMarioSet1.getY());
								attachChild(scores.fontScore100);
								scores.fontScore100.setZIndex(レイヤー13テキスト用);
								sortChildren();
								// 1.5秒ストップ！
								registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										scores.fontScore100.registerEntityModifier(new FadeOutModifier(0.5f));
										// 0.5秒ストップ！
										registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
											public void onTimePassed(TimerHandler pTimeHandler) {
												scores.fontScore100.detachSelf();
											}
										}));
									}
								}));
							}
							ブロックコイン黄色上昇移動時の値	= 24;
							ブロックコイン黄色下降移動時の値	= 4.8f;
							出現フラグブロックコイン黄色		= false;
							収納用エフェクト.add(blockCoins.effectBlockCoinYellow);
						}
					} else {
						if (marioSets.playerMarioSet2.getY()
								<= blockCoins.effectBlockCoinYellow.getY()) {
							// スタッフクレジットじゃないときの処理
							if (コースカウンター != 22) {
								// フォントを表示
								scores.fontScore100 = getBaseActivity().getResourceUtil()
										.getSprite("font_01_score_100.png");
								scores.fontScore100.setTag(
										Scores.TAG_FONT_01_SCORE_100);
								scores.fontScore100.setPosition(
										marioSets.playerMarioSet2.getX(),
										marioSets.playerMarioSet2.getY());
								attachChild(scores.fontScore100);
								scores.fontScore100.setZIndex(レイヤー13テキスト用);
								sortChildren();
								// 1.5秒ストップ！
								registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										scores.fontScore100.registerEntityModifier(new FadeOutModifier(0.5f));
										// 0.5秒ストップ！
										registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
											public void onTimePassed(TimerHandler pTimeHandler) {
												scores.fontScore100.detachSelf();
											}
										}));
									}
								}));
							}
							ブロックコイン黄色上昇移動時の値	= 24;
							ブロックコイン黄色下降移動時の値	= 4.8f;
							出現フラグブロックコイン黄色		= false;
							収納用エフェクト.add(blockCoins.effectBlockCoinYellow);
						}
					}
				}
			}
			// ブロックコイン赤色を上へ
			if (出現フラグブロックコイン赤色 == true) {
				if (グラチェンジフラグ == false) {
					blockCoins.effectBlockCoinRed.setX(
							marioSets.playerMarioSet1.getX());
				} else {
					blockCoins.effectBlockCoinRed.setX(
							marioSets.playerMarioSet2.getX());
				}
				blockCoins.effectBlockCoinRed.setY(
						blockCoins.effectBlockCoinRed.getY() - ブロックコイン赤色上昇移動時の値);
				ブロックコイン赤色上昇移動時の値 *= 0.864f;
				// ブロックコイン赤色を下へ
				if (ブロックコイン赤色上昇移動時の値 >= 0) {
					blockCoins.effectBlockCoinRed.setY(
							blockCoins.effectBlockCoinRed.getY() + ブロックコイン赤色下降移動時の値);
					ブロックコイン赤色下降移動時の値 *= 1.086f;
					// ブロックコイン赤色がマリオに触れたらリセット
					if (グラチェンジフラグ == false) {
						if (marioSets.playerMarioSet1.getY()
								<= blockCoins.effectBlockCoinRed.getY()) {
							// スタッフクレジットじゃないときの処理
							if (コースカウンター != 22) {
								// フォントを表示
								scores.fontScore200 = getBaseActivity().getResourceUtil()
										.getSprite("font_02_score_200.png");
								scores.fontScore200.setTag(
										Scores.TAG_FONT_02_SCORE_200);
								scores.fontScore200.setPosition(
										marioSets.playerMarioSet1.getX(),
										marioSets.playerMarioSet1.getY());
								attachChild(scores.fontScore200);
								scores.fontScore200.setZIndex(レイヤー13テキスト用);
								sortChildren();
								// 1.5秒ストップ！
								registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										scores.fontScore200.registerEntityModifier(new FadeOutModifier(0.5f));
										// 0.5秒ストップ！
										registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
											public void onTimePassed(TimerHandler pTimeHandler) {
												scores.fontScore200.detachSelf();
											}
										}));
									}
								}));
							}
							ブロックコイン赤色上昇移動時の値	= 24;
							ブロックコイン赤色下降移動時の値	= 4.8f;
							出現フラグブロックコイン赤色		= false;
							収納用エフェクト.add(blockCoins.effectBlockCoinRed);
						}
					} else {
						if (marioSets.playerMarioSet2.getY()
								<= blockCoins.effectBlockCoinRed.getY()) {
							// スタッフクレジットじゃないときの処理
							if (コースカウンター != 22) {
								// フォントを表示
								scores.fontScore200 = getBaseActivity().getResourceUtil()
										.getSprite("font_02_score_200.png");
								scores.fontScore200.setTag(
										Scores.TAG_FONT_02_SCORE_200);
								scores.fontScore200.setPosition(
										marioSets.playerMarioSet2.getX(),
										marioSets.playerMarioSet2.getY());
								attachChild(scores.fontScore200);
								scores.fontScore200.setZIndex(レイヤー13テキスト用);
								sortChildren();
								// 1.5秒ストップ！
								registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										scores.fontScore200.registerEntityModifier(new FadeOutModifier(0.5f));
										// 0.5秒ストップ！
										registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
											public void onTimePassed(TimerHandler pTimeHandler) {
												scores.fontScore200.detachSelf();
											}
										}));
									}
								}));
							}
							ブロックコイン赤色上昇移動時の値	= 24;
							ブロックコイン赤色下降移動時の値	= 4.8f;
							出現フラグブロックコイン赤色		= false;
							収納用エフェクト.add(blockCoins.effectBlockCoinRed);
						}
					}
				}
			}
			// ブロックコイン青色を上へ
			if (出現フラグブロックコイン青色 == true) {
				if (グラチェンジフラグ == false) {
					blockCoins.effectBlockCoinBlue.setX(
							marioSets.playerMarioSet1.getX());
				} else {
					blockCoins.effectBlockCoinBlue.setX(
							marioSets.playerMarioSet2.getX());
				}
				blockCoins.effectBlockCoinBlue.setY(
						blockCoins.effectBlockCoinBlue.getY() - ブロックコイン青色上昇移動時の値);
				ブロックコイン青色上昇移動時の値 *= 0.864f;
				// ブロックコイン青色を下へ
				if (ブロックコイン青色上昇移動時の値 >= 0) {
					blockCoins.effectBlockCoinBlue.setY(
							blockCoins.effectBlockCoinBlue.getY() + ブロックコイン青色下降移動時の値);
					ブロックコイン青色下降移動時の値 *= 1.086f;
					// ブロックコイン青色がマリオに触れたらリセット
					if (グラチェンジフラグ == false) {
						if (marioSets.playerMarioSet1.getY()
								<= blockCoins.effectBlockCoinBlue.getY()) {
							// スタッフクレジットじゃないときの処理
							if (コースカウンター != 22) {
								// フォントを表示
								scores.fontScore500 = getBaseActivity().getResourceUtil()
										.getSprite("font_05_score_500.png");
								scores.fontScore500.setTag(
										Scores.TAG_FONT_05_SCORE_500);
								scores.fontScore500.setPosition(
										marioSets.playerMarioSet1.getX(),
										marioSets.playerMarioSet1.getY());
								attachChild(scores.fontScore500);
								scores.fontScore500.setZIndex(レイヤー13テキスト用);
								sortChildren();
								// 1.5秒ストップ！
								registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										scores.fontScore500.registerEntityModifier(new FadeOutModifier(0.5f));
										// 0.5秒ストップ！
										registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
											public void onTimePassed(TimerHandler pTimeHandler) {
												scores.fontScore500.detachSelf();
											}
										}));
									}
								}));
							}
							ブロックコイン青色上昇移動時の値	= 24;
							ブロックコイン青色下降移動時の値	= 4.8f;
							出現フラグブロックコイン青色		= false;
							収納用エフェクト.add(blockCoins.effectBlockCoinBlue);
						}
					} else {
						if (marioSets.playerMarioSet2.getY()
								<= blockCoins.effectBlockCoinBlue.getY()) {
							// スタッフクレジットじゃないときの処理
							if (コースカウンター != 22) {
								// フォントを表示
								scores.fontScore500 = getBaseActivity().getResourceUtil()
										.getSprite("font_05_score_500.png");
								scores.fontScore500.setTag(
										Scores.TAG_FONT_05_SCORE_500);
								scores.fontScore500.setPosition(
										marioSets.playerMarioSet2.getX(),
										marioSets.playerMarioSet2.getY());
								attachChild(scores.fontScore500);
								scores.fontScore500.setZIndex(レイヤー13テキスト用);
								sortChildren();
								// 1.5秒ストップ！
								registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										scores.fontScore500.registerEntityModifier(new FadeOutModifier(0.5f));
										// 0.5秒ストップ！
										registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
											public void onTimePassed(TimerHandler pTimeHandler) {
												scores.fontScore500.detachSelf();
											}
										}));
									}
								}));
							}
							ブロックコイン青色上昇移動時の値	= 24;
							ブロックコイン青色下降移動時の値	= 4.8f;
							出現フラグブロックコイン青色		= false;
							収納用エフェクト.add(blockCoins.effectBlockCoinBlue);
						}
					}
				}
			}
			// ブロックメットアイテムを上へ
			if (出現フラグブロックメットアイテム == true) {
				ブロックメットアイテム.setY(
						ブロックメットアイテム.getY() - ブロックメットアイテム上昇移動時の値);
				ブロックメットアイテム上昇移動時の値 *= 0.99f;
				// ブロックメットアイテムを下へ
				if (ブロックメットアイテム上昇移動時の値 >= 0) {
					ブロックメットアイテム.setY(
							ブロックメットアイテム.getY() + ブロックメットアイテム下降移動時の値);
					ブロックメットアイテム下降移動時の値 *= 1.05f;
					if (ブロックメットアイテム下降移動時の値 >= 12) {
						ブロックメットアイテム下降移動時の値 = 12;
					}
					// ブロックメットアイテムがマリオに触れたらリセット
					if (グラチェンジフラグ == false && 状態フラグ復活中 == false) {
						if (marioSets.playerMarioSet1.getX()
								>= ブロックメットアイテム.getX() - 32 &&
								marioSets.playerMarioSet1.getY()
								< ブロックメットアイテム.getY() + 32 &&
								marioSets.playerMarioSet1.getY()
								> ブロックメットアイテム.getY() - 32) {
							ブロックメットアイテム上昇移動時の値	= 12;
							ブロックメットアイテム下降移動時の値	= 2.4f;
							出現フラグブロックメットアイテム		= false;
							// ブロックメットアイテム取得メソッドの呼び出し
							itemAndPlayerPowerUpItem1Decision();
							ブロックメットアイテム.detachSelf();
						}
					} else if (グラチェンジフラグ == true && 状態フラグ復活中 == false) {
						if (marioSets.playerMarioSet2.getX()
								>= ブロックメットアイテム.getX() - 32 &&
								marioSets.playerMarioSet2.getY()
								< ブロックメットアイテム.getY() + 32 &&
								marioSets.playerMarioSet2.getY()
								> ブロックメットアイテム.getY() - 32) {
							ブロックメットアイテム上昇移動時の値	= 12;
							ブロックメットアイテム下降移動時の値	= 2.4f;
							出現フラグブロックメットアイテム		= false;
							// ブロックメットアイテム取得メソッドの呼び出し
							itemAndPlayerPowerUpItem1Decision();
							ブロックメットアイテム.detachSelf();
						}
					}
				}
				// ブロックメットアイテムの右側移動処理。メットアイテムが特定の位置より左側なら実行
				if (ブロックメットアイテム.getX() <= 160) {
					ブロックメットアイテム.setX(
							ブロックメットアイテム.getX() + 3);
				}
				// ブロックメットアイテムが画面外へ行ったら削除
				if (ブロックメットアイテム.getY() >= 480) {
					ブロックメットアイテム上昇移動時の値	= 12;
					ブロックメットアイテム下降移動時の値	= 2.4f;
					出現フラグブロックメットアイテム		= false;
					ブロックメットアイテム.detachSelf();
				}
			}
			// ブロックシャツアイテムを上へ
			if (出現フラグブロックシャツアイテム == true) {
				ブロックシャツアイテム.setY(
						ブロックシャツアイテム.getY() - ブロックシャツアイテム上昇移動時の値);
				ブロックシャツアイテム上昇移動時の値 *= 0.99f;
				// ブロックシャツアイテムを下へ
				if (ブロックシャツアイテム上昇移動時の値 >= 0) {
					ブロックシャツアイテム.setY(
							ブロックシャツアイテム.getY() + ブロックシャツアイテム下降移動時の値);
					ブロックシャツアイテム下降移動時の値 *= 1.05f;
					if (ブロックシャツアイテム下降移動時の値 >= 12) {
						ブロックシャツアイテム下降移動時の値 = 12;
					}
					// ブロックシャツアイテムがマリオに触れたらリセット
					if (グラチェンジフラグ == false && 状態フラグ復活中 == false) {
						if (marioSets.playerMarioSet1.getX()
								>= ブロックシャツアイテム.getX() - 32 &&
								marioSets.playerMarioSet1.getY()
								< ブロックシャツアイテム.getY() + 32 &&
								marioSets.playerMarioSet1.getY()
								> ブロックシャツアイテム.getY() - 32) {
							ブロックシャツアイテム上昇移動時の値	= 12;
							ブロックシャツアイテム下降移動時の値	= 2.4f;
							出現フラグブロックシャツアイテム			= false;
							// ブロックシャツアイテム取得メソッドの呼び出し
							itemAndPlayerPowerUpItem2Decision();
							ブロックシャツアイテム.detachSelf();
						}
					} else if (グラチェンジフラグ == true && 状態フラグ復活中 == false) {
						if (marioSets.playerMarioSet2.getX()
								>= ブロックシャツアイテム.getX() - 32 &&
								marioSets.playerMarioSet2.getY()
								< ブロックシャツアイテム.getY() + 32 &&
								marioSets.playerMarioSet2.getY()
								> ブロックシャツアイテム.getY() - 32) {
							ブロックシャツアイテム上昇移動時の値	= 12;
							ブロックシャツアイテム下降移動時の値	= 2.4f;
							出現フラグブロックシャツアイテム			= false;
							// ブロックシャツアイテム取得メソッドの呼び出し
							itemAndPlayerPowerUpItem2Decision();
							ブロックシャツアイテム.detachSelf();
						}
					}
				}
				// ブロックシャツアイテムの右側移動処理。シャツアイテムが特定の位置より左側なら実行
				if (ブロックシャツアイテム.getX() <= 160) {
					ブロックシャツアイテム.setX(
							ブロックシャツアイテム.getX() + 3);
				}
				// ブロックシャツアイテムが画面外へ行ったら削除
				if (ブロックシャツアイテム.getY() >= 480) {
					ブロックシャツアイテム上昇移動時の値	= 12;
					ブロックシャツアイテム下降移動時の値	= 2.4f;
					出現フラグブロックシャツアイテム			= false;
					ブロックシャツアイテム.detachSelf();
				}
			}
			// ブロックズボンアイテムを上へ
			if (出現フラグブロックズボンアイテム == true) {
				ブロックズボンアイテム.setY(
						ブロックズボンアイテム.getY() - ブロックズボンアイテム上昇移動時の値);
				ブロックズボンアイテム上昇移動時の値 *= 0.99f;
				// ブロックズボンアイテムを下へ
				if (ブロックズボンアイテム上昇移動時の値 >= 0) {
					ブロックズボンアイテム.setY(
							ブロックズボンアイテム.getY() + ブロックズボンアイテム下降移動時の値);
					ブロックズボンアイテム下降移動時の値 *= 1.05f;
					if (ブロックズボンアイテム下降移動時の値 >= 12) {
						ブロックズボンアイテム下降移動時の値 = 12;
					}
					// ブロックズボンアイテムがマリオに触れたらリセット
					if (グラチェンジフラグ == false && 状態フラグ復活中 == false) {
						if (marioSets.playerMarioSet1.getX()
								>= ブロックズボンアイテム.getX() - 32 &&
								marioSets.playerMarioSet1.getY()
								< ブロックズボンアイテム.getY() + 32 &&
								marioSets.playerMarioSet1.getY()
								> ブロックズボンアイテム.getY() - 32) {
							ブロックズボンアイテム上昇移動時の値	= 12;
							ブロックズボンアイテム下降移動時の値	= 2.4f;
							出現フラグブロックズボンアイテム			= false;
							// ブロックズボンアイテム取得メソッドの呼び出し
							itemAndPlayerPowerUpItem3Decision();
							ブロックズボンアイテム.detachSelf();
						}
					} else if (グラチェンジフラグ == true && 状態フラグ復活中 == false) {
						if (marioSets.playerMarioSet2.getX()
								>= ブロックズボンアイテム.getX() - 32 &&
								marioSets.playerMarioSet2.getY()
								< ブロックズボンアイテム.getY() + 32 &&
								marioSets.playerMarioSet2.getY()
								> ブロックズボンアイテム.getY() - 32) {
							ブロックズボンアイテム上昇移動時の値	= 12;
							ブロックズボンアイテム下降移動時の値	= 2.4f;
							出現フラグブロックズボンアイテム			= false;
							// ブロックズボンアイテム取得メソッドの呼び出し
							itemAndPlayerPowerUpItem3Decision();
							ブロックズボンアイテム.detachSelf();
						}
					}
				}
				// ブロックズボンアイテムの右側移動処理。ズボンアイテムが特定の位置より左側なら実行
				if (ブロックズボンアイテム.getX() <= 160) {
					ブロックズボンアイテム.setX(
							ブロックズボンアイテム.getX() + 3);
				}
				// ブロックズボンアイテムが画面外へ行ったら削除
				if (ブロックズボンアイテム.getY() >= 480) {
					ブロックズボンアイテム上昇移動時の値	= 12;
					ブロックズボンアイテム下降移動時の値	= 2.4f;
					出現フラグブロックズボンアイテム			= false;
					ブロックズボンアイテム.detachSelf();
				}
			}
			// ブロックワンナップキノコを上へ
			if (出現フラグブロックワンナップキノコ == true) {
				ブロックワンナップキノコ.setY(
						ブロックワンナップキノコ.getY() - ブロックワンナップキノコ上昇移動時の値);
				ブロックワンナップキノコ上昇移動時の値 *= 0.99f;
				// ブロックワンナップキノコを下へ
				if (ブロックワンナップキノコ上昇移動時の値 >= 0) {
					ブロックワンナップキノコ.setY(
							ブロックワンナップキノコ.getY() + ブロックワンナップキノコ下降移動時の値);
					ブロックワンナップキノコ下降移動時の値 *= 1.05f;
					if (ブロックワンナップキノコ下降移動時の値 >= 12) {
						ブロックワンナップキノコ下降移動時の値 = 12;
					}
					// ブロックワンナップキノコがマリオに触れたらリセット
					if (グラチェンジフラグ == false && 状態フラグ復活中 == false) {
						if (marioSets.playerMarioSet1.getX()
								>= ブロックワンナップキノコ.getX() - 32 &&
								marioSets.playerMarioSet1.getY()
								< ブロックワンナップキノコ.getY() + 32 &&
								marioSets.playerMarioSet1.getY()
								> ブロックワンナップキノコ.getY() - 32) {
							ブロックワンナップキノコ上昇移動時の値	= 12;
							ブロックワンナップキノコ下降移動時の値	= 2.4f;
							出現フラグブロックワンナップキノコ		= false;
							// ブロックワンナップキノコ取得メソッドの呼び出し
							itemAndPlayerOneUpMushroomDecision();
							ブロックワンナップキノコ.detachSelf();
						}
					} else if (グラチェンジフラグ == true && 状態フラグ復活中 == false) {
						if (marioSets.playerMarioSet2.getX()
								>= ブロックワンナップキノコ.getX() - 32 &&
								marioSets.playerMarioSet2.getY()
								< ブロックワンナップキノコ.getY() + 32 &&
								marioSets.playerMarioSet2.getY()
								> ブロックワンナップキノコ.getY() - 32) {
							ブロックワンナップキノコ上昇移動時の値	= 12;
							ブロックワンナップキノコ下降移動時の値	= 2.4f;
							出現フラグブロックワンナップキノコ		= false;
							// ブロックワンナップキノコ取得メソッドの呼び出し
							itemAndPlayerOneUpMushroomDecision();
							ブロックワンナップキノコ.detachSelf();
						}
					}
				}
				// ブロックワンナップキノコの右側移動処理。ワンナップキノコが特定の位置より左側なら実行
				if (ブロックワンナップキノコ.getX() <= 160) {
					ブロックワンナップキノコ.setX(
							ブロックワンナップキノコ.getX() + 3);
				}
				// ブロックワンナップキノコが画面外へ行ったら削除
				if (ブロックワンナップキノコ.getY() >= 480) {
					ブロックワンナップキノコ上昇移動時の値	= 12;
					ブロックワンナップキノコ下降移動時の値	= 2.4f;
					出現フラグブロックワンナップキノコ		= false;
					ブロックワンナップキノコ.detachSelf();
				}
			}
			// ブロックファイアフラワー1を上へ
			if (出現フラグブロックファイアフラワー1 == true) {
				ブロックファイアフラワー1.setY(
						ブロックファイアフラワー1.getY() - ブロックファイアフラワー1上昇移動時の値);
				ブロックファイアフラワー1上昇移動時の値 *= 0.99f;
				// ブロックファイアフラワー1を下へ
				if (ブロックファイアフラワー1上昇移動時の値 >= 0) {
					ブロックファイアフラワー1.setY(
							ブロックファイアフラワー1.getY() + ブロックファイアフラワー1下降移動時の値);
					ブロックファイアフラワー1下降移動時の値 *= 1.05f;
					if (ブロックファイアフラワー1下降移動時の値 >= 12) {
						ブロックファイアフラワー1下降移動時の値 = 12;
					}
					// ブロックファイアフラワー1がマリオに触れたらリセット
					if (グラチェンジフラグ == false && 状態フラグ復活中 == false) {
						if (marioSets.playerMarioSet1.getX()
								>= ブロックファイアフラワー1.getX() - 32 &&
								marioSets.playerMarioSet1.getY()
								< ブロックファイアフラワー1.getY() + 32 &&
								marioSets.playerMarioSet1.getY()
								> ブロックファイアフラワー1.getY() - 32) {
							ブロックファイアフラワー1上昇移動時の値	= 12;
							ブロックファイアフラワー1下降移動時の値	= 2.4f;
							出現フラグブロックファイアフラワー1		= false;
							// ブロックファイアフラワー1取得メソッドの呼び出し
							itemAndPlayerFireFlowerSmallDecision();
							ブロックファイアフラワー1.detachSelf();
						}
					} else if (グラチェンジフラグ == true && 状態フラグ復活中 == false) {
						if (marioSets.playerMarioSet2.getX()
								>= ブロックファイアフラワー1.getX() - 32 &&
								marioSets.playerMarioSet2.getY()
								< ブロックファイアフラワー1.getY() + 32 &&
								marioSets.playerMarioSet2.getY()
								> ブロックファイアフラワー1.getY() - 32) {
							ブロックファイアフラワー1上昇移動時の値	= 12;
							ブロックファイアフラワー1下降移動時の値	= 2.4f;
							出現フラグブロックファイアフラワー1		= false;
							// ブロックファイアフラワー1取得メソッドの呼び出し
							itemAndPlayerFireFlowerSmallDecision();
							ブロックファイアフラワー1.detachSelf();
						}
					}
				}
				// ブロックファイアフラワー1の右側移動処理。ファイアフラワーが特定の位置より左側なら実行
				if (ブロックファイアフラワー1.getX() <= 160) {
					ブロックファイアフラワー1.setX(
							ブロックファイアフラワー1.getX() + 3);
				}
				// ブロックファイアフラワー1が画面外へ行ったら削除
				if (ブロックファイアフラワー1.getY() >= 480) {
					ブロックファイアフラワー1上昇移動時の値	= 12;
					ブロックファイアフラワー1下降移動時の値	= 2.4f;
					出現フラグブロックファイアフラワー1		= false;
					ブロックファイアフラワー1.detachSelf();
				}
			}
			// ブロックファイアフラワー2を上へ
			if (出現フラグブロックファイアフラワー2 == true) {
				ブロックファイアフラワー2.setY(
						ブロックファイアフラワー2.getY() - ブロックファイアフラワー2上昇移動時の値);
				ブロックファイアフラワー2上昇移動時の値 *= 0.99f;
				// ブロックファイアフラワー2を下へ
				if (ブロックファイアフラワー2上昇移動時の値 >= 0) {
					ブロックファイアフラワー2.setY(
							ブロックファイアフラワー2.getY() + ブロックファイアフラワー2下降移動時の値);
					ブロックファイアフラワー2下降移動時の値 *= 1.05f;
					if (ブロックファイアフラワー2下降移動時の値 >= 12) {
						ブロックファイアフラワー2下降移動時の値 = 12;
					}
					// ブロックファイアフラワー2がマリオに触れたらリセット
					if (グラチェンジフラグ == false && 状態フラグ復活中 == false) {
						if (marioSets.playerMarioSet1.getX()
								>= ブロックファイアフラワー2.getX() - 32 &&
								marioSets.playerMarioSet1.getY()
								< ブロックファイアフラワー2.getY() + 32 &&
								marioSets.playerMarioSet1.getY()
								> ブロックファイアフラワー2.getY() - 32) {
							ブロックファイアフラワー2上昇移動時の値	= 12;
							ブロックファイアフラワー2下降移動時の値	= 2.4f;
							出現フラグブロックファイアフラワー2		= false;
							// ブロックファイアフラワー2取得メソッドの呼び出し
							itemAndPlayerFireFlowerSmallDecision();
							ブロックファイアフラワー2.detachSelf();
						}
					} else if (グラチェンジフラグ == true && 状態フラグ復活中 == false) {
						if (marioSets.playerMarioSet2.getX()
								>= ブロックファイアフラワー2.getX() - 32 &&
								marioSets.playerMarioSet2.getY()
								< ブロックファイアフラワー2.getY() + 32 &&
								marioSets.playerMarioSet2.getY()
								> ブロックファイアフラワー2.getY() - 32) {
							ブロックファイアフラワー2上昇移動時の値	= 12;
							ブロックファイアフラワー2下降移動時の値	= 2.4f;
							出現フラグブロックファイアフラワー2		= false;
							// ブロックファイアフラワー2取得メソッドの呼び出し
							itemAndPlayerFireFlowerSmallDecision();
							ブロックファイアフラワー2.detachSelf();
						}
					}
				}
				// ブロックファイアフラワー2の右側移動処理。ファイアフラワーが特定の位置より左側なら実行
				if (ブロックファイアフラワー2.getX() <= 160) {
					ブロックファイアフラワー2.setX(
							ブロックファイアフラワー2.getX() + 3);
				}
				// ブロックファイアフラワー2が画面外へ行ったら削除
				if (ブロックファイアフラワー2.getY() >= 480) {
					ブロックファイアフラワー2上昇移動時の値	= 12;
					ブロックファイアフラワー2下降移動時の値	= 2.4f;
					出現フラグブロックファイアフラワー2		= false;
					ブロックファイアフラワー2.detachSelf();
				}
			}
		}
	}
	// 敵キャラをインクリ
	public void enemyIncrement() {
		// 昇天パックン
		if (getChildByIndex(敵キャラ).getTag() ==
				PiranhaPlants.TAG_ENEMY_09_PIRANHA_PLANT_GREY_NORMAL_0
				) {
			if (getChildByIndex(敵キャラ).getX() < 640) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() - 4);
			}
			// パックンが規定位置に達したら配列を完全削除
			if (getChildByIndex(敵キャラ).getX() <= -32) {
				// すぐに削除するとインデックスがずれるため、一旦配列に追加
				収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
			}
		}
		// 101.パックンフラワー（緑色／ノーマル1）
		if (getChildByIndex(敵キャラ).getTag() ==
				PiranhaPlants.TAG_ENEMY_21_PIRANHA_PLANT_GREEN_NORMAL_1
				) {
			// ビリビリ攻撃！
			if (getChildByIndex(敵キャラ).getX() == 640) {
				SoundPlay.seThunder.stop();
				SoundPlay.seThunder.play();
				enemyAttacks.effectEnemyAttackThunder = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("effect_31_enemy_attack_thunder.png", 1, 4);
				enemyAttacks.effectEnemyAttackThunder.setTag(
						EnemyAttacks.TAG_EFFECT_31_ENEMY_ATTACK_THUNDER);
				enemyAttacks.effectEnemyAttackThunder.setPosition(
						getChildByIndex(敵キャラ).getX(),
						getChildByIndex(敵キャラ).getY() + 32);
				enemyAttacks.effectEnemyAttackThunder.animate(ani並);
				attachChild(enemyAttacks.effectEnemyAttackThunder);
				enemyAttacks.effectEnemyAttackThunder.setZIndex(レイヤー08敵キャラ用);
				sortChildren();
			}
			if (getChildByIndex(敵キャラ).getX() < 640
					== getChildByIndex(敵キャラ).getX() >= 512) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() + 4);
			}
			// パックンが規定位置に達したら配列を完全削除
			if (getChildByIndex(敵キャラ).getX() <= 512) {
				// すぐに削除するとインデックスがずれるため、一旦配列に追加
				収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
			}
		}
		// 102.パックンフラワー（緑色／ノーマル2）
		if (getChildByIndex(敵キャラ).getTag() ==
				PiranhaPlants.TAG_ENEMY_22_PIRANHA_PLANT_GREEN_NORMAL_2
				) {
			if (getChildByIndex(敵キャラ).getX() < 800
					== getChildByIndex(敵キャラ).getX() >= 672) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() - 4);
			}
			// ビリビリ攻撃！
			if (getChildByIndex(敵キャラ).getX() == 560) {
				SoundPlay.seThunder.stop();
				SoundPlay.seThunder.play();
				enemyAttacks.effectEnemyAttackThunder = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("effect_31_enemy_attack_thunder.png", 1, 4);
				enemyAttacks.effectEnemyAttackThunder.setTag(
						EnemyAttacks.TAG_EFFECT_31_ENEMY_ATTACK_THUNDER);
				enemyAttacks.effectEnemyAttackThunder.setPosition(
						getChildByIndex(敵キャラ).getX(),
						getChildByIndex(敵キャラ).getY() + 32);
				enemyAttacks.effectEnemyAttackThunder.animate(ani並);
				attachChild(enemyAttacks.effectEnemyAttackThunder);
				enemyAttacks.effectEnemyAttackThunder.setZIndex(レイヤー08敵キャラ用);
				sortChildren();
			}
			if (getChildByIndex(敵キャラ).getX() < 560
					== getChildByIndex(敵キャラ).getX() >= 432) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() + 4);
			}
			// パックンが規定位置に達したら配列を完全削除
			if (getChildByIndex(敵キャラ).getX() <= 432) {
				// すぐに削除するとインデックスがずれるため、一旦配列に追加
				収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
			}
		}
		// 103.パックンフラワー（緑色／ノーマル3）
		if (getChildByIndex(敵キャラ).getTag() ==
				PiranhaPlants.TAG_ENEMY_23_PIRANHA_PLANT_GREEN_NORMAL_3
				) {
			// ビリビリ攻撃！
			if (getChildByIndex(敵キャラ).getX() == 560) {
				SoundPlay.seThunder.stop();
				SoundPlay.seThunder.play();
				enemyAttacks.effectEnemyAttackThunder = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("effect_31_enemy_attack_thunder.png", 1, 4);
				enemyAttacks.effectEnemyAttackThunder.setTag(
						EnemyAttacks.TAG_EFFECT_31_ENEMY_ATTACK_THUNDER);
				enemyAttacks.effectEnemyAttackThunder.setPosition(
						getChildByIndex(敵キャラ).getX(),
						getChildByIndex(敵キャラ).getY() + 32);
				enemyAttacks.effectEnemyAttackThunder.animate(ani並);
				attachChild(enemyAttacks.effectEnemyAttackThunder);
				enemyAttacks.effectEnemyAttackThunder.setZIndex(レイヤー08敵キャラ用);
				sortChildren();
			}
			if (getChildByIndex(敵キャラ).getX() < 560
					== getChildByIndex(敵キャラ).getX() >= 432) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() + 4);
			}
			// パックンが規定位置に達したら配列を完全削除
			if (getChildByIndex(敵キャラ).getX() <= 432) {
				// すぐに削除するとインデックスがずれるため、一旦配列に追加
				収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
			}
		}
		// 104.パックンフラワー（緑色／ノーマル4）
		if (getChildByIndex(敵キャラ).getTag() ==
				PiranhaPlants.TAG_ENEMY_24_PIRANHA_PLANT_GREEN_NORMAL_4
				) {
			if (getChildByIndex(敵キャラ).getX() < 720
					== getChildByIndex(敵キャラ).getX() >= 592) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() - 4);
			}
			// ビリビリ攻撃！
			if (getChildByIndex(敵キャラ).getX() == 480) {
				SoundPlay.seThunder.stop();
				SoundPlay.seThunder.play();
				enemyAttacks.effectEnemyAttackThunder = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("effect_31_enemy_attack_thunder.png", 1, 4);
				enemyAttacks.effectEnemyAttackThunder.setTag(
						EnemyAttacks.TAG_EFFECT_31_ENEMY_ATTACK_THUNDER);
				enemyAttacks.effectEnemyAttackThunder.setPosition(
						getChildByIndex(敵キャラ).getX(),
						getChildByIndex(敵キャラ).getY() + 32);
				enemyAttacks.effectEnemyAttackThunder.animate(ani並);
				attachChild(enemyAttacks.effectEnemyAttackThunder);
				enemyAttacks.effectEnemyAttackThunder.setZIndex(レイヤー08敵キャラ用);
				sortChildren();
			}
			if (getChildByIndex(敵キャラ).getX() < 480
					== getChildByIndex(敵キャラ).getX() >= 352) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() + 4);
			}
			// パックンが規定位置に達したら配列を完全削除
			if (getChildByIndex(敵キャラ).getX() <= 352) {
				// すぐに削除するとインデックスがずれるため、一旦配列に追加
				収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
			}
		}
		// 105.パックンフラワー（緑色／ノーマル5）
		if (getChildByIndex(敵キャラ).getTag() ==
				PiranhaPlants.TAG_ENEMY_25_PIRANHA_PLANT_GREEN_NORMAL_5
				) {
			if (getChildByIndex(敵キャラ).getX() < 560
					== getChildByIndex(敵キャラ).getX() >= 432) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() + 4);
			}
			// パックンが規定位置に達したら配列を完全削除
			if (getChildByIndex(敵キャラ).getX() <= 432) {
				// すぐに削除するとインデックスがずれるため、一旦配列に追加
				収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
			}
		}
		// 106.パックンフラワー（緑色／逆さま1）
		if (getChildByIndex(敵キャラ).getTag() ==
				PiranhaPlants.TAG_ENEMY_26_PIRANHA_PLANT_GREEN_UPSIDE_1
				) {
			// ビリビリ攻撃！
			if (getChildByIndex(敵キャラ).getX() == 640) {
				SoundPlay.seThunder.stop();
				SoundPlay.seThunder.play();
				enemyAttacks.effectEnemyAttackThunder = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("effect_31_enemy_attack_thunder.png", 1, 4);
				enemyAttacks.effectEnemyAttackThunder.setTag(
						EnemyAttacks.TAG_EFFECT_31_ENEMY_ATTACK_THUNDER);
				enemyAttacks.effectEnemyAttackThunder.setPosition(
						getChildByIndex(敵キャラ).getX(),
						getChildByIndex(敵キャラ).getY() + 32);
				enemyAttacks.effectEnemyAttackThunder.animate(ani並);
				attachChild(enemyAttacks.effectEnemyAttackThunder);
				enemyAttacks.effectEnemyAttackThunder.setZIndex(レイヤー08敵キャラ用);
				sortChildren();
			}
			if (getChildByIndex(敵キャラ).getX() < 640
					== getChildByIndex(敵キャラ).getX() >= 512) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() - 4);
			}
			// パックンが規定位置に達したら配列を完全削除
			if (getChildByIndex(敵キャラ).getX() <= 512) {
				// すぐに削除するとインデックスがずれるため、一旦配列に追加
				収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
			}
		}
		// 107.パックンフラワー（緑色／逆さま1）
		if (getChildByIndex(敵キャラ).getTag() ==
				PiranhaPlants.TAG_ENEMY_27_PIRANHA_PLANT_GREEN_UPSIDE_2
				) {
			if (getChildByIndex(敵キャラ).getX() < 800
					== getChildByIndex(敵キャラ).getX() >= 672) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() + 4);
			}
			// ビリビリ攻撃！
			if (getChildByIndex(敵キャラ).getX() == 560) {
				SoundPlay.seThunder.stop();
				SoundPlay.seThunder.play();
				enemyAttacks.effectEnemyAttackThunder = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("effect_31_enemy_attack_thunder.png", 1, 4);
				enemyAttacks.effectEnemyAttackThunder.setTag(
						EnemyAttacks.TAG_EFFECT_31_ENEMY_ATTACK_THUNDER);
				enemyAttacks.effectEnemyAttackThunder.setPosition(
						getChildByIndex(敵キャラ).getX(),
						getChildByIndex(敵キャラ).getY() + 32);
				enemyAttacks.effectEnemyAttackThunder.animate(ani並);
				attachChild(enemyAttacks.effectEnemyAttackThunder);
				enemyAttacks.effectEnemyAttackThunder.setZIndex(レイヤー08敵キャラ用);
				sortChildren();
			}
			if (getChildByIndex(敵キャラ).getX() < 560
					== getChildByIndex(敵キャラ).getX() >= 432) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() - 4);
			}
			// パックンが規定位置に達したら配列を完全削除
			if (getChildByIndex(敵キャラ).getX() <= 432) {
				// すぐに削除するとインデックスがずれるため、一旦配列に追加
				収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
			}
		}
		// 108.パックンフラワー（緑色／逆さま1）
		if (getChildByIndex(敵キャラ).getTag() ==
				PiranhaPlants.TAG_ENEMY_28_PIRANHA_PLANT_GREEN_UPSIDE_3
				) {
			// ビリビリ攻撃！
			if (getChildByIndex(敵キャラ).getX() == 560) {
				SoundPlay.seThunder.stop();
				SoundPlay.seThunder.play();
				enemyAttacks.effectEnemyAttackThunder = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("effect_31_enemy_attack_thunder.png", 1, 4);
				enemyAttacks.effectEnemyAttackThunder.setTag(
						EnemyAttacks.TAG_EFFECT_31_ENEMY_ATTACK_THUNDER);
				enemyAttacks.effectEnemyAttackThunder.setPosition(
						getChildByIndex(敵キャラ).getX(),
						getChildByIndex(敵キャラ).getY() + 32);
				enemyAttacks.effectEnemyAttackThunder.animate(ani並);
				attachChild(enemyAttacks.effectEnemyAttackThunder);
				enemyAttacks.effectEnemyAttackThunder.setZIndex(レイヤー08敵キャラ用);
				sortChildren();
			}
			if (getChildByIndex(敵キャラ).getX() < 560
					== getChildByIndex(敵キャラ).getX() >= 432) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() - 4);
			}
			// パックンが規定位置に達したら配列を完全削除
			if (getChildByIndex(敵キャラ).getX() <= 432) {
				// すぐに削除するとインデックスがずれるため、一旦配列に追加
				収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
			}
		}
		// 109.パックンフラワー（緑色／逆さま1）
		if (getChildByIndex(敵キャラ).getTag() ==
				PiranhaPlants.TAG_ENEMY_29_PIRANHA_PLANT_GREEN_UPSIDE_4
				) {
			if (getChildByIndex(敵キャラ).getX() < 720
					== getChildByIndex(敵キャラ).getX() >= 592) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() + 4);
			}
			// ビリビリ攻撃！
			if (getChildByIndex(敵キャラ).getX() == 480) {
				SoundPlay.seThunder.stop();
				SoundPlay.seThunder.play();
				enemyAttacks.effectEnemyAttackThunder = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("effect_31_enemy_attack_thunder.png", 1, 4);
				enemyAttacks.effectEnemyAttackThunder.setTag(
						EnemyAttacks.TAG_EFFECT_31_ENEMY_ATTACK_THUNDER);
				enemyAttacks.effectEnemyAttackThunder.setPosition(
						getChildByIndex(敵キャラ).getX(),
						getChildByIndex(敵キャラ).getY() + 32);
				enemyAttacks.effectEnemyAttackThunder.animate(ani並);
				attachChild(enemyAttacks.effectEnemyAttackThunder);
				enemyAttacks.effectEnemyAttackThunder.setZIndex(レイヤー08敵キャラ用);
				sortChildren();
			}
			if (getChildByIndex(敵キャラ).getX() < 480
					== getChildByIndex(敵キャラ).getX() >= 352) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() - 4);
			}
			// パックンが規定位置に達したら配列を完全削除
			if (getChildByIndex(敵キャラ).getX() <= 352) {
				// すぐに削除するとインデックスがずれるため、一旦配列に追加
				収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
			}
		}
		// 110.パックンフラワー（緑色／逆さま1）
		if (getChildByIndex(敵キャラ).getTag() ==
				PiranhaPlants.TAG_ENEMY_30_PIRANHA_PLANT_GREEN_UPSIDE_5
				) {
			if (getChildByIndex(敵キャラ).getX() < 560
					== getChildByIndex(敵キャラ).getX() >= 432) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() - 4);
			}
			// パックンが規定位置に達したら配列を完全削除
			if (getChildByIndex(敵キャラ).getX() <= 432) {
				// すぐに削除するとインデックスがずれるため、一旦配列に追加
				収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
			}
		}
		// 111.パックンフラワー（灰色／ノーマル1）
		if (getChildByIndex(敵キャラ).getTag() ==
				PiranhaPlants.TAG_ENEMY_31_PIRANHA_PLANT_GREY_NORMAL_1
				) {
			if (getChildByIndex(敵キャラ).getX() < 480
					== getChildByIndex(敵キャラ).getX() >= 352) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() + 4);
			}
			// パックンが規定位置に達したら配列を完全削除
			if (getChildByIndex(敵キャラ).getX() <= 352) {
				// すぐに削除するとインデックスがずれるため、一旦配列に追加
				収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
			}
		}
		// 112.パックンフラワー（灰色／ノーマル2）
		if (getChildByIndex(敵キャラ).getTag() ==
				PiranhaPlants.TAG_ENEMY_32_PIRANHA_PLANT_GREY_NORMAL_2
				) {
			if (getChildByIndex(敵キャラ).getX() < 640
					== getChildByIndex(敵キャラ).getX() >= 512) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() - 4);
			}
			// パックンが規定位置に達したら配列を完全削除
			if (getChildByIndex(敵キャラ).getX() <= -32) {
				// すぐに削除するとインデックスがずれるため、一旦配列に追加
				収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
			}
		}
		// 113.パックンフラワー（灰色／ノーマル3）
		if (getChildByIndex(敵キャラ).getTag() ==
				PiranhaPlants.TAG_ENEMY_33_PIRANHA_PLANT_GREY_NORMAL_3
				) {
			if (getChildByIndex(敵キャラ).getX() < 400
					== getChildByIndex(敵キャラ).getX() >= 272) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() + 4);
			}
			// パックンが規定位置に達したら配列を完全削除
			if (getChildByIndex(敵キャラ).getX() <= 272) {
				// すぐに削除するとインデックスがずれるため、一旦配列に追加
				収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
			}
		}
		// 114.パックンフラワー（灰色／ノーマル4）
		if (getChildByIndex(敵キャラ).getTag() ==
				PiranhaPlants.TAG_ENEMY_34_PIRANHA_PLANT_GREY_NORMAL_4
				) {
			if (getChildByIndex(敵キャラ).getX() < 560
					== getChildByIndex(敵キャラ).getX() >= 432) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() - 4);
			}
			// パックンが規定位置に達したら配列を完全削除
			if (getChildByIndex(敵キャラ).getX() <= -32) {
				// すぐに削除するとインデックスがずれるため、一旦配列に追加
				収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
			}
		}
		// 115.パックンフラワー（灰色／ノーマル5）
		// 116.パックンフラワー（灰色／逆さま1）
		if (getChildByIndex(敵キャラ).getTag() ==
				PiranhaPlants.TAG_ENEMY_36_PIRANHA_PLANT_GREY_UPSIDE_1
				) {
			if (getChildByIndex(敵キャラ).getX() < 480
					== getChildByIndex(敵キャラ).getX() >= 352) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() - 4);
			}
			// パックンが規定位置に達したら配列を完全削除※ここだけ0
			if (getChildByIndex(敵キャラ).getX() <= -32) {
				// すぐに削除するとインデックスがずれるため、一旦配列に追加
				収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
			}
		}
		// 117.パックンフラワー（灰色／逆さま1）
		if (getChildByIndex(敵キャラ).getTag() ==
				PiranhaPlants.TAG_ENEMY_37_PIRANHA_PLANT_GREY_UPSIDE_2
				) {
			if (getChildByIndex(敵キャラ).getX() < 640
					== getChildByIndex(敵キャラ).getX() >= 512) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() + 4);
			}
			// パックンが規定位置に達したら配列を完全削除
			if (getChildByIndex(敵キャラ).getX() <= -32) {
				// すぐに削除するとインデックスがずれるため、一旦配列に追加
				収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
			}
		}
		// 118.パックンフラワー（灰色／逆さま1）
		if (getChildByIndex(敵キャラ).getTag() ==
				PiranhaPlants.TAG_ENEMY_38_PIRANHA_PLANT_GREY_UPSIDE_3
				) {
			if (getChildByIndex(敵キャラ).getX() < 400
					== getChildByIndex(敵キャラ).getX() >= 272) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() - 4);
			}
			// パックンが規定位置に達したら配列を完全削除
			if (getChildByIndex(敵キャラ).getX() <= -32) {
				// すぐに削除するとインデックスがずれるため、一旦配列に追加
				収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
			}
		}
		// 119.パックンフラワー（灰色／逆さま1）
		if (getChildByIndex(敵キャラ).getTag() ==
				PiranhaPlants.TAG_ENEMY_39_PIRANHA_PLANT_GREY_UPSIDE_4
				) {
			if (getChildByIndex(敵キャラ).getX() < 560
					== getChildByIndex(敵キャラ).getX() >= 432) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() + 4);
			}
			// パックンが規定位置に達したら配列を完全削除
			if (getChildByIndex(敵キャラ).getX() <= -32) {
				// すぐに削除するとインデックスがずれるため、一旦配列に追加
				収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
			}
		}
		// 120.パックンフラワー（灰色／逆さま1）
	}
	// ボスキャラをインクリ
	public void bossIncrement() {
		if (getChildByIndex(敵キャラ).getTag() ==
				Bowsers.			TAG_ENEMY_41_BOWSER_NORMAL_LEVEL_1
				|| getChildByIndex(敵キャラ).getTag() ==
				Bowsers.			TAG_ENEMY_42_BOWSER_NORMAL_LEVEL_2
				|| getChildByIndex(敵キャラ).getTag() ==
				Bowsers.			TAG_ENEMY_43_BOWSER_NORMAL_LEVEL_3
				|| getChildByIndex(敵キャラ).getTag() ==
				Bowsers.			TAG_ENEMY_44_BOWSER_NORMAL_LEVEL_4
				|| getChildByIndex(敵キャラ).getTag() ==
				Bowsers.			TAG_ENEMY_45_BOWSER_FINAL
				) {
			// 各ボス初期ポジション
			if (getChildByIndex(敵キャラ).getY() > 128 && ノーマルボス行動パターン == 0) {
				getChildByIndex(敵キャラ).setY(
						getChildByIndex(敵キャラ).getY() - 2);
			}
			// 体力があるうちは攻撃
			if (ボスレベル1体力 > 0) {
				// パターン1
				if (ノーマルボス行動パターン == 1) {
					// 上へ-32
					if (ノーマルボス行動ユニット == 1) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() > 96) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() - 4);
								} else {
									if (ノーマルボス行動ユニット == 1) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 2;
									}
								}
							}
						}));
						// 下へ+32
					} else if (ノーマルボス行動ユニット == 2) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() < 128) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() + 4);
								} else {
									if (ノーマルボス行動ユニット == 2) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 3;
									}
								}
							}
						}));
						// 下へ+32
					} else if (ノーマルボス行動ユニット == 3) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() < 160) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() + 4);
								} else {
									if (ノーマルボス行動ユニット == 3) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 4;
									}
								}
							}
						}));
						// 上へ-64（パターン1終）
					} else if (ノーマルボス行動ユニット == 4) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() > 128) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() - 4);
								} else {
									if (ノーマルボス行動ユニット == 4) {
										ノーマルボス行動ユニット = 1;
										// ノーマルボス行動のランダム処理
										int r = (int)(Math.random() * 9);
										switch (r) {
										case 0:
											ノーマルボス行動パターン = 2;
											break;
										case 1:
											ノーマルボス行動パターン = 3;
											break;
										case 2:
											ノーマルボス行動パターン = 4;
											break;
										case 3:
											ノーマルボス行動パターン = 5;
											break;
										case 4:
											ノーマルボス行動パターン = 6;
											break;
										case 5:
											ノーマルボス行動パターン = 7;
											break;
										case 6:
											ノーマルボス行動パターン = 8;
											break;
										case 7:
											ノーマルボス行動パターン = 9;
											break;
										case 8:
											ノーマルボス行動パターン = 10;
											break;
										}
									}
								}
							}
						}));
					}
					// パターン2
				} else if (ノーマルボス行動パターン == 2) {
					// 下へ+96
					if (ノーマルボス行動ユニット == 1) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() < 224) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() + 4);
								} else {
									if (ノーマルボス行動ユニット == 1) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 2;
									}
								}
							}
						}));
						// 上へ-32
					} else if (ノーマルボス行動ユニット == 2) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() > 192) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() - 4);
								} else {
									if (ノーマルボス行動ユニット == 2) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 3;
									}
								}
							}
						}));
						// 上へ-32
					} else if (ノーマルボス行動ユニット == 3) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() > 160) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() - 4);
								} else {
									if (ノーマルボス行動ユニット == 3) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 4;
									}
								}
							}
						}));
						// 上へ-32（パターン2終）
					} else if (ノーマルボス行動ユニット == 4) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() > 128) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() - 4);
								} else {
									if (ノーマルボス行動ユニット == 4) {
										ノーマルボス行動ユニット = 1;
										// ノーマルボス行動のランダム処理
										int r = (int)(Math.random() * 9);
										switch (r) {
										case 0:
											ノーマルボス行動パターン = 1;
											break;
										case 1:
											ノーマルボス行動パターン = 3;
											break;
										case 2:
											ノーマルボス行動パターン = 4;
											break;
										case 3:
											ノーマルボス行動パターン = 5;
											break;
										case 4:
											ノーマルボス行動パターン = 6;
											break;
										case 5:
											ノーマルボス行動パターン = 7;
											break;
										case 6:
											ノーマルボス行動パターン = 8;
											break;
										case 7:
											ノーマルボス行動パターン = 9;
											break;
										case 8:
											ノーマルボス行動パターン = 10;
											break;
										}
									}
								}
							}
						}));
					}
					// パターン3
				} else if (ノーマルボス行動パターン == 3) {
					// その場
					if (ノーマルボス行動ユニット == 1) {
						// 0.5秒ストップ！
						registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (ノーマルボス行動ユニット == 1) {
									// ニードル攻撃
									SoundPlay.seNeedle.stop();
									SoundPlay.seNeedle.play();
									enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
											.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
									enemyAttacks.effectEnemyAttackNeedle.setTag(
											EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
									enemyAttacks.effectEnemyAttackNeedle.setPosition(
											bowsers.enemyBowserNormalLevel1.getX() - 32,
											bowsers.enemyBowserNormalLevel1.getY() + 64);
									enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
									attachChild(enemyAttacks.effectEnemyAttackNeedle);
									enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
									sortChildren();
									ノーマルボス行動ユニット = 2;
								}
							}
						}));
						// その場
					} else if (ノーマルボス行動ユニット == 2) {
						// 0.5秒ストップ！
						registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (ノーマルボス行動ユニット == 2) {
									// ニードル攻撃
									SoundPlay.seNeedle.stop();
									SoundPlay.seNeedle.play();
									enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
											.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
									enemyAttacks.effectEnemyAttackNeedle.setTag(
											EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
									enemyAttacks.effectEnemyAttackNeedle.setPosition(
											bowsers.enemyBowserNormalLevel1.getX() - 32,
											bowsers.enemyBowserNormalLevel1.getY() + 64);
									enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
									attachChild(enemyAttacks.effectEnemyAttackNeedle);
									enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
									sortChildren();
									ノーマルボス行動ユニット = 3;
								}
							}
						}));
						// その場
					} else if (ノーマルボス行動ユニット == 3) {
						// 0.5秒ストップ！
						registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (ノーマルボス行動ユニット == 3) {
									// ニードル攻撃
									SoundPlay.seNeedle.stop();
									SoundPlay.seNeedle.play();
									enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
											.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
									enemyAttacks.effectEnemyAttackNeedle.setTag(
											EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
									enemyAttacks.effectEnemyAttackNeedle.setPosition(
											bowsers.enemyBowserNormalLevel1.getX() - 32,
											bowsers.enemyBowserNormalLevel1.getY() + 64);
									enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
									attachChild(enemyAttacks.effectEnemyAttackNeedle);
									enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
									sortChildren();
									ノーマルボス行動ユニット = 4;
								}
							}
						}));
						// その場（パターン3終）
					} else if (ノーマルボス行動ユニット == 4) {
						// 0.5秒ストップ！
						registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (ノーマルボス行動ユニット == 4) {
									ノーマルボス行動ユニット = 1;
									// ノーマルボス行動のランダム処理
									int r = (int)(Math.random() * 9);
									switch (r) {
									case 0:
										ノーマルボス行動パターン = 1;
										break;
									case 1:
										ノーマルボス行動パターン = 2;
										break;
									case 2:
										ノーマルボス行動パターン = 4;
										break;
									case 3:
										ノーマルボス行動パターン = 5;
										break;
									case 4:
										ノーマルボス行動パターン = 6;
										break;
									case 5:
										ノーマルボス行動パターン = 7;
										break;
									case 6:
										ノーマルボス行動パターン = 8;
										break;
									case 7:
										ノーマルボス行動パターン = 9;
										break;
									case 8:
										ノーマルボス行動パターン = 10;
										break;
									}
								}
							}
						}));
					}
					// パターン4
				} else if (ノーマルボス行動パターン == 4) {
					// 下へ+64
					if (ノーマルボス行動ユニット == 1) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() < 192) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() + 4);
								} else {
									if (ノーマルボス行動ユニット == 1) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 2;
									}
								}
							}
						}));
						// その場
					} else if (ノーマルボス行動ユニット == 2) {
						// 0.5秒ストップ！
						registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (ノーマルボス行動ユニット == 2) {
									// ニードル攻撃
									SoundPlay.seNeedle.stop();
									SoundPlay.seNeedle.play();
									enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
											.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
									enemyAttacks.effectEnemyAttackNeedle.setTag(
											EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
									enemyAttacks.effectEnemyAttackNeedle.setPosition(
											bowsers.enemyBowserNormalLevel1.getX() - 32,
											bowsers.enemyBowserNormalLevel1.getY() + 64);
									enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
									attachChild(enemyAttacks.effectEnemyAttackNeedle);
									enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
									sortChildren();
									ノーマルボス行動ユニット = 3;
								}
							}
						}));
						// その場
					} else if (ノーマルボス行動ユニット == 3) {
						// 0.5秒ストップ！
						registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (ノーマルボス行動ユニット == 3) {
									// ニードル攻撃
									SoundPlay.seNeedle.stop();
									SoundPlay.seNeedle.play();
									enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
											.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
									enemyAttacks.effectEnemyAttackNeedle.setTag(
											EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
									enemyAttacks.effectEnemyAttackNeedle.setPosition(
											bowsers.enemyBowserNormalLevel1.getX() - 32,
											bowsers.enemyBowserNormalLevel1.getY() + 64);
									enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
									attachChild(enemyAttacks.effectEnemyAttackNeedle);
									enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
									sortChildren();
									ノーマルボス行動ユニット = 4;
								}
							}
						}));
						// 上へ-64（パターン4終）
					} else if (ノーマルボス行動ユニット == 4) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() > 128) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() - 4);
								} else {
									if (ノーマルボス行動ユニット == 4) {
										ノーマルボス行動ユニット = 1;
										// ノーマルボス行動のランダム処理
										int r = (int)(Math.random() * 9);
										switch (r) {
										case 0:
											ノーマルボス行動パターン = 1;
											break;
										case 1:
											ノーマルボス行動パターン = 2;
											break;
										case 2:
											ノーマルボス行動パターン = 3;
											break;
										case 3:
											ノーマルボス行動パターン = 5;
											break;
										case 4:
											ノーマルボス行動パターン = 6;
											break;
										case 5:
											ノーマルボス行動パターン = 7;
											break;
										case 6:
											ノーマルボス行動パターン = 8;
											break;
										case 7:
											ノーマルボス行動パターン = 9;
											break;
										case 8:
											ノーマルボス行動パターン = 10;
											break;
										}
									}
								}
							}
						}));
					}
					// パターン5
				} else if (ノーマルボス行動パターン == 5) {
					// 上へ-32
					if (ノーマルボス行動ユニット == 1) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() > 96) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() - 4);
								} else {
									if (ノーマルボス行動ユニット == 1) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 2;
									}
								}
							}
						}));
						// 下へ+32
					} else if (ノーマルボス行動ユニット == 2) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() < 128) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() + 4);
								} else {
									if (ノーマルボス行動ユニット == 2) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 3;
									}
								}
							}
						}));
						// その場
					} else if (ノーマルボス行動ユニット == 3) {
						// 0.5秒ストップ！
						registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (ノーマルボス行動ユニット == 3) {
									// ニードル攻撃
									SoundPlay.seNeedle.stop();
									SoundPlay.seNeedle.play();
									enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
											.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
									enemyAttacks.effectEnemyAttackNeedle.setTag(
											EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
									enemyAttacks.effectEnemyAttackNeedle.setPosition(
											bowsers.enemyBowserNormalLevel1.getX() - 32,
											bowsers.enemyBowserNormalLevel1.getY() + 64);
									enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
									attachChild(enemyAttacks.effectEnemyAttackNeedle);
									enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
									sortChildren();
									ノーマルボス行動ユニット = 4;
								}
							}
						}));
						// その場（パターン5終）
					} else if (ノーマルボス行動ユニット == 4) {
						// 0.5秒ストップ！
						registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (ノーマルボス行動ユニット == 4) {
									ノーマルボス行動ユニット = 1;
									// ノーマルボス行動のランダム処理
									int r = (int)(Math.random() * 9);
									switch (r) {
									case 0:
										ノーマルボス行動パターン = 1;
										break;
									case 1:
										ノーマルボス行動パターン = 2;
										break;
									case 2:
										ノーマルボス行動パターン = 3;
										break;
									case 3:
										ノーマルボス行動パターン = 4;
										break;
									case 4:
										ノーマルボス行動パターン = 6;
										break;
									case 5:
										ノーマルボス行動パターン = 7;
										break;
									case 6:
										ノーマルボス行動パターン = 8;
										break;
									case 7:
										ノーマルボス行動パターン = 9;
										break;
									case 8:
										ノーマルボス行動パターン = 10;
										break;
									}
								}
							}
						}));
					}
					// パターン6
				} else if (ノーマルボス行動パターン == 6) {
					// 下へ+96
					if (ノーマルボス行動ユニット == 1) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() < 224) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() + 4);
								} else {
									if (ノーマルボス行動ユニット == 1) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 2;
									}
								}
							}
						}));
						// 上へ-32
					} else if (ノーマルボス行動ユニット == 2) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() > 192) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() - 4);
								} else {
									if (ノーマルボス行動ユニット == 2) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 3;
									}
								}
							}
						}));
						// その場
					} else if (ノーマルボス行動ユニット == 3) {
						// 0.5秒ストップ！
						registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (ノーマルボス行動ユニット == 3) {
									// ニードル攻撃
									SoundPlay.seNeedle.stop();
									SoundPlay.seNeedle.play();
									enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
											.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
									enemyAttacks.effectEnemyAttackNeedle.setTag(
											EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
									enemyAttacks.effectEnemyAttackNeedle.setPosition(
											bowsers.enemyBowserNormalLevel1.getX() - 32,
											bowsers.enemyBowserNormalLevel1.getY() + 64);
									enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
									attachChild(enemyAttacks.effectEnemyAttackNeedle);
									enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
									sortChildren();
									ノーマルボス行動ユニット = 4;
								}
							}
						}));
						// 上へ-64（パターン6終）
					} else if (ノーマルボス行動ユニット == 4) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() > 128) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() - 4);
								} else {
									if (ノーマルボス行動ユニット == 4) {
										ノーマルボス行動ユニット = 1;
										// ノーマルボス行動のランダム処理
										int r = (int)(Math.random() * 9);
										switch (r) {
										case 0:
											ノーマルボス行動パターン = 1;
											break;
										case 1:
											ノーマルボス行動パターン = 2;
											break;
										case 2:
											ノーマルボス行動パターン = 3;
											break;
										case 3:
											ノーマルボス行動パターン = 4;
											break;
										case 4:
											ノーマルボス行動パターン = 5;
											break;
										case 5:
											ノーマルボス行動パターン = 7;
											break;
										case 6:
											ノーマルボス行動パターン = 8;
											break;
										case 7:
											ノーマルボス行動パターン = 9;
											break;
										case 8:
											ノーマルボス行動パターン = 10;
											break;
										}
									}
								}
							}
						}));
					}
					// パターン7
				} else if (ノーマルボス行動パターン == 7) {
					// 上へ-32
					if (ノーマルボス行動ユニット == 1) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() > 96) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() - 4);
								} else {
									if (ノーマルボス行動ユニット == 1) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 2;
									}
								}
							}
						}));
						// その場
					} else if (ノーマルボス行動ユニット == 2) {
						// 0.5秒ストップ！
						registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (ノーマルボス行動ユニット == 2) {
									// ニードル攻撃
									SoundPlay.seNeedle.stop();
									SoundPlay.seNeedle.play();
									enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
											.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
									enemyAttacks.effectEnemyAttackNeedle.setTag(
											EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
									enemyAttacks.effectEnemyAttackNeedle.setPosition(
											bowsers.enemyBowserNormalLevel1.getX() - 32,
											bowsers.enemyBowserNormalLevel1.getY() + 64);
									enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
									attachChild(enemyAttacks.effectEnemyAttackNeedle);
									enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
									sortChildren();
									ノーマルボス行動ユニット = 3;
								}
							}
						}));
						// 下へ+64
					} else if (ノーマルボス行動ユニット == 3) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() < 160) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() + 4);
								} else {
									if (ノーマルボス行動ユニット == 3) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 4;
									}
								}
							}
						}));
						// 上へ-32（パターン7終）
					} else if (ノーマルボス行動ユニット == 4) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() > 128) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() - 4);
								} else {
									if (ノーマルボス行動ユニット == 4) {
										ノーマルボス行動ユニット = 1;
										// ノーマルボス行動のランダム処理
										int r = (int)(Math.random() * 9);
										switch (r) {
										case 0:
											ノーマルボス行動パターン = 1;
											break;
										case 1:
											ノーマルボス行動パターン = 2;
											break;
										case 2:
											ノーマルボス行動パターン = 3;
											break;
										case 3:
											ノーマルボス行動パターン = 4;
											break;
										case 4:
											ノーマルボス行動パターン = 5;
											break;
										case 5:
											ノーマルボス行動パターン = 6;
											break;
										case 6:
											ノーマルボス行動パターン = 8;
											break;
										case 7:
											ノーマルボス行動パターン = 9;
											break;
										case 8:
											ノーマルボス行動パターン = 10;
											break;
										}
									}
								}
							}
						}));
					}
					// パターン8
				} else if (ノーマルボス行動パターン == 8) {
					// 下へ+96
					if (ノーマルボス行動ユニット == 1) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() < 224) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() + 4);
								} else {
									if (ノーマルボス行動ユニット == 1) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 2;
									}
								}
							}
						}));
						// その場
					} else if (ノーマルボス行動ユニット == 2) {
						// 0.5秒ストップ！
						registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (ノーマルボス行動ユニット == 2) {
									// ニードル攻撃
									SoundPlay.seNeedle.stop();
									SoundPlay.seNeedle.play();
									enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
											.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
									enemyAttacks.effectEnemyAttackNeedle.setTag(
											EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
									enemyAttacks.effectEnemyAttackNeedle.setPosition(
											bowsers.enemyBowserNormalLevel1.getX() - 32,
											bowsers.enemyBowserNormalLevel1.getY() + 64);
									enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
									attachChild(enemyAttacks.effectEnemyAttackNeedle);
									enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
									sortChildren();
									ノーマルボス行動ユニット = 3;
								}
							}
						}));
						// 上へ+64
					} else if (ノーマルボス行動ユニット == 3) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() > 160) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() - 4);
								} else {
									if (ノーマルボス行動ユニット == 3) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 4;
									}
								}
							}
						}));
						// 上へ-32（パターン8終）
					} else if (ノーマルボス行動ユニット == 4) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() > 128) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() - 4);
								} else {
									if (ノーマルボス行動ユニット == 4) {
										ノーマルボス行動ユニット = 1;
										// ノーマルボス行動のランダム処理
										int r = (int)(Math.random() * 9);
										switch (r) {
										case 0:
											ノーマルボス行動パターン = 1;
											break;
										case 1:
											ノーマルボス行動パターン = 2;
											break;
										case 2:
											ノーマルボス行動パターン = 3;
											break;
										case 3:
											ノーマルボス行動パターン = 4;
											break;
										case 4:
											ノーマルボス行動パターン = 5;
											break;
										case 5:
											ノーマルボス行動パターン = 6;
											break;
										case 6:
											ノーマルボス行動パターン = 7;
											break;
										case 7:
											ノーマルボス行動パターン = 9;
											break;
										case 8:
											ノーマルボス行動パターン = 10;
											break;
										}
									}
								}
							}
						}));
					}
					// パターン9
				} else if (ノーマルボス行動パターン == 9) {
					// その場
					if (ノーマルボス行動ユニット == 1) {
						// 0.5秒ストップ！
						registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (ノーマルボス行動ユニット == 1) {
									// ニードル攻撃
									SoundPlay.seNeedle.stop();
									SoundPlay.seNeedle.play();
									enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
											.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
									enemyAttacks.effectEnemyAttackNeedle.setTag(
											EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
									enemyAttacks.effectEnemyAttackNeedle.setPosition(
											bowsers.enemyBowserNormalLevel1.getX() - 32,
											bowsers.enemyBowserNormalLevel1.getY() + 64);
									enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
									attachChild(enemyAttacks.effectEnemyAttackNeedle);
									enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
									sortChildren();
									ノーマルボス行動ユニット = 2;
								}
							}
						}));
						// 下へ+32
					} else if (ノーマルボス行動ユニット == 2) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() < 160) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() + 4);
								} else {
									if (ノーマルボス行動ユニット == 2) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 3;
									}
								}
							}
						}));
						// 上へ-64
					} else if (ノーマルボス行動ユニット == 3) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() > 96) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() - 4);
								} else {
									if (ノーマルボス行動ユニット == 3) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 4;
									}
								}
							}
						}));
						// 下へ+32（パターン9終）
					} else if (ノーマルボス行動ユニット == 4) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() < 128) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() + 4);
								} else {
									if (ノーマルボス行動ユニット == 4) {
										ノーマルボス行動ユニット = 1;
										// ノーマルボス行動のランダム処理
										int r = (int)(Math.random() * 9);
										switch (r) {
										case 0:
											ノーマルボス行動パターン = 1;
											break;
										case 1:
											ノーマルボス行動パターン = 2;
											break;
										case 2:
											ノーマルボス行動パターン = 3;
											break;
										case 3:
											ノーマルボス行動パターン = 4;
											break;
										case 4:
											ノーマルボス行動パターン = 5;
											break;
										case 5:
											ノーマルボス行動パターン = 6;
											break;
										case 6:
											ノーマルボス行動パターン = 7;
											break;
										case 7:
											ノーマルボス行動パターン = 8;
											break;
										case 8:
											ノーマルボス行動パターン = 10;
											break;
										}
									}
								}
							}
						}));
					}
					// パターン10
				} else if (ノーマルボス行動パターン == 10) {
					// 下へ+64
					if (ノーマルボス行動ユニット == 1) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() < 192) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() + 4);
								} else {
									if (ノーマルボス行動ユニット == 1) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 2;
									}
								}
							}
						}));
						// 上へ-32
					} else if (ノーマルボス行動ユニット == 2) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() > 160) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() - 4);
								} else {
									if (ノーマルボス行動ユニット == 2) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 3;
									}
								}
							}
						}));
						// 下へ+64
					} else if (ノーマルボス行動ユニット == 3) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() < 224) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() + 4);
								} else {
									if (ノーマルボス行動ユニット == 3) {
										// ニードル攻撃
										SoundPlay.seNeedle.stop();
										SoundPlay.seNeedle.play();
										enemyAttacks.effectEnemyAttackNeedle = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("effect_32_enemy_attack_needle.png", 1, 4);
										enemyAttacks.effectEnemyAttackNeedle.setTag(
												EnemyAttacks.TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE);
										enemyAttacks.effectEnemyAttackNeedle.setPosition(
												bowsers.enemyBowserNormalLevel1.getX() - 32,
												bowsers.enemyBowserNormalLevel1.getY() + 64);
										enemyAttacks.effectEnemyAttackNeedle.animate(ani並);
										attachChild(enemyAttacks.effectEnemyAttackNeedle);
										enemyAttacks.effectEnemyAttackNeedle.setZIndex(レイヤー08敵キャラ用);
										sortChildren();
										ノーマルボス行動ユニット = 4;
									}
								}
							}
						}));
						// 上へ-32（パターン10終）
					} else if (ノーマルボス行動ユニット == 4) {
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								if (bowsers.enemyBowserNormalLevel1.getY() > 128) {
									bowsers.enemyBowserNormalLevel1.setY(
											bowsers.enemyBowserNormalLevel1.getY() - 4);
								} else {
									if (ノーマルボス行動ユニット == 4) {
										ノーマルボス行動ユニット = 1;
										// ノーマルボス行動のランダム処理
										int r = (int)(Math.random() * 9);
										switch (r) {
										case 0:
											ノーマルボス行動パターン = 1;
											break;
										case 1:
											ノーマルボス行動パターン = 2;
											break;
										case 2:
											ノーマルボス行動パターン = 3;
											break;
										case 3:
											ノーマルボス行動パターン = 4;
											break;
										case 4:
											ノーマルボス行動パターン = 5;
											break;
										case 5:
											ノーマルボス行動パターン = 6;
											break;
										case 6:
											ノーマルボス行動パターン = 7;
											break;
										case 7:
											ノーマルボス行動パターン = 8;
											break;
										case 8:
											ノーマルボス行動パターン = 9;
											break;
										}
									}
								}
							}
						}));
					}
				}
				// 体力がなくなるとやられ演出
			} else if (ボスレベル1体力 <= 0 && フラグボスキャラ出現 == true) {
				// 0.5秒ストップ！
				registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						MusicPlay.bgmNormalBossTheme.setVolume(0.9f);
						// 0.5秒ストップ！
						registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								MusicPlay.bgmNormalBossTheme.setVolume(0.8f);
								// 0.5秒ストップ！
								registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
									public void onTimePassed(TimerHandler pTimeHandler) {
										MusicPlay.bgmNormalBossTheme.setVolume(0.7f);
										// 0.5秒ストップ！
										registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
											public void onTimePassed(TimerHandler pTimeHandler) {
												MusicPlay.bgmNormalBossTheme.setVolume(0.6f);
												// 0.5秒ストップ！
												registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
													public void onTimePassed(TimerHandler pTimeHandler) {
														MusicPlay.bgmNormalBossTheme.setVolume(0.5f);
														// 0.5秒ストップ！
														registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
															public void onTimePassed(TimerHandler pTimeHandler) {
																MusicPlay.bgmNormalBossTheme.setVolume(0.4f);
																// 0.5秒ストップ！
																registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
																	public void onTimePassed(TimerHandler pTimeHandler) {
																		MusicPlay.bgmNormalBossTheme.setVolume(0.3f);
																		// 0.5秒ストップ！
																		registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
																			public void onTimePassed(TimerHandler pTimeHandler) {
																				MusicPlay.bgmNormalBossTheme.setVolume(0.2f);
																				// 0.5秒ストップ！
																				registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
																					public void onTimePassed(TimerHandler pTimeHandler) {
																						MusicPlay.bgmNormalBossTheme.setVolume(0.1f);
																						// 0.5秒ストップ！
																						registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
																							public void onTimePassed(TimerHandler pTimeHandler) {
																								MusicPlay.bgmNormalBossTheme.setVolume(0);
																							}
																						}));
																					}
																				}));
																			}
																		}));
																	}
																}));
															}
														}));
													}
												}));
											}
										}));
									}
								}));
							}
						}));
					}
				}));
				フラグボスキャラ生存 = false;
				bowsers.enemyBowserNormalLevel1.registerEntityModifier(new LoopEntityModifier(
						new SequenceEntityModifier(new FadeOutModifier(
								0.005f), new FadeInModifier(0.005f)), 900));
				bowsers.enemyBowserNormalLevel1.setY(
						bowsers.enemyBowserNormalLevel1.getY() + 2);
				// ボスキャラのゆらゆら処理
				if (フラグボスキャラゆらゆら == true) {
					bowsers.enemyBowserNormalLevel1.setX(
							bowsers.enemyBowserNormalLevel1.getX() + 2);
					if (bowsers.enemyBowserNormalLevel1.getX() > ボスキャラゆらゆら値右) {
						フラグボスキャラゆらゆら = false;
					}
				} else {
					bowsers.enemyBowserNormalLevel1.setX(
							bowsers.enemyBowserNormalLevel1.getX() - 2);
					if (bowsers.enemyBowserNormalLevel1.getX() < ボスキャラゆらゆら値左) {
						フラグボスキャラゆらゆら = true;
					}
				}
				if (フラグボスキャラバーン == false) {
					フラグボスキャラバーン = true;
					// 0.25秒ストップ！
					registerUpdateHandler(new TimerHandler(0.25f, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							SoundPlay.seNormalBossDefeat.stop();
							SoundPlay.seNormalBossDefeat.play();
							フラグボスキャラバーン = false;
							// 爆発エフェクトの表示
							bombs.effectBombFireball1 = getBaseActivity().getResourceUtil()
									.getAnimatedSprite("effect_05_bomb_fireball_1.png", 1, 6);
							bombs.effectBombFireball1.setTag(
									Bombs.TAG_EFFECT_05_BOMB_FIREBALL_1);
							// エフェク位置のランダム処理
							int r = (int)(Math.random() * 6);
							switch (r) {
							case 0:
								bombs.effectBombFireball1.setPosition(
										bowsers.enemyBowserNormalLevel1.getX(),
										bowsers.enemyBowserNormalLevel1.getY());
								break;
							case 1:
								bombs.effectBombFireball1.setPosition(
										bowsers.enemyBowserNormalLevel1.getX() + 32,
										bowsers.enemyBowserNormalLevel1.getY());
								break;
							case 2:
								bombs.effectBombFireball1.setPosition(
										bowsers.enemyBowserNormalLevel1.getX(),
										bowsers.enemyBowserNormalLevel1.getY() + 32);
								break;
							case 3:
								bombs.effectBombFireball1.setPosition(
										bowsers.enemyBowserNormalLevel1.getX() + 32,
										bowsers.enemyBowserNormalLevel1.getY() + 32);
								break;
							case 4:
								bombs.effectBombFireball1.setPosition(
										bowsers.enemyBowserNormalLevel1.getX(),
										bowsers.enemyBowserNormalLevel1.getY() + 64);
								break;
							case 5:
								bombs.effectBombFireball1.setPosition(
										bowsers.enemyBowserNormalLevel1.getX() + 32,
										bowsers.enemyBowserNormalLevel1.getY() + 64);
								break;
							}
							bombs.effectBombFireball1.animate(
									new long[] { ani速, ani速, ani速, ani速, ani速, ani速, }, 0, 5, false);
							attachChild(bombs.effectBombFireball1);
							bombs.effectBombFireball1.setZIndex(レイヤー05ボール用);
							sortChildren();
						}
					}));
				}
			}
		}
	}
	// プレイヤーをインクリ
	public void playerIncrement() {
		// バルーンにぶら下がっている時は判定しない
		if (出現フラグバルーン == false && メモリーの開放をしたかどうか == false) {
			// 普通のジャンプ
			if (踏みジャン実行フラグ == false && バック転実行フラグ == false) {
				// プレイヤーの上昇移動
				if (プレイヤーの上昇移動フラグ == true) {
					普通ジャンプの下降移動値 = 4.8f;
					if (グラチェンジフラグ == false) {
						marioSets.playerMarioSet1.setY(
								marioSets.playerMarioSet1.getY() - 普通ジャンプの上昇移動値);
					} else {
						marioSets.playerMarioSet2.setY(
								marioSets.playerMarioSet2.getY() - 普通ジャンプの上昇移動値);
					}
					普通ジャンプの上昇移動値 *= 0.864f;
					// プレイヤーの下降移動
				} else if (プレイヤーのダッシュフラグ == false) {
					ダッシュカウンター			= 0;
					普通ジャンプの上昇移動値	= 24;
					プレイヤーの下降移動フラグ	= true;
					if (グラチェンジフラグ == false) {
						if (状態フラグ無敵 == false) {
							marioSets.playerMarioSet1.stopAnimation();
						}
						marioSets.playerMarioSet1.setY(
								marioSets.playerMarioSet1.getY() + 普通ジャンプの下降移動値);
					} else {
						marioSets.playerMarioSet2.stopAnimation();
						marioSets.playerMarioSet2.setY(
								marioSets.playerMarioSet2.getY() + 普通ジャンプの下降移動値);
					}
					普通ジャンプの下降移動値 *= 1.086f;
					if (普通ジャンプの下降移動値 >= 14.4f) {
						普通ジャンプの下降移動値 = 14.4f;
					}
				} else if (プレイヤーのダッシュフラグ == true) {
					普通ジャンプの下降移動値 = 4.8f;
				}
				// ジャンプ時の限界値（5ブロック分+@）に達したら…強制落下処理
				if (グラチェンジフラグ == false) {
					if (marioSets.playerMarioSet1.getY() <= プレイヤーのジャンプ値) {
						プレイヤーの上昇移動フラグ = false;
						プレイヤーの下降移動フラグ = true;
					}
				} else {
					if (marioSets.playerMarioSet2.getY() <= プレイヤーのジャンプ値) {
						プレイヤーの上昇移動フラグ = false;
						プレイヤーの下降移動フラグ = true;
					}
				}
				// 踏み台ジャンプ
			} else if (踏みジャン実行フラグ == true && バック転実行フラグ == false) {
				// プレイヤーの上昇移動
				プレイヤーの上昇移動フラグ	= true;
				プレイヤーの下降移動フラグ	= false;
				if (グラチェンジフラグ == false) {
					marioSets.playerMarioSet1.setY(
							marioSets.playerMarioSet1.getY() - 踏み台ジャンプの上昇移動値);
				} else {
					marioSets.playerMarioSet2.setY(
							marioSets.playerMarioSet2.getY() - 踏み台ジャンプの上昇移動値);
				}
				踏み台ジャンプの上昇移動値 *= 0.864f;
				// プレイヤーの下降移動
				if (グラチェンジフラグ == false) {
					marioSets.playerMarioSet1.setY(
							marioSets.playerMarioSet1.getY() + 踏み台ジャンプの下降移動値);
				} else {
					marioSets.playerMarioSet2.setY(
							marioSets.playerMarioSet2.getY() + 踏み台ジャンプの下降移動値);
				}
				踏み台ジャンプの下降移動値 *= 1.086f;
				if (踏み台ジャンプの下降移動値 >= 14.4f) {
					踏み台ジャンプの下降移動値 = 14.4f;
				}
				// これがないと落下時、マリオが地面にめり込む
				if (踏み台ジャンプの上昇移動値 <= 7.5) {
					プレイヤーの上昇移動フラグ = false;
					プレイヤーの下降移動フラグ = true;
				}
				// バック転ジャンプ
			} else if (バック転実行フラグ == true) {
				// プレイヤーの上昇移動
				プレイヤーの上昇移動フラグ	= true;
				プレイヤーの下降移動フラグ	= false;
				if (グラチェンジフラグ == false) {
					marioSets.playerMarioSet1.setY(
							marioSets.playerMarioSet1.getY() - バック転ジャンプの上昇移動値);
				} else {
					marioSets.playerMarioSet2.setY(
							marioSets.playerMarioSet2.getY() - バック転ジャンプの上昇移動値);
				}
				バック転ジャンプの上昇移動値 *= 0.864f;
				// プレイヤーの下降移動
				if (グラチェンジフラグ == false) {
					marioSets.playerMarioSet1.setY(
							marioSets.playerMarioSet1.getY() + バック転ジャンプの下降移動値);
				} else {
					marioSets.playerMarioSet2.setY(
							marioSets.playerMarioSet2.getY() + バック転ジャンプの下降移動値);
				}
				バック転ジャンプの下降移動値 *= 1.086f;
				if (バック転ジャンプの下降移動値 >= 14.4f) {
					バック転ジャンプの下降移動値 = 14.4f;
				}
				// これがないと落下時、マリオが地面にめり込む
				if (バック転ジャンプの上昇移動値 <= 7.5) {
					プレイヤーの上昇移動フラグ = false;
					プレイヤーの下降移動フラグ = true;
				}
			}
			// マリオを「エ゛エーイ！」
			if (エエーイ実行フラグ == true) {
				if (グラチェンジフラグ == false) {
					marioSets.playerMarioSet1.setRotation(
							marioSets.playerMarioSet1.getRotation() - 40);
				} else {
					marioSets.playerMarioSet2.setRotation(
							marioSets.playerMarioSet2.getRotation() - 40);
				}
			}
			// マリオをバック転！
			if (バック転実行フラグ == true) {
				if (グラチェンジフラグ == false) {
					marioSets.playerMarioSet1.setRotation(
							marioSets.playerMarioSet1.getRotation() - 40);
				} else {
					marioSets.playerMarioSet2.setRotation(
							marioSets.playerMarioSet2.getRotation() - 40);
				}
				// 回転エフェクトを移動、させるだけ
				if (グラチェンジフラグ == false) {
					marios.effectMarioBackFlip.setPosition(
							marioSets.playerMarioSet1.getX() - 16,
							marioSets.playerMarioSet1.getY());
				} else {
					marios.effectMarioBackFlip.setPosition(
							marioSets.playerMarioSet2.getX() - 16,
							marioSets.playerMarioSet2.getY());
				}
			}
			// プレイヤーの上側移動処理。
			// プレイヤーの判定中2フラグがトゥルーの時のみ実行
			if (判定中2フラグ == true && 判定中1フラグ == false && プレイヤーの下降移動フラグ == false) {
				if (グラチェンジフラグ == false) {
					marioSets.playerMarioSet1.setY(
							marioSets.playerMarioSet1.getY() - 32);
				} else {
					marioSets.playerMarioSet2.setY(
							marioSets.playerMarioSet2.getY() - 32);
				}
			}
			// プレイヤーの左側移動処理。
			// プレイヤーの判定中フラグたちがトゥルーの時のみ実行
			if (判定中1フラグ == true && 左側移動フラグ == true
					|| 判定中2フラグ == true && 左側移動フラグ == true) {
				if (グラチェンジフラグ == false) {
					marioSets.playerMarioSet1.setX(
							marioSets.playerMarioSet1.getX() - 画面のスピード);
				} else {
					marioSets.playerMarioSet2.setX(
							marioSets.playerMarioSet2.getX() - 画面のスピード);
				}
			}
			// プレイヤーの右側移動処理。
			// プレイヤーが特定の位置より左側でかつ、何も衝突していない時のみ実行
			if (グラチェンジフラグ == false) {
				if (marioSets.playerMarioSet1.getX() < 160
						&& 左側移動フラグ == false) {
					右側移動フラグ = true;
				} else if (marioSets.playerMarioSet1.getX() >= 160) {
					右側移動フラグ = false;
				}
				// 右移動フラグがとぅるーで何も衝突していない場合
				if (右側移動フラグ == true && 左側移動フラグ == false) {
					くっつきカウンター = 0;
					marioSets.playerMarioSet1.setX(
							marioSets.playerMarioSet1.getX() + 4);
				}
			} else {
				if (marioSets.playerMarioSet2.getX() < 160
						&& 左側移動フラグ == false) {
					右側移動フラグ = true;
				} else if (marioSets.playerMarioSet2.getX() >= 160) {
					右側移動フラグ = false;
				}
				// 右移動フラグがとぅるーで何も衝突していない場合
				if (右側移動フラグ == true && 左側移動フラグ == false) {
					くっつきカウンター = 0;
					marioSets.playerMarioSet2.setX(
							marioSets.playerMarioSet2.getX() + 4);
				}
			}
			// コース端っこに行っても右側移動処理。
			if (コースの端っこかどうか == true) {
				if (グラチェンジフラグ == false) {
					marioSets.playerMarioSet1.setX(
							marioSets.playerMarioSet1.getX() + 画面のスピード);
				} else {
					marioSets.playerMarioSet2.setX(
							marioSets.playerMarioSet2.getX() + 画面のスピード);
				}
			}
			// SCスキップしても右側移動処理。
			if (クレジットスキップしたかどうか == true) {
				if (グラチェンジフラグ == false) {
					marioSets.playerMarioSet1.setX(
							marioSets.playerMarioSet1.getX() + 6);
				} else {
					marioSets.playerMarioSet2.setX(
							marioSets.playerMarioSet2.getX() + 6);
				}
			}
			// ボールハンドエフェクトの移動
			if (ボールハンド実行フラグ == true) {
				// ボールハンドエフェクトを移動、させるだけ
				if (グラチェンジフラグ == false) {
					hands.playerHandFireball.setPosition(
							marioSets.playerMarioSet1.getX() + 8,
							marioSets.playerMarioSet1.getY() + 8);
				} else {
					hands.playerHandFireball.setPosition(
							marioSets.playerMarioSet2.getX() + 8,
							marioSets.playerMarioSet2.getY() + 8);
				}
			}
			// パンチハンドエフェクトの移動
			if (パンチハンド実行フラグ == true) {
				// パンチハンドエフェクトを移動、させるだけ
				if (グラチェンジフラグ == false) {
					hands.playerHandPunch.setPosition(
							marioSets.playerMarioSet1.getX() + 8,
							marioSets.playerMarioSet1.getY() + 8);
				} else {
					hands.playerHandPunch.setPosition(
							marioSets.playerMarioSet2.getX() + 8,
							marioSets.playerMarioSet2.getY() + 8);
				}
			}
			// プレイヤーの落下ミス処理。
			// マリオが特定の位置より下側の場合実行
			if (コースの端っこかどうか == false && クレジットスキップしたかどうか == false) {
				if (グラチェンジフラグ == false) {
					if (marioSets.playerMarioSet1.getY() >= 544) {
						VoicePlay.voicePlayerDropMiss.stop();
						VoicePlay.voicePlayerDropMiss.play();
						// 残機が1の場合はゲームオーバー
						if (現在のライフ <= 1 && ゲームオーバーかどうか == false) {
							gameStop();
						} else {
							// それ以外は普通のミス処理
							playerDown();
						}
					}
				} else {
					if (marioSets.playerMarioSet2.getY() >= 544) {
						VoicePlay.voicePlayerDropMiss.stop();
						VoicePlay.voicePlayerDropMiss.play();
						// 残機が1の場合はゲームオーバー
						if (現在のライフ <= 1 && ゲームオーバーかどうか == false) {
							gameStop();
						} else {
							// それ以外は普通のミス処理
							playerDown();
						}
					}
				}
			}
			// 当たり判定をインクリ
			if (グラチェンジフラグ == false) {
				// 上の当たり判定をインクリ
				contactLines.playerContactLineAbove.setPosition(
						marioSets.playerMarioSet1.getX() + 0,
						marioSets.playerMarioSet1.getY() + 0);
				// 下の当たり判定をインクリ
				contactLines.playerContactLineBelow.setPosition(
						marioSets.playerMarioSet1.getX() + 0,
						marioSets.playerMarioSet1.getY() + 64);
				// 中の当たり判定（1つ目）をインクリ
				contactLines.playerContactLineCenter1.setPosition(
						marioSets.playerMarioSet1.getX() + 16,
						marioSets.playerMarioSet1.getY() + 24);
				// 中の当たり判定（2つ目）をインクリ
				contactLines.playerContactLineCenter2.setPosition(
						marioSets.playerMarioSet1.getX() + 16,
						marioSets.playerMarioSet1.getY() + 32);
				// 核の当たり判定をインクリ
				contactLines.playerContactLineCore.setPosition(
						marioSets.playerMarioSet1.getX() + 0,
						marioSets.playerMarioSet1.getY() + 16);
			} else {
				// 上の当たり判定をインクリ
				contactLines.playerContactLineAbove.setPosition(
						marioSets.playerMarioSet2.getX() + 0,
						marioSets.playerMarioSet2.getY() + 0);
				// 下の当たり判定をインクリ
				contactLines.playerContactLineBelow.setPosition(
						marioSets.playerMarioSet2.getX() + 0,
						marioSets.playerMarioSet2.getY() + 64);
				// 中の当たり判定（1つ目）をインクリ
				contactLines.playerContactLineCenter1.setPosition(
						marioSets.playerMarioSet2.getX() + 16,
						marioSets.playerMarioSet2.getY() + 24);
				// 中の当たり判定（2つ目）をインクリ
				contactLines.playerContactLineCenter2.setPosition(
						marioSets.playerMarioSet2.getX() + 16,
						marioSets.playerMarioSet2.getY() + 32);
				// 核の当たり判定をインクリ
				contactLines.playerContactLineCore.setPosition(
						marioSets.playerMarioSet2.getX() + 0,
						marioSets.playerMarioSet2.getY() + 16);
			}
		}
	}
	// フォントをインクリ
	public void fontIncrement(Sprite sp) {
		if (敵キャラ連続ヒット == 2) {
			// フォントを表示
			scores.fontScoreX2 = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("font_22_score_x2.png", 1, 4);
			scores.fontScoreX2.setTag(
					Scores.TAG_FONT_22_SCORE_X2);
			if (グラチェンジフラグ == false) {
				scores.fontScoreX2.setPosition(
						marioSets.playerMarioSet1.getX() + 8,
						marioSets.playerMarioSet1.getY() + 8);
			} else {
				scores.fontScoreX2.setPosition(
						marioSets.playerMarioSet2.getX() + 8,
						marioSets.playerMarioSet2.getY() + 8);
			}
			scores.fontScoreX2.animate(ani速);
			attachChild(scores.fontScoreX2);
			scores.fontScoreX2.setZIndex(レイヤー13テキスト用);
			sortChildren();
			scores.fontScoreX2.registerEntityModifier(
					new LoopEntityModifier(new SequenceEntityModifier(
							new ScaleModifier(0.25f, 0.5f, 1.0f),
							new ScaleModifier(0.25f, 1.0f, 0.5f)), 12));
			// 1.5秒ストップ！
			registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					scores.fontScoreX2.registerEntityModifier(new FadeOutModifier(0.5f));
					// 0.5秒ストップ！
					registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							scores.fontScoreX2.detachSelf();
						}
					}));
				}
			}));
		} else if (敵キャラ連続ヒット == 3) {
			// フォントを表示
			scores.fontScoreX3 = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("font_23_score_x3.png", 1, 4);
			scores.fontScoreX3.setTag(
					Scores.TAG_FONT_23_SCORE_X3);
			if (グラチェンジフラグ == false) {
				scores.fontScoreX3.setPosition(
						marioSets.playerMarioSet1.getX() + 8,
						marioSets.playerMarioSet1.getY() + 8);
			} else {
				scores.fontScoreX3.setPosition(
						marioSets.playerMarioSet2.getX() + 8,
						marioSets.playerMarioSet2.getY() + 8);
			}
			scores.fontScoreX3.animate(ani速);
			attachChild(scores.fontScoreX3);
			scores.fontScoreX3.setZIndex(レイヤー13テキスト用);
			sortChildren();
			scores.fontScoreX3.registerEntityModifier(
					new LoopEntityModifier(new SequenceEntityModifier(
							new ScaleModifier(0.25f, 0.5f, 1.0f),
							new ScaleModifier(0.25f, 1.0f, 0.5f)), 12));
			// 1.5秒ストップ！
			registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					scores.fontScoreX3.registerEntityModifier(new FadeOutModifier(0.5f));
					// 0.5秒ストップ！
					registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							scores.fontScoreX3.detachSelf();
						}
					}));
				}
			}));
		} else if (敵キャラ連続ヒット == 4) {
			// フォントを表示
			scores.fontScoreX4 = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("font_24_score_x4.png", 1, 4);
			scores.fontScoreX4.setTag(
					Scores.TAG_FONT_24_SCORE_X4);
			if (グラチェンジフラグ == false) {
				scores.fontScoreX4.setPosition(
						marioSets.playerMarioSet1.getX() + 8,
						marioSets.playerMarioSet1.getY() + 8);
			} else {
				scores.fontScoreX4.setPosition(
						marioSets.playerMarioSet2.getX() + 8,
						marioSets.playerMarioSet2.getY() + 8);
			}
			scores.fontScoreX4.animate(ani速);
			attachChild(scores.fontScoreX4);
			scores.fontScoreX4.setZIndex(レイヤー13テキスト用);
			sortChildren();
			scores.fontScoreX4.registerEntityModifier(
					new LoopEntityModifier(new SequenceEntityModifier(
							new ScaleModifier(0.25f, 0.5f, 1.0f),
							new ScaleModifier(0.25f, 1.0f, 0.5f)), 12));
			// 1.5秒ストップ！
			registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					scores.fontScoreX4.registerEntityModifier(new FadeOutModifier(0.5f));
					// 0.5秒ストップ！
					registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							scores.fontScoreX4.detachSelf();
						}
					}));
				}
			}));
		} else if (敵キャラ連続ヒット == 5) {
			// フォントを表示
			scores.fontScoreX5 = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("font_25_score_x5.png", 1, 4);
			scores.fontScoreX5.setTag(
					Scores.TAG_FONT_25_SCORE_X5);
			if (グラチェンジフラグ == false) {
				scores.fontScoreX5.setPosition(
						marioSets.playerMarioSet1.getX() + 8,
						marioSets.playerMarioSet1.getY() + 8);
			} else {
				scores.fontScoreX5.setPosition(
						marioSets.playerMarioSet2.getX() + 8,
						marioSets.playerMarioSet2.getY() + 8);
			}
			scores.fontScoreX5.animate(ani速);
			attachChild(scores.fontScoreX5);
			scores.fontScoreX5.setZIndex(レイヤー13テキスト用);
			sortChildren();
			scores.fontScoreX5.registerEntityModifier(
					new LoopEntityModifier(new SequenceEntityModifier(
							new ScaleModifier(0.25f, 0.5f, 1.0f),
							new ScaleModifier(0.25f, 1.0f, 0.5f)), 12));
			// 1.5秒ストップ！
			registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					scores.fontScoreX5.registerEntityModifier(new FadeOutModifier(0.5f));
					// 0.5秒ストップ！
					registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							scores.fontScoreX5.detachSelf();
						}
					}));
				}
			}));
		}
	}
	// WORLD 1をインクリ
	public void world1Increment() {
		// 1-1の読み込み
		if (コースカウンター == 1) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign01();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign01();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// 入り口演出の追加
			if (ヨコ == 740 && メモリーカウンター == 3) {
				出現フラグワールド1地下入り口 = true;
				// 入り口
				ワールド1地下入り口 = getBaseActivity().getResourceUtil()
						.getSprite("back_11_underground_entrance_1.png");
				ワールド1地下入り口.setPosition(800, 0);
				attachChild(ワールド1地下入り口);
				ワールド1地下入り口.setZIndex(レイヤー01背景用);
				sortChildren();
				// 中間
				ワールド1地下中間 = getBaseActivity().getResourceUtil()
						.getSprite("back_12_underground_inside_1.png");
				ワールド1地下中間.setPosition(1120, 0);
				attachChild(ワールド1地下中間);
				ワールド1地下中間.setZIndex(レイヤー11特殊背景用);
				sortChildren();
				// ゴール後の処理
			} else if (ヨコ == 750 && メモリーカウンター == 3) {
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				現在の距離 = 0;
				現在のコンチニュー = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// ※↑ここまでコピペ
				if (状態フラグ無敵 == false) {
					musicStop();
				}
				コースカウンター = 2;
				ミュージック待機中かどうか = true;
				// データ（全て）の保存
				dataSave();
				コースデータ.getInstance(getBaseActivity()).setコースデータ(コースカウンター);
				// テキストの初期化
				textInit();
				// 背景の初期化
				backInit();
				// 背景の削除処理
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						ワールド1.detachSelf();
						ワールド1.dispose();
						ワールド1 = null;
						地上雲1.detachSelf();
						地上雲1.dispose();
						地上雲1 = null;
						地上雲2.detachSelf();
						地上雲2.dispose();
						地上雲2 = null;
					}
				}));
				// テキストをふぃーどばっく！
				ワールドテキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				テキスト9.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				コーステキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
			}
			// 1-2の読み込み
		} else if (コースカウンター == 2) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign02();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign02();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ミュージックのリソースと切り替え
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ミュージック待機中かどうか = false;
				if (状態フラグ無敵 == false) {
					// ミュージックリソースの解放
					getBaseActivity().getMusicManager().releaseAll();
					musicPlay();
				}
			}
			// 入り口演出の削除
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ワールド1地下入り口.registerEntityModifier(new FadeOutModifier(1.5f));
				ワールド1地下中間.registerEntityModifier(new FadeOutModifier(1.5f));
				// 1.5秒ストップ！
				registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						if (メモリーの開放をしたかどうか == false) {
							出現フラグワールド1地下入り口 = false;
							ワールド1地下入り口.detachSelf();
							ワールド1地下中間.detachSelf();
						}
					}
				}));
				// ゴール後の処理
			} else if (ヨコ == 650 && メモリーカウンター == 3) {
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				現在の距離 = 0;
				現在のコンチニュー = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// ※↑ここまでコピペ
				if (状態フラグ無敵 == false) {
					musicStop();
				}
				コースカウンター = 3;
				ミュージック待機中かどうか = true;
				// データ（全て）の保存
				dataSave();
				コースデータ.getInstance(getBaseActivity()).setコースデータ(コースカウンター);
				// テキストの初期化
				textInit();
				// 背景の初期化
				backInit();
				// 背景の削除処理
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						地下エリア.detachSelf();
					}
				}));
				// テキストをふぃーどばっく！
				ワールドテキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				テキスト9.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				コーステキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
			}
			// 1-3の読み込み
		} else if (コースカウンター == 3) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign03();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign03();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ミュージックのリソースと切り替え
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ミュージック待機中かどうか = false;
				if (状態フラグ無敵 == false) {
					// ミュージックリソースの解放
					getBaseActivity().getMusicManager().releaseAll();
					musicPlay();
				}
			}
			// 入り口演出の追加
			if (ヨコ == 840 && メモリーカウンター == 3) {
				出現フラグワールド1お城入り口 = true;
				// 入り口
				ワールド1お城入り口 = getBaseActivity().getResourceUtil()
						.getSprite("back_23_castle_entrance_1.png");
				ワールド1お城入り口.setPosition(800, 0);
				attachChild(ワールド1お城入り口);
				ワールド1お城入り口.setZIndex(レイヤー01背景用);
				sortChildren();
				// 中間
				ワールド1お城中間 = getBaseActivity().getResourceUtil()
						.getSprite("back_24_castle_inside_1.png");
				ワールド1お城中間.setPosition(1120, 0);
				attachChild(ワールド1お城中間);
				ワールド1お城中間.setZIndex(レイヤー11特殊背景用);
				sortChildren();
				// ゴール後の処理
			} else if (ヨコ == 850 && メモリーカウンター == 3) {
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				現在の距離 = 0;
				現在のコンチニュー = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// ※↑ここまでコピペ
				if (状態フラグ無敵 == false) {
					musicStop();
				}
				コースカウンター = 4;
				ミュージック待機中かどうか = true;
				// データ（全て）の保存
				dataSave();
				コースデータ.getInstance(getBaseActivity()).setコースデータ(コースカウンター);
				// テキストの初期化
				textInit();
				// 背景の初期化
				backInit();
				// 背景の削除処理
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						ワールド1.detachSelf();
						アスレチック雲1.detachSelf();
						アスレチック雲2.detachSelf();
					}
				}));
				// テキストをふぃーどばっく！
				ワールドテキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				テキスト9.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				コーステキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
			}
			// 1-4の読み込み
		} else if (コースカウンター == 4
				&& ボスエリアかどうか == false && ボスリトライ時かどうか == false) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 900; ヨコ < タイル位置カウンター + 901; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign04();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign04();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ミュージックのリソースと切り替え
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ミュージック待機中かどうか = false;
				if (状態フラグ無敵 == false) {
					// ミュージックリソースの解放
					getBaseActivity().getMusicManager().releaseAll();
					musicPlay();
				}
			}
			// 入り口演出の削除
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ワールド1お城入り口.registerEntityModifier(new FadeOutModifier(1.5f));
				ワールド1お城中間.registerEntityModifier(new FadeOutModifier(1.5f));
				// 1.5秒ストップ！
				registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						if (メモリーの開放をしたかどうか == false) {
							出現フラグワールド1お城入り口 = false;
							ワールド1お城入り口.detachSelf();
							ワールド1お城中間.detachSelf();
						}
					}
				}));
			}
			// ボス前まできたことを証明！
			if (ヨコ == 900 && メモリーカウンター == 3) {
				ボス戦前データ.getInstance(getBaseActivity()).setボス戦前データ(1);
				// 変数の処理
				現在のコンチニュー = 0;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// データ（全て）の保存
				dataSave();
			}
			// ボス戦前の処理（※ノーリトライ時のみ！）
			if (イントロ中かどうか == true) {
				if (ヨコ == 925 && メモリーカウンター == 3) {
					// タイルに接触していない場合の処理
					if (フラグタイル接触 == false && 状態フラグ復活中 == true
							&& フラグバルーン掴み == true) {
						フラグバルーン掴み		= false;
						フラグバル放メッセージ		= false;
						// ボイスのランダム処理
						int r = (int)(Math.random() * 3);
						switch (r) {
						case 0:
							VoicePlay.voiceBackFlip1.stop();
							VoicePlay.voiceBackFlip1.play();
							break;
						case 1:
							VoicePlay.voiceBackFlip2.stop();
							VoicePlay.voiceBackFlip2.play();
							break;
						case 2:
							VoicePlay.voiceBackFlip3.stop();
							VoicePlay.voiceBackFlip3.play();
							break;
						}
						backFlipJumpSprite();
						// タイルに接触している場合はフラグバルーン放したいをとぅるー！
					} else if (フラグタイル接触 == true && 状態フラグ復活中 == true
							&& フラグバルーン掴み == true && フラグバルーン放したい == false) {
						フラグバルーン放したい		= true;
						フラグバル放メッセージ		= true;
					}
					MusicPlay.bgmCastleIntroduction.setVolume(1.0f);
				} else if (ヨコ == 926 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.9f);
				} else if (ヨコ == 927 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.8f);
				} else if (ヨコ == 928 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.7f);
				} else if (ヨコ == 929 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.6f);
				} else if (ヨコ == 930 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.5f);
				} else if (ヨコ == 931 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.4f);
				} else if (ヨコ == 932 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.3f);
				} else if (ヨコ == 933 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.2f);
				} else if (ヨコ == 934 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.1f);
				} else if (ヨコ == 935 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0);
				}
			} else if (イントロ中かどうか == false) {
				if (ヨコ == 925 && メモリーカウンター == 3) {
					// タイルに接触していない場合の処理
					if (フラグタイル接触 == false && 状態フラグ復活中 == true
							&& フラグバルーン掴み == true) {
						フラグバルーン掴み		= false;
						フラグバル放メッセージ		= false;
						// ボイスのランダム処理
						int r = (int)(Math.random() * 3);
						switch (r) {
						case 0:
							VoicePlay.voiceBackFlip1.stop();
							VoicePlay.voiceBackFlip1.play();
							break;
						case 1:
							VoicePlay.voiceBackFlip2.stop();
							VoicePlay.voiceBackFlip2.play();
							break;
						case 2:
							VoicePlay.voiceBackFlip3.stop();
							VoicePlay.voiceBackFlip3.play();
							break;
						}
						backFlipJumpSprite();
						// タイルに接触している場合はフラグバルーン放したいをとぅるー！
					} else if (フラグタイル接触 == true && 状態フラグ復活中 == true
							&& フラグバルーン掴み == true && フラグバルーン放したい == false) {
						フラグバルーン放したい		= true;
						フラグバル放メッセージ		= true;
					}
					MusicPlay.bgmCastleTheme.setVolume(1.0f);
				} else if (ヨコ == 926 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.9f);
				} else if (ヨコ == 927 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.8f);
				} else if (ヨコ == 928 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.7f);
				} else if (ヨコ == 929 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.6f);
				} else if (ヨコ == 930 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.5f);
				} else if (ヨコ == 931 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.4f);
				} else if (ヨコ == 932 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.3f);
				} else if (ヨコ == 933 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.2f);
				} else if (ヨコ == 934 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.1f);
				} else if (ヨコ == 935 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0);
				}
			}
			// ボスが出現！
			if (ヨコ == 1050 && メモリーカウンター == 3
					&& フラグボスキャラ出現 == false) {
				// ミュージックリソースの解放
				if (状態フラグ無敵 == false) {
					musicStop();
					getBaseActivity().getMusicManager().releaseAll();
				}
				フラグボスキャラ出現 = true;
				if (状態フラグ無敵 == false) {
					musicPlay();
				}
				bowsers.enemyBowserNormalLevel1 = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("enemy_21_bowser_normal_level_1.png", 1, 12);
				bowsers.enemyBowserNormalLevel1.setTag(
						Bowsers.TAG_ENEMY_41_BOWSER_NORMAL_LEVEL_1);
				bowsers.enemyBowserNormalLevel1.setPosition(640, 480);
				bowsers.enemyBowserNormalLevel1.animate(
						new long[] { aniスター, aniスター, aniスター, aniスター,
								aniスター, aniスター, aniスター, aniスター, }, 0, 7, true);
				attachChild(bowsers.enemyBowserNormalLevel1);
				bowsers.enemyBowserNormalLevel1.setZIndex(レイヤー08敵キャラ用);
				sortChildren();
				// エリアの移動処理
			} else if (ヨコ == 1100 && メモリーカウンター == 3
					&& ボスエリアかどうか == false) {
				if (状態フラグ無敵 == false) {
					musicStop();
					getBaseActivity().getMusicManager().releaseAll();
				}
				ボスエリアかどうか = true;
				if (状態フラグ無敵 == false) {
					musicPlay();
				}
				フラグボスキャラ生存 = true;
				// 四角形を描画
				final Rectangle フラッシュ四角形 = new Rectangle(0, 0, getBaseActivity().getEngine()
						.getCamera().getWidth(), getBaseActivity().getEngine()
						.getCamera().getHeight(), getBaseActivity()
						.getVertexBufferObjectManager());
				フラッシュ四角形.setColor(0.8f, 0.8f, 0.8f);
				attachChild(フラッシュ四角形);
				フラッシュ四角形.setZIndex(レイヤー16ポーズ用);
				sortChildren();
				フラッシュ四角形.registerEntityModifier(new FadeInModifier(0.2f));
				// 0.15秒ストップ！
				registerUpdateHandler(new TimerHandler(0.15f, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						フラッシュ四角形.registerEntityModifier(new FadeOutModifier(0.2f));
						bowsers.enemyBowserNormalLevel1.animate(
								new long[] { ani速, ani速, ani速, ani速, }, 8, 11, true);
						// 0.15秒ストップ！
						registerUpdateHandler(new TimerHandler(0.15f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								フラッシュ四角形.detachSelf();
							}
						}));
					}
				}));
				// ボスエリアのランダム処理
				int ボスエリア = (int)(Math.random() * 10);
				switch (ボスエリア) {
				case 0:
					ボスエリアカウンター = 1;
					break;
				case 1:
					ボスエリアカウンター = 2;
					break;
				case 2:
					ボスエリアカウンター = 3;
					break;
				case 3:
					ボスエリアカウンター = 4;
					break;
				case 4:
					ボスエリアカウンター = 5;
					break;
				case 5:
					ボスエリアカウンター = 6;
					break;
				case 6:
					ボスエリアカウンター = 7;
					break;
				case 7:
					ボスエリアカウンター = 8;
					break;
				case 8:
					ボスエリアカウンター = 9;
					break;
				case 9:
					ボスエリアカウンター = 10;
					break;
				}
				// ノーマルボス行動のランダム処理
				int ノーマルボス行動 = (int)(Math.random() * 10);
				switch (ノーマルボス行動) {
				case 0:
					ノーマルボス行動パターン = 1;
					break;
				case 1:
					ノーマルボス行動パターン = 2;
					break;
				case 2:
					ノーマルボス行動パターン = 3;
					break;
				case 3:
					ノーマルボス行動パターン = 4;
					break;
				case 4:
					ノーマルボス行動パターン = 5;
					break;
				case 5:
					ノーマルボス行動パターン = 6;
					break;
				case 6:
					ノーマルボス行動パターン = 7;
					break;
				case 7:
					ノーマルボス行動パターン = 8;
					break;
				case 8:
					ノーマルボス行動パターン = 9;
					break;
				case 9:
					ノーマルボス行動パターン = 10;
					break;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア0の読み込み（※リトライ時はここから読み込まれる！）
		} else if (コースカウンター == 4 && ボスエリアカウンター == 0 && ボスリトライ時かどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign00();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign00();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			if (ヨコ == 145 && メモリーカウンター == 3
					&& フラグボスキャラ出現 == false) {
				// ミュージックリソースの解放
				if (状態フラグ無敵 == false) {
					musicStop();
					getBaseActivity().getMusicManager().releaseAll();
				}
				フラグボスキャラ出現 = true;
				if (状態フラグ無敵 == false) {
					musicPlay();
				}
				bowsers.enemyBowserNormalLevel1 = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("enemy_21_bowser_normal_level_1.png", 1, 12);
				bowsers.enemyBowserNormalLevel1.setTag(
						Bowsers.TAG_ENEMY_41_BOWSER_NORMAL_LEVEL_1);
				bowsers.enemyBowserNormalLevel1.setPosition(640, 480);
				bowsers.enemyBowserNormalLevel1.animate(
						new long[] { aniスター, aniスター, aniスター, aniスター,
								aniスター, aniスター, aniスター, aniスター, }, 0, 7, true);
				attachChild(bowsers.enemyBowserNormalLevel1);
				bowsers.enemyBowserNormalLevel1.setZIndex(レイヤー08敵キャラ用);
				sortChildren();
				// エリアの移動処理
			} else if (ヨコ == 195 && メモリーカウンター == 3
					&& ボスエリアかどうか == false) {
				if (状態フラグ無敵 == false) {
					musicStop();
					getBaseActivity().getMusicManager().releaseAll();
				}
				ボスエリアかどうか = true;
				if (状態フラグ無敵 == false) {
					musicPlay();
				}
				フラグボスキャラ生存 = true;
				// 四角形を描画
				final Rectangle フラッシュ四角形 = new Rectangle(0, 0, getBaseActivity().getEngine()
						.getCamera().getWidth(), getBaseActivity().getEngine()
						.getCamera().getHeight(), getBaseActivity()
						.getVertexBufferObjectManager());
				フラッシュ四角形.setColor(0.8f, 0.8f, 0.8f);
				attachChild(フラッシュ四角形);
				フラッシュ四角形.setZIndex(レイヤー16ポーズ用);
				sortChildren();
				フラッシュ四角形.registerEntityModifier(new FadeInModifier(0.2f));
				// 0.15秒ストップ！
				registerUpdateHandler(new TimerHandler(0.15f, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						フラッシュ四角形.registerEntityModifier(new FadeOutModifier(0.2f));
						bowsers.enemyBowserNormalLevel1.animate(
								new long[] { ani速, ani速, ani速, ani速, }, 8, 11, true);
						// 0.15秒ストップ！
						registerUpdateHandler(new TimerHandler(0.15f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								フラッシュ四角形.detachSelf();
							}
						}));
					}
				}));
				// ボスエリアのランダム処理
				int ボスエリア = (int)(Math.random() * 10);
				switch (ボスエリア) {
				case 0:
					ボスエリアカウンター = 1;
					break;
				case 1:
					ボスエリアカウンター = 2;
					break;
				case 2:
					ボスエリアカウンター = 3;
					break;
				case 3:
					ボスエリアカウンター = 4;
					break;
				case 4:
					ボスエリアカウンター = 5;
					break;
				case 5:
					ボスエリアカウンター = 6;
					break;
				case 6:
					ボスエリアカウンター = 7;
					break;
				case 7:
					ボスエリアカウンター = 8;
					break;
				case 8:
					ボスエリアカウンター = 9;
					break;
				case 9:
					ボスエリアカウンター = 10;
					break;
				}
				// ノーマルボス行動のランダム処理
				int ノーマルボス行動 = (int)(Math.random() * 10);
				switch (ノーマルボス行動) {
				case 0:
					ノーマルボス行動パターン = 1;
					break;
				case 1:
					ノーマルボス行動パターン = 2;
					break;
				case 2:
					ノーマルボス行動パターン = 3;
					break;
				case 3:
					ノーマルボス行動パターン = 4;
					break;
				case 4:
					ノーマルボス行動パターン = 5;
					break;
				case 5:
					ノーマルボス行動パターン = 6;
					break;
				case 6:
					ノーマルボス行動パターン = 7;
					break;
				case 7:
					ノーマルボス行動パターン = 8;
					break;
				case 8:
					ノーマルボス行動パターン = 9;
					break;
				case 9:
					ノーマルボス行動パターン = 10;
					break;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ※↓ここから共通処理
			// ボスエリア1の読み込み
		} else if (コースカウンター == 4 && ボスエリアカウンター == 1 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign01();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign01();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 2;
						break;
					case 1:
						ボスエリアカウンター = 3;
						break;
					case 2:
						ボスエリアカウンター = 4;
						break;
					case 3:
						ボスエリアカウンター = 5;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア2の読み込み
		} else if (コースカウンター == 4 && ボスエリアカウンター == 2 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign02();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign02();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 3;
						break;
					case 2:
						ボスエリアカウンター = 4;
						break;
					case 3:
						ボスエリアカウンター = 5;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア3の読み込み
		} else if (コースカウンター == 4 && ボスエリアカウンター == 3 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign03();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign03();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 4;
						break;
					case 3:
						ボスエリアカウンター = 5;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア4の読み込み
		} else if (コースカウンター == 4 && ボスエリアカウンター == 4 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign04();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign04();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 5;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア5の読み込み
		} else if (コースカウンター == 4 && ボスエリアカウンター == 5 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign05();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign05();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア6の読み込み
		} else if (コースカウンター == 4 && ボスエリアカウンター == 6 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign06();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign06();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア7の読み込み
		} else if (コースカウンター == 4 && ボスエリアカウンター == 7 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign07();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign07();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 6;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア8の読み込み
		} else if (コースカウンター == 4 && ボスエリアカウンター == 8 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign08();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign08();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 6;
						break;
					case 6:
						ボスエリアカウンター = 7;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア9の読み込み
		} else if (コースカウンター == 4 && ボスエリアカウンター == 9 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign09();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign09();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 6;
						break;
					case 6:
						ボスエリアカウンター = 7;
						break;
					case 7:
						ボスエリアカウンター = 8;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア10の読み込み
		} else if (コースカウンター == 4 && ボスエリアカウンター == 10 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign10();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign10();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 6;
						break;
					case 6:
						ボスエリアカウンター = 7;
						break;
					case 7:
						ボスエリアカウンター = 8;
						break;
					case 8:
						ボスエリアカウンター = 9;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア31の読み込み
		} else if (コースカウンター == 4 && ボスエリアカウンター == 31 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign31();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign31();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				コースの端っこかどうか = true;
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						ゲームを終了したかどうか = true;
						// データ（全て）の保存
						dataSave();
						コースデータ.getInstance(getBaseActivity()).setコースデータ(5);
						// 1.25秒ストップ！
						registerUpdateHandler(new TimerHandler(1.25f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								// 再度、ゲーム画面の読み込み
								MainScene scene = new MainScene(getBaseActivity());
								getBaseActivity().refreshRunningScene(scene);
								// ミュージックリソースの解放
								getBaseActivity().getMusicManager().releaseAll();
							}
						}));
					}
				}));
			}
		}
	}
	// WORLD 2をインクリ
	public void world2Increment() {
		// 2-1の読み込み
		if (コースカウンター == 5) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign05();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign05();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ゴール後の処理
			if (ヨコ == 750 && メモリーカウンター == 3) {
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				現在の距離 = 0;
				現在のコンチニュー = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// ※↑ここまでコピペ
				if (状態フラグ無敵 == false) {
					musicStop();
				}
				コースカウンター = 6;
				ミュージック待機中かどうか = true;
				// キラー青フラグをオン！
				フラグキラー青色 = true;
				// データ（全て）の保存
				dataSave();
				コースデータ.getInstance(getBaseActivity()).setコースデータ(コースカウンター);
				// テキストの初期化
				textInit();
				// 同一背景なので変更はしない
				// テキストをふぃーどばっく！
				ワールドテキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				テキスト9.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				コーステキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
			}
			// 2-2の読み込み
		} else if (コースカウンター == 6) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign06();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign06();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ミュージックのリソースと切り替え
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ミュージック待機中かどうか = false;
				if (状態フラグ無敵 == false) {
					// ミュージックリソースの解放
					getBaseActivity().getMusicManager().releaseAll();
					musicPlay();
				}
			}
			// キラー青フラグをオフ！
			if (ヨコ == 500 && メモリーカウンター == 3) {
				フラグキラー青色 = false;
				// 入り口演出の追加
			} else if (ヨコ == 540 && メモリーカウンター == 3) {
				出現フラグワールド2地下入り口 = true;
				// 入り口
				ワールド2地下入り口 = getBaseActivity().getResourceUtil()
						.getSprite("back_13_underground_entrance_2.png");
				ワールド2地下入り口.setPosition(800, 0);
				attachChild(ワールド2地下入り口);
				ワールド2地下入り口.setZIndex(レイヤー01背景用);
				sortChildren();
				// 中間
				ワールド2地下中間 = getBaseActivity().getResourceUtil()
						.getSprite("back_14_underground_inside_2.png");
				ワールド2地下中間.setPosition(1120, 0);
				attachChild(ワールド2地下中間);
				ワールド2地下中間.setZIndex(レイヤー11特殊背景用);
				sortChildren();
				// ゴール後の処理
			} else if (ヨコ == 550 && メモリーカウンター == 3) {
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				現在の距離 = 0;
				現在のコンチニュー = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// ※↑ここまでコピペ
				if (状態フラグ無敵 == false) {
					musicStop();
				}
				コースカウンター = 7;
				ミュージック待機中かどうか = true;
				// データ（全て）の保存
				dataSave();
				コースデータ.getInstance(getBaseActivity()).setコースデータ(コースカウンター);
				// テキストの初期化
				textInit();
				// 背景の初期化
				backInit();
				// 背景の削除処理
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						ワールド2.detachSelf();
						地上雲1.detachSelf();
						地上雲2.detachSelf();
					}
				}));
				// テキストをふぃーどばっく！
				ワールドテキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				テキスト9.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				コーステキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
			}
			// 2-3の読み込み
		} else if (コースカウンター == 7) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign07();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign07();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ミュージックのリソースと切り替え
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ミュージック待機中かどうか = false;
				if (状態フラグ無敵 == false) {
					// ミュージックリソースの解放
					getBaseActivity().getMusicManager().releaseAll();
					musicPlay();
				}
			}
			// 入り口演出の削除
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ワールド2地下入り口.registerEntityModifier(new FadeOutModifier(1.5f));
				ワールド2地下中間.registerEntityModifier(new FadeOutModifier(1.5f));
				// 1.5秒ストップ！
				registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						if (メモリーの開放をしたかどうか == false) {
							出現フラグワールド2地下入り口 = false;
							ワールド2地下入り口.detachSelf();
							ワールド2地下中間.detachSelf();
						}
					}
				}));
				// 入り口演出の追加
			} else if (ヨコ == 840 && メモリーカウンター == 3) {
				出現フラグワールド2お城入り口 = true;
				// 入り口
				ワールド2お城入り口 = getBaseActivity().getResourceUtil()
						.getSprite("back_31_castle_entrance_5.png");
				ワールド2お城入り口.setPosition(800, 0);
				attachChild(ワールド2お城入り口);
				ワールド2お城入り口.setZIndex(レイヤー01背景用);
				sortChildren();
				// 中間
				ワールド2お城中間 = getBaseActivity().getResourceUtil()
						.getSprite("back_32_castle_inside_5.png");
				ワールド2お城中間.setPosition(1120, 0);
				attachChild(ワールド2お城中間);
				ワールド2お城中間.setZIndex(レイヤー11特殊背景用);
				sortChildren();
				// ゴール後の処理
			} else if (ヨコ == 850 && メモリーカウンター == 3) {
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				現在の距離 = 0;
				現在のコンチニュー = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// ※↑ここまでコピペ
				if (状態フラグ無敵 == false) {
					musicStop();
				}
				コースカウンター = 8;
				ミュージック待機中かどうか = true;
				// データ（全て）の保存
				dataSave();
				コースデータ.getInstance(getBaseActivity()).setコースデータ(コースカウンター);
				// テキストの初期化
				textInit();
				// 背景の初期化
				backInit();
				// 背景の削除処理
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						地下エリア.detachSelf();
						水1.detachSelf();
						水2.detachSelf();
					}
				}));
				// テキストをふぃーどばっく！
				ワールドテキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				テキスト9.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				コーステキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
			}
			// 2-4の読み込み
		} else if (コースカウンター == 8
				&& ボスエリアかどうか == false && ボスリトライ時かどうか == false) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 1000; ヨコ < タイル位置カウンター + 1001; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign08();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign08();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ミュージックのリソースと切り替え
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ミュージック待機中かどうか = false;
				if (状態フラグ無敵 == false) {
					// ミュージックリソースの解放
					getBaseActivity().getMusicManager().releaseAll();
					musicPlay();
				}
			}
			// 入り口演出の削除
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ワールド2お城入り口.registerEntityModifier(new FadeOutModifier(1.5f));
				ワールド2お城中間.registerEntityModifier(new FadeOutModifier(1.5f));
				// 1.5秒ストップ！
				registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						if (メモリーの開放をしたかどうか == false) {
							出現フラグワールド2お城入り口 = false;
							ワールド2お城入り口.detachSelf();
							ワールド2お城中間.detachSelf();
						}
					}
				}));
			}
			// ボス前まできたことを証明！
			if (ヨコ == 1000 && メモリーカウンター == 3) {
				ボス戦前データ.getInstance(getBaseActivity()).setボス戦前データ(2);
				// 変数の処理
				現在のコンチニュー = 0;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// データ（全て）の保存
				dataSave();
			}
			// ボス戦前の処理（※ノーリトライ時のみ！）
			if (イントロ中かどうか == true) {
				if (ヨコ == 1025 && メモリーカウンター == 3) {
					// タイルに接触していない場合の処理
					if (フラグタイル接触 == false && 状態フラグ復活中 == true
							&& フラグバルーン掴み == true) {
						フラグバルーン掴み		= false;
						フラグバル放メッセージ		= false;
						// ボイスのランダム処理
						int r = (int)(Math.random() * 3);
						switch (r) {
						case 0:
							VoicePlay.voiceBackFlip1.stop();
							VoicePlay.voiceBackFlip1.play();
							break;
						case 1:
							VoicePlay.voiceBackFlip2.stop();
							VoicePlay.voiceBackFlip2.play();
							break;
						case 2:
							VoicePlay.voiceBackFlip3.stop();
							VoicePlay.voiceBackFlip3.play();
							break;
						}
						backFlipJumpSprite();
						// タイルに接触している場合はフラグバルーン放したいをとぅるー！
					} else if (フラグタイル接触 == true && 状態フラグ復活中 == true
							&& フラグバルーン掴み == true && フラグバルーン放したい == false) {
						フラグバルーン放したい		= true;
						フラグバル放メッセージ		= true;
					}
					MusicPlay.bgmCastleIntroduction.setVolume(1.0f);
				} else if (ヨコ == 1026 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.9f);
				} else if (ヨコ == 1027 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.8f);
				} else if (ヨコ == 1028 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.7f);
				} else if (ヨコ == 1029 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.6f);
				} else if (ヨコ == 1030 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.5f);
				} else if (ヨコ == 1031 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.4f);
				} else if (ヨコ == 1032 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.3f);
				} else if (ヨコ == 1033 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.2f);
				} else if (ヨコ == 1034 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.1f);
				} else if (ヨコ == 1035 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0);
				}
			} else if (イントロ中かどうか == false) {
				if (ヨコ == 1025 && メモリーカウンター == 3) {
					// タイルに接触していない場合の処理
					if (フラグタイル接触 == false && 状態フラグ復活中 == true
							&& フラグバルーン掴み == true) {
						フラグバルーン掴み		= false;
						フラグバル放メッセージ		= false;
						// ボイスのランダム処理
						int r = (int)(Math.random() * 3);
						switch (r) {
						case 0:
							VoicePlay.voiceBackFlip1.stop();
							VoicePlay.voiceBackFlip1.play();
							break;
						case 1:
							VoicePlay.voiceBackFlip2.stop();
							VoicePlay.voiceBackFlip2.play();
							break;
						case 2:
							VoicePlay.voiceBackFlip3.stop();
							VoicePlay.voiceBackFlip3.play();
							break;
						}
						backFlipJumpSprite();
						// タイルに接触している場合はフラグバルーン放したいをとぅるー！
					} else if (フラグタイル接触 == true && 状態フラグ復活中 == true
							&& フラグバルーン掴み == true && フラグバルーン放したい == false) {
						フラグバルーン放したい		= true;
						フラグバル放メッセージ		= true;
					}
					MusicPlay.bgmCastleTheme.setVolume(1.0f);
				} else if (ヨコ == 1026 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.9f);
				} else if (ヨコ == 1027 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.8f);
				} else if (ヨコ == 1028 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.7f);
				} else if (ヨコ == 1029 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.6f);
				} else if (ヨコ == 1030 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.5f);
				} else if (ヨコ == 1031 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.4f);
				} else if (ヨコ == 1032 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.3f);
				} else if (ヨコ == 1033 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.2f);
				} else if (ヨコ == 1034 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.1f);
				} else if (ヨコ == 1035 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0);
				}
			}
			// ボスが出現！
			if (ヨコ == 1150 && メモリーカウンター == 3
					&& フラグボスキャラ出現 == false) {
				// ミュージックリソースの解放
				if (状態フラグ無敵 == false) {
					musicStop();
					getBaseActivity().getMusicManager().releaseAll();
				}
				フラグボスキャラ出現 = true;
				if (状態フラグ無敵 == false) {
					musicPlay();
				}
				bowsers.enemyBowserNormalLevel1 = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("enemy_21_bowser_normal_level_1.png", 1, 12);
				bowsers.enemyBowserNormalLevel1.setTag(
						Bowsers.TAG_ENEMY_41_BOWSER_NORMAL_LEVEL_1);
				bowsers.enemyBowserNormalLevel1.setPosition(640, 480);
				bowsers.enemyBowserNormalLevel1.animate(
						new long[] { aniスター, aniスター, aniスター, aniスター,
								aniスター, aniスター, aniスター, aniスター, }, 0, 7, true);
				attachChild(bowsers.enemyBowserNormalLevel1);
				bowsers.enemyBowserNormalLevel1.setZIndex(レイヤー08敵キャラ用);
				sortChildren();
				// エリアの移動処理
			} else if (ヨコ == 1200 && メモリーカウンター == 3
					&& ボスエリアかどうか == false) {
				if (状態フラグ無敵 == false) {
					musicStop();
					getBaseActivity().getMusicManager().releaseAll();
				}
				ボスエリアかどうか = true;
				if (状態フラグ無敵 == false) {
					musicPlay();
				}
				フラグボスキャラ生存 = true;
				// 四角形を描画
				final Rectangle フラッシュ四角形 = new Rectangle(0, 0, getBaseActivity().getEngine()
						.getCamera().getWidth(), getBaseActivity().getEngine()
						.getCamera().getHeight(), getBaseActivity()
						.getVertexBufferObjectManager());
				フラッシュ四角形.setColor(0.8f, 0.8f, 0.8f);
				attachChild(フラッシュ四角形);
				フラッシュ四角形.setZIndex(レイヤー16ポーズ用);
				sortChildren();
				フラッシュ四角形.registerEntityModifier(new FadeInModifier(0.2f));
				// 0.15秒ストップ！
				registerUpdateHandler(new TimerHandler(0.15f, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						フラッシュ四角形.registerEntityModifier(new FadeOutModifier(0.2f));
						bowsers.enemyBowserNormalLevel1.animate(
								new long[] { ani速, ani速, ani速, ani速, }, 8, 11, true);
						// 0.15秒ストップ！
						registerUpdateHandler(new TimerHandler(0.15f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								フラッシュ四角形.detachSelf();
							}
						}));
					}
				}));
				// ボスエリアのランダム処理
				int ボスエリア = (int)(Math.random() * 10);
				switch (ボスエリア) {
				case 0:
					ボスエリアカウンター = 1;
					break;
				case 1:
					ボスエリアカウンター = 2;
					break;
				case 2:
					ボスエリアカウンター = 3;
					break;
				case 3:
					ボスエリアカウンター = 4;
					break;
				case 4:
					ボスエリアカウンター = 5;
					break;
				case 5:
					ボスエリアカウンター = 6;
					break;
				case 6:
					ボスエリアカウンター = 7;
					break;
				case 7:
					ボスエリアカウンター = 8;
					break;
				case 8:
					ボスエリアカウンター = 9;
					break;
				case 9:
					ボスエリアカウンター = 10;
					break;
				}
				// ノーマルボス行動のランダム処理
				int ノーマルボス行動 = (int)(Math.random() * 10);
				switch (ノーマルボス行動) {
				case 0:
					ノーマルボス行動パターン = 1;
					break;
				case 1:
					ノーマルボス行動パターン = 2;
					break;
				case 2:
					ノーマルボス行動パターン = 3;
					break;
				case 3:
					ノーマルボス行動パターン = 4;
					break;
				case 4:
					ノーマルボス行動パターン = 5;
					break;
				case 5:
					ノーマルボス行動パターン = 6;
					break;
				case 6:
					ノーマルボス行動パターン = 7;
					break;
				case 7:
					ノーマルボス行動パターン = 8;
					break;
				case 8:
					ノーマルボス行動パターン = 9;
					break;
				case 9:
					ノーマルボス行動パターン = 10;
					break;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア0の読み込み（※リトライ時はここから読み込まれる！）
		} else if (コースカウンター == 8 && ボスエリアカウンター == 0 && ボスリトライ時かどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign00();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign00();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			if (ヨコ == 145 && メモリーカウンター == 3
					&& フラグボスキャラ出現 == false) {
				// ミュージックリソースの解放
				if (状態フラグ無敵 == false) {
					musicStop();
					getBaseActivity().getMusicManager().releaseAll();
				}
				フラグボスキャラ出現 = true;
				if (状態フラグ無敵 == false) {
					musicPlay();
				}
				bowsers.enemyBowserNormalLevel1 = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("enemy_21_bowser_normal_level_1.png", 1, 12);
				bowsers.enemyBowserNormalLevel1.setTag(
						Bowsers.TAG_ENEMY_41_BOWSER_NORMAL_LEVEL_1);
				bowsers.enemyBowserNormalLevel1.setPosition(640, 480);
				bowsers.enemyBowserNormalLevel1.animate(
						new long[] { aniスター, aniスター, aniスター, aniスター,
								aniスター, aniスター, aniスター, aniスター, }, 0, 7, true);
				attachChild(bowsers.enemyBowserNormalLevel1);
				bowsers.enemyBowserNormalLevel1.setZIndex(レイヤー08敵キャラ用);
				sortChildren();
				// エリアの移動処理
			} else if (ヨコ == 195 && メモリーカウンター == 3
					&& ボスエリアかどうか == false) {
				if (状態フラグ無敵 == false) {
					musicStop();
					getBaseActivity().getMusicManager().releaseAll();
				}
				ボスエリアかどうか = true;
				if (状態フラグ無敵 == false) {
					musicPlay();
				}
				フラグボスキャラ生存 = true;
				// 四角形を描画
				final Rectangle フラッシュ四角形 = new Rectangle(0, 0, getBaseActivity().getEngine()
						.getCamera().getWidth(), getBaseActivity().getEngine()
						.getCamera().getHeight(), getBaseActivity()
						.getVertexBufferObjectManager());
				フラッシュ四角形.setColor(0.8f, 0.8f, 0.8f);
				attachChild(フラッシュ四角形);
				フラッシュ四角形.setZIndex(レイヤー16ポーズ用);
				sortChildren();
				フラッシュ四角形.registerEntityModifier(new FadeInModifier(0.2f));
				// 0.15秒ストップ！
				registerUpdateHandler(new TimerHandler(0.15f, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						フラッシュ四角形.registerEntityModifier(new FadeOutModifier(0.2f));
						bowsers.enemyBowserNormalLevel1.animate(
								new long[] { ani速, ani速, ani速, ani速, }, 8, 11, true);
						// 0.15秒ストップ！
						registerUpdateHandler(new TimerHandler(0.15f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								フラッシュ四角形.detachSelf();
							}
						}));
					}
				}));
				// ボスエリアのランダム処理
				int ボスエリア = (int)(Math.random() * 10);
				switch (ボスエリア) {
				case 0:
					ボスエリアカウンター = 1;
					break;
				case 1:
					ボスエリアカウンター = 2;
					break;
				case 2:
					ボスエリアカウンター = 3;
					break;
				case 3:
					ボスエリアカウンター = 4;
					break;
				case 4:
					ボスエリアカウンター = 5;
					break;
				case 5:
					ボスエリアカウンター = 6;
					break;
				case 6:
					ボスエリアカウンター = 7;
					break;
				case 7:
					ボスエリアカウンター = 8;
					break;
				case 8:
					ボスエリアカウンター = 9;
					break;
				case 9:
					ボスエリアカウンター = 10;
					break;
				}
				// ノーマルボス行動のランダム処理
				int ノーマルボス行動 = (int)(Math.random() * 10);
				switch (ノーマルボス行動) {
				case 0:
					ノーマルボス行動パターン = 1;
					break;
				case 1:
					ノーマルボス行動パターン = 2;
					break;
				case 2:
					ノーマルボス行動パターン = 3;
					break;
				case 3:
					ノーマルボス行動パターン = 4;
					break;
				case 4:
					ノーマルボス行動パターン = 5;
					break;
				case 5:
					ノーマルボス行動パターン = 6;
					break;
				case 6:
					ノーマルボス行動パターン = 7;
					break;
				case 7:
					ノーマルボス行動パターン = 8;
					break;
				case 8:
					ノーマルボス行動パターン = 9;
					break;
				case 9:
					ノーマルボス行動パターン = 10;
					break;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ※↓ここから共通処理
			// ボスエリア1の読み込み
		} else if (コースカウンター == 8 && ボスエリアカウンター == 1 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign01();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign01();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 2;
						break;
					case 1:
						ボスエリアカウンター = 3;
						break;
					case 2:
						ボスエリアカウンター = 4;
						break;
					case 3:
						ボスエリアカウンター = 5;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア2の読み込み
		} else if (コースカウンター == 8 && ボスエリアカウンター == 2 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign02();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign02();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 3;
						break;
					case 2:
						ボスエリアカウンター = 4;
						break;
					case 3:
						ボスエリアカウンター = 5;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア3の読み込み
		} else if (コースカウンター == 8 && ボスエリアカウンター == 3 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign03();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign03();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 4;
						break;
					case 3:
						ボスエリアカウンター = 5;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア4の読み込み
		} else if (コースカウンター == 8 && ボスエリアカウンター == 4 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign04();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign04();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 5;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア5の読み込み
		} else if (コースカウンター == 8 && ボスエリアカウンター == 5 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign05();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign05();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア6の読み込み
		} else if (コースカウンター == 8 && ボスエリアカウンター == 6 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign06();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign06();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア7の読み込み
		} else if (コースカウンター == 8 && ボスエリアカウンター == 7 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign07();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign07();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 6;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア8の読み込み
		} else if (コースカウンター == 8 && ボスエリアカウンター == 8 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign08();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign08();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 6;
						break;
					case 6:
						ボスエリアカウンター = 7;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア9の読み込み
		} else if (コースカウンター == 8 && ボスエリアカウンター == 9 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign09();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign09();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 6;
						break;
					case 6:
						ボスエリアカウンター = 7;
						break;
					case 7:
						ボスエリアカウンター = 8;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア10の読み込み
		} else if (コースカウンター == 8 && ボスエリアカウンター == 10 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign10();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign10();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 6;
						break;
					case 6:
						ボスエリアカウンター = 7;
						break;
					case 7:
						ボスエリアカウンター = 8;
						break;
					case 8:
						ボスエリアカウンター = 9;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア31の読み込み
		} else if (コースカウンター == 8 && ボスエリアカウンター == 31 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign31();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign31();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				コースの端っこかどうか = true;
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						ゲームを終了したかどうか = true;
						// データ（全て）の保存
						dataSave();
						コースデータ.getInstance(getBaseActivity()).setコースデータ(9);
						// 1.25秒ストップ！
						registerUpdateHandler(new TimerHandler(1.25f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								// 再度、ゲーム画面の読み込み
								MainScene scene = new MainScene(getBaseActivity());
								getBaseActivity().refreshRunningScene(scene);
								// ミュージックリソースの解放
								getBaseActivity().getMusicManager().releaseAll();
							}
						}));
					}
				}));
			}
		}
	}
	// WORLD 3をインクリ
	public void world3Increment() {
		// 3-1の読み込み
		if (コースカウンター == 9) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign09();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign09();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// 入り口演出の追加
			if (ヨコ == 940 && メモリーカウンター == 3) {
				出現フラグワールド3地下入り口 = true;
				// 入り口
				ワールド3地下入り口 = getBaseActivity().getResourceUtil()
						.getSprite("back_15_underground_entrance_3.png");
				ワールド3地下入り口.setPosition(800, 0);
				attachChild(ワールド3地下入り口);
				ワールド3地下入り口.setZIndex(レイヤー01背景用);
				sortChildren();
				// 中間
				ワールド3地下中間 = getBaseActivity().getResourceUtil()
						.getSprite("back_16_underground_inside_3.png");
				ワールド3地下中間.setPosition(1120, 0);
				attachChild(ワールド3地下中間);
				ワールド3地下中間.setZIndex(レイヤー11特殊背景用);
				sortChildren();
				// ゴール後の処理
			} else if (ヨコ == 950 && メモリーカウンター == 3) {
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				現在の距離 = 0;
				現在のコンチニュー = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// ※↑ここまでコピペ
				if (状態フラグ無敵 == false) {
					musicStop();
				}
				コースカウンター = 10;
				ミュージック待機中かどうか = true;
				// データ（全て）の保存
				dataSave();
				コースデータ.getInstance(getBaseActivity()).setコースデータ(コースカウンター);
				// テキストの初期化
				textInit();
				// 背景の初期化
				backInit();
				// 背景の削除処理
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						ワールド3.detachSelf();
						地上雲1.detachSelf();
						地上雲2.detachSelf();
					}
				}));
				// テキストをふぃーどばっく！
				ワールドテキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				テキスト9.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				コーステキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
			}
			// 3-2の読み込み
		} else if (コースカウンター == 10) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign10();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign10();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ミュージックのリソースと切り替え
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ミュージック待機中かどうか = false;
				if (状態フラグ無敵 == false) {
					// ミュージックリソースの解放
					getBaseActivity().getMusicManager().releaseAll();
					musicPlay();
				}
			}
			// 入り口演出の削除
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ワールド3地下入り口.registerEntityModifier(new FadeOutModifier(1.5f));
				ワールド3地下中間.registerEntityModifier(new FadeOutModifier(1.5f));
				// 1.5秒ストップ！
				registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						if (メモリーの開放をしたかどうか == false) {
							出現フラグワールド3地下入り口 = false;
							ワールド3地下入り口.detachSelf();
							ワールド3地下中間.detachSelf();
						}
					}
				}));
				// ゴール後の処理
			} else if (ヨコ == 750 && メモリーカウンター == 3) {
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				現在の距離 = 0;
				現在のコンチニュー = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// ※↑ここまでコピペ
				if (状態フラグ無敵 == false) {
					musicStop();
				}
				コースカウンター = 11;
				ミュージック待機中かどうか = true;
				// データ（全て）の保存
				dataSave();
				コースデータ.getInstance(getBaseActivity()).setコースデータ(コースカウンター);
				// テキストの初期化
				textInit();
				// 背景の初期化
				backInit();
				// 背景の削除処理
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						地下エリア.detachSelf();
						水1.detachSelf();
						水2.detachSelf();
					}
				}));
				// テキストをふぃーどばっく！
				ワールドテキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				テキスト9.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				コーステキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
			}
			// 3-3の読み込み
		} else if (コースカウンター == 11) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign11();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign11();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ミュージックのリソースと切り替え
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ミュージック待機中かどうか = false;
				if (状態フラグ無敵 == false) {
					// ミュージックリソースの解放
					getBaseActivity().getMusicManager().releaseAll();
					musicPlay();
				}
			}
			// 入り口演出の追加
			if (ヨコ == 1040 && メモリーカウンター == 3) {
				出現フラグワールド3お城入り口 = true;
				// 入り口
				ワールド3お城入り口 = getBaseActivity().getResourceUtil()
						.getSprite("back_27_castle_entrance_3.png");
				ワールド3お城入り口.setPosition(800, 0);
				attachChild(ワールド3お城入り口);
				ワールド3お城入り口.setZIndex(レイヤー01背景用);
				sortChildren();
				// 中間
				ワールド3お城中間 = getBaseActivity().getResourceUtil()
						.getSprite("back_28_castle_inside_3.png");
				ワールド3お城中間.setPosition(1120, 0);
				attachChild(ワールド3お城中間);
				ワールド3お城中間.setZIndex(レイヤー11特殊背景用);
				sortChildren();
				// ゴール後の処理
			} else if (ヨコ == 1050 && メモリーカウンター == 3) {
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				現在の距離 = 0;
				現在のコンチニュー = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// ※↑ここまでコピペ
				if (状態フラグ無敵 == false) {
					musicStop();
				}
				コースカウンター = 12;
				ミュージック待機中かどうか = true;
				// データ（全て）の保存
				dataSave();
				コースデータ.getInstance(getBaseActivity()).setコースデータ(コースカウンター);
				// テキストの初期化
				textInit();
				// 背景の初期化
				backInit();
				// 背景の削除処理
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						ワールド3.detachSelf();
						アスレチック雲1.detachSelf();
						アスレチック雲2.detachSelf();
					}
				}));
				// テキストをふぃーどばっく！
				ワールドテキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				テキスト9.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				コーステキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
			}
			// 3-4の読み込み
		} else if (コースカウンター == 12
				&& ボスエリアかどうか == false && ボスリトライ時かどうか == false) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 800; ヨコ < タイル位置カウンター + 801; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign12();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign12();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ミュージックのリソースと切り替え
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ミュージック待機中かどうか = false;
				if (状態フラグ無敵 == false) {
					// ミュージックリソースの解放
					getBaseActivity().getMusicManager().releaseAll();
					musicPlay();
				}
			}
			// 入り口演出の削除
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ワールド3お城入り口.registerEntityModifier(new FadeOutModifier(1.5f));
				ワールド3お城中間.registerEntityModifier(new FadeOutModifier(1.5f));
				// 1.5秒ストップ！
				registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						if (メモリーの開放をしたかどうか == false) {
							出現フラグワールド3お城入り口 = false;
							ワールド3お城入り口.detachSelf();
							ワールド3お城中間.detachSelf();
						}
					}
				}));
			}
			// ボス前まできたことを証明！
			if (ヨコ == 800 && メモリーカウンター == 3) {
				ボス戦前データ.getInstance(getBaseActivity()).setボス戦前データ(3);
				// 変数の処理
				現在のコンチニュー = 0;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// データ（全て）の保存
				dataSave();
			}
			// ボス戦前の処理（※ノーリトライ時のみ！）
			if (イントロ中かどうか == true) {
				if (ヨコ == 825 && メモリーカウンター == 3) {
					// タイルに接触していない場合の処理
					if (フラグタイル接触 == false && 状態フラグ復活中 == true
							&& フラグバルーン掴み == true) {
						フラグバルーン掴み		= false;
						フラグバル放メッセージ		= false;
						// ボイスのランダム処理
						int r = (int)(Math.random() * 3);
						switch (r) {
						case 0:
							VoicePlay.voiceBackFlip1.stop();
							VoicePlay.voiceBackFlip1.play();
							break;
						case 1:
							VoicePlay.voiceBackFlip2.stop();
							VoicePlay.voiceBackFlip2.play();
							break;
						case 2:
							VoicePlay.voiceBackFlip3.stop();
							VoicePlay.voiceBackFlip3.play();
							break;
						}
						backFlipJumpSprite();
						// タイルに接触している場合はフラグバルーン放したいをとぅるー！
					} else if (フラグタイル接触 == true && 状態フラグ復活中 == true
							&& フラグバルーン掴み == true && フラグバルーン放したい == false) {
						フラグバルーン放したい		= true;
						フラグバル放メッセージ		= true;
					}
					MusicPlay.bgmCastleIntroduction.setVolume(1.0f);
				} else if (ヨコ == 826 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.9f);
				} else if (ヨコ == 827 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.8f);
				} else if (ヨコ == 828 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.7f);
				} else if (ヨコ == 829 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.6f);
				} else if (ヨコ == 830 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.5f);
				} else if (ヨコ == 831 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.4f);
				} else if (ヨコ == 832 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.3f);
				} else if (ヨコ == 833 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.2f);
				} else if (ヨコ == 834 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.1f);
				} else if (ヨコ == 835 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0);
				}
			} else if (イントロ中かどうか == false) {
				if (ヨコ == 825 && メモリーカウンター == 3) {
					// タイルに接触していない場合の処理
					if (フラグタイル接触 == false && 状態フラグ復活中 == true
							&& フラグバルーン掴み == true) {
						フラグバルーン掴み		= false;
						フラグバル放メッセージ		= false;
						// ボイスのランダム処理
						int r = (int)(Math.random() * 3);
						switch (r) {
						case 0:
							VoicePlay.voiceBackFlip1.stop();
							VoicePlay.voiceBackFlip1.play();
							break;
						case 1:
							VoicePlay.voiceBackFlip2.stop();
							VoicePlay.voiceBackFlip2.play();
							break;
						case 2:
							VoicePlay.voiceBackFlip3.stop();
							VoicePlay.voiceBackFlip3.play();
							break;
						}
						backFlipJumpSprite();
						// タイルに接触している場合はフラグバルーン放したいをとぅるー！
					} else if (フラグタイル接触 == true && 状態フラグ復活中 == true
							&& フラグバルーン掴み == true && フラグバルーン放したい == false) {
						フラグバルーン放したい		= true;
						フラグバル放メッセージ		= true;
					}
					MusicPlay.bgmCastleTheme.setVolume(1.0f);
				} else if (ヨコ == 826 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.9f);
				} else if (ヨコ == 827 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.8f);
				} else if (ヨコ == 828 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.7f);
				} else if (ヨコ == 829 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.6f);
				} else if (ヨコ == 830 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.5f);
				} else if (ヨコ == 831 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.4f);
				} else if (ヨコ == 832 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.3f);
				} else if (ヨコ == 833 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.2f);
				} else if (ヨコ == 834 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.1f);
				} else if (ヨコ == 835 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0);
				}
			}
			// ボスが出現！
			if (ヨコ == 950 && メモリーカウンター == 3
					&& フラグボスキャラ出現 == false) {
				// ミュージックリソースの解放
				if (状態フラグ無敵 == false) {
					musicStop();
					getBaseActivity().getMusicManager().releaseAll();
				}
				フラグボスキャラ出現 = true;
				if (状態フラグ無敵 == false) {
					musicPlay();
				}
				bowsers.enemyBowserNormalLevel1 = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("enemy_21_bowser_normal_level_1.png", 1, 12);
				bowsers.enemyBowserNormalLevel1.setTag(
						Bowsers.TAG_ENEMY_41_BOWSER_NORMAL_LEVEL_1);
				bowsers.enemyBowserNormalLevel1.setPosition(640, 480);
				bowsers.enemyBowserNormalLevel1.animate(
						new long[] { aniスター, aniスター, aniスター, aniスター,
								aniスター, aniスター, aniスター, aniスター, }, 0, 7, true);
				attachChild(bowsers.enemyBowserNormalLevel1);
				bowsers.enemyBowserNormalLevel1.setZIndex(レイヤー08敵キャラ用);
				sortChildren();
				// エリアの移動処理
			} else if (ヨコ == 1000 && メモリーカウンター == 3
					&& ボスエリアかどうか == false) {
				if (状態フラグ無敵 == false) {
					musicStop();
					getBaseActivity().getMusicManager().releaseAll();
				}
				ボスエリアかどうか = true;
				if (状態フラグ無敵 == false) {
					musicPlay();
				}
				フラグボスキャラ生存 = true;
				// 四角形を描画
				final Rectangle フラッシュ四角形 = new Rectangle(0, 0, getBaseActivity().getEngine()
						.getCamera().getWidth(), getBaseActivity().getEngine()
						.getCamera().getHeight(), getBaseActivity()
						.getVertexBufferObjectManager());
				フラッシュ四角形.setColor(0.8f, 0.8f, 0.8f);
				attachChild(フラッシュ四角形);
				フラッシュ四角形.setZIndex(レイヤー16ポーズ用);
				sortChildren();
				フラッシュ四角形.registerEntityModifier(new FadeInModifier(0.2f));
				// 0.15秒ストップ！
				registerUpdateHandler(new TimerHandler(0.15f, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						フラッシュ四角形.registerEntityModifier(new FadeOutModifier(0.2f));
						bowsers.enemyBowserNormalLevel1.animate(
								new long[] { ani速, ani速, ani速, ani速, }, 8, 11, true);
						// 0.15秒ストップ！
						registerUpdateHandler(new TimerHandler(0.15f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								フラッシュ四角形.detachSelf();
							}
						}));
					}
				}));
				// ボスエリアのランダム処理
				int ボスエリア = (int)(Math.random() * 10);
				switch (ボスエリア) {
				case 0:
					ボスエリアカウンター = 1;
					break;
				case 1:
					ボスエリアカウンター = 2;
					break;
				case 2:
					ボスエリアカウンター = 3;
					break;
				case 3:
					ボスエリアカウンター = 4;
					break;
				case 4:
					ボスエリアカウンター = 5;
					break;
				case 5:
					ボスエリアカウンター = 6;
					break;
				case 6:
					ボスエリアカウンター = 7;
					break;
				case 7:
					ボスエリアカウンター = 8;
					break;
				case 8:
					ボスエリアカウンター = 9;
					break;
				case 9:
					ボスエリアカウンター = 10;
					break;
				}
				// ノーマルボス行動のランダム処理
				int ノーマルボス行動 = (int)(Math.random() * 10);
				switch (ノーマルボス行動) {
				case 0:
					ノーマルボス行動パターン = 1;
					break;
				case 1:
					ノーマルボス行動パターン = 2;
					break;
				case 2:
					ノーマルボス行動パターン = 3;
					break;
				case 3:
					ノーマルボス行動パターン = 4;
					break;
				case 4:
					ノーマルボス行動パターン = 5;
					break;
				case 5:
					ノーマルボス行動パターン = 6;
					break;
				case 6:
					ノーマルボス行動パターン = 7;
					break;
				case 7:
					ノーマルボス行動パターン = 8;
					break;
				case 8:
					ノーマルボス行動パターン = 9;
					break;
				case 9:
					ノーマルボス行動パターン = 10;
					break;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア0の読み込み（※リトライ時はここから読み込まれる！）
		} else if (コースカウンター == 12 && ボスエリアカウンター == 0 && ボスリトライ時かどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign00();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign00();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			if (ヨコ == 145 && メモリーカウンター == 3
					&& フラグボスキャラ出現 == false) {
				// ミュージックリソースの解放
				if (状態フラグ無敵 == false) {
					musicStop();
					getBaseActivity().getMusicManager().releaseAll();
				}
				フラグボスキャラ出現 = true;
				if (状態フラグ無敵 == false) {
					musicPlay();
				}
				bowsers.enemyBowserNormalLevel1 = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("enemy_21_bowser_normal_level_1.png", 1, 12);
				bowsers.enemyBowserNormalLevel1.setTag(
						Bowsers.TAG_ENEMY_41_BOWSER_NORMAL_LEVEL_1);
				bowsers.enemyBowserNormalLevel1.setPosition(640, 480);
				bowsers.enemyBowserNormalLevel1.animate(
						new long[] { aniスター, aniスター, aniスター, aniスター,
								aniスター, aniスター, aniスター, aniスター, }, 0, 7, true);
				attachChild(bowsers.enemyBowserNormalLevel1);
				bowsers.enemyBowserNormalLevel1.setZIndex(レイヤー08敵キャラ用);
				sortChildren();
				// エリアの移動処理
			} else if (ヨコ == 195 && メモリーカウンター == 3
					&& ボスエリアかどうか == false) {
				if (状態フラグ無敵 == false) {
					musicStop();
					getBaseActivity().getMusicManager().releaseAll();
				}
				ボスエリアかどうか = true;
				if (状態フラグ無敵 == false) {
					musicPlay();
				}
				フラグボスキャラ生存 = true;
				// 四角形を描画
				final Rectangle フラッシュ四角形 = new Rectangle(0, 0, getBaseActivity().getEngine()
						.getCamera().getWidth(), getBaseActivity().getEngine()
						.getCamera().getHeight(), getBaseActivity()
						.getVertexBufferObjectManager());
				フラッシュ四角形.setColor(0.8f, 0.8f, 0.8f);
				attachChild(フラッシュ四角形);
				フラッシュ四角形.setZIndex(レイヤー16ポーズ用);
				sortChildren();
				フラッシュ四角形.registerEntityModifier(new FadeInModifier(0.2f));
				// 0.15秒ストップ！
				registerUpdateHandler(new TimerHandler(0.15f, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						フラッシュ四角形.registerEntityModifier(new FadeOutModifier(0.2f));
						bowsers.enemyBowserNormalLevel1.animate(
								new long[] { ani速, ani速, ani速, ani速, }, 8, 11, true);
						// 0.15秒ストップ！
						registerUpdateHandler(new TimerHandler(0.15f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								フラッシュ四角形.detachSelf();
							}
						}));
					}
				}));
				// ボスエリアのランダム処理
				int ボスエリア = (int)(Math.random() * 10);
				switch (ボスエリア) {
				case 0:
					ボスエリアカウンター = 1;
					break;
				case 1:
					ボスエリアカウンター = 2;
					break;
				case 2:
					ボスエリアカウンター = 3;
					break;
				case 3:
					ボスエリアカウンター = 4;
					break;
				case 4:
					ボスエリアカウンター = 5;
					break;
				case 5:
					ボスエリアカウンター = 6;
					break;
				case 6:
					ボスエリアカウンター = 7;
					break;
				case 7:
					ボスエリアカウンター = 8;
					break;
				case 8:
					ボスエリアカウンター = 9;
					break;
				case 9:
					ボスエリアカウンター = 10;
					break;
				}
				// ノーマルボス行動のランダム処理
				int ノーマルボス行動 = (int)(Math.random() * 10);
				switch (ノーマルボス行動) {
				case 0:
					ノーマルボス行動パターン = 1;
					break;
				case 1:
					ノーマルボス行動パターン = 2;
					break;
				case 2:
					ノーマルボス行動パターン = 3;
					break;
				case 3:
					ノーマルボス行動パターン = 4;
					break;
				case 4:
					ノーマルボス行動パターン = 5;
					break;
				case 5:
					ノーマルボス行動パターン = 6;
					break;
				case 6:
					ノーマルボス行動パターン = 7;
					break;
				case 7:
					ノーマルボス行動パターン = 8;
					break;
				case 8:
					ノーマルボス行動パターン = 9;
					break;
				case 9:
					ノーマルボス行動パターン = 10;
					break;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ※↓ここから共通処理
			// ボスエリア1の読み込み
		} else if (コースカウンター == 12 && ボスエリアカウンター == 1 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign01();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign01();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 2;
						break;
					case 1:
						ボスエリアカウンター = 3;
						break;
					case 2:
						ボスエリアカウンター = 4;
						break;
					case 3:
						ボスエリアカウンター = 5;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア2の読み込み
		} else if (コースカウンター == 12 && ボスエリアカウンター == 2 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign02();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign02();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 3;
						break;
					case 2:
						ボスエリアカウンター = 4;
						break;
					case 3:
						ボスエリアカウンター = 5;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア3の読み込み
		} else if (コースカウンター == 12 && ボスエリアカウンター == 3 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign03();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign03();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 4;
						break;
					case 3:
						ボスエリアカウンター = 5;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア4の読み込み
		} else if (コースカウンター == 12 && ボスエリアカウンター == 4 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign04();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign04();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 5;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア5の読み込み
		} else if (コースカウンター == 12 && ボスエリアカウンター == 5 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign05();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign05();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア6の読み込み
		} else if (コースカウンター == 12 && ボスエリアカウンター == 6 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign06();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign06();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア7の読み込み
		} else if (コースカウンター == 12 && ボスエリアカウンター == 7 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign07();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign07();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 6;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア8の読み込み
		} else if (コースカウンター == 12 && ボスエリアカウンター == 8 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign08();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign08();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 6;
						break;
					case 6:
						ボスエリアカウンター = 7;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア9の読み込み
		} else if (コースカウンター == 12 && ボスエリアカウンター == 9 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign09();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign09();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 6;
						break;
					case 6:
						ボスエリアカウンター = 7;
						break;
					case 7:
						ボスエリアカウンター = 8;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア10の読み込み
		} else if (コースカウンター == 12 && ボスエリアカウンター == 10 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign10();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign10();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 6;
						break;
					case 6:
						ボスエリアカウンター = 7;
						break;
					case 7:
						ボスエリアカウンター = 8;
						break;
					case 8:
						ボスエリアカウンター = 9;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア31の読み込み
		} else if (コースカウンター == 12 && ボスエリアカウンター == 31 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign31();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign31();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				コースの端っこかどうか = true;
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						ゲームを終了したかどうか = true;
						// データ（全て）の保存
						dataSave();
						コースデータ.getInstance(getBaseActivity()).setコースデータ(13);
						// 1.25秒ストップ！
						registerUpdateHandler(new TimerHandler(1.25f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								// 再度、ゲーム画面の読み込み
								MainScene scene = new MainScene(getBaseActivity());
								getBaseActivity().refreshRunningScene(scene);
								// ミュージックリソースの解放
								getBaseActivity().getMusicManager().releaseAll();
							}
						}));
					}
				}));
			}
		}
	}
	// WORLD 4をインクリ
	public void world4Increment() {
		// 4-1の読み込み
		if (コースカウンター == 13) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign13();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign13();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ゴール後の処理
			if (ヨコ == 950 && メモリーカウンター == 3) {
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				現在の距離 = 0;
				現在のコンチニュー = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// ※↑ここまでコピペ
				if (状態フラグ無敵 == false) {
					musicStop();
				}
				コースカウンター = 14;
				ミュージック待機中かどうか = true;
				// キラー青フラグをオン！
				フラグキラー青色 = true;
				// データ（全て）の保存
				dataSave();
				コースデータ.getInstance(getBaseActivity()).setコースデータ(コースカウンター);
				// テキストの初期化
				textInit();
				// 同一背景なので変更はしない
				// テキストをふぃーどばっく！
				ワールドテキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				テキスト9.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				コーステキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
			}
			// 4-2の読み込み
		} else if (コースカウンター == 14) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign14();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign14();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ミュージックのリソースと切り替え
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ミュージック待機中かどうか = false;
				if (状態フラグ無敵 == false) {
					// ミュージックリソースの解放
					getBaseActivity().getMusicManager().releaseAll();
					musicPlay();
				}
			}
			// 一足先に溶岩を削除
			if (ヨコ == 735 && メモリーカウンター == 3) {
				溶岩1.registerEntityModifier(new FadeOutModifier(3));
				溶岩2.registerEntityModifier(new FadeOutModifier(3));
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						溶岩1.detachSelf();
						溶岩2.detachSelf();
					}
				}));
				// キラー青フラグをオフ！
			} else if (ヨコ == 1000 && メモリーカウンター == 3) {
				フラグキラー青色 = false;
				// ゴール後の処理
			} else if (ヨコ == 1050 && メモリーカウンター == 3) {
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				現在の距離 = 0;
				現在のコンチニュー = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// ※↑ここまでコピペ
				if (状態フラグ無敵 == false) {
					musicStop();
				}
				コースカウンター = 15;
				ミュージック待機中かどうか = true;
				// データ（全て）の保存
				dataSave();
				コースデータ.getInstance(getBaseActivity()).setコースデータ(コースカウンター);
				// テキストの初期化
				textInit();
				// 背景の初期化
				backInit();
				// 背景の削除処理
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						ワールド4.detachSelf();
						地上雲1.detachSelf();
						地上雲2.detachSelf();
					}
				}));
				// テキストをふぃーどばっく！
				ワールドテキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				テキスト9.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				コーステキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
			}
			// 4-3の読み込み
		} else if (コースカウンター == 15) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign15();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign15();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ミュージックのリソースと切り替え
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ミュージック待機中かどうか = false;
				if (状態フラグ無敵 == false) {
					// ミュージックリソースの解放
					getBaseActivity().getMusicManager().releaseAll();
					musicPlay();
				}
			}
			// ブロック背景の追加
			if (ヨコ == 550 && メモリーカウンター == 3) {
				出現フラグブロック背景1 = true;
				// ブロック
				ブロック背景1 = getBaseActivity().getResourceUtil()
						.getSprite("back_35_castle_block_1.png");
				ブロック背景1.setPosition(800, 0);
				attachChild(ブロック背景1);
				ブロック背景1.setZIndex(レイヤー02タイル用);
				sortChildren();
			} else if (ヨコ == 620 && メモリーカウンター == 3) {
				出現フラグブロック背景2 = true;
				// ブロック
				ブロック背景2 = getBaseActivity().getResourceUtil()
						.getSprite("back_36_castle_block_2.png");
				ブロック背景2.setPosition(800, 0);
				attachChild(ブロック背景2);
				ブロック背景2.setZIndex(レイヤー02タイル用);
				sortChildren();
			} else if (ヨコ == 660 && メモリーカウンター == 3) {
				出現フラグブロック背景3 = true;
				// ブロック
				ブロック背景3 = getBaseActivity().getResourceUtil()
						.getSprite("back_37_castle_block_3.png");
				ブロック背景3.setPosition(800, 0);
				attachChild(ブロック背景3);
				ブロック背景3.setZIndex(レイヤー02タイル用);
				sortChildren();
			} else if (ヨコ == 690 && メモリーカウンター == 3) {
				出現フラグブロック背景4 = true;
				// ブロック
				ブロック背景4 = getBaseActivity().getResourceUtil()
						.getSprite("back_38_castle_block_4.png");
				ブロック背景4.setPosition(800, 0);
				attachChild(ブロック背景4);
				ブロック背景4.setZIndex(レイヤー02タイル用);
				sortChildren();
			}
			// 入り口演出の追加
			if (ヨコ == 740 && メモリーカウンター == 3) {
				出現フラグワールド4お城入り口 = true;
				// 入り口
				ワールド4お城入り口 = getBaseActivity().getResourceUtil()
						.getSprite("back_29_castle_entrance_4.png");
				ワールド4お城入り口.setPosition(800, 0);
				attachChild(ワールド4お城入り口);
				ワールド4お城入り口.setZIndex(レイヤー01背景用);
				sortChildren();
				// 中間
				ワールド4お城中間 = getBaseActivity().getResourceUtil()
						.getSprite("back_30_castle_inside_4.png");
				ワールド4お城中間.setPosition(1120, 0);
				attachChild(ワールド4お城中間);
				ワールド4お城中間.setZIndex(レイヤー11特殊背景用);
				sortChildren();
				// ゴール後の処理
			} else if (ヨコ == 750 && メモリーカウンター == 3) {
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				現在の距離 = 0;
				現在のコンチニュー = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// ※↑ここまでコピペ
				if (状態フラグ無敵 == false) {
					musicStop();
				}
				コースカウンター = 16;
				ミュージック待機中かどうか = true;
				// データ（全て）の保存
				dataSave();
				コースデータ.getInstance(getBaseActivity()).setコースデータ(コースカウンター);
				// テキストの初期化
				textInit();
				// 同一テーマなので雲と溶岩のみ初期化
				アスレチック雲1.registerEntityModifier(new FadeOutModifier(3));
				アスレチック雲2.registerEntityModifier(new FadeOutModifier(3));
				溶岩1 = getBaseActivity().getResourceUtil()
						.getSprite("back_10_lava.png");
				溶岩1.setPosition(0, 0);
				attachChild(溶岩1);
				溶岩1.registerEntityModifier(new FadeInModifier(3));
				溶岩2 = getBaseActivity().getResourceUtil()
						.getSprite("back_10_lava.png");
				// 画面幅*2分右へ配置する
				溶岩2.setPosition(getBaseActivity().getEngine().getCamera()
						.getWidth() * 2, 0);
				attachChild(溶岩2);
				溶岩2.registerEntityModifier(new FadeInModifier(3));
				// 背景の削除処理
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						アスレチック雲1.detachSelf();
						アスレチック雲2.detachSelf();
						ブロック背景1.detachSelf();
						ブロック背景2.detachSelf();
						ブロック背景3.detachSelf();
						ブロック背景4.detachSelf();
					}
				}));
				// テキストをふぃーどばっく！
				ワールドテキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				テキスト9.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				コーステキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
			}
			// 4-4の読み込み
		} else if (コースカウンター == 16
				&& ボスエリアかどうか == false && ボスリトライ時かどうか == false) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 1200; ヨコ < タイル位置カウンター + 1201; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign16();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign16();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ミュージックのリソースと切り替え
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ミュージック待機中かどうか = false;
				if (状態フラグ無敵 == false) {
					// ミュージックリソースの解放
					getBaseActivity().getMusicManager().releaseAll();
					musicPlay();
				}
			}
			// 入り口演出の削除
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ワールド4お城入り口.registerEntityModifier(new FadeOutModifier(1.5f));
				ワールド4お城中間.registerEntityModifier(new FadeOutModifier(1.5f));
				// 1.5秒ストップ！
				registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						if (メモリーの開放をしたかどうか == false) {
							出現フラグワールド4お城入り口 = false;
							ワールド4お城入り口.detachSelf();
							ワールド4お城中間.detachSelf();
						}
					}
				}));
			}
			// ボス前まできたことを証明！
			if (ヨコ == 1200 && メモリーカウンター == 3) {
				ボス戦前データ.getInstance(getBaseActivity()).setボス戦前データ(4);
				// 変数の処理
				現在のコンチニュー = 0;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// データ（全て）の保存
				dataSave();
			}
			// ボス戦前の処理（※ノーリトライ時のみ！）
			if (イントロ中かどうか == true) {
				if (ヨコ == 1225 && メモリーカウンター == 3) {
					// タイルに接触していない場合の処理
					if (フラグタイル接触 == false && 状態フラグ復活中 == true
							&& フラグバルーン掴み == true) {
						フラグバルーン掴み		= false;
						フラグバル放メッセージ		= false;
						// ボイスのランダム処理
						int r = (int)(Math.random() * 3);
						switch (r) {
						case 0:
							VoicePlay.voiceBackFlip1.stop();
							VoicePlay.voiceBackFlip1.play();
							break;
						case 1:
							VoicePlay.voiceBackFlip2.stop();
							VoicePlay.voiceBackFlip2.play();
							break;
						case 2:
							VoicePlay.voiceBackFlip3.stop();
							VoicePlay.voiceBackFlip3.play();
							break;
						}
						backFlipJumpSprite();
						// タイルに接触している場合はフラグバルーン放したいをとぅるー！
					} else if (フラグタイル接触 == true && 状態フラグ復活中 == true
							&& フラグバルーン掴み == true && フラグバルーン放したい == false) {
						フラグバルーン放したい		= true;
						フラグバル放メッセージ		= true;
					}
					MusicPlay.bgmCastleIntroduction.setVolume(1.0f);
				} else if (ヨコ == 1226 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.9f);
				} else if (ヨコ == 1227 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.8f);
				} else if (ヨコ == 1228 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.7f);
				} else if (ヨコ == 1229 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.6f);
				} else if (ヨコ == 1230 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.5f);
				} else if (ヨコ == 1231 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.4f);
				} else if (ヨコ == 1232 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.3f);
				} else if (ヨコ == 1233 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.2f);
				} else if (ヨコ == 1234 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0.1f);
				} else if (ヨコ == 1235 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleIntroduction.setVolume(0);
				}
			} else if (イントロ中かどうか == false) {
				if (ヨコ == 1225 && メモリーカウンター == 3) {
					// タイルに接触していない場合の処理
					if (フラグタイル接触 == false && 状態フラグ復活中 == true
							&& フラグバルーン掴み == true) {
						フラグバルーン掴み		= false;
						フラグバル放メッセージ		= false;
						// ボイスのランダム処理
						int r = (int)(Math.random() * 3);
						switch (r) {
						case 0:
							VoicePlay.voiceBackFlip1.stop();
							VoicePlay.voiceBackFlip1.play();
							break;
						case 1:
							VoicePlay.voiceBackFlip2.stop();
							VoicePlay.voiceBackFlip2.play();
							break;
						case 2:
							VoicePlay.voiceBackFlip3.stop();
							VoicePlay.voiceBackFlip3.play();
							break;
						}
						backFlipJumpSprite();
						// タイルに接触している場合はフラグバルーン放したいをとぅるー！
					} else if (フラグタイル接触 == true && 状態フラグ復活中 == true
							&& フラグバルーン掴み == true && フラグバルーン放したい == false) {
						フラグバルーン放したい		= true;
						フラグバル放メッセージ		= true;
					}
					MusicPlay.bgmCastleTheme.setVolume(1.0f);
				} else if (ヨコ == 1226 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.9f);
				} else if (ヨコ == 1227 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.8f);
				} else if (ヨコ == 1228 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.7f);
				} else if (ヨコ == 1229 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.6f);
				} else if (ヨコ == 1230 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.5f);
				} else if (ヨコ == 1231 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.4f);
				} else if (ヨコ == 1232 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.3f);
				} else if (ヨコ == 1233 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.2f);
				} else if (ヨコ == 1234 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0.1f);
				} else if (ヨコ == 1235 && メモリーカウンター == 3) {
					MusicPlay.bgmCastleTheme.setVolume(0);
				}
			}
			// ボスが出現！
			if (ヨコ == 1350 && メモリーカウンター == 3
					&& フラグボスキャラ出現 == false) {
				// ミュージックリソースの解放
				if (状態フラグ無敵 == false) {
					musicStop();
					getBaseActivity().getMusicManager().releaseAll();
				}
				フラグボスキャラ出現 = true;
				if (状態フラグ無敵 == false) {
					musicPlay();
				}
				bowsers.enemyBowserNormalLevel1 = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("enemy_21_bowser_normal_level_1.png", 1, 12);
				bowsers.enemyBowserNormalLevel1.setTag(
						Bowsers.TAG_ENEMY_41_BOWSER_NORMAL_LEVEL_1);
				bowsers.enemyBowserNormalLevel1.setPosition(640, 480);
				bowsers.enemyBowserNormalLevel1.animate(
						new long[] { aniスター, aniスター, aniスター, aniスター,
								aniスター, aniスター, aniスター, aniスター, }, 0, 7, true);
				attachChild(bowsers.enemyBowserNormalLevel1);
				bowsers.enemyBowserNormalLevel1.setZIndex(レイヤー08敵キャラ用);
				sortChildren();
				// エリアの移動処理
			} else if (ヨコ == 1400 && メモリーカウンター == 3
					&& ボスエリアかどうか == false) {
				if (状態フラグ無敵 == false) {
					musicStop();
					getBaseActivity().getMusicManager().releaseAll();
				}
				ボスエリアかどうか = true;
				if (状態フラグ無敵 == false) {
					musicPlay();
				}
				フラグボスキャラ生存 = true;
				// 四角形を描画
				final Rectangle フラッシュ四角形 = new Rectangle(0, 0, getBaseActivity().getEngine()
						.getCamera().getWidth(), getBaseActivity().getEngine()
						.getCamera().getHeight(), getBaseActivity()
						.getVertexBufferObjectManager());
				フラッシュ四角形.setColor(0.8f, 0.8f, 0.8f);
				attachChild(フラッシュ四角形);
				フラッシュ四角形.setZIndex(レイヤー16ポーズ用);
				sortChildren();
				フラッシュ四角形.registerEntityModifier(new FadeInModifier(0.2f));
				// 0.15秒ストップ！
				registerUpdateHandler(new TimerHandler(0.15f, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						フラッシュ四角形.registerEntityModifier(new FadeOutModifier(0.2f));
						bowsers.enemyBowserNormalLevel1.animate(
								new long[] { ani速, ani速, ani速, ani速, }, 8, 11, true);
						// 0.15秒ストップ！
						registerUpdateHandler(new TimerHandler(0.15f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								フラッシュ四角形.detachSelf();
							}
						}));
					}
				}));
				// ボスエリアのランダム処理
				int ボスエリア = (int)(Math.random() * 10);
				switch (ボスエリア) {
				case 0:
					ボスエリアカウンター = 1;
					break;
				case 1:
					ボスエリアカウンター = 2;
					break;
				case 2:
					ボスエリアカウンター = 3;
					break;
				case 3:
					ボスエリアカウンター = 4;
					break;
				case 4:
					ボスエリアカウンター = 5;
					break;
				case 5:
					ボスエリアカウンター = 6;
					break;
				case 6:
					ボスエリアカウンター = 7;
					break;
				case 7:
					ボスエリアカウンター = 8;
					break;
				case 8:
					ボスエリアカウンター = 9;
					break;
				case 9:
					ボスエリアカウンター = 10;
					break;
				}
				// ノーマルボス行動のランダム処理
				int ノーマルボス行動 = (int)(Math.random() * 10);
				switch (ノーマルボス行動) {
				case 0:
					ノーマルボス行動パターン = 1;
					break;
				case 1:
					ノーマルボス行動パターン = 2;
					break;
				case 2:
					ノーマルボス行動パターン = 3;
					break;
				case 3:
					ノーマルボス行動パターン = 4;
					break;
				case 4:
					ノーマルボス行動パターン = 5;
					break;
				case 5:
					ノーマルボス行動パターン = 6;
					break;
				case 6:
					ノーマルボス行動パターン = 7;
					break;
				case 7:
					ノーマルボス行動パターン = 8;
					break;
				case 8:
					ノーマルボス行動パターン = 9;
					break;
				case 9:
					ノーマルボス行動パターン = 10;
					break;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア0の読み込み（※リトライ時はここから読み込まれる！）
		} else if (コースカウンター == 16 && ボスエリアカウンター == 0 && ボスリトライ時かどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign00();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign00();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			if (ヨコ == 145 && メモリーカウンター == 3
					&& フラグボスキャラ出現 == false) {
				// ミュージックリソースの解放
				if (状態フラグ無敵 == false) {
					musicStop();
					getBaseActivity().getMusicManager().releaseAll();
				}
				フラグボスキャラ出現 = true;
				if (状態フラグ無敵 == false) {
					musicPlay();
				}
				bowsers.enemyBowserNormalLevel1 = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("enemy_21_bowser_normal_level_1.png", 1, 12);
				bowsers.enemyBowserNormalLevel1.setTag(
						Bowsers.TAG_ENEMY_41_BOWSER_NORMAL_LEVEL_1);
				bowsers.enemyBowserNormalLevel1.setPosition(640, 480);
				bowsers.enemyBowserNormalLevel1.animate(
						new long[] { aniスター, aniスター, aniスター, aniスター,
								aniスター, aniスター, aniスター, aniスター, }, 0, 7, true);
				attachChild(bowsers.enemyBowserNormalLevel1);
				bowsers.enemyBowserNormalLevel1.setZIndex(レイヤー08敵キャラ用);
				sortChildren();
				// エリアの移動処理
			} else if (ヨコ == 195 && メモリーカウンター == 3
					&& ボスエリアかどうか == false) {
				if (状態フラグ無敵 == false) {
					musicStop();
					getBaseActivity().getMusicManager().releaseAll();
				}
				ボスエリアかどうか = true;
				if (状態フラグ無敵 == false) {
					musicPlay();
				}
				フラグボスキャラ生存 = true;
				// 四角形を描画
				final Rectangle フラッシュ四角形 = new Rectangle(0, 0, getBaseActivity().getEngine()
						.getCamera().getWidth(), getBaseActivity().getEngine()
						.getCamera().getHeight(), getBaseActivity()
						.getVertexBufferObjectManager());
				フラッシュ四角形.setColor(0.8f, 0.8f, 0.8f);
				attachChild(フラッシュ四角形);
				フラッシュ四角形.setZIndex(レイヤー16ポーズ用);
				sortChildren();
				フラッシュ四角形.registerEntityModifier(new FadeInModifier(0.2f));
				// 0.15秒ストップ！
				registerUpdateHandler(new TimerHandler(0.15f, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						フラッシュ四角形.registerEntityModifier(new FadeOutModifier(0.2f));
						bowsers.enemyBowserNormalLevel1.animate(
								new long[] { ani速, ani速, ani速, ani速, }, 8, 11, true);
						// 0.15秒ストップ！
						registerUpdateHandler(new TimerHandler(0.15f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								フラッシュ四角形.detachSelf();
							}
						}));
					}
				}));
				// ボスエリアのランダム処理
				int ボスエリア = (int)(Math.random() * 10);
				switch (ボスエリア) {
				case 0:
					ボスエリアカウンター = 1;
					break;
				case 1:
					ボスエリアカウンター = 2;
					break;
				case 2:
					ボスエリアカウンター = 3;
					break;
				case 3:
					ボスエリアカウンター = 4;
					break;
				case 4:
					ボスエリアカウンター = 5;
					break;
				case 5:
					ボスエリアカウンター = 6;
					break;
				case 6:
					ボスエリアカウンター = 7;
					break;
				case 7:
					ボスエリアカウンター = 8;
					break;
				case 8:
					ボスエリアカウンター = 9;
					break;
				case 9:
					ボスエリアカウンター = 10;
					break;
				}
				// ノーマルボス行動のランダム処理
				int ノーマルボス行動 = (int)(Math.random() * 10);
				switch (ノーマルボス行動) {
				case 0:
					ノーマルボス行動パターン = 1;
					break;
				case 1:
					ノーマルボス行動パターン = 2;
					break;
				case 2:
					ノーマルボス行動パターン = 3;
					break;
				case 3:
					ノーマルボス行動パターン = 4;
					break;
				case 4:
					ノーマルボス行動パターン = 5;
					break;
				case 5:
					ノーマルボス行動パターン = 6;
					break;
				case 6:
					ノーマルボス行動パターン = 7;
					break;
				case 7:
					ノーマルボス行動パターン = 8;
					break;
				case 8:
					ノーマルボス行動パターン = 9;
					break;
				case 9:
					ノーマルボス行動パターン = 10;
					break;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ※↓ここから共通処理
			// ボスエリア1の読み込み
		} else if (コースカウンター == 16 && ボスエリアカウンター == 1 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign01();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign01();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 2;
						break;
					case 1:
						ボスエリアカウンター = 3;
						break;
					case 2:
						ボスエリアカウンター = 4;
						break;
					case 3:
						ボスエリアカウンター = 5;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア2の読み込み
		} else if (コースカウンター == 16 && ボスエリアカウンター == 2 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign02();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign02();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 3;
						break;
					case 2:
						ボスエリアカウンター = 4;
						break;
					case 3:
						ボスエリアカウンター = 5;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア3の読み込み
		} else if (コースカウンター == 16 && ボスエリアカウンター == 3 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign03();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign03();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 4;
						break;
					case 3:
						ボスエリアカウンター = 5;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア4の読み込み
		} else if (コースカウンター == 16 && ボスエリアカウンター == 4 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign04();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign04();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 5;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア5の読み込み
		} else if (コースカウンター == 16 && ボスエリアカウンター == 5 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign05();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign05();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 6;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア6の読み込み
		} else if (コースカウンター == 16 && ボスエリアカウンター == 6 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign06();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign06();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 7;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア7の読み込み
		} else if (コースカウンター == 16 && ボスエリアカウンター == 7 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign07();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign07();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 6;
						break;
					case 6:
						ボスエリアカウンター = 8;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア8の読み込み
		} else if (コースカウンター == 16 && ボスエリアカウンター == 8 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign08();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign08();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 6;
						break;
					case 6:
						ボスエリアカウンター = 7;
						break;
					case 7:
						ボスエリアカウンター = 9;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア9の読み込み
		} else if (コースカウンター == 16 && ボスエリアカウンター == 9 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign09();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign09();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 6;
						break;
					case 6:
						ボスエリアカウンター = 7;
						break;
					case 7:
						ボスエリアカウンター = 8;
						break;
					case 8:
						ボスエリアカウンター = 10;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア10の読み込み
		} else if (コースカウンター == 16 && ボスエリアカウンター == 10 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign10();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign10();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				// ボスエリアのランダム処理
				if (フラグボスキャラ生存 == true) {
					int r = (int)(Math.random() * 9);
					switch (r) {
					case 0:
						ボスエリアカウンター = 1;
						break;
					case 1:
						ボスエリアカウンター = 2;
						break;
					case 2:
						ボスエリアカウンター = 3;
						break;
					case 3:
						ボスエリアカウンター = 4;
						break;
					case 4:
						ボスエリアカウンター = 5;
						break;
					case 5:
						ボスエリアカウンター = 6;
						break;
					case 6:
						ボスエリアカウンター = 7;
						break;
					case 7:
						ボスエリアカウンター = 8;
						break;
					case 8:
						ボスエリアカウンター = 9;
						break;
					}
				} else {
					ボスエリアカウンター = 31;
				}
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ※↑ここまでコピペ
			}
			// ボスエリア31の読み込み
		} else if (コースカウンター == 16 && ボスエリアカウンター == 31 && ボスエリアかどうか == true) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign31();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							bossCourseDataAssign31();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// エリアの移動処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				コースの端っこかどうか = true;
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						ゲームを終了したかどうか = true;
						// スコア（全て）の保存
						scoreSave();
						// データ（全て）の保存
						dataSave();
						// ゲームクリアしたことを証明
						ゲームクリアデータ.getInstance(getBaseActivity()).setゲームクリアデータ(1);
						// ここで、中断データもデクリ
						中断セーブデータ.getInstance(getBaseActivity()).set中断セーブデータ(0);
						// すべての宝物を集めた場合のみ隠しワールドへ。そうでない場合はスタッフクレジット
						コースデータ.getInstance(getBaseActivity()).setコースデータ(22);
						// 1.25秒ストップ！
						registerUpdateHandler(new TimerHandler(1.25f, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								// 再度、ゲーム画面の読み込み
								MainScene scene = new MainScene(getBaseActivity());
								getBaseActivity().refreshRunningScene(scene);
								// ミュージックリソースの解放
								getBaseActivity().getMusicManager().releaseAll();
							}
						}));
					}
				}));
			}
		}
	}
	// WORLD Sをインクリ
	public void worldSIncrement() {
		// S-1の読み込み
		if (コースカウンター == 17) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign17();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign17();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ゴール後の処理
			if (ヨコ == 1050 && メモリーカウンター == 3) {
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				現在の距離 = 0;
				現在のコンチニュー = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// ※↑ここまでコピペ
				if (状態フラグ無敵 == false) {
					musicStop();
				}
				コースカウンター = 18;
				ミュージック待機中かどうか = true;
				// データ（全て）の保存
				dataSave();
				コースデータ.getInstance(getBaseActivity()).setコースデータ(コースカウンター);
				// テキストの初期化
				textInit();
				// 背景の初期化
				backInit();
				// 背景の削除処理
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						ワールド1.detachSelf();
						アスレチック雲1.detachSelf();
						アスレチック雲2.detachSelf();
						水1.detachSelf();
						水2.detachSelf();
					}
				}));
				// テキストをふぃーどばっく！
				ワールドテキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				テキスト9.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				コーステキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
			}
			// S-2の読み込み
		} else if (コースカウンター == 18) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign18();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign18();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ミュージックのリソースと切り替え
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ミュージック待機中かどうか = false;
				if (状態フラグ無敵 == false) {
					// ミュージックリソースの解放
					getBaseActivity().getMusicManager().releaseAll();
					musicPlay();
				}
			}
			// ゴール後の処理
			if (ヨコ == 750 && メモリーカウンター == 3) {
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				現在の距離 = 0;
				現在のコンチニュー = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// ※↑ここまでコピペ
				if (状態フラグ無敵 == false) {
					musicStop();
				}
				コースカウンター = 19;
				ミュージック待機中かどうか = true;
				// データ（全て）の保存
				dataSave();
				コースデータ.getInstance(getBaseActivity()).setコースデータ(コースカウンター);
				// テキストの初期化
				textInit();
				// 背景の初期化
				backInit();
				// 背景の削除処理
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						ワールド2.detachSelf();
						地上雲1.detachSelf();
						地上雲2.detachSelf();
					}
				}));
				// テキストをふぃーどばっく！
				ワールドテキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				テキスト9.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				コーステキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
			}
			// S-3の読み込み
		} else if (コースカウンター == 19) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign19();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign19();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ミュージックのリソースと切り替え
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ミュージック待機中かどうか = false;
				if (状態フラグ無敵 == false) {
					// ミュージックリソースの解放
					getBaseActivity().getMusicManager().releaseAll();
					musicPlay();
				}
			}
			// ゴール後の処理
			if (ヨコ == 950 && メモリーカウンター == 3) {
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				現在の距離 = 0;
				現在のコンチニュー = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// ※↑ここまでコピペ
				if (状態フラグ無敵 == false) {
					musicStop();
				}
				コースカウンター = 20;
				ミュージック待機中かどうか = true;
				// データ（全て）の保存
				dataSave();
				コースデータ.getInstance(getBaseActivity()).setコースデータ(コースカウンター);
				// テキストの初期化
				textInit();
				// 背景の初期化
				backInit();
				// 背景の削除処理
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						ワールド3.detachSelf();
						水1.detachSelf();
						水2.detachSelf();
					}
				}));
				// テキストをふぃーどばっく！
				ワールドテキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				テキスト9.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				コーステキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
			}
			// S-4の読み込み
		} else if (コースカウンター == 20) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 50; ヨコ < タイル位置カウンター + 51; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign20();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign20();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ミュージックのリソースと切り替え
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ミュージック待機中かどうか = false;
				if (状態フラグ無敵 == false) {
					// ミュージックリソースの解放
					getBaseActivity().getMusicManager().releaseAll();
					musicPlay();
				}
			}
			// ゴール後の処理
			if (ヨコ == 100 && メモリーカウンター == 3) {
				タテ = 0;
				ヨコ = 0;
				現在の距離 = 0;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
			}
//			// ゴール後の処理
//			if (ヨコ == 1250 && メモリーカウンター == 3) {
//				// ※↓ここからコピペ
//				// 変数の処理
//				タテ = 0;
//				ヨコ = 0;
//				現在の距離 = 0;
//				現在のコンチニュー = 0;
//				ここからスタートかどうか = false;
//				// ※0にするとなぜか読み込まない
//				タイル位置カウンター = -1;
//				タイル位置バックアップ = -1;
//				// ミスカウンターを0に
//				連続ミスカウンター = 0;
//				// ※↑ここまでコピペ
//				if (状態フラグ無敵 == false) {
//					musicStop();
//				}
//				コースカウンター = 21;
//				ミュージック待機中かどうか = true;
//				// データ（全て）の保存
//				dataSave();
//				コースデータ.getInstance(getBaseActivity()).setコースデータ(コースカウンター);
//				// テキストの初期化
//				textInit();
//				// 背景の初期化
//				backInit();
//				// 背景の削除処理
//				// 3秒ストップ！
//				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
//					public void onTimePassed(TimerHandler pTimeHandler) {
//						ワールド4.detachSelf();
//						アスレチック雲1.detachSelf();
//						アスレチック雲2.detachSelf();
//						溶岩1.detachSelf();
//						溶岩2.detachSelf();
//					}
//				}));
//				// テキストをふぃーどばっく！
//				ワールドテキスト常時.registerEntityModifier(
//						new LoopEntityModifier(new SequenceEntityModifier(
//								new ScaleModifier(0.25f, 1.0f, 1.5f),
//								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
//				テキスト9.registerEntityModifier(
//						new LoopEntityModifier(new SequenceEntityModifier(
//								new ScaleModifier(0.25f, 1.0f, 1.5f),
//								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
//				コーステキスト常時.registerEntityModifier(
//						new LoopEntityModifier(new SequenceEntityModifier(
//								new ScaleModifier(0.25f, 1.0f, 1.5f),
//								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
//			}
			// S-Sの読み込み
		} else if (コースカウンター == 21) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign21();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign21();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ミュージックのリソースと切り替え
			if (ヨコ == 20 && メモリーカウンター == 3) {
				ミュージック待機中かどうか = false;
				if (状態フラグ無敵 == false) {
					// ミュージックリソースの解放
					getBaseActivity().getMusicManager().releaseAll();
					musicPlay();
				}
			}
			// ゴール後の処理
			if (ヨコ == 750 && メモリーカウンター == 3) {
				// ※↓ここからコピペ
				// 変数の処理
				タテ = 0;
				ヨコ = 0;
				現在の距離 = 0;
				現在のコンチニュー = 0;
				ここからスタートかどうか = false;
				// ※0にするとなぜか読み込まない
				タイル位置カウンター = -1;
				タイル位置バックアップ = -1;
				// ミスカウンターを0に
				連続ミスカウンター = 0;
				// ※↑ここまでコピペ
				if (状態フラグ無敵 == false) {
					musicStop();
				}
				コースカウンター = 22;
				ミュージック待機中かどうか = true;
				// データ（全て）の保存
				dataSave();
				コースデータ.getInstance(getBaseActivity()).setコースデータ(コースカウンター);
				// テキストの初期化
				textInit();
				// 同一背景なので変更はしない
				// テキストをふぃーどばっく！
				ワールドテキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				テキスト9.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
				コーステキスト常時.registerEntityModifier(
						new LoopEntityModifier(new SequenceEntityModifier(
								new ScaleModifier(0.25f, 1.0f, 1.5f),
								new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
			}
			// S-Rの読み込み
		} else if (コースカウンター == 22) {
			// コースを読み込む前に、すでにタイルが読み込まれていないか確認する
			if (タイル位置カウンター != タイル位置バックアップ) {
				// コースデータ上下の読み込み。（スクロール時）
				for (タテ = 0; タテ < 15; タテ++) {
					// コースデータ左右の読み込み。（※途中からデバッグしたい場合、ここの数値をいじればよい）
					if (ここからスタートかどうか == true) {
						for (ヨコ = タイル位置カウンター + 25; ヨコ < タイル位置カウンター + 26; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign22();
						}
					} else {
						for (ヨコ = タイル位置カウンター + 0; ヨコ < タイル位置カウンター + 1; ヨコ++) {
							// スプライトの割り振り
							normalCourseDataAssign22();
						}
					}
				}
				// 現在のタイルの位置を代入
				タイル位置バックアップ = タイル位置カウンター;
			}
			// ゴール後の処理
			if (ヨコ == 1100 && メモリーカウンター == 3) {
				コースの端っこかどうか = true;
			}
		}
	}
	
	// ===========================================================
	// ハンドラー系
	// ===========================================================
	
	public TimerHandler スタート時レート
	= new TimerHandler(1f / 30f, true, new ITimerCallback() {
		public void onTimePassed(TimerHandler pTimerHandler) {
			// スタッフクレジットじゃないときの処理
			if (コースカウンター != 22) {
				// マリオの移動
				if (プレイヤーのダッシュフラグ == false) {
					if (グラチェンジフラグ == false) {
						marioSets.playerMarioSet1.setY(
								marioSets.playerMarioSet1.getY() - 待機ジャンプの上昇移動値);
					} else {
						marioSets.playerMarioSet2.setY(
								marioSets.playerMarioSet2.getY() - 待機ジャンプの上昇移動値);
					}
					待機ジャンプの上昇移動値 *= 0.924f;
					// マリオを下へ
					if (待機ジャンプの上昇移動値 >= 0) {
						if (グラチェンジフラグ == false) {
							marioSets.playerMarioSet1.setY(
									marioSets.playerMarioSet1.getY() + 待機ジャンプの下降移動値);
						} else {
							marioSets.playerMarioSet2.setY(
									marioSets.playerMarioSet2.getY() + 待機ジャンプの下降移動値);
						}
						待機ジャンプの下降移動値 *= 1.086f;
						if (待機ジャンプの下降移動値 >= 14.4f) {
							待機ジャンプの下降移動値 = 14.4f;
						}
						// フラグ位置を高さにあわせて変更
						// ボス戦前は強制レベ1
						if (ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 1 && コースカウンター == 4
								|| ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 2 && コースカウンター == 8
								|| ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 3 && コースカウンター == 12
								|| ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 4 && コースカウンター == 16) {
							// 高さが一定の位置に着たらライン変更
							if (グラチェンジフラグ == false) {
								if (marioSets.playerMarioSet1.getY() <= 288) {
									プレイヤーの下降移動フラグ = true;
								}
							} else {
								if (marioSets.playerMarioSet2.getY() <= 288) {
									プレイヤーの下降移動フラグ = true;
								}
							}
							// 高さレベル1
						} else if (コースカウンター == 1 || コースカウンター == 2
								|| コースカウンター == 3 || コースカウンター == 5
								|| コースカウンター == 6 || コースカウンター == 7
								|| コースカウンター == 16 || コースカウンター == 21
								|| コースカウンター == 22 || コースカウンター == 0
								) {
							// 高さが一定の位置に着たらライン変更
							if (グラチェンジフラグ == false) {
								if (marioSets.playerMarioSet1.getY() <= 288) {
									プレイヤーの下降移動フラグ = true;
								}
							} else {
								if (marioSets.playerMarioSet2.getY() <= 288) {
									プレイヤーの下降移動フラグ = true;
								}
							}
							// 高さレベル2
						} else if (コースカウンター == 8 || コースカウンター == 9
								|| コースカウンター == 12 || コースカウンター == 14
								|| コースカウンター == 18
								) {
							// 高さが一定の位置に着たらライン変更
							if (グラチェンジフラグ == false) {
								if (marioSets.playerMarioSet1.getY() <= 224) {
									プレイヤーの下降移動フラグ = true;
								}
							} else {
								if (marioSets.playerMarioSet2.getY() <= 224) {
									プレイヤーの下降移動フラグ = true;
								}
							}
							// 高さレベル3
						} else if (コースカウンター == 10 || コースカウンター == 11
								|| コースカウンター == 13 || コースカウンター == 15
								|| コースカウンター == 20
								) {
							// 高さが一定の位置に着たらライン変更
							if (グラチェンジフラグ == false) {
								if (marioSets.playerMarioSet1.getY() <= 160) {
									プレイヤーの下降移動フラグ = true;
								}
							} else {
								if (marioSets.playerMarioSet2.getY() <= 160) {
									プレイヤーの下降移動フラグ = true;
								}
							}
							// 高さレベル4
						} else if (コースカウンター == 4 || コースカウンター == 17
								) {
							// 高さが一定の位置に着たらライン変更
							if (グラチェンジフラグ == false) {
								if (marioSets.playerMarioSet1.getY() <= 96) {
									プレイヤーの下降移動フラグ = true;
								}
							} else {
								if (marioSets.playerMarioSet2.getY() <= 96) {
									プレイヤーの下降移動フラグ = true;
								}
							}
							// 高さレベル5
						} else if (コースカウンター == 19
								) {
							// 高さが一定の位置に着たらライン変更
							if (グラチェンジフラグ == false) {
								if (marioSets.playerMarioSet1.getY() <= 32) {
									プレイヤーの下降移動フラグ = true;
								}
							} else {
								if (marioSets.playerMarioSet2.getY() <= 32) {
									プレイヤーの下降移動フラグ = true;
								}
							}
						}
						// ストップ位置を高さにあわせて変更
						// ボス戦前は強制レベ1
						if (ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 1 && コースカウンター == 4
								|| ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 2 && コースカウンター == 8
								|| ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 3 && コースカウンター == 12
								|| ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 4 && コースカウンター == 16) {
							// ラインが地面に触れたらダッシュ！
							if (contactLines.playerContactLineBelow.getY() >= 384
									&& プレイヤーの下降移動フラグ == true) {
								// ダッシュ時のグラ
								playerDashAnimation();
								プレイヤーのダッシュフラグ = true;
							}
							// 高さレベル1
						} else if (コースカウンター == 1 || コースカウンター == 2
								|| コースカウンター == 3 || コースカウンター == 5
								|| コースカウンター == 6 || コースカウンター == 7
								|| コースカウンター == 16 || コースカウンター == 21
								|| コースカウンター == 22 || コースカウンター == 0
								) {
							// ラインが地面に触れたらダッシュ！
							if (contactLines.playerContactLineBelow.getY() >= 384
									&& プレイヤーの下降移動フラグ == true) {
								// ダッシュ時のグラ
								playerDashAnimation();
								プレイヤーのダッシュフラグ = true;
							}
							// 高さレベル2
						} else if (コースカウンター == 8 || コースカウンター == 9
								|| コースカウンター == 12 || コースカウンター == 14
								|| コースカウンター == 18
								) {
							// ラインが地面に触れたらダッシュ！
							if (contactLines.playerContactLineBelow.getY() >= 320
									&& プレイヤーの下降移動フラグ == true) {
								// ダッシュ時のグラ
								playerDashAnimation();
								プレイヤーのダッシュフラグ = true;
							}
							// 高さレベル3
						} else if (コースカウンター == 10 || コースカウンター == 11
								|| コースカウンター == 13 || コースカウンター == 15
								|| コースカウンター == 20
								) {
							// ラインが地面に触れたらダッシュ！
							if (contactLines.playerContactLineBelow.getY() >= 256
									&& プレイヤーの下降移動フラグ == true) {
								// ダッシュ時のグラ
								playerDashAnimation();
								プレイヤーのダッシュフラグ = true;
							}
							// 高さレベル4
						} else if (コースカウンター == 4 || コースカウンター == 17
								) {
							// ラインが地面に触れたらダッシュ！
							if (contactLines.playerContactLineBelow.getY() >= 192
									&& プレイヤーの下降移動フラグ == true) {
								// ダッシュ時のグラ
								playerDashAnimation();
								プレイヤーのダッシュフラグ = true;
							}
							// 高さレベル5
						} else if (コースカウンター == 19
								) {
							// ラインが地面に触れたらダッシュ！
							if (contactLines.playerContactLineBelow.getY() >= 128
									&& プレイヤーの下降移動フラグ == true) {
								// ダッシュ時のグラ
								playerDashAnimation();
								プレイヤーのダッシュフラグ = true;
							}
						}
					}
				} else {
					// ヘルプ画面（ジャンプ）
					// ハイスコアが0以下の時のみヘルプ画面を出す
					if (SPUtil.getInstance(getBaseActivity()).getHighScore() >= 0) {
						if (ゲーム待機中かどうか == true) {
							
							
							
						} else {
							// 1秒間に30回、フレームレートを呼び出し
							registerUpdateHandler(フレームレート);
							// 3秒毎にキラー出現時間を呼び出し
							registerUpdateHandler(キラー出現レート);
							// Sceneのタッチリスナーを登録
							setOnSceneTouchListener(MainScene.this);
						}
					} else {
						manualView();
					}
					// ダッシュ位置を高さにあわせて変更
					// ボス戦前は強制レベ1
					if (ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 1 && コースカウンター == 4
							|| ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 2 && コースカウンター == 8
							|| ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 3 && コースカウンター == 12
							|| ボス戦前データ.getInstance(getBaseActivity()).getボス戦前データ() == 4 && コースカウンター == 16) {
						if (グラチェンジフラグ == false) {
							marioSets.playerMarioSet1.setPosition(
									marioSets.playerMarioSet1.getX() + 8,
									352);
						} else {
							marioSets.playerMarioSet2.setPosition(
									marioSets.playerMarioSet2.getX() + 8,
									352);
						}
						// 高さレベル1
					} else if (コースカウンター == 1 || コースカウンター == 2
							|| コースカウンター == 3 || コースカウンター == 5
							|| コースカウンター == 6 || コースカウンター == 7
							|| コースカウンター == 16 || コースカウンター == 21
							|| コースカウンター == 22 || コースカウンター == 0
							) {
						if (グラチェンジフラグ == false) {
							marioSets.playerMarioSet1.setPosition(
									marioSets.playerMarioSet1.getX() + 8,
									352);
						} else {
							marioSets.playerMarioSet2.setPosition(
									marioSets.playerMarioSet2.getX() + 8,
									352);
						}
						// 高さレベル2
					} else if (コースカウンター == 8 || コースカウンター == 9
							|| コースカウンター == 12 || コースカウンター == 14
							|| コースカウンター == 18
							) {
						if (グラチェンジフラグ == false) {
							marioSets.playerMarioSet1.setPosition(
									marioSets.playerMarioSet1.getX() + 8,
									288);
						} else {
							marioSets.playerMarioSet2.setPosition(
									marioSets.playerMarioSet2.getX() + 8,
									288);
						}
						// 高さレベル3
					} else if (コースカウンター == 10 || コースカウンター == 11
							|| コースカウンター == 13 || コースカウンター == 15
							|| コースカウンター == 20
							) {
						if (グラチェンジフラグ == false) {
							marioSets.playerMarioSet1.setPosition(
									marioSets.playerMarioSet1.getX() + 8,
									224);
						} else {
							marioSets.playerMarioSet2.setPosition(
									marioSets.playerMarioSet2.getX() + 8,
									224);
						}
						// 高さレベル4
					} else if (コースカウンター == 4 || コースカウンター == 17
							) {
						if (グラチェンジフラグ == false) {
							marioSets.playerMarioSet1.setPosition(
									marioSets.playerMarioSet1.getX() + 8,
									160);
						} else {
							marioSets.playerMarioSet2.setPosition(
									marioSets.playerMarioSet2.getX() + 8,
									160);
						}
						// 高さレベル5
					} else if (コースカウンター == 19
							) {
						if (グラチェンジフラグ == false) {
							marioSets.playerMarioSet1.setPosition(
									marioSets.playerMarioSet1.getX() + 8,
									96);
						} else {
							marioSets.playerMarioSet2.setPosition(
									marioSets.playerMarioSet2.getX() + 8,
									96);
						}
					}
					// ゲームスタート！
					if (グラチェンジフラグ == false) {
						if (marioSets.playerMarioSet1.getX() >= 160) {
							musicPlay();
							ゲーム待機中かどうか = false;
							待機ジャンプの上昇移動値 = 48;
							待機ジャンプの下降移動値 = 9.6f;
							// スタート時レートをストップ！
							unregisterUpdateHandler(スタート時レート);
							// 1秒間に30回、フレームレートを呼び出し
							registerUpdateHandler(フレームレート);
							// 3秒毎にキラー出現時間を呼び出し
							registerUpdateHandler(キラー出現レート);
							// Sceneのタッチリスナーを登録
							setOnSceneTouchListener(MainScene.this);
						}
					} else {
						if (marioSets.playerMarioSet2.getX() >= 160) {
							musicPlay();
							ゲーム待機中かどうか = false;
							待機ジャンプの上昇移動値 = 48;
							待機ジャンプの下降移動値 = 9.6f;
							// スタート時レートをストップ！
							unregisterUpdateHandler(スタート時レート);
							// 1秒間に30回、フレームレートを呼び出し
							registerUpdateHandler(フレームレート);
							// 3秒毎にキラー出現時間を呼び出し
							registerUpdateHandler(キラー出現レート);
							// Sceneのタッチリスナーを登録
							setOnSceneTouchListener(MainScene.this);
						}
					}
				}
				// スタッフクレジット時の処理
			} else {
				if (グラチェンジフラグ == false) {
					marioSets.playerMarioSet1.setPosition(
							marioSets.playerMarioSet1.getX() + 8,
							352);
				} else {
					marioSets.playerMarioSet2.setPosition(
							marioSets.playerMarioSet2.getX() + 8,
							352);
				}
				// スタッフクレジットスタート！
				if (グラチェンジフラグ == false) {
					if (marioSets.playerMarioSet1.getX() >= 160) {
						musicPlay();
						ゲーム待機中かどうか = false;
						待機ジャンプの上昇移動値 = 48;
						待機ジャンプの下降移動値 = 9.6f;
						// スタート時レートをストップ！
						unregisterUpdateHandler(スタート時レート);
						// 1秒間に30回、フレームレートを呼び出し
						registerUpdateHandler(フレームレート);
						// 3秒毎にキラー出現時間を呼び出し
						registerUpdateHandler(キラー出現レート);
						// Sceneのタッチリスナーを登録
						setOnSceneTouchListener(MainScene.this);
					}
				} else {
					if (marioSets.playerMarioSet2.getX() >= 160) {
						musicPlay();
						ゲーム待機中かどうか = false;
						待機ジャンプの上昇移動値 = 48;
						待機ジャンプの下降移動値 = 9.6f;
						// スタート時レートをストップ！
						unregisterUpdateHandler(スタート時レート);
						// 1秒間に30回、フレームレートを呼び出し
						registerUpdateHandler(フレームレート);
						// 3秒毎にキラー出現時間を呼び出し
						registerUpdateHandler(キラー出現レート);
						// Sceneのタッチリスナーを登録
						setOnSceneTouchListener(MainScene.this);
					}
				}
			}
			// 当たり判定をインクリ
			if (グラチェンジフラグ == false) {
				// 上の当たり判定をインクリ
				contactLines.playerContactLineAbove.setPosition(
						marioSets.playerMarioSet1.getX() + 0,
						marioSets.playerMarioSet1.getY() + 0);
				// 下の当たり判定をインクリ
				contactLines.playerContactLineBelow.setPosition(
						marioSets.playerMarioSet1.getX() + 0,
						marioSets.playerMarioSet1.getY() + 64);
				// 中の当たり判定（1つ目）をインクリ
				contactLines.playerContactLineCenter1.setPosition(
						marioSets.playerMarioSet1.getX() + 16,
						marioSets.playerMarioSet1.getY() + 24);
				// 中の当たり判定（2つ目）をインクリ
				contactLines.playerContactLineCenter2.setPosition(
						marioSets.playerMarioSet1.getX() + 16,
						marioSets.playerMarioSet1.getY() + 32);
				// 核の当たり判定をインクリ
				contactLines.playerContactLineCore.setPosition(
						marioSets.playerMarioSet1.getX() + 0,
						marioSets.playerMarioSet1.getY() + 16);
			} else {
				// 上の当たり判定をインクリ
				contactLines.playerContactLineAbove.setPosition(
						marioSets.playerMarioSet2.getX() + 0,
						marioSets.playerMarioSet2.getY() + 0);
				// 下の当たり判定をインクリ
				contactLines.playerContactLineBelow.setPosition(
						marioSets.playerMarioSet2.getX() + 0,
						marioSets.playerMarioSet2.getY() + 64);
				// 中の当たり判定（1つ目）をインクリ
				contactLines.playerContactLineCenter1.setPosition(
						marioSets.playerMarioSet2.getX() + 16,
						marioSets.playerMarioSet2.getY() + 24);
				// 中の当たり判定（2つ目）をインクリ
				contactLines.playerContactLineCenter2.setPosition(
						marioSets.playerMarioSet2.getX() + 16,
						marioSets.playerMarioSet2.getY() + 32);
				// 核の当たり判定をインクリ
				contactLines.playerContactLineCore.setPosition(
						marioSets.playerMarioSet2.getX() + 0,
						marioSets.playerMarioSet2.getY() + 16);
			}
		}
	});
	public TimerHandler 復活時レート
	= new TimerHandler(1f / 30f, true, new ITimerCallback() {
		public void onTimePassed(TimerHandler pTimerHandler) {
			// バルーンのインクリ
			if (出現フラグバルーン == true) {
				// バルーンを上へ
				if (移動フラグバルーン == true) {
					if (balloons.enemyBalloonNotObject.getY() >= 144) {
						balloons.enemyBalloonNotObject.setY(
								balloons.enemyBalloonNotObject.getY() - バルーンの上昇移動値1);
						バルーンの上昇移動値1 *= 1.05f;
					} else {
						balloons.enemyBalloonNotObject.setY(
								balloons.enemyBalloonNotObject.getY() - バルーンの上昇移動値2);
						バルーンの上昇移動値2 *= 0.95f;
						if (balloons.enemyBalloonNotObject.getY() <= 0) {
							移動フラグバルーン		= false;
							バルーンの上昇移動値1	= 5f;
							バルーンの上昇移動値2	= 10f;
						}
					}
				}
				// バルーンを下へ
				if (移動フラグバルーン == false) {
					if (balloons.enemyBalloonNotObject.getY() <= 144) {
						balloons.enemyBalloonNotObject.setY(
								balloons.enemyBalloonNotObject.getY() + バルーンの下降移動値1);
						バルーンの下降移動値1 *= 1.05f;
					} else {
						balloons.enemyBalloonNotObject.setY(
								balloons.enemyBalloonNotObject.getY() + バルーンの下降移動値2);
						バルーンの下降移動値2 *= 0.95f;
						if (balloons.enemyBalloonNotObject.getY() >= 288) {
							移動フラグバルーン		= true;
							バルーンの下降移動値1	= 5f;
							バルーンの下降移動値2	= 10f;
						}
					}
				}
			}
			// 吹き出しをインクリ
			marios.effectMarioBalloon.setPosition(
					balloons.enemyBalloonNotObject.getX() + 16,
					balloons.enemyBalloonNotObject.getY() + 16);
			// マリオをインクリ
			if (グラチェンジフラグ == false) {
				marioSets.playerMarioSet1.setPosition(
						balloons.enemyBalloonNotObject.getX(),
						balloons.enemyBalloonNotObject.getY() + 64);
			} else {
				marioSets.playerMarioSet2.setPosition(
						balloons.enemyBalloonNotObject.getX(),
						balloons.enemyBalloonNotObject.getY() + 64);
			}
			// 当たり判定をインクリ
			if (グラチェンジフラグ == false) {
				// 上の当たり判定をインクリ
				contactLines.playerContactLineAbove.setPosition(
						marioSets.playerMarioSet1.getX() + 0,
						marioSets.playerMarioSet1.getY() + 0);
				// 下の当たり判定をインクリ
				contactLines.playerContactLineBelow.setPosition(
						marioSets.playerMarioSet1.getX() + 0,
						marioSets.playerMarioSet1.getY() + 64);
				// 中の当たり判定（1つ目）をインクリ
				contactLines.playerContactLineCenter1.setPosition(
						marioSets.playerMarioSet1.getX() + 16,
						marioSets.playerMarioSet1.getY() + 24);
				// 中の当たり判定（2つ目）をインクリ
				contactLines.playerContactLineCenter2.setPosition(
						marioSets.playerMarioSet1.getX() + 16,
						marioSets.playerMarioSet1.getY() + 32);
				// 核の当たり判定をインクリ
				contactLines.playerContactLineCore.setPosition(
						marioSets.playerMarioSet1.getX() + 0,
						marioSets.playerMarioSet1.getY() + 16);
			} else {
				// 上の当たり判定をインクリ
				contactLines.playerContactLineAbove.setPosition(
						marioSets.playerMarioSet2.getX() + 0,
						marioSets.playerMarioSet2.getY() + 0);
				// 下の当たり判定をインクリ
				contactLines.playerContactLineBelow.setPosition(
						marioSets.playerMarioSet2.getX() + 0,
						marioSets.playerMarioSet2.getY() + 64);
				// 中の当たり判定（1つ目）をインクリ
				contactLines.playerContactLineCenter1.setPosition(
						marioSets.playerMarioSet2.getX() + 16,
						marioSets.playerMarioSet2.getY() + 24);
				// 中の当たり判定（2つ目）をインクリ
				contactLines.playerContactLineCenter2.setPosition(
						marioSets.playerMarioSet2.getX() + 16,
						marioSets.playerMarioSet2.getY() + 32);
				// 核の当たり判定をインクリ
				contactLines.playerContactLineCore.setPosition(
						marioSets.playerMarioSet2.getX() + 0,
						marioSets.playerMarioSet2.getY() + 16);
			}
			// カウントダウン処理
			復活タイムカウンター++;
			// テキストをセット
			テキスト3.setPosition(
					marios.effectMarioBalloon.getX() + 24,
					marios.effectMarioBalloon.getY() + 64);
			ライフテキスト一時.setPosition(
					marios.effectMarioBalloon.getX() + 48,
					marios.effectMarioBalloon.getY() + 64);
			カウントダウンテキスト.setPosition(
					marios.effectMarioBalloon.getX() + 24,
					marios.effectMarioBalloon.getY() + 16);
			// テキストのインクリ
			if (復活タイムカウンター == 30) {
				フラグバル放メッセージ = false;
				復活タイムバックアップ = 4;
				カウントダウンテキスト.setText("" + 復活タイムバックアップ);
				カウントダウンテキスト.setScale(1);
			} else if (復活タイムカウンター == 60) {
				フラグバル放メッセージ = false;
				復活タイムバックアップ = 3;
				カウントダウンテキスト.setText("" + 復活タイムバックアップ);
				カウントダウンテキスト.setScale(1);
			} else if (復活タイムカウンター == 90) {
				フラグバル放メッセージ = false;
				復活タイムバックアップ = 2;
				カウントダウンテキスト.setText("" + 復活タイムバックアップ);
				カウントダウンテキスト.setColor(1, 0, 0);
				カウントダウンテキスト.setScale(1);
			} else if (復活タイムカウンター == 120) {
				フラグバル放メッセージ = false;
				復活タイムバックアップ = 1;
				カウントダウンテキスト.setText("" + 復活タイムバックアップ);
				カウントダウンテキスト.setColor(1, 0, 0);
				カウントダウンテキスト.setScale(1);
			} else if (復活タイムカウンター == 150) {
				フラグバル放メッセージ = false;
				復活タイムバックアップ = 0;
				カウントダウンテキスト.setText("" + 復活タイムバックアップ);
				カウントダウンテキスト.setColor(1, 0, 0);
				カウントダウンテキスト.setScale(1);
				// 時間切れミス
			} else if (復活タイムカウンター >= 180) {
				VoicePlay.voicePlayerEnemyMiss.stop();
				VoicePlay.voicePlayerEnemyMiss.play();
				フラグバルーン放したい = false;
				フラグバル放メッセージ = false;
				カウントダウンテキスト.setX(
						marios.effectMarioBalloon.getX() + 12);
				カウントダウンテキスト.setText("Go!");
				カウントダウンテキスト.setColor(1, 0, 0);
				カウントダウンテキスト.setScale(0.75f);
				フラグバルーン掴み = false;
				// やられ変数
				if (ゲームオーバーかどうか == false) {
					marios.effectMarioMissNormal = getBaseActivity().getResourceUtil()
							.getSprite("effect_37_mario_miss_normal.png");
					marios.effectMarioMissNormal.setTag(Marios.TAG_EFFECT_37_MARIO_MISS_NORMAL);
					if (グラチェンジフラグ == false) {
						marios.effectMarioMissNormal.setPosition(marioSets.playerMarioSet1);
					} else {
						marios.effectMarioMissNormal.setPosition(marioSets.playerMarioSet2);
					}
					attachChild(marios.effectMarioMissNormal);
					marios.effectMarioMissNormal.setZIndex(レイヤー09エフェクト用);
					sortChildren();
				}
				// 残機が1の場合はゲームオーバー
				if (現在のライフ <= 1 && ゲームオーバーかどうか == false) {
					gameStop();
				} else {
					// それ以外は普通のミス処理
					playerDown();
				}
			}
			if (フラグバル放メッセージ == true) {
				カウントダウンテキスト.setX(
						marios.effectMarioBalloon.getX() + 12);
				カウントダウンテキスト.setText("OK!");
				カウントダウンテキスト.setColor(1, 0, 0);
				カウントダウンテキスト.setScale(0.75f);
			}
			// 最後に2つのフラグを同時に満たした場合、バルーンから離れる処理
			if (フラグタイル接触 == false && フラグバルーン放したい == true) {
				フラグバルーン掴み	= false;
				フラグバルーン放したい	= false;
				フラグバル放メッセージ	= false;
				// ボイスのランダム処理
				int r = (int)(Math.random() * 3);
				switch (r) {
				case 0:
					VoicePlay.voiceBackFlip1.stop();
					VoicePlay.voiceBackFlip1.play();
					break;
				case 1:
					VoicePlay.voiceBackFlip2.stop();
					VoicePlay.voiceBackFlip2.play();
					break;
				case 2:
					VoicePlay.voiceBackFlip3.stop();
					VoicePlay.voiceBackFlip3.play();
					break;
				}
				backFlipJumpSprite();
			}
		}
	});
	public TimerHandler フレームレート
	= new TimerHandler(1f / 30f, true, new ITimerCallback() {
		public void onTimePassed(TimerHandler pTimerHandler) {
			// フラグの初期化
			プレイヤーのジャンプフラグ	= true;
			プレイヤーのダッシュフラグ		= false;
			判定中1フラグ			= false;
			判定中2フラグ			= false;
			左側移動フラグ			= false;
			リフト上昇フラグ			= false;
			リフト下降フラグ			= false;
			フラグタイル接触			= false;
			ジャンプカウンター			+= 8;
			// インクリ関係（その1）
			iconIncrement();
			backIncrement();
			courseIncrement();
			// タグの呼び出し
			effectTagDecision();		// エフェクトタグの呼び出し
			fontTagDecision();			// フォントタグの呼び出し
			if (ゲームオーバーかどうか == false) {
				tileTagDecision();		// タイルタグの呼び出し
				itemTagDecision();		// アイテムタグの呼び出し
				enemyTagDecision();		// 敵キャラタグの呼び出し
				playerTagDecision();	// プレイヤータグの呼び出し
			}
			// ボール系アレイの削除処理
			for (Nボール用フォー = 0; Nボール用フォー < 収納用Nボール.size(); Nボール用フォー++) {
				if (収納用Nボール.get(Nボール用フォー).getX() >= 880) {
					Nボールカウンター--;
					収納用プレイヤー.add(収納用Nボール.get(Nボール用フォー));
					収納用Nボール.remove(Nボール用フォー);
				}
			}
			for (Sボール用フォー = 0; Sボール用フォー < 収納用Sボール.size(); Sボール用フォー++) {
				if (収納用Sボール.get(Sボール用フォー).getX() >= 880) {
					Sボールカウンター--;
					収納用プレイヤー.add(収納用Sボール.get(Sボール用フォー));
					収納用Sボール.remove(Sボール用フォー);
				}
			}
			for (衝撃波上用フォー = 0; 衝撃波上用フォー < 収納用衝撃波上.size(); 衝撃波上用フォー++) {
				if (収納用衝撃波上.get(衝撃波上用フォー).getY() <= 32) {
					収納用プレイヤー.add(収納用衝撃波上.get(衝撃波上用フォー));
					収納用衝撃波上.remove(衝撃波上用フォー);
				}
			}
			for (衝撃波下用フォー = 0; 衝撃波下用フォー < 収納用衝撃波下.size(); 衝撃波下用フォー++) {
				if (収納用衝撃波下.get(衝撃波下用フォー).getY() >= 416) {
					収納用プレイヤー.add(収納用衝撃波下.get(衝撃波下用フォー));
					収納用衝撃波下.remove(衝撃波下用フォー);
				}
			}
			// 配列の中身を削除
			for (Sprite sp : 収納用タイル) {
				sp.detachSelf();
			}
			for (Sprite sp : 収納用アイテム) {
				sp.detachSelf();
			}
			for (Sprite sp : 収納用敵キャラ) {
				sp.detachSelf();
			}
			for (Sprite sp : 収納用プレイヤー) {
				sp.detachSelf();
			}
			for (Sprite sp : 収納用エフェクト) {
				sp.detachSelf();
			}
			for (Sprite sp : 収納用フォント) {
				sp.detachSelf();
			}
			// 配列の中身をクリーン
			収納用タイル.clear();
			収納用アイテム.clear();
			収納用敵キャラ.clear();
			収納用プレイヤー.clear();
			収納用エフェクト.clear();
			収納用フォント.clear();
			// インクリ関係（その2）
			if (ゲームオーバーかどうか == false) {
				textIncrement();		// ノーマルテキストをインクリ
				debugTextIncrement();	// デバッグテキストをインクリ
				scoreIncrement();		// スコアをインクリ
				itemIncrement();		// アイテムをインクリ
				playerIncrement();		// プレイヤーをインクリ
			}
			// ハンドラーカウントが4になった時、1マス分進む
			if (コースの端っこかどうか == false) {
				ハンドラーカウンター++;
				メモリーカウンター++;
				if ((ハンドラーカウンター % 4) == 0 && ゲームオーバーかどうか == false) {
					タイル位置カウンター++;
					メモリーカウンター = 0;
				}
			}
			// ミュージックのみのストップ処理を解除（スタッフクレジットとか…）
			if (コースの端っこかどうか == false && 状態フラグ中断中 == true) {
				状態フラグ中断中 = false;
				musicResume();
			}
			// メモリーの解放
			if (ゲームを終了したかどうか == true && メモリーの開放をしたかどうか == false) {
				destroy();
			}
			// ハンドラーの解放
			if (メモリーの開放をしたかどうか == true) {
				free();
			}
		}
	});
	public TimerHandler キラー出現レート
	= new TimerHandler(3, true, new ITimerCallback() {
		public void onTimePassed(TimerHandler pTimerHandler) {
			if (フラグキラー青色 == true) {
				SoundPlay.seBulletBill.stop();
				SoundPlay.seBulletBill.play();
				// キラーの出現ポイント
				int appPoint = 0;
				int r = (int)(Math.random() * 10);
				switch (r) {
				case 0:
					appPoint = 352;	// 下から4マス
					break;
				case 1:
					appPoint = 320;	// 下から5マス
					break;
				case 2:
					appPoint = 288;	// 下から6マス
					break;
				case 3:
					appPoint = 256;	// 下から7マス
					break;
				case 4:
					appPoint = 224;	// 下から8マス
					break;
				case 5:
					appPoint = 192;	// 下から9マス
					break;
				case 6:
					appPoint = 160;	// 下から10マス
					break;
				case 7:
					appPoint = 128;	// 下から11マス
					break;
				case 8:
					appPoint = 96;	// 下から12マス
					break;
				case 9:
					appPoint = 64;	// 下から13マス
					break;
				}
				bulletBills.enemyBulletBillBlue = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("enemy_04_bullet_bill_blue.png", 1, 2);
				bulletBills.enemyBulletBillBlue.setTag(
						BulletBills.TAG_ENEMY_04_BULLET_BILL_BLUE);
				// 画面右外に追加。y座標（appPoint）はランダム
				bulletBills.enemyBulletBillBlue.setPosition(getBaseActivity().getEngine()
						.getCamera().getWidth() + bulletBills.enemyBulletBillBlue
						.getWidth(), appPoint);
				bulletBills.enemyBulletBillBlue.animate(ani並);
				attachChild(bulletBills.enemyBulletBillBlue);
				bulletBills.enemyBulletBillBlue.setZIndex(レイヤー08敵キャラ用);
				sortChildren();
			}
		}
	});
	public CustomTimerHandler 無敵時間
	= new CustomTimerHandler(12, new ITimerCallback() {
		public void onTimePassed(TimerHandler pTimerHandler) {
			if (ゲームオーバーかどうか == false) {
				musicStop();
				// ミュージックリソースの解放
				getBaseActivity().getMusicManager().releaseAll();
				状態フラグ無敵 = false;
				musicPlay();
				// マリオの状態をフラグ化
				// ※1
				if (メット取得フラグ == true && シャツ取得フラグ == false
						&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
					グラチェンジフラグ = true;
					// ※2
				} else if (メット取得フラグ == true && シャツ取得フラグ == true
						&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
					グラチェンジフラグ = true;
					// ※3
				} else if (メット取得フラグ == false && シャツ取得フラグ == true
						&& ズボン取得フラグ == false && 状態フラグ無敵 == false) {
					グラチェンジフラグ = true;
					// ※4
				} else if (メット取得フラグ == false && シャツ取得フラグ == true
						&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
					グラチェンジフラグ = true;
					// ※5
				} else if (メット取得フラグ == false && シャツ取得フラグ == false
						&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
					グラチェンジフラグ = true;
					// ※6
				} else if (メット取得フラグ == true && シャツ取得フラグ == false
						&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
					グラチェンジフラグ = true;
				}
				// マリオのグラをチェンジ！
				if (グラチェンジフラグ == true) {
					// マリオのグラセット2
					marioSets.playerMarioSet2 = getBaseActivity().getResourceUtil()
							.getAnimatedSprite("player_02_mario_set_2.png", 1, 30);
					marioSets.playerMarioSet2.setPosition(marioSets.playerMarioSet1);
					attachChild(marioSets.playerMarioSet2);
					marioSets.playerMarioSet2.setZIndex(レイヤー10プレイヤー用);
					sortChildren();
					// 元のグラは削除
					marioSets.playerMarioSet1.detachSelf();
				}
				// 攻撃時のグラ
				if (ボールハンド実行フラグ == true || パンチハンド実行フラグ == true) {
					playerAttackAnimation();
				} else {
					// ダッシュ時のグラ
					if (プレイヤーのダッシュフラグ == true && プレイヤーのジャンプフラグ == false) {
						playerDashAnimation();
						// ジャンプ時のグラ
					} else if (プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true) {
						playerJumpAnimation();
					}
				}
				// 無敵解除後、ボール数が0の場合
				if (現在のボール < 1) {
					// ※ここで隠す
					if (攻撃ボタン位置 == 0) {
						ボール攻撃ボタンプッシュ.setPosition(0, 480);
						ボール攻撃ボタン.setPosition(0, 480);
						パンチ攻撃ボタンプッシュ.setPosition(0, 352);
						パンチ攻撃ボタン.setPosition(0, 352);
					} else if (攻撃ボタン位置 == 1) {
						ボール攻撃ボタンプッシュ.setPosition(336, 480);
						ボール攻撃ボタン.setPosition(336, 480);
						パンチ攻撃ボタンプッシュ.setPosition(336, 352);
						パンチ攻撃ボタン.setPosition(336, 352);
					} else if (攻撃ボタン位置 == 2) {
						ボール攻撃ボタンプッシュ.setPosition(672, 480);
						ボール攻撃ボタン.setPosition(672, 480);
						パンチ攻撃ボタンプッシュ.setPosition(672, 352);
						パンチ攻撃ボタン.setPosition(672, 352);
					}
				}
			}
			// ハンドラーをリセット
			無敵時間.reset();
			unregisterUpdateHandler(無敵時間);
			収納用ハンドラー.remove(無敵時間);
		}
	});
	public CustomTimerHandler 点滅時間
	= new CustomTimerHandler(2.5f, new ITimerCallback() {
		public void onTimePassed(TimerHandler pTimerHandler) {
			状態フラグ点滅 = false;
			// 体にあわせてハンドの点滅も解除
			if (ボールハンド実行フラグ == true) {
				hands.playerHandFireball.clearEntityModifiers();
				hands.playerHandFireball.setAlpha(1);
			} else if (パンチハンド実行フラグ == true) {
				hands.playerHandPunch.clearEntityModifiers();
				hands.playerHandPunch.setAlpha(1);
			}
			// ハンドラーをリセット
			点滅時間.reset();
			unregisterUpdateHandler(点滅時間);
			収納用ハンドラー.remove(点滅時間);
		}
	});
	public CustomTimerHandler ボール時間
	= new CustomTimerHandler(0.25f, new ITimerCallback() {
		public void onTimePassed(TimerHandler pTimerHandler) {
			// 実行フラグをふぁるす！
			ボールハンド実行フラグ = false;
			// 直接デタッチすると配列がずれるので、いったん配列に格納
			収納用プレイヤー.add(hands.playerHandFireball);
			// デフォルトアニメ
			if (メモリーの開放をしたかどうか == false) {
				playerDefaultAnimation();
			}
			// タイムフラグをふぁるす！
			ボールハンドタイムフラグ = false;
			// ハンドラーをリセット
			ボール時間.reset();
			unregisterUpdateHandler(ボール時間);
			収納用ハンドラー.remove(ボール時間);
		}
	});
	public CustomTimerHandler パンチ実行時間
	= new CustomTimerHandler(0.25f, new ITimerCallback() {
		public void onTimePassed(TimerHandler pTimerHandler) {
			// 実行フラグをふぁるす！
			パンチハンド実行フラグ = false;
			// 直接デタッチすると配列がずれるので、いったん配列に格納
			収納用プレイヤー.add(hands.playerHandPunch);
			// デフォルトアニメ
			if (メモリーの開放をしたかどうか == false) {
				playerDefaultAnimation();
			}
			// パンチタイム時間
			registerUpdateHandler(パンチタイム時間);
			収納用ハンドラー.add(パンチタイム時間);
			// ハンドラーをリセット
			パンチ実行時間.reset();
			unregisterUpdateHandler(パンチ実行時間);
			収納用ハンドラー.remove(パンチ実行時間);
		}
	});
	public CustomTimerHandler パンチタイム時間
	= new CustomTimerHandler(0.25f, new ITimerCallback() {
		public void onTimePassed(TimerHandler pTimerHandler) {
			パンチハンドタイムフラグ = false;
			// ハンドラーをリセット
			パンチタイム時間.reset();
			unregisterUpdateHandler(パンチタイム時間);
			収納用ハンドラー.remove(パンチタイム時間);
		}
	});
	public CustomTimerHandler バック転時間
	= new CustomTimerHandler(0.5f, new ITimerCallback() {
		public void onTimePassed(TimerHandler pTimerHandler) {
			バック転ジャンプの上昇移動値	= 0;
			バック転ジャンプの下降移動値	= 0;
			// プレイヤーの動きとモーションをストップ！
			if (バック転実行フラグ == true && メモリーの開放をしたかどうか == false) {
				if (グラチェンジフラグ == false) {
					if (状態フラグ無敵 == false) {
						marioSets.playerMarioSet1.stopAnimation();
					}
					marioSets.playerMarioSet1.setRotation(0);
				} else {
					marioSets.playerMarioSet2.stopAnimation();
					marioSets.playerMarioSet2.setRotation(0);
				}
			}
			// 直接デタッチすると配列がずれるので、いったん配列に格納
			収納用プレイヤー.add(marios.effectMarioBackFlip);
			// 実行フラグとタイムフラグをふぁるす！
			バック転実行フラグ		= false;
			バック転タイムフラグ		= false;
			// ハンドラーをリセット
			バック転時間.reset();
			unregisterUpdateHandler(バック転時間);
			収納用ハンドラー.remove(バック転時間);
		}
	});
	
	// ===========================================================
	// アクション系
	// ===========================================================
	
	// ジャンプ（ノーマル）スプライト
	public void normalJumpSprite() {
		SoundPlay.seJump.stop();
		SoundPlay.seJump.play();
		ダッシュカウンター = 0;
		ジャンプカウンター = 0;
		プレイヤーのダッシュフラグ		= false;
		プレイヤーのジャンプフラグ	= true;
		// ジャンプごとにチェンジブロックを入れ替え
		if (フラグチェンジブロック == true) {
			フラグチェンジブロック = false;
		} else {
			フラグチェンジブロック = true;
		}
		// プレイヤーの動きをストップ！
		if (グラチェンジフラグ == false) {
			marioSets.playerMarioSet1.stopAnimation();
		} else {
			marioSets.playerMarioSet2.stopAnimation();
		}
		if (パンチハンド実行フラグ == false && ボールハンド実行フラグ == false) {
			// ジャンプ時のグラ
			playerJumpAnimation();
		}
	}
	// ジャンプ（バック転）スプライト
	public void backFlipJumpSprite() {
		SoundPlay.seTap.stop();
		SoundPlay.seTap.play();
		ジャンプカウンター			= 0;
		バック転実行フラグ		= true;
		バック転タイムフラグ		= true;
		バック転ジャンプの上昇移動値	= 24;
		バック転ジャンプの下降移動値	= 4.8f;
		// 「エ゛エーイ！」をキャンセル
		if (エエーイ実行フラグ == true) {
			エエーイ実行フラグ		= false;
			if (グラチェンジフラグ == false) {
				marioSets.playerMarioSet1.setRotation(0);
			} else {
				marioSets.playerMarioSet2.setRotation(0);
			}
		}
		// ボールハンドをキャンセル（※非表示のみ）
		if (ボールハンド実行フラグ == true) {
			hands.playerHandFireball.setAlpha(0);
		}
		// パンチハンドをキャンセル（※完全に削除）
		if (パンチハンド実行フラグ == true) {
			// 実行フラグをふぁるす！
			パンチハンド実行フラグ = false;
			// 直接デタッチすると配列がずれるので、いったん配列に格納
			収納用プレイヤー.add(hands.playerHandPunch);
			// デフォルトアニメ
			if (メモリーの開放をしたかどうか == false) {
				playerDefaultAnimation();
			}
			// パンチタイム時間
			registerUpdateHandler(パンチタイム時間);
			収納用ハンドラー.add(パンチタイム時間);
			// ハンドラーをリセット
			パンチ実行時間.reset();
			unregisterUpdateHandler(パンチ実行時間);
			収納用ハンドラー.remove(パンチ実行時間);
		}
		// ダッシュアニメの呼び出し
		playerDashAnimation();
		// 回転エフェクトを追加する
		marios.effectMarioBackFlip = getBaseActivity().getResourceUtil()
				.getAnimatedSprite("effect_35_mario_back_flip.png", 1, 2);
		if (グラチェンジフラグ == false) {
			marios.effectMarioBackFlip.setPosition(
					marioSets.playerMarioSet1.getX() -16,
					marioSets.playerMarioSet1.getY());
		} else {
			marios.effectMarioBackFlip.setPosition(
					marioSets.playerMarioSet2.getX() - 16,
					marioSets.playerMarioSet2.getY());
		}
		marios.effectMarioBackFlip.animate(ani並);
		attachChild(marios.effectMarioBackFlip);
		// レイヤーを入れるとなぜかバグる
		marios.effectMarioBackFlip.registerEntityModifier(
				new FadeOutModifier(0.5f));
		// バック転時間
		registerUpdateHandler(バック転時間);
		収納用ハンドラー.add(バック転時間);
		// 復活時は再度フレームレートを呼び出す
		if (状態フラグ復活中 == true) {
			バルーンの上昇移動値1	= 5;
			バルーンの上昇移動値2	= 10;
			バルーンの下降移動値1	= 5;
			バルーンの下降移動値2	= 10;
			// 復活処理
			状態フラグ生存			= true;
			状態フラグ点滅			= true;
			// 忘れずにフラグをふぁるす！
			ゲーム待機中かどうか		= false;
			出現フラグバルーン		= false;
			状態フラグ復活中			= false;
			// バルーンを消す！
			balloons.enemyBalloonNotObject.registerEntityModifier(new FadeOutModifier(0.5f));
			registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					balloons.enemyBalloonNotObject.detachSelf();
				}
			}));
			// 吹き出しを消す！
			marios.effectMarioBalloon.registerEntityModifier(new FadeOutModifier(0.5f));
			registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					marios.effectMarioBalloon.detachSelf();
				}
			}));
			// テキストを消す！
			テキスト3.registerEntityModifier(new FadeOutModifier(0.5f));
			registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					テキスト3.detachSelf();
				}
			}));
			ライフテキスト一時.registerEntityModifier(new FadeOutModifier(0.5f));
			registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					ライフテキスト一時.detachSelf();
				}
			}));
			カウントダウンテキスト.registerEntityModifier(new FadeOutModifier(0.5f));
			registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					カウントダウンテキスト.detachSelf();
				}
			}));
			// 復活時レートをストップ！
			unregisterUpdateHandler(復活時レート);
			// ボタンが押せないのを解除
			registerTouchArea(ボール攻撃ボタン);
			registerTouchArea(パンチ攻撃ボタン);
			// マリオを点滅させる（※停止分（0.5f）は加算しない！）
			if (グラチェンジフラグ == false) {
				marioSets.playerMarioSet1.registerEntityModifier(new LoopEntityModifier(
						new SequenceEntityModifier(new FadeOutModifier(
								0.005f), new FadeInModifier(0.005f)), 250));
				registerUpdateHandler(点滅時間);
				収納用ハンドラー.add(点滅時間);
			} else {
				marioSets.playerMarioSet2.registerEntityModifier(new LoopEntityModifier(
						new SequenceEntityModifier(new FadeOutModifier(
								0.005f), new FadeInModifier(0.005f)), 250));
				registerUpdateHandler(点滅時間);
				収納用ハンドラー.add(点滅時間);
			}
		}
	}
	// 攻撃（ボール）スプライト
	public void ballAttackSprite() {
		// 無敵じゃない場合、ノーマル攻撃処理
		if (状態フラグ無敵 == false) {
			// シャツ"無し"の場合、シングルボール処理
			if (シャツ取得フラグ == false) {
				// ボールが残っている場合、何もしない
				if (現在のボール > 1) {
					// 1度に出せるボールは2つまで！
					if (Nボールカウンター < 2) {
						SoundPlay.seball.stop();
						SoundPlay.seball.play();
						ボールテキスト.registerEntityModifier(
								new LoopEntityModifier(new SequenceEntityModifier(
										new ScaleModifier(0.25f, 1.0f, 1.5f),
										new ScaleModifier(0.25f, 1.5f, 1.0f)), 1));
						現在のボール -= 1;
						Nボールカウンター++;
						// ノーマルボールを追加
						fireballs.playerFireballNormal1 = getBaseActivity().getResourceUtil()
								.getAnimatedSprite("player_07_fireball_normal_1.png", 1, 4);
						fireballs.playerFireballNormal1.setTag(
								Fireballs.TAG_PLAYER_07_FIREBALL_NORMAL_1);
						if (グラチェンジフラグ == false) {
							fireballs.playerFireballNormal1.setPosition(
									marioSets.playerMarioSet1.getX() + 16,
									marioSets.playerMarioSet1.getY() + 16);
						} else {
							fireballs.playerFireballNormal1.setPosition(
									marioSets.playerMarioSet2.getX() + 16,
									marioSets.playerMarioSet2.getY() + 16);
						}
						fireballs.playerFireballNormal1.animate(ani速);
						attachChild(fireballs.playerFireballNormal1);
						fireballs.playerFireballNormal1.setZIndex(レイヤー05ボール用);
						sortChildren();
						// ボールをArrayListに放り込む
						収納用Nボール.add(fireballs.playerFireballNormal1);
						// ボールハンドの処理
						if (ボールハンドタイムフラグ == false) {
							ボールハンド実行フラグ = true;
							ボールハンドタイムフラグ = true;
							// ボールハンドを追加
							hands.playerHandFireball = getBaseActivity().getResourceUtil()
									.getAnimatedSprite("player_14_hand_fireball.png", 1, 2);
							hands.playerHandFireball.setTag(
									Hands.TAG_PLAYER_14_HAND_FIREBALL);
							if (グラチェンジフラグ == false) {
								hands.playerHandFireball.setPosition(
										marioSets.playerMarioSet1.getX() + 8,
										marioSets.playerMarioSet1.getY() + 8);
							} else {
								hands.playerHandFireball.setPosition(
										marioSets.playerMarioSet2.getX() + 8,
										marioSets.playerMarioSet2.getY() + 8);
							}
							// 無敵時はおててのカラーを変更
							if (状態フラグ無敵 == false) {
								hands.playerHandFireball.setCurrentTileIndex(0);
							} else {
								hands.playerHandFireball.setCurrentTileIndex(1);
							}
							// バック転時はおててを表示しない
							if (バック転実行フラグ == true) {
								hands.playerHandFireball.setAlpha(0);
							}
							attachChild(hands.playerHandFireball);
							hands.playerHandFireball.setZIndex(レイヤー10プレイヤー用);
							sortChildren();
							// 点滅フラグがオンの場合、点滅処理
							if (状態フラグ点滅 == true) {
								// ボールハンドを点滅させる（※停止分（0.5f）ももれなく加算！）
								hands.playerHandFireball.registerEntityModifier(new LoopEntityModifier(
										new SequenceEntityModifier(new FadeOutModifier(
												0.005f), new FadeInModifier(0.005f)), 300));
							}
						}
						// プレイヤーの動きをストップ！
						if (グラチェンジフラグ == false) {
							marioSets.playerMarioSet1.stopAnimation();
						} else {
							marioSets.playerMarioSet2.stopAnimation();
						}
						// 攻撃時のグラ
						if (バック転実行フラグ == false) {
							playerAttackAnimation();
						}
						// すでに攻撃中の場合はリセット
						if (ボールハンド実行フラグ == true) {
							// ハンドラーをリセット
							ボール時間.reset();
							unregisterUpdateHandler(ボール時間);
							収納用ハンドラー.remove(ボール時間);
						}
						// ボール時間
						registerUpdateHandler(ボール時間);
						収納用ハンドラー.add(ボール時間);
					}
					// 残りのボールがなくなったら、攻撃ボタンを隠す
				} else {
					// 1度に出せるボールは2つまで！
					if (Nボールカウンター < 2) {
						SoundPlay.seball.stop();
						SoundPlay.seball.play();
						ボールテキスト.registerEntityModifier(
								new LoopEntityModifier(new SequenceEntityModifier(
										new ScaleModifier(0.25f, 1.0f, 1.5f),
										new ScaleModifier(0.25f, 1.5f, 1.0f)), 1));
						現在のボール -= 1;
						Nボールカウンター++;
						// ノーマルボールを追加
						fireballs.playerFireballNormal1 = getBaseActivity().getResourceUtil()
								.getAnimatedSprite("player_07_fireball_normal_1.png", 1, 4);
						fireballs.playerFireballNormal1.setTag(
								Fireballs.TAG_PLAYER_07_FIREBALL_NORMAL_1);
						if (グラチェンジフラグ == false) {
							fireballs.playerFireballNormal1.setPosition(
									marioSets.playerMarioSet1.getX() + 16,
									marioSets.playerMarioSet1.getY() + 16);
						} else {
							fireballs.playerFireballNormal1.setPosition(
									marioSets.playerMarioSet2.getX() + 16,
									marioSets.playerMarioSet2.getY() + 16);
						}
						fireballs.playerFireballNormal1.animate(ani速);
						attachChild(fireballs.playerFireballNormal1);
						fireballs.playerFireballNormal1.setZIndex(レイヤー05ボール用);
						sortChildren();
						// ボールをArrayListに放り込む
						収納用Nボール.add(fireballs.playerFireballNormal1);
						// ボールハンドの処理
						if (ボールハンドタイムフラグ == false) {
							ボールハンド実行フラグ = true;
							ボールハンドタイムフラグ = true;
							// ボールハンドを追加
							hands.playerHandFireball = getBaseActivity().getResourceUtil()
									.getAnimatedSprite("player_14_hand_fireball.png", 1, 2);
							hands.playerHandFireball.setTag(
									Hands.TAG_PLAYER_14_HAND_FIREBALL);
							if (グラチェンジフラグ == false) {
								hands.playerHandFireball.setPosition(
										marioSets.playerMarioSet1.getX() + 8,
										marioSets.playerMarioSet1.getY() + 8);
							} else {
								hands.playerHandFireball.setPosition(
										marioSets.playerMarioSet2.getX() + 8,
										marioSets.playerMarioSet2.getY() + 8);
							}
							// 無敵時はおててのカラーを変更
							if (状態フラグ無敵 == false) {
								hands.playerHandFireball.setCurrentTileIndex(0);
							} else {
								hands.playerHandFireball.setCurrentTileIndex(1);
							}
							// バック転時はおててを表示しない
							if (バック転実行フラグ == true) {
								hands.playerHandFireball.setAlpha(0);
							}
							attachChild(hands.playerHandFireball);
							hands.playerHandFireball.setZIndex(レイヤー10プレイヤー用);
							sortChildren();
							// 点滅フラグがオンの場合、点滅処理
							if (状態フラグ点滅 == true) {
								// ボールハンドを点滅させる（※停止分（0.5f）ももれなく加算！）
								hands.playerHandFireball.registerEntityModifier(new LoopEntityModifier(
										new SequenceEntityModifier(new FadeOutModifier(
												0.005f), new FadeInModifier(0.005f)), 300));
							}
						}
						// プレイヤーの動きをストップ！
						if (グラチェンジフラグ == false) {
							marioSets.playerMarioSet1.stopAnimation();
						} else {
							marioSets.playerMarioSet2.stopAnimation();
						}
						// 攻撃時のグラ
						if (バック転実行フラグ == false) {
							playerAttackAnimation();
						}
						// すでに攻撃中の場合はリセット
						if (ボールハンド実行フラグ == true) {
							// ハンドラーをリセット
							ボール時間.reset();
							unregisterUpdateHandler(ボール時間);
							収納用ハンドラー.remove(ボール時間);
						}
						// ボール時間
						registerUpdateHandler(ボール時間);
						収納用ハンドラー.add(ボール時間);
						// ※ここで隠す
						if (攻撃ボタン位置 == 0) {
							ボール攻撃ボタンプッシュ.setPosition(0, 480);
							ボール攻撃ボタン.setPosition(0, 480);
							パンチ攻撃ボタンプッシュ.setPosition(0, 352);
							パンチ攻撃ボタン.setPosition(0, 352);
						} else if (攻撃ボタン位置 == 1) {
							ボール攻撃ボタンプッシュ.setPosition(336, 480);
							ボール攻撃ボタン.setPosition(336, 480);
							パンチ攻撃ボタンプッシュ.setPosition(336, 352);
							パンチ攻撃ボタン.setPosition(336, 352);
						} else if (攻撃ボタン位置 == 2) {
							ボール攻撃ボタンプッシュ.setPosition(672, 480);
							ボール攻撃ボタン.setPosition(672, 480);
							パンチ攻撃ボタンプッシュ.setPosition(672, 352);
							パンチ攻撃ボタン.setPosition(672, 352);
						}
					}
				}
				// シャツ"有り"の場合、ダブルボール処理
			} else if (シャツ取得フラグ == true) {
				// ボールが残っている場合、何もしない
				if (現在のボール > 1) {
					// 1度に出せるボールは4つまで！
					if (Nボールカウンター < 3) {
						SoundPlay.seball.stop();
						SoundPlay.seball.play();
						ボールテキスト.registerEntityModifier(
								new LoopEntityModifier(new SequenceEntityModifier(
										new ScaleModifier(0.25f, 1.0f, 1.5f),
										new ScaleModifier(0.25f, 1.5f, 1.0f)), 1));
						現在のボール -= 1;
						Nボールカウンター += 2;
						// ノーマルボール（1こめ）を追加
						fireballs.playerFireballNormal1 = getBaseActivity().getResourceUtil()
								.getAnimatedSprite("player_07_fireball_normal_1.png", 1, 4);
						fireballs.playerFireballNormal1.setTag(
								Fireballs.TAG_PLAYER_07_FIREBALL_NORMAL_1);
						if (グラチェンジフラグ == false) {
							fireballs.playerFireballNormal1.setPosition(
									marioSets.playerMarioSet1.getX() + 16,
									marioSets.playerMarioSet1.getY() + 16);
						} else {
							fireballs.playerFireballNormal1.setPosition(
									marioSets.playerMarioSet2.getX() + 16,
									marioSets.playerMarioSet2.getY() + 16);
						}
						fireballs.playerFireballNormal1.animate(ani速);
						attachChild(fireballs.playerFireballNormal1);
						fireballs.playerFireballNormal1.setZIndex(レイヤー05ボール用);
						sortChildren();
						// ボールをArrayListに放り込む
						収納用Nボール.add(fireballs.playerFireballNormal1);
						// ノーマルボール（2こめ）を追加
						fireballs.playerFireballNormal2 = getBaseActivity().getResourceUtil()
								.getAnimatedSprite("player_08_fireball_normal_2.png", 1, 4);
						fireballs.playerFireballNormal2.setTag(
								Fireballs.TAG_PLAYER_08_FIREBALL_NORMAL_2);
						if (グラチェンジフラグ == false) {
							fireballs.playerFireballNormal2.setPosition(
									marioSets.playerMarioSet1.getX() + 32,
									marioSets.playerMarioSet1.getY());
						} else {
							fireballs.playerFireballNormal2.setPosition(
									marioSets.playerMarioSet2.getX() + 32,
									marioSets.playerMarioSet2.getY());
						}
						fireballs.playerFireballNormal2.animate(ani速);
						attachChild(fireballs.playerFireballNormal2);
						fireballs.playerFireballNormal2.setZIndex(レイヤー05ボール用);
						sortChildren();
						// ボールをArrayListに放り込む
						収納用Nボール.add(fireballs.playerFireballNormal2);
						// 全能力MAXの場合、衝撃波を追加！！
						if (メット取得フラグ == true && シャツ取得フラグ == true
							&& ズボン取得フラグ == true) {
							// 衝撃波（上）を追加
							fireballs.playerFireballShockWaveAdove = getBaseActivity().getResourceUtil()
									.getAnimatedSprite("player_12_fireball_shock_wave_above.png", 1, 2);
							fireballs.playerFireballShockWaveAdove.setTag(
									Fireballs.TAG_PLAYER_12_FIREBALL_SHOCK_WAVE_ADOVE);
							if (グラチェンジフラグ == false) {
								fireballs.playerFireballShockWaveAdove.setPosition(
										marioSets.playerMarioSet1.getX() + 16,
										marioSets.playerMarioSet1.getY() + 16);
							} else {
								fireballs.playerFireballShockWaveAdove.setPosition(
										marioSets.playerMarioSet2.getX() + 16,
										marioSets.playerMarioSet2.getY() + 16);
							}
							fireballs.playerFireballShockWaveAdove.animate(ani速);
							fireballs.playerFireballShockWaveAdove.setAlpha(0.75f);
							attachChild(fireballs.playerFireballShockWaveAdove);
							fireballs.playerFireballShockWaveAdove.setZIndex(レイヤー05ボール用);
							sortChildren();
							// 衝撃波もArrayListに放り込む
							収納用衝撃波上.add(fireballs.playerFireballShockWaveAdove);
							// 衝撃波（下）を追加
							fireballs.playerFireballShockWaveBelow = getBaseActivity().getResourceUtil()
									.getAnimatedSprite("player_13_fireball_shock_wave_below.png", 1, 2);
							fireballs.playerFireballShockWaveBelow.setTag(
									Fireballs.TAG_PLAYER_13_FIREBALL_SHOCK_WAVE_BELOW);
							if (グラチェンジフラグ == false) {
								fireballs.playerFireballShockWaveBelow.setPosition(
										marioSets.playerMarioSet1.getX() + 16,
										marioSets.playerMarioSet1.getY() + 16);
							} else {
								fireballs.playerFireballShockWaveBelow.setPosition(
										marioSets.playerMarioSet2.getX() + 16,
										marioSets.playerMarioSet2.getY() + 16);
							}
							fireballs.playerFireballShockWaveBelow.animate(ani速);
							fireballs.playerFireballShockWaveBelow.setAlpha(0.75f);
							attachChild(fireballs.playerFireballShockWaveBelow);
							fireballs.playerFireballShockWaveBelow.setZIndex(レイヤー05ボール用);
							sortChildren();
							// 衝撃波もArrayListに放り込む
							収納用衝撃波下.add(fireballs.playerFireballShockWaveBelow);
						}
						// ボールハンドの処理
						if (ボールハンドタイムフラグ == false) {
							ボールハンド実行フラグ = true;
							ボールハンドタイムフラグ = true;
							// ボールハンドを追加
							hands.playerHandFireball = getBaseActivity().getResourceUtil()
									.getAnimatedSprite("player_14_hand_fireball.png", 1, 2);
							hands.playerHandFireball.setTag(
									Hands.TAG_PLAYER_14_HAND_FIREBALL);
							if (グラチェンジフラグ == false) {
								hands.playerHandFireball.setPosition(
										marioSets.playerMarioSet1.getX() + 8,
										marioSets.playerMarioSet1.getY() + 8);
							} else {
								hands.playerHandFireball.setPosition(
										marioSets.playerMarioSet2.getX() + 8,
										marioSets.playerMarioSet2.getY() + 8);
							}
							// 無敵時はおててのカラーを変更
							if (状態フラグ無敵 == false) {
								hands.playerHandFireball.setCurrentTileIndex(0);
							} else {
								hands.playerHandFireball.setCurrentTileIndex(1);
							}
							// バック転時はおててを表示しない
							if (バック転実行フラグ == true) {
								hands.playerHandFireball.setAlpha(0);
							}
							attachChild(hands.playerHandFireball);
							hands.playerHandFireball.setZIndex(レイヤー10プレイヤー用);
							sortChildren();
							// 点滅フラグがオンの場合、点滅処理
							if (状態フラグ点滅 == true) {
								// ボールハンドを点滅させる（※停止分（0.5f）ももれなく加算！）
								hands.playerHandFireball.registerEntityModifier(new LoopEntityModifier(
										new SequenceEntityModifier(new FadeOutModifier(
												0.005f), new FadeInModifier(0.005f)), 300));
							}
						}
						// プレイヤーの動きをストップ！
						if (グラチェンジフラグ == false) {
							marioSets.playerMarioSet1.stopAnimation();
						} else {
							marioSets.playerMarioSet2.stopAnimation();
						}
						// 攻撃時のグラ
						if (バック転実行フラグ == false) {
							playerAttackAnimation();
						}
						// すでに攻撃中の場合はリセット
						if (ボールハンド実行フラグ == true) {
							// ハンドラーをリセット
							ボール時間.reset();
							unregisterUpdateHandler(ボール時間);
							収納用ハンドラー.remove(ボール時間);
						}
						// ボール時間
						registerUpdateHandler(ボール時間);
						収納用ハンドラー.add(ボール時間);
					}
					// 残りのボールがなくなったら、攻撃ボタンを隠す
				} else {
					// 1度に出せるボールは4つまで！
					if (Nボールカウンター < 3) {
						SoundPlay.seball.stop();
						SoundPlay.seball.play();
						ボールテキスト.registerEntityModifier(
								new LoopEntityModifier(new SequenceEntityModifier(
										new ScaleModifier(0.25f, 1.0f, 1.5f),
										new ScaleModifier(0.25f, 1.5f, 1.0f)), 1));
						現在のボール -= 1;
						Nボールカウンター += 2;
						// ノーマルボール（1こめ）を追加
						fireballs.playerFireballNormal1 = getBaseActivity().getResourceUtil()
								.getAnimatedSprite("player_07_fireball_normal_1.png", 1, 4);
						fireballs.playerFireballNormal1.setTag(
								Fireballs.TAG_PLAYER_07_FIREBALL_NORMAL_1);
						if (グラチェンジフラグ == false) {
							fireballs.playerFireballNormal1.setPosition(
									marioSets.playerMarioSet1.getX() + 16,
									marioSets.playerMarioSet1.getY() + 16);
						} else {
							fireballs.playerFireballNormal1.setPosition(
									marioSets.playerMarioSet2.getX() + 16,
									marioSets.playerMarioSet2.getY() + 16);
						}
						fireballs.playerFireballNormal1.animate(ani速);
						attachChild(fireballs.playerFireballNormal1);
						fireballs.playerFireballNormal1.setZIndex(レイヤー05ボール用);
						sortChildren();
						// ボールをArrayListに放り込む
						収納用Nボール.add(fireballs.playerFireballNormal1);
						// ノーマルボール（2こめ）を追加
						fireballs.playerFireballNormal2 = getBaseActivity().getResourceUtil()
								.getAnimatedSprite("player_08_fireball_normal_2.png", 1, 4);
						fireballs.playerFireballNormal2.setTag(
								Fireballs.TAG_PLAYER_08_FIREBALL_NORMAL_2);
						if (グラチェンジフラグ == false) {
							fireballs.playerFireballNormal2.setPosition(
									marioSets.playerMarioSet1.getX() + 32,
									marioSets.playerMarioSet1.getY());
						} else {
							fireballs.playerFireballNormal2.setPosition(
									marioSets.playerMarioSet2.getX() + 32,
									marioSets.playerMarioSet2.getY());
						}
						fireballs.playerFireballNormal2.animate(ani速);
						attachChild(fireballs.playerFireballNormal2);
						fireballs.playerFireballNormal2.setZIndex(レイヤー05ボール用);
						sortChildren();
						// ボールをArrayListに放り込む
						収納用Nボール.add(fireballs.playerFireballNormal2);
						// 全能力MAXの場合、衝撃波を追加！！
						if (メット取得フラグ == true && シャツ取得フラグ == true
							&& ズボン取得フラグ == true) {
							// 衝撃波（上）を追加
							fireballs.playerFireballShockWaveAdove = getBaseActivity().getResourceUtil()
									.getAnimatedSprite("player_12_fireball_shock_wave_above.png", 1, 2);
							fireballs.playerFireballShockWaveAdove.setTag(
									Fireballs.TAG_PLAYER_12_FIREBALL_SHOCK_WAVE_ADOVE);
							if (グラチェンジフラグ == false) {
								fireballs.playerFireballShockWaveAdove.setPosition(
										marioSets.playerMarioSet1.getX() + 16,
										marioSets.playerMarioSet1.getY() + 16);
							} else {
								fireballs.playerFireballShockWaveAdove.setPosition(
										marioSets.playerMarioSet2.getX() + 16,
										marioSets.playerMarioSet2.getY() + 16);
							}
							fireballs.playerFireballShockWaveAdove.animate(ani速);
							fireballs.playerFireballShockWaveAdove.setAlpha(0.75f);
							attachChild(fireballs.playerFireballShockWaveAdove);
							fireballs.playerFireballShockWaveAdove.setZIndex(レイヤー05ボール用);
							sortChildren();
							// 衝撃波もArrayListに放り込む
							収納用衝撃波上.add(fireballs.playerFireballShockWaveAdove);
							// 衝撃波（下）を追加
							fireballs.playerFireballShockWaveBelow = getBaseActivity().getResourceUtil()
									.getAnimatedSprite("player_13_fireball_shock_wave_below.png", 1, 2);
							fireballs.playerFireballShockWaveBelow.setTag(
									Fireballs.TAG_PLAYER_13_FIREBALL_SHOCK_WAVE_BELOW);
							if (グラチェンジフラグ == false) {
								fireballs.playerFireballShockWaveBelow.setPosition(
										marioSets.playerMarioSet1.getX() + 16,
										marioSets.playerMarioSet1.getY() + 16);
							} else {
								fireballs.playerFireballShockWaveBelow.setPosition(
										marioSets.playerMarioSet2.getX() + 16,
										marioSets.playerMarioSet2.getY() + 16);
							}
							fireballs.playerFireballShockWaveBelow.animate(ani速);
							fireballs.playerFireballShockWaveBelow.setAlpha(0.75f);
							attachChild(fireballs.playerFireballShockWaveBelow);
							fireballs.playerFireballShockWaveBelow.setZIndex(レイヤー05ボール用);
							sortChildren();
							// 衝撃波もArrayListに放り込む
							収納用衝撃波下.add(fireballs.playerFireballShockWaveBelow);
						}
						// ボールハンドの処理
						if (ボールハンドタイムフラグ == false) {
							ボールハンド実行フラグ = true;
							ボールハンドタイムフラグ = true;
							// ボールハンドを追加
							hands.playerHandFireball = getBaseActivity().getResourceUtil()
									.getAnimatedSprite("player_14_hand_fireball.png", 1, 2);
							hands.playerHandFireball.setTag(
									Hands.TAG_PLAYER_14_HAND_FIREBALL);
							if (グラチェンジフラグ == false) {
								hands.playerHandFireball.setPosition(
										marioSets.playerMarioSet1.getX() + 8,
										marioSets.playerMarioSet1.getY() + 8);
							} else {
								hands.playerHandFireball.setPosition(
										marioSets.playerMarioSet2.getX() + 8,
										marioSets.playerMarioSet2.getY() + 8);
							}
							// 無敵時はおててのカラーを変更
							if (状態フラグ無敵 == false) {
								hands.playerHandFireball.setCurrentTileIndex(0);
							} else {
								hands.playerHandFireball.setCurrentTileIndex(1);
							}
							// バック転時はおててを表示しない
							if (バック転実行フラグ == true) {
								hands.playerHandFireball.setAlpha(0);
							}
							attachChild(hands.playerHandFireball);
							hands.playerHandFireball.setZIndex(レイヤー10プレイヤー用);
							sortChildren();
							// 点滅フラグがオンの場合、点滅処理
							if (状態フラグ点滅 == true) {
								// ボールハンドを点滅させる（※停止分（0.5f）ももれなく加算！）
								hands.playerHandFireball.registerEntityModifier(new LoopEntityModifier(
										new SequenceEntityModifier(new FadeOutModifier(
												0.005f), new FadeInModifier(0.005f)), 300));
							}
						}
						// プレイヤーの動きをストップ！
						if (グラチェンジフラグ == false) {
							marioSets.playerMarioSet1.stopAnimation();
						} else {
							marioSets.playerMarioSet2.stopAnimation();
						}
						// 攻撃時のグラ
						if (バック転実行フラグ == false) {
							playerAttackAnimation();
						}
						// すでに攻撃中の場合はリセット
						if (ボールハンド実行フラグ == true) {
							// ハンドラーをリセット
							ボール時間.reset();
							unregisterUpdateHandler(ボール時間);
							収納用ハンドラー.remove(ボール時間);
						}
						// ボール時間
						registerUpdateHandler(ボール時間);
						収納用ハンドラー.add(ボール時間);
						// ※ここで隠す
						if (攻撃ボタン位置 == 0) {
							ボール攻撃ボタンプッシュ.setPosition(0, 480);
							ボール攻撃ボタン.setPosition(0, 480);
							パンチ攻撃ボタンプッシュ.setPosition(0, 352);
							パンチ攻撃ボタン.setPosition(0, 352);
						} else if (攻撃ボタン位置 == 1) {
							ボール攻撃ボタンプッシュ.setPosition(336, 480);
							ボール攻撃ボタン.setPosition(336, 480);
							パンチ攻撃ボタンプッシュ.setPosition(336, 352);
							パンチ攻撃ボタン.setPosition(336, 352);
						} else if (攻撃ボタン位置 == 2) {
							ボール攻撃ボタンプッシュ.setPosition(672, 480);
							ボール攻撃ボタン.setPosition(672, 480);
							パンチ攻撃ボタンプッシュ.setPosition(672, 352);
							パンチ攻撃ボタン.setPosition(672, 352);
						}
					}
				}
			}
			// 無敵時は強力なボールを発射！
		} else {
			// シャツ"無し"の場合、シングルボール処理
			if (シャツ取得フラグ == false) {
				// 1度に出せるボールは2つまで！
				if (Sボールカウンター < 2) {
					SoundPlay.seball.stop();
					SoundPlay.seball.play();
					// ボイスのランダム処理
					int r = (int)(Math.random() * 3);
					switch (r) {
					case 0:
						VoicePlay.voiceSuperBall1.stop();
						VoicePlay.voiceSuperBall1.play();
						break;
					case 1:
						VoicePlay.voiceSuperBall2.stop();
						VoicePlay.voiceSuperBall2.play();
						break;
					case 2:
						VoicePlay.voiceSuperBall3.stop();
						VoicePlay.voiceSuperBall3.play();
						break;
					}
					Sボールカウンター += 1;
					// スーパーボールを追加
					fireballs.playerFireballSuper1 = getBaseActivity().getResourceUtil()
							.getAnimatedSprite("player_09_fireball_super_1.png", 1, 4);
					fireballs.playerFireballSuper1.setTag(
							Fireballs.TAG_PLAYER_09_FIREBALL_SUPER_1);
					if (グラチェンジフラグ == false) {
						fireballs.playerFireballSuper1.setPosition(
								marioSets.playerMarioSet1.getX() + 32,
								marioSets.playerMarioSet1.getY());
					} else {
						fireballs.playerFireballSuper1.setPosition(
								marioSets.playerMarioSet2.getX() + 32,
								marioSets.playerMarioSet2.getY());
					}
					fireballs.playerFireballSuper1.animate(ani速);
					attachChild(fireballs.playerFireballSuper1);
					fireballs.playerFireballSuper1.setZIndex(レイヤー05ボール用);
					sortChildren();
					// ボールをArrayListに放り込む
					収納用Sボール.add(fireballs.playerFireballSuper1);
					// 全能力MAXの場合、衝撃波を追加！！
					if (メット取得フラグ == true && シャツ取得フラグ == true
						&& ズボン取得フラグ == true) {
						// 衝撃波（上）を追加
						fireballs.playerFireballShockWaveAdove = getBaseActivity().getResourceUtil()
								.getAnimatedSprite("player_12_fireball_shock_wave_above.png", 1, 2);
						fireballs.playerFireballShockWaveAdove.setTag(
								Fireballs.TAG_PLAYER_12_FIREBALL_SHOCK_WAVE_ADOVE);
						if (グラチェンジフラグ == false) {
							fireballs.playerFireballShockWaveAdove.setPosition(
									marioSets.playerMarioSet1.getX() + 16,
									marioSets.playerMarioSet1.getY() + 16);
						} else {
							fireballs.playerFireballShockWaveAdove.setPosition(
									marioSets.playerMarioSet2.getX() + 16,
									marioSets.playerMarioSet2.getY() + 16);
						}
						fireballs.playerFireballShockWaveAdove.animate(ani速);
						fireballs.playerFireballShockWaveAdove.setAlpha(0.75f);
						attachChild(fireballs.playerFireballShockWaveAdove);
						fireballs.playerFireballShockWaveAdove.setZIndex(レイヤー05ボール用);
						sortChildren();
						// 衝撃波もArrayListに放り込む
						収納用衝撃波上.add(fireballs.playerFireballShockWaveAdove);
						// 衝撃波（下）を追加
						fireballs.playerFireballShockWaveBelow = getBaseActivity().getResourceUtil()
								.getAnimatedSprite("player_13_fireball_shock_wave_below.png", 1, 2);
						fireballs.playerFireballShockWaveBelow.setTag(
								Fireballs.TAG_PLAYER_13_FIREBALL_SHOCK_WAVE_BELOW);
						if (グラチェンジフラグ == false) {
							fireballs.playerFireballShockWaveBelow.setPosition(
									marioSets.playerMarioSet1.getX() + 16,
									marioSets.playerMarioSet1.getY() + 16);
						} else {
							fireballs.playerFireballShockWaveBelow.setPosition(
									marioSets.playerMarioSet2.getX() + 16,
									marioSets.playerMarioSet2.getY() + 16);
						}
						fireballs.playerFireballShockWaveBelow.animate(ani速);
						fireballs.playerFireballShockWaveBelow.setAlpha(0.75f);
						attachChild(fireballs.playerFireballShockWaveBelow);
						fireballs.playerFireballShockWaveBelow.setZIndex(レイヤー05ボール用);
						sortChildren();
						// 衝撃波もArrayListに放り込む
						収納用衝撃波下.add(fireballs.playerFireballShockWaveBelow);
					}
					// ボールハンドの処理
					if (ボールハンドタイムフラグ == false) {
						ボールハンド実行フラグ = true;
						ボールハンドタイムフラグ = true;
						// ボールハンドを追加
						hands.playerHandFireball = getBaseActivity().getResourceUtil()
								.getAnimatedSprite("player_14_hand_fireball.png", 1, 2);
						hands.playerHandFireball.setTag(
								Hands.TAG_PLAYER_14_HAND_FIREBALL);
						if (グラチェンジフラグ == false) {
							hands.playerHandFireball.setPosition(
									marioSets.playerMarioSet1.getX() + 8,
									marioSets.playerMarioSet1.getY() + 8);
						} else {
							hands.playerHandFireball.setPosition(
									marioSets.playerMarioSet2.getX() + 8,
									marioSets.playerMarioSet2.getY() + 8);
						}
						// 無敵時はおててのカラーを変更
						if (状態フラグ無敵 == false) {
							hands.playerHandFireball.setCurrentTileIndex(0);
						} else {
							hands.playerHandFireball.setCurrentTileIndex(1);
						}
						// バック転時はおててを表示しない
						if (バック転実行フラグ == true) {
							hands.playerHandFireball.setAlpha(0);
						}
						attachChild(hands.playerHandFireball);
						hands.playerHandFireball.setZIndex(レイヤー10プレイヤー用);
						sortChildren();
						// 点滅フラグがオンの場合、点滅処理
						if (状態フラグ点滅 == true) {
							// ボールハンドを点滅させる（※停止分（0.5f）ももれなく加算！）
							hands.playerHandFireball.registerEntityModifier(new LoopEntityModifier(
									new SequenceEntityModifier(new FadeOutModifier(
											0.005f), new FadeInModifier(0.005f)), 300));
						}
					}
					// プレイヤーの動きをストップ！
					if (グラチェンジフラグ == false) {
						marioSets.playerMarioSet1.stopAnimation();
					} else {
						marioSets.playerMarioSet2.stopAnimation();
					}
					// 攻撃時のグラ
					if (バック転実行フラグ == false) {
						playerAttackAnimation();
					}
					// すでに攻撃中の場合はリセット
					if (ボールハンド実行フラグ == true) {
						// ハンドラーをリセット
						ボール時間.reset();
						unregisterUpdateHandler(ボール時間);
						収納用ハンドラー.remove(ボール時間);
					}
					// ボール時間
					registerUpdateHandler(ボール時間);
					収納用ハンドラー.add(ボール時間);
				}
				// シャツ"有り"の場合も、シングルボール処理
				// ※但し、グラフィック上ではダブルボール処理
			} else if (シャツ取得フラグ == true) {
				// 1度に出せるボールは2つまで！
				if (Sボールカウンター < 2) {
					SoundPlay.seball.stop();
					SoundPlay.seball.play();
					// ボイスのランダム処理
					int r = (int)(Math.random() * 3);
					switch (r) {
					case 0:
						VoicePlay.voiceSuperBall1.stop();
						VoicePlay.voiceSuperBall1.play();
						break;
					case 1:
						VoicePlay.voiceSuperBall2.stop();
						VoicePlay.voiceSuperBall2.play();
						break;
					case 2:
						VoicePlay.voiceSuperBall3.stop();
						VoicePlay.voiceSuperBall3.play();
						break;
					}
					Sボールカウンター += 1;
					// スーパーボールを追加
					fireballs.playerFireballSuper2 = getBaseActivity().getResourceUtil()
							.getAnimatedSprite("player_10_fireball_super_2.png", 1, 4);
					fireballs.playerFireballSuper2.setTag(
							Fireballs.TAG_PLAYER_10_FIREBALL_SUPER_2);
					if (グラチェンジフラグ == false) {
						fireballs.playerFireballSuper2.setPosition(
								marioSets.playerMarioSet1.getX() + 32,
								marioSets.playerMarioSet1.getY() - 32);
					} else {
						fireballs.playerFireballSuper2.setPosition(
								marioSets.playerMarioSet2.getX() + 32,
								marioSets.playerMarioSet2.getY() - 32);
					}
					fireballs.playerFireballSuper2.animate(ani速);
					attachChild(fireballs.playerFireballSuper2);
					fireballs.playerFireballSuper2.setZIndex(レイヤー05ボール用);
					sortChildren();
					// ボールをArrayListに放り込む
					収納用Sボール.add(fireballs.playerFireballSuper2);
					// 全能力MAXの場合、衝撃波を追加！！
					if (メット取得フラグ == true && シャツ取得フラグ == true
						&& ズボン取得フラグ == true) {
						// 衝撃波（上）を追加
						fireballs.playerFireballShockWaveAdove = getBaseActivity().getResourceUtil()
								.getAnimatedSprite("player_12_fireball_shock_wave_above.png", 1, 2);
						fireballs.playerFireballShockWaveAdove.setTag(
								Fireballs.TAG_PLAYER_12_FIREBALL_SHOCK_WAVE_ADOVE);
						if (グラチェンジフラグ == false) {
							fireballs.playerFireballShockWaveAdove.setPosition(
									marioSets.playerMarioSet1.getX() + 16,
									marioSets.playerMarioSet1.getY() + 16);
						} else {
							fireballs.playerFireballShockWaveAdove.setPosition(
									marioSets.playerMarioSet2.getX() + 16,
									marioSets.playerMarioSet2.getY() + 16);
						}
						fireballs.playerFireballShockWaveAdove.animate(ani速);
						fireballs.playerFireballShockWaveAdove.setAlpha(0.75f);
						attachChild(fireballs.playerFireballShockWaveAdove);
						fireballs.playerFireballShockWaveAdove.setZIndex(レイヤー05ボール用);
						sortChildren();
						// 衝撃波もArrayListに放り込む
						収納用衝撃波上.add(fireballs.playerFireballShockWaveAdove);
						// 衝撃波（下）を追加
						fireballs.playerFireballShockWaveBelow = getBaseActivity().getResourceUtil()
								.getAnimatedSprite("player_13_fireball_shock_wave_below.png", 1, 2);
						fireballs.playerFireballShockWaveBelow.setTag(
								Fireballs.TAG_PLAYER_13_FIREBALL_SHOCK_WAVE_BELOW);
						if (グラチェンジフラグ == false) {
							fireballs.playerFireballShockWaveBelow.setPosition(
									marioSets.playerMarioSet1.getX() + 16,
									marioSets.playerMarioSet1.getY() + 16);
						} else {
							fireballs.playerFireballShockWaveBelow.setPosition(
									marioSets.playerMarioSet2.getX() + 16,
									marioSets.playerMarioSet2.getY() + 16);
						}
						fireballs.playerFireballShockWaveBelow.animate(ani速);
						fireballs.playerFireballShockWaveBelow.setAlpha(0.75f);
						attachChild(fireballs.playerFireballShockWaveBelow);
						fireballs.playerFireballShockWaveBelow.setZIndex(レイヤー05ボール用);
						sortChildren();
						// 衝撃波もArrayListに放り込む
						収納用衝撃波下.add(fireballs.playerFireballShockWaveBelow);
					}
					// ボールハンドの処理
					if (ボールハンドタイムフラグ == false) {
						ボールハンド実行フラグ = true;
						ボールハンドタイムフラグ = true;
						// ボールハンドを追加
						hands.playerHandFireball = getBaseActivity().getResourceUtil()
								.getAnimatedSprite("player_14_hand_fireball.png", 1, 2);
						hands.playerHandFireball.setTag(
								Hands.TAG_PLAYER_14_HAND_FIREBALL);
						if (グラチェンジフラグ == false) {
							hands.playerHandFireball.setPosition(
									marioSets.playerMarioSet1.getX() + 8,
									marioSets.playerMarioSet1.getY() + 8);
						} else {
							hands.playerHandFireball.setPosition(
									marioSets.playerMarioSet2.getX() + 8,
									marioSets.playerMarioSet2.getY() + 8);
						}
						// 無敵時はおててのカラーを変更
						if (状態フラグ無敵 == false) {
							hands.playerHandFireball.setCurrentTileIndex(0);
						} else {
							hands.playerHandFireball.setCurrentTileIndex(1);
						}
						// バック転時はおててを表示しない
						if (バック転実行フラグ == true) {
							hands.playerHandFireball.setAlpha(0);
						}
						attachChild(hands.playerHandFireball);
						hands.playerHandFireball.setZIndex(レイヤー10プレイヤー用);
						sortChildren();
						// 点滅フラグがオンの場合、点滅処理
						if (状態フラグ点滅 == true) {
							// ボールハンドを点滅させる（※停止分（0.5f）ももれなく加算！）
							hands.playerHandFireball.registerEntityModifier(new LoopEntityModifier(
									new SequenceEntityModifier(new FadeOutModifier(
											0.005f), new FadeInModifier(0.005f)), 300));
						}
					}
					// プレイヤーの動きをストップ！
					if (グラチェンジフラグ == false) {
						marioSets.playerMarioSet1.stopAnimation();
					} else {
						marioSets.playerMarioSet2.stopAnimation();
					}
					// 攻撃時のグラ
					if (バック転実行フラグ == false) {
						playerAttackAnimation();
					}
					// すでに攻撃中の場合はリセット
					if (ボールハンド実行フラグ == true) {
						// ハンドラーをリセット
						ボール時間.reset();
						unregisterUpdateHandler(ボール時間);
						収納用ハンドラー.remove(ボール時間);
					}
					// ボール時間
					registerUpdateHandler(ボール時間);
					収納用ハンドラー.add(ボール時間);
				}
			}
		}
	}
	// 攻撃（パンチ）スプライト
	public void punchAttackSprite() {
		if (パンチハンドタイムフラグ == false) {
			SoundPlay.sePunch.stop();
			SoundPlay.sePunch.play();
			VoicePlay.voicePunch.stop();
			VoicePlay.voicePunch.play();
			パンチハンド実行フラグ = true;
			パンチハンドタイムフラグ = true;
			// パンチハンドを追加
			hands.playerHandPunch = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("player_15_hand_punch.png", 1, 2);
			hands.playerHandPunch.setTag(
					Hands.TAG_PLAYER_15_HAND_PUNCH);
			if (グラチェンジフラグ == false) {
				hands.playerHandPunch.setPosition(
						marioSets.playerMarioSet1.getX() + 8,
						marioSets.playerMarioSet1.getY() + 8);
			} else {
				hands.playerHandPunch.setPosition(
						marioSets.playerMarioSet2.getX() + 8,
						marioSets.playerMarioSet2.getY() + 8);
			}
			if (状態フラグ無敵 == false) {
				hands.playerHandPunch.setCurrentTileIndex(0);
			} else {
				hands.playerHandPunch.setCurrentTileIndex(1);
			}
			attachChild(hands.playerHandPunch);
			hands.playerHandPunch.setZIndex(レイヤー10プレイヤー用);
			sortChildren();
			// 点滅フラグがオンの場合、点滅処理
			if (状態フラグ点滅 == true) {
				// パンチハンドを点滅させる（※停止分（0.5f）ももれなく加算！）
				hands.playerHandPunch.registerEntityModifier(new LoopEntityModifier(
						new SequenceEntityModifier(new FadeOutModifier(
								0.005f), new FadeInModifier(0.005f)), 300));
			}
			// プレイヤーの動きをストップ！
			if (グラチェンジフラグ == false) {
				marioSets.playerMarioSet1.stopAnimation();
			} else {
				marioSets.playerMarioSet2.stopAnimation();
			}
			// 攻撃時のグラ
			playerAttackAnimation();
			// パンチ実行時間
			registerUpdateHandler(パンチ実行時間);
			収納用ハンドラー.add(パンチ実行時間);
		}
	}
	// 無敵（ノーマル）スプライト
	public void normalStarmanSprite() {
		musicStop();
		// ボイスのランダム処理
		int r = (int)(Math.random() * 3);
		switch (r) {
		case 0:
			VoicePlay.voicePowerUpItem1.stop();
			VoicePlay.voicePowerUpItem1.play();
			break;
		case 1:
			VoicePlay.voicePowerUpItem2.stop();
			VoicePlay.voicePowerUpItem2.play();
			break;
		case 2:
			VoicePlay.voicePowerUpItem3.stop();
			VoicePlay.voicePowerUpItem3.play();
			break;
		}
		状態フラグ無敵 = true;
		現在のノーマルメーター -= 120;
		// 無敵メーターに切り替え
		メーターフィーバー = getBaseActivity().getResourceUtil()
		.getAnimatedSprite("icon_14_normal_meter_2.png", 1, 4);
		メーターフィーバー.setPosition(640, 80);
		メーターフィーバー.setCurrentTileIndex(1);
		attachChild(メーターフィーバー);
		メーターフィーバー.setZIndex(レイヤー12アイコン用);
		sortChildren();
		// 現在のボールが0の場合のみ、ボール攻撃ボタンを表示
		if (現在のボール == 0) {
			if (攻撃ボタン位置 == 0) {
				ボール攻撃ボタンプッシュ.setPosition(0, 352);
				ボール攻撃ボタン.setPosition(0, 352);
				パンチ攻撃ボタンプッシュ.setPosition(0, 480);
				パンチ攻撃ボタン.setPosition(0, 480);
			} else if (攻撃ボタン位置 == 1) {
				ボール攻撃ボタンプッシュ.setPosition(336, 352);
				ボール攻撃ボタン.setPosition(336, 352);
				パンチ攻撃ボタンプッシュ.setPosition(336, 480);
				パンチ攻撃ボタン.setPosition(336, 480);
			} else if (攻撃ボタン位置 == 2) {
				ボール攻撃ボタンプッシュ.setPosition(672, 352);
				ボール攻撃ボタン.setPosition(672, 352);
				パンチ攻撃ボタンプッシュ.setPosition(672, 480);
				パンチ攻撃ボタン.setPosition(672, 480);
			}
			ボール攻撃ボタンプッシュ.registerEntityModifier(
					new LoopEntityModifier(new SequenceEntityModifier(
							new ScaleModifier(0.25f, 1.0f, 1.5f),
							new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
			ボール攻撃ボタン.registerEntityModifier(
					new LoopEntityModifier(new SequenceEntityModifier(
							new ScaleModifier(0.25f, 1.0f, 1.5f),
							new ScaleModifier(0.25f, 1.5f, 1.0f)), 2));
		}
		// マリオのグラをチェンジ！
		if (グラチェンジフラグ == true) {
			グラチェンジフラグ = false;
			// マリオのグラセット1
			marioSets.playerMarioSet1 = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("player_01_mario_set_1.png", 1, 30);
			marioSets.playerMarioSet1.setPosition(marioSets.playerMarioSet2);
			attachChild(marioSets.playerMarioSet1);
			marioSets.playerMarioSet1.setZIndex(レイヤー10プレイヤー用);
			sortChildren();
			// 元のグラは削除
			marioSets.playerMarioSet2.detachSelf();
		}
		// 攻撃時のグラ
		if (ボールハンド実行フラグ == true || パンチハンド実行フラグ == true) {
			playerAttackAnimation();
		} else {
			// ダッシュ時のグラ
			if (プレイヤーのダッシュフラグ == true && プレイヤーのジャンプフラグ == false) {
				playerDashAnimation();
				// ジャンプ時のグラ
			} else if (プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true) {
				playerJumpAnimation();
			}
		}
		// メーターをふぃーどばっく！
		メーターフィーバー.registerEntityModifier(
				new LoopEntityModifier(new SequenceEntityModifier(
						new ScaleModifier(0.25f, 1.0f, 1.5f),
						new ScaleModifier(0.25f, 1.5f, 1.0f)), 4));
		gamePause();
		// 待機フラグをON！
		ゲーム待機中かどうか = true;
		// 0.5秒ストップ！
		registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
			public void onTimePassed(TimerHandler pTimeHandler) {
				musicPlay();
				// 待機フラグをOFF！
				ゲーム待機中かどうか = false;
				gameResume();
			}
		}));
		// 2秒ストップ！
		registerUpdateHandler(new TimerHandler(2f, new ITimerCallback() {
			public void onTimePassed(TimerHandler pTimeHandler) {
				メーターフィーバー.detachSelf();
			}
		}));
		// すでに無敵中の場合はリセット
		if (状態フラグ無敵 == true) {
			// ハンドラーをリセット
			無敵時間.reset();
			unregisterUpdateHandler(無敵時間);
			収納用ハンドラー.remove(無敵時間);
		}
		// 無敵時間
		registerUpdateHandler(無敵時間);
		収納用ハンドラー.add(無敵時間);
	}
	// 無敵（ファイナル）スプライト
	public void finalStarmanSprite() {
		
	}
	
	// ===========================================================
	// ポーズ系
	// ===========================================================
	
	// ポーズの処理
	public void pauseView() {
		// ゲームプレイ時以外はポーズ画面を出さない
		if (ゲーム待機中かどうか == true || ゲームオーバーかどうか == true || コースの端っこかどうか == true) {
			return;
			// ポーズ時も、もちろん出さない！
		} else if (ポーズ中かどうか == true) {
			return;
			// スタッフクレジット時はミュージックのみストップ
		} else if (コースカウンター == 22) {
			状態フラグ中断中 = true;
			musicPause();
			return;
		}
		SoundPlay.sePause.stop();
		SoundPlay.sePause.play();
		ポーズ中かどうか = true;
		ポーズプレイ押したかどうか  = false;
		musicPause();
		gamePause();
		// 四角形を描画
		ゲームポーズ四角形 = new Rectangle(0, 0, getBaseActivity().getEngine()
				.getCamera().getWidth(), getBaseActivity().getEngine()
				.getCamera().getHeight(), getBaseActivity()
				.getVertexBufferObjectManager());
		ゲームポーズ四角形.setBlendFunction(
				GL10.GL_ONE_MINUS_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);
		ゲームポーズ四角形.setAlpha(0.75f);
		ゲームポーズ四角形.setColor(0, 0, 0);
		attachChild(ゲームポーズ四角形);
		ゲームポーズ四角形.setZIndex(レイヤー16ポーズ用);
		sortChildren();
		// アイコン
		// アイコンマリオをアニマテッドで描画
		if (メット取得フラグ == true
				&& シャツ取得フラグ == false && ズボン取得フラグ == false) {
			アイコンマリオ = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("player_02_mario_set_2.png", 1, 30);
			アイコンマリオ.setPosition(320, 192);
			アイコンマリオ.setCurrentTileIndex(3);
			attachChild(アイコンマリオ);
			アイコンマリオ.setZIndex(レイヤー16ポーズ用);
			sortChildren();
		} else if (メット取得フラグ == true && シャツ取得フラグ == true
				&& ズボン取得フラグ == false) {
			アイコンマリオ = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("player_02_mario_set_2.png", 1, 30);
			アイコンマリオ.setPosition(320, 192);
			アイコンマリオ.setCurrentTileIndex(8);
			attachChild(アイコンマリオ);
			アイコンマリオ.setZIndex(レイヤー16ポーズ用);
			sortChildren();
		} else if (シャツ取得フラグ == true
				&& メット取得フラグ == false && ズボン取得フラグ == false) {
			アイコンマリオ = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("player_02_mario_set_2.png", 1, 30);
			アイコンマリオ.setPosition(320, 192);
			アイコンマリオ.setCurrentTileIndex(13);
			attachChild(アイコンマリオ);
			アイコンマリオ.setZIndex(レイヤー16ポーズ用);
			sortChildren();
		} else if (シャツ取得フラグ == true && ズボン取得フラグ == true
				&& メット取得フラグ == false) {
			アイコンマリオ = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("player_02_mario_set_2.png", 1, 30);
			アイコンマリオ.setPosition(320, 192);
			アイコンマリオ.setCurrentTileIndex(18);
			attachChild(アイコンマリオ);
			アイコンマリオ.setZIndex(レイヤー16ポーズ用);
			sortChildren();
		} else if (ズボン取得フラグ == true
				&& メット取得フラグ == false && シャツ取得フラグ == false) {
			アイコンマリオ = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("player_02_mario_set_2.png", 1, 30);
			アイコンマリオ.setPosition(320, 192);
			アイコンマリオ.setCurrentTileIndex(23);
			attachChild(アイコンマリオ);
			アイコンマリオ.setZIndex(レイヤー16ポーズ用);
			sortChildren();
		} else if (ズボン取得フラグ == true && メット取得フラグ == true
				&& シャツ取得フラグ == false) {
			アイコンマリオ = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("player_02_mario_set_2.png", 1, 30);
			アイコンマリオ.setPosition(320, 192);
			アイコンマリオ.setCurrentTileIndex(28);
			attachChild(アイコンマリオ);
			アイコンマリオ.setZIndex(レイヤー16ポーズ用);
			sortChildren();
		} else if (ズボン取得フラグ == true && メット取得フラグ == true && シャツ取得フラグ == true) {
			アイコンマリオ = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("player_01_mario_set_1.png", 1, 30);
			アイコンマリオ.setPosition(320, 192);
			アイコンマリオ.setCurrentTileIndex(8);
			attachChild(アイコンマリオ);
			アイコンマリオ.setZIndex(レイヤー16ポーズ用);
			sortChildren();
		} else if (ズボン取得フラグ == false && メット取得フラグ == false && シャツ取得フラグ == false) {
			アイコンマリオ = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("player_01_mario_set_1.png", 1, 30);
			アイコンマリオ.setPosition(320, 192);
			アイコンマリオ.setCurrentTileIndex(3);
			attachChild(アイコンマリオ);
			アイコンマリオ.setZIndex(レイヤー16ポーズ用);
			sortChildren();
		}
		// クリスタルの表示処理
		// ノーマルカラーとスペシャルカラー
		if (コースカウンター <= 16) {
			if (現在のクリスタル >= 1) {
				アイコンノークリ1 = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("icon_10_power_crystal.png", 1, 9);
				アイコンノークリ1.setPosition(256, 272);
				アイコンノークリ1.animate(
						new long[] { ani遅, ani遅, ani遅, ani遅, }, 1, 4, true);
				attachChild(アイコンノークリ1);
				アイコンノークリ1.setZIndex(レイヤー16ポーズ用);
				sortChildren();
			} else {
				アイコンノークリ1 = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("icon_10_power_crystal.png", 1, 9);
				アイコンノークリ1.setPosition(256, 272);
				アイコンノークリ1.setCurrentTileIndex(0);
				attachChild(アイコンノークリ1);
				アイコンノークリ1.setZIndex(レイヤー16ポーズ用);
				sortChildren();
			}
			if (現在のクリスタル >= 2) {
				アイコンノークリ2 = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("icon_10_power_crystal.png", 1, 9);
				placeToCenterX(アイコンノークリ2, 272);
				アイコンノークリ2.animate(
						new long[] { ani遅, ani遅, ani遅, ani遅, }, 1, 4, true);
				attachChild(アイコンノークリ2);
				アイコンノークリ2.setZIndex(レイヤー16ポーズ用);
				sortChildren();
			} else {
				アイコンノークリ2 = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("icon_10_power_crystal.png", 1, 9);
				placeToCenterX(アイコンノークリ2, 272);
				アイコンノークリ2.setCurrentTileIndex(0);
				attachChild(アイコンノークリ2);
				アイコンノークリ2.setZIndex(レイヤー16ポーズ用);
				sortChildren();
			}
			if (現在のクリスタル >= 3) {
				アイコンノークリ3 = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("icon_10_power_crystal.png", 1, 9);
				アイコンノークリ3.setPosition(512, 272);
				アイコンノークリ3.animate(
						new long[] { ani遅, ani遅, ani遅, ani遅, }, 1, 4, true);
				attachChild(アイコンノークリ3);
				アイコンノークリ3.setZIndex(レイヤー16ポーズ用);
				sortChildren();
			} else {
				アイコンノークリ3 = getBaseActivity().getResourceUtil()
						.getAnimatedSprite("icon_10_power_crystal.png", 1, 9);
				アイコンノークリ3.setPosition(512, 272);
				アイコンノークリ3.setCurrentTileIndex(0);
				attachChild(アイコンノークリ3);
				アイコンノークリ3.setZIndex(レイヤー16ポーズ用);
				sortChildren();
			}
		} else {
			// スペクリは後日追加！
		}
		// 英文字
		// Game Pausedアイコンを表示
		ゲーポーズ文字 = getBaseActivity().getResourceUtil()
				.getAnimatedSprite("icon_39_game_paused.png", 1, 5);
		placeToCenterX(ゲーポーズ文字, 112);
		ゲーポーズ文字.animate(ani遅);
		attachChild(ゲーポーズ文字);
		ゲーポーズ文字.setZIndex(レイヤー16ポーズ用);
		sortChildren();
		// テキスト
		// まず、バルーン時はライテキを移動
		if (状態フラグ復活中	 == true) {
			テキスト3.setPosition(394, 212);
			テキスト3.setZIndex(レイヤー17デバッグ用);
			sortChildren();
			ライフテキスト一時.setPosition(464, 212);
			ライフテキスト一時.setZIndex(レイヤー17デバッグ用);
			sortChildren();
		} else {
			// 端末に搭載されたフォントを利用する
			Texture texture = new BitmapTextureAtlas(getBaseActivity()
					.getTextureManager(), 512, 512,
					TextureOptions.BILINEAR_PREMULTIPLYALPHA);
			Font font = new Font(getBaseActivity().getFontManager(), texture,
					Typeface.DEFAULT_BOLD, 24, true, Color.WHITE);
			getBaseActivity().getTextureManager().loadTexture(texture);
			getBaseActivity().getFontManager().loadFont(font);
			// テキスト3の表示
			テキスト3		= new Text(394, 212, font, "×",
					42, new TextOptions(HorizontalAlign.LEFT),
					getBaseActivity().getVertexBufferObjectManager());
			attachChild(テキスト3);
			テキスト3.setZIndex(レイヤー17デバッグ用);
			sortChildren();
			// ライフテキスト一時の表示
			ライフテキスト一時	= new Text(464, 212, font, ""
					+ 現在のライフ, 42, new TextOptions(HorizontalAlign.LEFT),
					getBaseActivity().getVertexBufferObjectManager());
			attachChild(ライフテキスト一時);
			ライフテキスト一時.setZIndex(レイヤー17デバッグ用);
			sortChildren();
		}
		// ボタン
		try {
			// プレイボタンの追加
			gamePauses.buttonGamePausePlay = getBaseActivity().getResourceUtil()
					.getButtonSprite("button_25_game_pause_play.png",
							"button_25_game_pause_play_push.png");
			gamePauses.buttonGamePausePlay.setPosition(160, 320);
			gamePauses.buttonGamePausePlay.setTag(GamePauses.TAG_BUTTON_25_GAME_PAUSE_PLAY);
			gamePauses.buttonGamePausePlay.setOnClickListener(this);
			registerTouchArea(gamePauses.buttonGamePausePlay);
			ゲームポーズ四角形.attachChild(gamePauses.buttonGamePausePlay);
			// オプションボタン（ポーズ時）の追加
			gamePauses.buttonGamePauseOption = getBaseActivity().getResourceUtil()
					.getButtonSprite("button_26_game_pause_option.png",
							"button_26_game_pause_option_push.png");
			placeToCenterX(gamePauses.buttonGamePauseOption, 320);
			gamePauses.buttonGamePauseOption.setTag(GamePauses.TAG_BUTTON_26_GAME_PAUSE_OPTION);
			gamePauses.buttonGamePauseOption.setOnClickListener(this);
			registerTouchArea(gamePauses.buttonGamePauseOption);
			ゲームポーズ四角形.attachChild(gamePauses.buttonGamePauseOption);
			// タイトルボタン（ポーズ時）の追加
			gamePauses.buttonGamePauseTitle = getBaseActivity().getResourceUtil()
					.getButtonSprite("button_27_game_pause_title.png",
							"button_27_game_pause_title_push.png");
			gamePauses.buttonGamePauseTitle.setPosition(544, 320);
			gamePauses.buttonGamePauseTitle.setTag(GamePauses.TAG_BUTTON_27_GAME_PAUSE_TITLE);
			gamePauses.buttonGamePauseTitle.setOnClickListener(this);
			registerTouchArea(gamePauses.buttonGamePauseTitle);
			ゲームポーズ四角形.attachChild(gamePauses.buttonGamePauseTitle);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	// ゲームを中断
	public void gamePause() {
		// 全てのアニマテッドスプライトのアニメーションをストップ！
		for (int i = 0; i < getChildCount(); i++) {
			if (getChildByIndex(i)instanceof AnimatedSprite) {
				((AnimatedSprite)getChildByIndex(i)).stopAnimation();
			}
		}
		// ボタンが効かなくなる処理
		unregisterTouchArea(ボール攻撃ボタン);
		unregisterTouchArea(パンチ攻撃ボタン);
		// ハンドラーをストップ！
		if (状態フラグ復活中 == true) {
			unregisterUpdateHandler(復活時レート);
		}
		unregisterUpdateHandler(フレームレート);
		unregisterUpdateHandler(キラー出現レート);
		// ハンドラーを格納
		for (CustomTimerHandler handler : 収納用ハンドラー) {
			handler.pause();
		}
	}
	// ゲームを再開
	public void gameResume() {
		// ボタンが効くようになる処理
		if (状態フラグ復活中 == false) {
			registerTouchArea(ボール攻撃ボタン);
			registerTouchArea(パンチ攻撃ボタン);
		}
		// ストップしたハンドラーを再度動かす
		if (状態フラグ復活中 == true) {
			registerUpdateHandler(復活時レート);
		}
		registerUpdateHandler(フレームレート);
		registerUpdateHandler(キラー出現レート);
		// アニマテッドスプライトを再度動かす
		if (メモリーの開放をしたかどうか == false) {
			// ワールド3の背景
			if (コースカウンター == 9 || コースカウンター == 11
					|| コースカウンター == 19) {
				ワールド3.animate(ani遅);
			}
			// アイコン
			アイコイン.animate(ani遅);
			アイコンボール.animate(ani速);
			if (現在のクリスタル == 0) {
				アイコンクリス.setCurrentTileIndex(0);
			} else if (現在のクリスタル == 1) {
				アイコンクリス.animate(
						new long[] { ani遅, ani遅, ani遅, ani遅, }, 1, 4, true);
			} else if (現在のクリスタル == 2) {
				アイコンクリス.animate(
						new long[] { ani遅, ani遅, ani遅, ani遅, }, 5, 8, true);
			}
			アイコンカーソル.animate(ani並);
			// エフェクト
			if (出現フラグブロックコイン黄色 == true) {
				blockCoins.effectBlockCoinYellow.animate(ani並);
			}
			if (出現フラグブロックコイン赤色 == true) {
				blockCoins.effectBlockCoinRed.animate(ani並);
			}
			if (出現フラグブロックコイン青色 == true) {
				blockCoins.effectBlockCoinBlue.animate(ani並);
			}
			if (出現フラグブロックメットアイテム == true) {
				ブロックメットアイテム.animate(ani速);
			}
			if (出現フラグブロックシャツアイテム == true) {
				ブロックシャツアイテム.animate(ani速);
			}
			if (出現フラグブロックズボンアイテム == true) {
				ブロックズボンアイテム.animate(ani速);
			}
			if (出現フラグブロックワンナップキノコ == true) {
				// ワンナップキノコとおうかん
				if (現在のライフ < 10) {
					ブロックワンナップキノコ.animate(
							new long[] { ani遅, ani遅, ani遅, ani遅, }, 0, 3, true);
				} else {
					ブロックワンナップキノコ.animate(
							new long[] { ani遅, ani遅, ani遅, ani遅, }, 4, 7, true);
				}
			}
			if (出現フラグブロックファイアフラワー1 == true) {
				ブロックファイアフラワー1.animate(ani速);
			}
			if (出現フラグブロックファイアフラワー2 == true) {
				ブロックファイアフラワー2.animate(ani速);
			}
			// 敵キャラ
			if (出現フラグきいろコインバルーン == true) {
				balloons.enemyBalloonCoinYellow.animate(ani遅);
			}
			if (出現フラグあかコインバルーン == true) {
				balloons.enemyBalloonCoinRed.animate(ani遅);
			}
			if (出現フラグあおコインバルーン == true) {
				balloons.enemyBalloonCoinBlue.animate(ani遅);
			}
			if (出現フラグワンナップキノコバルーン == true) {
				balloons.enemyBalloonOneUpMushroom.animate(ani遅);
			}
			if (出現フラグファイアフラワーバルーン == true) {
				balloons.enemyBalloonFireFlowerSmall.animate(ani遅);
			}
			// こっちはタグを使って簡単に処理
			for (int i = 0; i < getChildCount(); i++) {
				// タイル
				if (getChildByIndex(i).getTag() ==
						QuestionBlockShorts.TAG_TILE_41_QUESTION_BLOCK_SHORT_COIN_YELLOW) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani遅, ani遅, ani遅, ani遅, ani遅, }, 0, 4, true);
				} else if (getChildByIndex(i).getTag() ==
						QuestionBlockShorts.TAG_TILE_42_QUESTION_BLOCK_SHORT_COIN_RED) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani遅, ani遅, ani遅, ani遅, ani遅, }, 0, 4, true);
				} else if (getChildByIndex(i).getTag() ==
						QuestionBlockShorts.TAG_TILE_43_QUESTION_BLOCK_SHORT_COIN_BLUE) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani遅, ani遅, ani遅, ani遅, ani遅, }, 0, 4, true);
				} else if (getChildByIndex(i).getTag() ==
						QuestionBlockShorts.TAG_TILE_44_QUESTION_BLOCK_SHORT_POWER_UP_ITEM) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani遅, ani遅, ani遅, ani遅, ani遅, }, 0, 4, true);
				} else if (getChildByIndex(i).getTag() ==
						QuestionBlockShorts.TAG_TILE_45_QUESTION_BLOCK_SHORT_ONE_UP_MUSHROOM) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani遅, ani遅, ani遅, ani遅, ani遅, }, 0, 4, true);
				} else if (getChildByIndex(i).getTag() ==
						QuestionBlockShorts.TAG_TILE_46_QUESTION_BLOCK_SHORT_FIRE_FLOWER_SMALL) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani遅, ani遅, ani遅, ani遅, ani遅, }, 0, 4, true);
				} else if (getChildByIndex(i).getTag() ==
						QuestionBlockLongs.	TAG_TILE_47_QUESTION_BLOCK_LONG_COIN_YELLOW) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani遅, ani遅, ani遅, ani遅, ani遅, }, 0, 4, true);
				} else if (getChildByIndex(i).getTag() ==
						QuestionBlockLongs.	TAG_TILE_48_QUESTION_BLOCK_LONG_COIN_RED) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani遅, ani遅, ani遅, ani遅, ani遅, }, 0, 4, true);
				} else if (getChildByIndex(i).getTag() ==
						QuestionBlockLongs.	TAG_TILE_49_QUESTION_BLOCK_LONG_COIN_BLUE) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani遅, ani遅, ani遅, ani遅, ani遅, }, 0, 4, true);
				} else if (getChildByIndex(i).getTag() ==
						QuestionBlockLongs.	TAG_TILE_50_QUESTION_BLOCK_LONG_POWER_UP_ITEM) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani遅, ani遅, ani遅, ani遅, ani遅, }, 0, 4, true);
				} else if (getChildByIndex(i).getTag() ==
						QuestionBlockLongs.	TAG_TILE_51_QUESTION_BLOCK_LONG_ONE_UP_MUSHROOM) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani遅, ani遅, ani遅, ani遅, ani遅, }, 0, 4, true);
				} else if (getChildByIndex(i).getTag() ==
						QuestionBlockLongs.	TAG_TILE_52_QUESTION_BLOCK_LONG_FIRE_FLOWER_SMALL) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani遅, ani遅, ani遅, ani遅, ani遅, }, 0, 4, true);
				} else if (getChildByIndex(i).getTag() ==
						JumpingBoards.		TAG_TILE_53_JUMPING_BOARD_NORMAL) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani並, ani並, }, 0, 1, true);
				} else if (getChildByIndex(i).getTag() ==
						JumpingBoards.		TAG_TILE_54_JUMPING_BOARD_SUPER) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani並, ani並, }, 0, 1, true);
				} else if (getChildByIndex(i).getTag() ==
						LiftReds.			TAG_TILE_55_LIFT_RED_1) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani遅);
				} else if (getChildByIndex(i).getTag() ==
						LiftReds.			TAG_TILE_56_LIFT_RED_2) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani遅);
				} else if (getChildByIndex(i).getTag() ==
						LiftReds.			TAG_TILE_57_LIFT_RED_3) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani遅);
				} else if (getChildByIndex(i).getTag() ==
						LiftBlues.			TAG_TILE_58_LIFT_BLUE_1) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani遅);
				} else if (getChildByIndex(i).getTag() ==
						LiftBlues.			TAG_TILE_59_LIFT_BLUE_2) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani遅);
				} else if (getChildByIndex(i).getTag() ==
						LiftBlues.			TAG_TILE_60_LIFT_BLUE_3) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani遅);
				} else if (getChildByIndex(i).getTag() ==
						ChangeBlocks.		TAG_TILE_61_CHANGE_BLOCK_RED) {
					if (フラグチェンジブロック == true) {
						((AnimatedSprite) getChildByIndex(i)).animate(
								new long[] { ani遅, ani遅, ani遅, ani遅, }, 0, 3, true);
					} else {
						((AnimatedSprite) getChildByIndex(i)).setCurrentTileIndex(4);
					}
				} else if (getChildByIndex(i).getTag() ==
						ChangeBlocks.		TAG_TILE_62_CHANGE_BLOCK_GREEN) {
					if (フラグチェンジブロック == false) {
						((AnimatedSprite) getChildByIndex(i)).animate(
								new long[] { ani遅, ani遅, ani遅, ani遅, }, 0, 3, true);
					} else {
						((AnimatedSprite) getChildByIndex(i)).setCurrentTileIndex(4);
					}
				} else if (getChildByIndex(i).getTag() ==
						GoalRings.			TAG_TILE_69_GOAL_RING_LEFT) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani並);
				} else if (getChildByIndex(i).getTag() ==
						GoalRings.			TAG_TILE_70_GOAL_RING_RIGHT) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani並);
					// アイテム
				} else if (getChildByIndex(i).getTag() ==
						Coins.				TAG_ITEM_01_COIN_YELLOW) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani遅);
				} else if (getChildByIndex(i).getTag() ==
						Coins.				TAG_ITEM_02_COIN_RED) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani遅);
				} else if (getChildByIndex(i).getTag() ==
						Coins.				TAG_ITEM_03_COIN_BLUE) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani遅);
				} else if (getChildByIndex(i).getTag() ==
						PowerUpItems.		TAG_ITEM_04_POWER_UP_ITEM_1) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani速);
				} else if (getChildByIndex(i).getTag() ==
						PowerUpItems.		TAG_ITEM_05_POWER_UP_ITEM_2) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani速);
				} else if (getChildByIndex(i).getTag() ==
						PowerUpItems.		TAG_ITEM_06_POWER_UP_ITEM_3) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani速);
				} else if (getChildByIndex(i).getTag() ==
						OneUpMushroom.		TAG_ITEM_07_ONE_UP_MUSHROOM) {
					// ワンナップキノコとおうかん
					if (現在のライフ < 10) {
						((AnimatedSprite) getChildByIndex(i)).animate(
								new long[] { ani遅, ani遅, ani遅, ani遅, }, 0, 3, true);
					} else {
						((AnimatedSprite) getChildByIndex(i)).animate(
								new long[] { ani遅, ani遅, ani遅, ani遅, }, 4, 7, true);
					}
				} else if (getChildByIndex(i).getTag() ==
						FireFlowers.		TAG_ITEM_08_FIRE_FLOWER_SMALL) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani速);
				} else if (getChildByIndex(i).getTag() ==
						FireFlowers.		TAG_ITEM_09_FIRE_FLOWER_BIG) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani速);
				} else if (getChildByIndex(i).getTag() ==
						PowerCrystal.		TAG_ITEM_10_POWER_CRYSTAL) {
					// ノーマルカラーとスペシャルカラー
					if (コースカウンター <= 16) {
						((AnimatedSprite) getChildByIndex(i)).animate(
								new long[] { ani遅, ani遅, ani遅, ani遅, }, 0, 3, true);
					} else {
						((AnimatedSprite) getChildByIndex(i)).animate(
								new long[] { ani遅, ani遅, ani遅, ani遅, }, 4, 7, true);
					}
					// 敵キャラ
				} else if (getChildByIndex(i).getTag() ==
						Goomba.				TAG_ENEMY_01_GOOMBA) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani並);
				} else if (getChildByIndex(i).getTag() ==
						KoopaParatroopas.	TAG_ENEMY_02_KOOPA_PARATROOPA_GREEN) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani並);
				} else if (getChildByIndex(i).getTag() ==
						KoopaParatroopas.	TAG_ENEMY_03_KOOPA_PARATROOPA_RED) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani並);
				} else if (getChildByIndex(i).getTag() ==
						BulletBills.		TAG_ENEMY_04_BULLET_BILL_BLUE) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani並);
				} else if (getChildByIndex(i).getTag() ==
						BulletBills.		TAG_ENEMY_05_BULLET_BILL_YELLOW) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani並);
				} else if (getChildByIndex(i).getTag() ==
						BulletBills.		TAG_ENEMY_06_BULLET_BILL_RED) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani並);
				} else if (getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_07_PIRANHA_PLANT_GREEN_NORMAL_0
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_21_PIRANHA_PLANT_GREEN_NORMAL_1
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_22_PIRANHA_PLANT_GREEN_NORMAL_2
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_23_PIRANHA_PLANT_GREEN_NORMAL_3
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_24_PIRANHA_PLANT_GREEN_NORMAL_4
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_25_PIRANHA_PLANT_GREEN_NORMAL_5) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani遅);
				} else if (getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_08_PIRANHA_PLANT_GREEN_UPSIDE_0
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_26_PIRANHA_PLANT_GREEN_UPSIDE_1
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_27_PIRANHA_PLANT_GREEN_UPSIDE_2
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_28_PIRANHA_PLANT_GREEN_UPSIDE_3
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_29_PIRANHA_PLANT_GREEN_UPSIDE_4
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_30_PIRANHA_PLANT_GREEN_UPSIDE_5) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani遅);
				} else if (getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_09_PIRANHA_PLANT_GREY_NORMAL_0
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_31_PIRANHA_PLANT_GREY_NORMAL_1
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_32_PIRANHA_PLANT_GREY_NORMAL_2
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_33_PIRANHA_PLANT_GREY_NORMAL_3
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_34_PIRANHA_PLANT_GREY_NORMAL_4
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_35_PIRANHA_PLANT_GREY_NORMAL_5) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani遅);
				} else if (getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_10_PIRANHA_PLANT_GREY_UPSIDE_0
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_36_PIRANHA_PLANT_GREY_UPSIDE_1
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_37_PIRANHA_PLANT_GREY_UPSIDE_2
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_38_PIRANHA_PLANT_GREY_UPSIDE_3
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_39_PIRANHA_PLANT_GREY_UPSIDE_4
						|| getChildByIndex(i).getTag() ==
						PiranhaPlants.		TAG_ENEMY_40_PIRANHA_PLANT_GREY_UPSIDE_5) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani遅);
				} else if (getChildByIndex(i).getTag() ==
						BuzzyBeetle.		TAG_ENEMY_11_BUZZY_BEETLE) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani並);
				} else if (getChildByIndex(i).getTag() ==
						Spinys.				TAG_ENEMY_12_SPINY_NORMAL) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani並);
				} else if (getChildByIndex(i).getTag() ==
						Spinys.				TAG_ENEMY_13_SPINY_EGG) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani遅);
				} else if (getChildByIndex(i).getTag() ==
						CheepCheep.			TAG_ENEMY_14_CHEEP_CHEEP) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani遅);
				} else if (getChildByIndex(i).getTag() ==
						Balloons.			TAG_ENEMY_15_BALLOON_COIN_YELLOW) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani遅);
				} else if (getChildByIndex(i).getTag() ==
						Balloons.			TAG_ENEMY_16_BALLOON_COIN_RED) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani遅);
				} else if (getChildByIndex(i).getTag() ==
						Balloons.			TAG_ENEMY_17_BALLOON_COIN_BLUE) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani遅);
				} else if (getChildByIndex(i).getTag() ==
						Balloons.			TAG_ENEMY_18_BALLOON_ONE_UP_MUSHROOM) {
					// ワンナップキノコとおうかん
					if (現在のライフ < 10) {
						((AnimatedSprite) getChildByIndex(i)).animate(
								new long[] { ani遅, ani遅, ani遅, ani遅, }, 0, 3, true);
					} else {
						((AnimatedSprite) getChildByIndex(i)).animate(
								new long[] { ani遅, ani遅, ani遅, ani遅, }, 4, 7, true);
					}
				} else if (getChildByIndex(i).getTag() ==
						Balloons.			TAG_ENEMY_19_BALLOON_FIRE_FLOWER_SMALL) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani速);
				} else if (getChildByIndex(i).getTag() ==
						Balloons.			TAG_ENEMY_20_BALLOON_NOT_OBJECT) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani遅);
				} else if (getChildByIndex(i).getTag() ==
						Bowsers.			TAG_ENEMY_41_BOWSER_NORMAL_LEVEL_1) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani速, ani速, ani速, ani速, }, 8, 11, true);
				} else if (getChildByIndex(i).getTag() ==
						Bowsers.			TAG_ENEMY_42_BOWSER_NORMAL_LEVEL_2) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani速, ani速, ani速, ani速, }, 8, 11, true);
				} else if (getChildByIndex(i).getTag() ==
						Bowsers.			TAG_ENEMY_43_BOWSER_NORMAL_LEVEL_3) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani速, ani速, ani速, ani速, }, 8, 11, true);
				} else if (getChildByIndex(i).getTag() ==
						Bowsers.			TAG_ENEMY_44_BOWSER_NORMAL_LEVEL_4) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani速, ani速, ani速, ani速, }, 8, 11, true);
				} else if (getChildByIndex(i).getTag() ==
						Bowsers.			TAG_ENEMY_45_BOWSER_FINAL) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani速, ani速, ani速, ani速, }, 8, 11, true);
					// プレイヤー
				} else if (getChildByIndex(i).getTag() ==
						Fireballs.			TAG_PLAYER_07_FIREBALL_NORMAL_1) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani速);
				} else if (getChildByIndex(i).getTag() ==
						Fireballs.			TAG_PLAYER_08_FIREBALL_NORMAL_2) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani速);
				} else if (getChildByIndex(i).getTag() ==
						Fireballs.			TAG_PLAYER_09_FIREBALL_SUPER_1) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani速);
				} else if (getChildByIndex(i).getTag() ==
						Fireballs.			TAG_PLAYER_10_FIREBALL_SUPER_2) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani速);
				} else if (getChildByIndex(i).getTag() ==
						Fireballs.			TAG_PLAYER_11_FIREBALL_FINAL) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani速);
				} else if (getChildByIndex(i).getTag() ==
						Fireballs.			TAG_PLAYER_12_FIREBALL_SHOCK_WAVE_ADOVE) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani速);
				} else if (getChildByIndex(i).getTag() ==
						Fireballs.			TAG_PLAYER_13_FIREBALL_SHOCK_WAVE_BELOW) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani速);
					// エフェクト
				} else if (getChildByIndex(i).getTag() ==
						Fonts.				TAG_EFFECT_10_FONT_ONE_UP) {
					((AnimatedSprite) getChildByIndex(i)).animate(
							new long[] { ani速, ani速, ani速, ani速, }, 0, 3, true);
					// フォント
				} else if (getChildByIndex(i).getTag() ==
						Scores.				TAG_FONT_21_SCORE_X1) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani速);
				} else if (getChildByIndex(i).getTag() ==
						Scores.				TAG_FONT_22_SCORE_X2) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani速);
				} else if (getChildByIndex(i).getTag() ==
						Scores.				TAG_FONT_23_SCORE_X3) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani速);
				} else if (getChildByIndex(i).getTag() ==
						Scores.				TAG_FONT_24_SCORE_X4) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani速);
				} else if (getChildByIndex(i).getTag() ==
						Scores.				TAG_FONT_25_SCORE_X5) {
					((AnimatedSprite) getChildByIndex(i)).animate(ani速);
				}
			}
			// ダッシュ時のグラ
			if (!プレイヤーのジャンプフラグ && !ボールハンド実行フラグ
					&& !パンチハンド実行フラグ && !状態フラグ復活中) {
				playerDashAnimation();
			}
		}
		for (CustomTimerHandler handler : 収納用ハンドラー) {
			handler.resume();
		}
	}
	
	// ===========================================================
	// クリア系
	// ===========================================================
	
	// コースクリア
	public void courseClear() {
		// クリアの演出
		クリアイコン.registerEntityModifier(new AlphaModifier(0.5f, 0, 0.5f));
		// 7.5秒ストップ！
		registerUpdateHandler(new TimerHandler(7.5f, new ITimerCallback() {
			public void onTimePassed(TimerHandler pTimeHandler) {
				if (メモリーの開放をしたかどうか == false) {
					クリアイコン.registerEntityModifier(new AlphaModifier(0.5f, 0.5f, 0));
				}
				// クリアイコンは透明にするだけで、デタッチはしない
			}
		}));
		// クリアロゴ1
		final Sprite クリアロゴ1 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
				"icon_27_world_clear_world.png");
		クリアロゴ1.setPosition(800, 144);
		attachChild(クリアロゴ1);
		クリアロゴ1.setZIndex(レイヤー15ロゴ用);
		sortChildren();
		// ロゴをスライド
		クリアロゴ1.registerEntityModifier(new SequenceEntityModifier(
				new MoveModifier(1.5f, クリアロゴ1.getX(), クリアロゴ1.getX()
						- クリアロゴ1.getWidth() - 480, クリアロゴ1.getY(),
						クリアロゴ1.getY(), EaseBackInOut.getInstance())));
		// 3秒ストップ！
		registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
			public void onTimePassed(TimerHandler pTimeHandler) {
				// ロゴをスライド
				クリアロゴ1.registerEntityModifier(new SequenceEntityModifier(
						new MoveModifier(1.5f, クリアロゴ1.getX(), クリアロゴ1.getX()
								- クリアロゴ1.getWidth() - 480, クリアロゴ1.getY(),
								クリアロゴ1.getY(), EaseBackInOut.getInstance())));
				// 1秒ストップ！
				registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						クリアロゴ1.detachSelf();
					}
				}));
			}
		}));
		// 3.5秒ストップ！
		registerUpdateHandler(new TimerHandler(3.5f, new ITimerCallback() {
			public void onTimePassed(TimerHandler pTimeHandler) {
				// クリアロゴ6
				final Sprite クリアロゴ6 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
						"icon_27_world_clear_world.png");
				クリアロゴ6.setPosition(800, 144);
				attachChild(クリアロゴ6);
				クリアロゴ6.setZIndex(レイヤー15ロゴ用);
				sortChildren();
				// ロゴをスライド
				クリアロゴ6.registerEntityModifier(new SequenceEntityModifier(
						new MoveModifier(1.5f, クリアロゴ6.getX(), クリアロゴ6.getX()
								- クリアロゴ6.getWidth() - 480, クリアロゴ6.getY(),
								クリアロゴ6.getY(), EaseBackInOut.getInstance())));
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						// ロゴをスライド
						クリアロゴ6.registerEntityModifier(new SequenceEntityModifier(
								new MoveModifier(1.5f, クリアロゴ6.getX(), クリアロゴ6.getX()
										- クリアロゴ6.getWidth() - 480, クリアロゴ6.getY(),
										クリアロゴ6.getY(), EaseBackInOut.getInstance())));
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								クリアロゴ6.detachSelf();
							}
						}));
					}
				}));
			}
		}));
		if (コースカウンター == 1 || コースカウンター == 2
				|| コースカウンター == 3 || コースカウンター == 4) {
			// クリアロゴ2
			final Sprite クリアロゴ2 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
					"icon_21_world_clear_1.png");
			クリアロゴ2.setPosition(800, 144);
			attachChild(クリアロゴ2);
			クリアロゴ2.setZIndex(レイヤー15ロゴ用);
			sortChildren();
			// ロゴをスライド
			クリアロゴ2.registerEntityModifier(new SequenceEntityModifier(
					new MoveModifier(1.5f, クリアロゴ2.getX(), クリアロゴ2.getX()
							- クリアロゴ2.getWidth() - 416, クリアロゴ2.getY(),
							クリアロゴ2.getY(), EaseBackInOut.getInstance())));
			// 3秒ストップ！
			registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// ロゴをスライド
					クリアロゴ2.registerEntityModifier(new SequenceEntityModifier(
							new MoveModifier(1.5f, クリアロゴ2.getX(), クリアロゴ2.getX()
									- クリアロゴ2.getWidth() - 480, クリアロゴ2.getY(),
									クリアロゴ2.getY(), EaseBackInOut.getInstance())));
					// 1秒ストップ！
					registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							クリアロゴ2.detachSelf();
						}
					}));
				}
			}));
			// 3.5秒ストップ！
			registerUpdateHandler(new TimerHandler(3.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// クリアロゴ7
					final Sprite クリアロゴ7 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
							"icon_21_world_clear_1.png");
					クリアロゴ7.setPosition(800, 144);
					attachChild(クリアロゴ7);
					クリアロゴ7.setZIndex(レイヤー15ロゴ用);
					sortChildren();
					// ロゴをスライド
					クリアロゴ7.registerEntityModifier(new SequenceEntityModifier(
							new MoveModifier(1.5f, クリアロゴ7.getX(), クリアロゴ7.getX()
									- クリアロゴ7.getWidth() - 416, クリアロゴ7.getY(),
									クリアロゴ7.getY(), EaseBackInOut.getInstance())));
					// 3秒ストップ！
					registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							// ロゴをスライド
							クリアロゴ7.registerEntityModifier(new SequenceEntityModifier(
									new MoveModifier(1.5f, クリアロゴ7.getX(), クリアロゴ7.getX()
											- クリアロゴ7.getWidth() - 480, クリアロゴ7.getY(),
											クリアロゴ7.getY(), EaseBackInOut.getInstance())));
							// 1秒ストップ！
							registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
								public void onTimePassed(TimerHandler pTimeHandler) {
									クリアロゴ7.detachSelf();
								}
							}));
						}
					}));
				}
			}));
		} else if (コースカウンター == 5 || コースカウンター == 6
				|| コースカウンター == 7 || コースカウンター == 8) {
			// クリアロゴ2
			final Sprite クリアロゴ2 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
					"icon_22_world_clear_2.png");
			クリアロゴ2.setPosition(800, 144);
			attachChild(クリアロゴ2);
			クリアロゴ2.setZIndex(レイヤー15ロゴ用);
			sortChildren();
			// ロゴをスライド
			クリアロゴ2.registerEntityModifier(new SequenceEntityModifier(
					new MoveModifier(1.5f, クリアロゴ2.getX(), クリアロゴ2.getX()
							- クリアロゴ2.getWidth() - 416, クリアロゴ2.getY(),
							クリアロゴ2.getY(), EaseBackInOut.getInstance())));
			// 3秒ストップ！
			registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// ロゴをスライド
					クリアロゴ2.registerEntityModifier(new SequenceEntityModifier(
							new MoveModifier(1.5f, クリアロゴ2.getX(), クリアロゴ2.getX()
									- クリアロゴ2.getWidth() - 480, クリアロゴ2.getY(),
									クリアロゴ2.getY(), EaseBackInOut.getInstance())));
					// 1秒ストップ！
					registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							クリアロゴ2.detachSelf();
						}
					}));
				}
			}));
			// 3.5秒ストップ！
			registerUpdateHandler(new TimerHandler(3.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// クリアロゴ7
					final Sprite クリアロゴ7 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
							"icon_22_world_clear_2.png");
					クリアロゴ7.setPosition(800, 144);
					attachChild(クリアロゴ7);
					クリアロゴ7.setZIndex(レイヤー15ロゴ用);
					sortChildren();
					// ロゴをスライド
					クリアロゴ7.registerEntityModifier(new SequenceEntityModifier(
							new MoveModifier(1.5f, クリアロゴ7.getX(), クリアロゴ7.getX()
									- クリアロゴ7.getWidth() - 416, クリアロゴ7.getY(),
									クリアロゴ7.getY(), EaseBackInOut.getInstance())));
					// 3秒ストップ！
					registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							// ロゴをスライド
							クリアロゴ7.registerEntityModifier(new SequenceEntityModifier(
									new MoveModifier(1.5f, クリアロゴ7.getX(), クリアロゴ7.getX()
											- クリアロゴ7.getWidth() - 480, クリアロゴ7.getY(),
											クリアロゴ7.getY(), EaseBackInOut.getInstance())));
							// 1秒ストップ！
							registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
								public void onTimePassed(TimerHandler pTimeHandler) {
									クリアロゴ7.detachSelf();
								}
							}));
						}
					}));
				}
			}));
		} else if (コースカウンター == 9 || コースカウンター == 10
				|| コースカウンター == 11 || コースカウンター == 12) {
			// クリアロゴ2
			final Sprite クリアロゴ2 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
					"icon_23_world_clear_3.png");
			クリアロゴ2.setPosition(800, 144);
			attachChild(クリアロゴ2);
			クリアロゴ2.setZIndex(レイヤー15ロゴ用);
			sortChildren();
			// ロゴをスライド
			クリアロゴ2.registerEntityModifier(new SequenceEntityModifier(
					new MoveModifier(1.5f, クリアロゴ2.getX(), クリアロゴ2.getX()
							- クリアロゴ2.getWidth() - 416, クリアロゴ2.getY(),
							クリアロゴ2.getY(), EaseBackInOut.getInstance())));
			// 3秒ストップ！
			registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// ロゴをスライド
					クリアロゴ2.registerEntityModifier(new SequenceEntityModifier(
							new MoveModifier(1.5f, クリアロゴ2.getX(), クリアロゴ2.getX()
									- クリアロゴ2.getWidth() - 480, クリアロゴ2.getY(),
									クリアロゴ2.getY(), EaseBackInOut.getInstance())));
					// 1秒ストップ！
					registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							クリアロゴ2.detachSelf();
						}
					}));
				}
			}));
			// 3.5秒ストップ！
			registerUpdateHandler(new TimerHandler(3.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// クリアロゴ7
					final Sprite クリアロゴ7 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
							"icon_23_world_clear_3.png");
					クリアロゴ7.setPosition(800, 144);
					attachChild(クリアロゴ7);
					クリアロゴ7.setZIndex(レイヤー15ロゴ用);
					sortChildren();
					// ロゴをスライド
					クリアロゴ7.registerEntityModifier(new SequenceEntityModifier(
							new MoveModifier(1.5f, クリアロゴ7.getX(), クリアロゴ7.getX()
									- クリアロゴ7.getWidth() - 416, クリアロゴ7.getY(),
									クリアロゴ7.getY(), EaseBackInOut.getInstance())));
					// 3秒ストップ！
					registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							// ロゴをスライド
							クリアロゴ7.registerEntityModifier(new SequenceEntityModifier(
									new MoveModifier(1.5f, クリアロゴ7.getX(), クリアロゴ7.getX()
											- クリアロゴ7.getWidth() - 480, クリアロゴ7.getY(),
											クリアロゴ7.getY(), EaseBackInOut.getInstance())));
							// 1秒ストップ！
							registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
								public void onTimePassed(TimerHandler pTimeHandler) {
									クリアロゴ7.detachSelf();
								}
							}));
						}
					}));
				}
			}));
		} else if (コースカウンター == 13 || コースカウンター == 14
				|| コースカウンター == 16 || コースカウンター == 15) {
			// クリアロゴ2
			final Sprite クリアロゴ2 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
					"icon_24_world_clear_4.png");
			クリアロゴ2.setPosition(800, 144);
			attachChild(クリアロゴ2);
			クリアロゴ2.setZIndex(レイヤー15ロゴ用);
			sortChildren();
			// ロゴをスライド
			クリアロゴ2.registerEntityModifier(new SequenceEntityModifier(
					new MoveModifier(1.5f, クリアロゴ2.getX(), クリアロゴ2.getX()
							- クリアロゴ2.getWidth() - 416, クリアロゴ2.getY(),
							クリアロゴ2.getY(), EaseBackInOut.getInstance())));
			// 3秒ストップ！
			registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// ロゴをスライド
					クリアロゴ2.registerEntityModifier(new SequenceEntityModifier(
							new MoveModifier(1.5f, クリアロゴ2.getX(), クリアロゴ2.getX()
									- クリアロゴ2.getWidth() - 480, クリアロゴ2.getY(),
									クリアロゴ2.getY(), EaseBackInOut.getInstance())));
					// 1秒ストップ！
					registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							クリアロゴ2.detachSelf();
						}
					}));
				}
			}));
			// 3.5秒ストップ！
			registerUpdateHandler(new TimerHandler(3.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// クリアロゴ7
					final Sprite クリアロゴ7 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
							"icon_24_world_clear_4.png");
					クリアロゴ7.setPosition(800, 144);
					attachChild(クリアロゴ7);
					クリアロゴ7.setZIndex(レイヤー15ロゴ用);
					sortChildren();
					// ロゴをスライド
					クリアロゴ7.registerEntityModifier(new SequenceEntityModifier(
							new MoveModifier(1.5f, クリアロゴ7.getX(), クリアロゴ7.getX()
									- クリアロゴ7.getWidth() - 416, クリアロゴ7.getY(),
									クリアロゴ7.getY(), EaseBackInOut.getInstance())));
					// 3秒ストップ！
					registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							// ロゴをスライド
							クリアロゴ7.registerEntityModifier(new SequenceEntityModifier(
									new MoveModifier(1.5f, クリアロゴ7.getX(), クリアロゴ7.getX()
											- クリアロゴ7.getWidth() - 480, クリアロゴ7.getY(),
											クリアロゴ7.getY(), EaseBackInOut.getInstance())));
							// 1秒ストップ！
							registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
								public void onTimePassed(TimerHandler pTimeHandler) {
									クリアロゴ7.detachSelf();
								}
							}));
						}
					}));
				}
			}));
		} else if (コースカウンター == 17 || コースカウンター == 18
				|| コースカウンター == 19 || コースカウンター == 20
				|| コースカウンター == 21) {
			// クリアロゴ2
			final Sprite クリアロゴ2 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
					"icon_25_world_clear_S.png");
			クリアロゴ2.setPosition(800, 144);
			attachChild(クリアロゴ2);
			クリアロゴ2.setZIndex(レイヤー15ロゴ用);
			sortChildren();
			// ロゴをスライド
			クリアロゴ2.registerEntityModifier(new SequenceEntityModifier(
					new MoveModifier(1.5f, クリアロゴ2.getX(), クリアロゴ2.getX()
							- クリアロゴ2.getWidth() - 416, クリアロゴ2.getY(),
							クリアロゴ2.getY(), EaseBackInOut.getInstance())));
			// 3秒ストップ！
			registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// ロゴをスライド
					クリアロゴ2.registerEntityModifier(new SequenceEntityModifier(
							new MoveModifier(1.5f, クリアロゴ2.getX(), クリアロゴ2.getX()
									- クリアロゴ2.getWidth() - 480, クリアロゴ2.getY(),
									クリアロゴ2.getY(), EaseBackInOut.getInstance())));
					// 1秒ストップ！
					registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							クリアロゴ2.detachSelf();
						}
					}));
				}
			}));
			// 3.5秒ストップ！
			registerUpdateHandler(new TimerHandler(3.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// クリアロゴ7
					final Sprite クリアロゴ7 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
							"icon_25_world_clear_S.png");
					クリアロゴ7.setPosition(800, 144);
					attachChild(クリアロゴ7);
					クリアロゴ7.setZIndex(レイヤー15ロゴ用);
					sortChildren();
					// ロゴをスライド
					クリアロゴ7.registerEntityModifier(new SequenceEntityModifier(
							new MoveModifier(1.5f, クリアロゴ7.getX(), クリアロゴ7.getX()
									- クリアロゴ7.getWidth() - 416, クリアロゴ7.getY(),
									クリアロゴ7.getY(), EaseBackInOut.getInstance())));
					// 3秒ストップ！
					registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							// ロゴをスライド
							クリアロゴ7.registerEntityModifier(new SequenceEntityModifier(
									new MoveModifier(1.5f, クリアロゴ7.getX(), クリアロゴ7.getX()
											- クリアロゴ7.getWidth() - 480, クリアロゴ7.getY(),
											クリアロゴ7.getY(), EaseBackInOut.getInstance())));
							// 1秒ストップ！
							registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
								public void onTimePassed(TimerHandler pTimeHandler) {
									クリアロゴ7.detachSelf();
								}
							}));
						}
					}));
				}
			}));
		}
		// クリアロゴ3
		final Sprite クリアロゴ3 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
				"icon_26_world_clear_hyphen.png");
		クリアロゴ3.setPosition(800, 160);
		attachChild(クリアロゴ3);
		クリアロゴ3.setZIndex(レイヤー15ロゴ用);
		sortChildren();
		// ロゴをスライド
		クリアロゴ3.registerEntityModifier(new SequenceEntityModifier(
				new MoveModifier(1.5f, クリアロゴ3.getX(), クリアロゴ3.getX()
						- クリアロゴ3.getWidth() - 384, クリアロゴ3.getY(),
						クリアロゴ3.getY(), EaseBackInOut.getInstance())));
		// 3秒ストップ！
		registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
			public void onTimePassed(TimerHandler pTimeHandler) {
				// ロゴをスライド
				クリアロゴ3.registerEntityModifier(new SequenceEntityModifier(
						new MoveModifier(1.5f, クリアロゴ3.getX(), クリアロゴ3.getX()
								- クリアロゴ3.getWidth() - 480, クリアロゴ3.getY(),
								クリアロゴ3.getY(), EaseBackInOut.getInstance())));
				// 1秒ストップ！
				registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						クリアロゴ3.detachSelf();
					}
				}));
			}
		}));
		// 3.5秒ストップ！
		registerUpdateHandler(new TimerHandler(3.5f, new ITimerCallback() {
			public void onTimePassed(TimerHandler pTimeHandler) {
				// クリアロゴ8
				final Sprite クリアロゴ8 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
						"icon_26_world_clear_hyphen.png");
				クリアロゴ8.setPosition(800, 160);
				attachChild(クリアロゴ8);
				クリアロゴ8.setZIndex(レイヤー15ロゴ用);
				sortChildren();
				// ロゴをスライド
				クリアロゴ8.registerEntityModifier(new SequenceEntityModifier(
						new MoveModifier(1.5f, クリアロゴ8.getX(), クリアロゴ8.getX()
								- クリアロゴ8.getWidth() - 384, クリアロゴ8.getY(),
								クリアロゴ8.getY(), EaseBackInOut.getInstance())));
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						// ロゴをスライド
						クリアロゴ8.registerEntityModifier(new SequenceEntityModifier(
								new MoveModifier(1.5f, クリアロゴ8.getX(), クリアロゴ8.getX()
										- クリアロゴ8.getWidth() - 480, クリアロゴ8.getY(),
										クリアロゴ8.getY(), EaseBackInOut.getInstance())));
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								クリアロゴ8.detachSelf();
							}
						}));
					}
				}));
			}
		}));
		if (コースカウンター == 1 || コースカウンター == 5
				|| コースカウンター == 9 || コースカウンター == 13
				|| コースカウンター == 17) {
			// クリアロゴ4
			final Sprite クリアロゴ4 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
					"icon_21_world_clear_1.png");
			クリアロゴ4.setPosition(800, 144);
			attachChild(クリアロゴ4);
			クリアロゴ4.setZIndex(レイヤー15ロゴ用);
			sortChildren();
			// ロゴをスライド
			クリアロゴ4.registerEntityModifier(new SequenceEntityModifier(
					new MoveModifier(1.5f, クリアロゴ4.getX(), クリアロゴ4.getX()
							- クリアロゴ4.getWidth() - 352, クリアロゴ4.getY(),
							クリアロゴ4.getY(), EaseBackInOut.getInstance())));
			// 3秒ストップ！
			registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// ロゴをスライド
					クリアロゴ4.registerEntityModifier(new SequenceEntityModifier(
							new MoveModifier(1.5f, クリアロゴ4.getX(), クリアロゴ4.getX()
									- クリアロゴ4.getWidth() - 480, クリアロゴ4.getY(),
									クリアロゴ4.getY(), EaseBackInOut.getInstance())));
					// 1秒ストップ！
					registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							クリアロゴ4.detachSelf();
						}
					}));
				}
			}));
			// 3.5秒ストップ！
			registerUpdateHandler(new TimerHandler(3.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// クリアロゴ9
					final Sprite クリアロゴ9 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
							"icon_22_world_clear_2.png");
					クリアロゴ9.setPosition(800, 144);
					attachChild(クリアロゴ9);
					クリアロゴ9.setZIndex(レイヤー15ロゴ用);
					sortChildren();
					// ロゴをスライド
					クリアロゴ9.registerEntityModifier(new SequenceEntityModifier(
							new MoveModifier(1.5f, クリアロゴ9.getX(), クリアロゴ9.getX()
									- クリアロゴ9.getWidth() - 352, クリアロゴ9.getY(),
									クリアロゴ9.getY(), EaseBackInOut.getInstance())));
					// 3秒ストップ！
					registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							// ロゴをスライド
							クリアロゴ9.registerEntityModifier(new SequenceEntityModifier(
									new MoveModifier(1.5f, クリアロゴ9.getX(), クリアロゴ9.getX()
											- クリアロゴ9.getWidth() - 480, クリアロゴ9.getY(),
											クリアロゴ9.getY(), EaseBackInOut.getInstance())));
							// 1秒ストップ！
							registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
								public void onTimePassed(TimerHandler pTimeHandler) {
									クリアロゴ9.detachSelf();
								}
							}));
						}
					}));
				}
			}));
		} else if (コースカウンター == 2 || コースカウンター == 6
				|| コースカウンター == 10 || コースカウンター == 14
				|| コースカウンター == 18) {
			// クリアロゴ4
			final Sprite クリアロゴ4 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
					"icon_22_world_clear_2.png");
			クリアロゴ4.setPosition(800, 144);
			attachChild(クリアロゴ4);
			クリアロゴ4.setZIndex(レイヤー15ロゴ用);
			sortChildren();
			// ロゴをスライド
			クリアロゴ4.registerEntityModifier(new SequenceEntityModifier(
					new MoveModifier(1.5f, クリアロゴ4.getX(), クリアロゴ4.getX()
							- クリアロゴ4.getWidth() - 352, クリアロゴ4.getY(),
							クリアロゴ4.getY(), EaseBackInOut.getInstance())));
			// 3秒ストップ！
			registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// ロゴをスライド
					クリアロゴ4.registerEntityModifier(new SequenceEntityModifier(
							new MoveModifier(1.5f, クリアロゴ4.getX(), クリアロゴ4.getX()
									- クリアロゴ4.getWidth() - 480, クリアロゴ4.getY(),
									クリアロゴ4.getY(), EaseBackInOut.getInstance())));
					// 1秒ストップ！
					registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							クリアロゴ4.detachSelf();
						}
					}));
				}
			}));
			// 3.5秒ストップ！
			registerUpdateHandler(new TimerHandler(3.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// クリアロゴ9
					final Sprite クリアロゴ9 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
							"icon_23_world_clear_3.png");
					クリアロゴ9.setPosition(800, 144);
					attachChild(クリアロゴ9);
					クリアロゴ9.setZIndex(レイヤー15ロゴ用);
					sortChildren();
					// ロゴをスライド
					クリアロゴ9.registerEntityModifier(new SequenceEntityModifier(
							new MoveModifier(1.5f, クリアロゴ9.getX(), クリアロゴ9.getX()
									- クリアロゴ9.getWidth() - 352, クリアロゴ9.getY(),
									クリアロゴ9.getY(), EaseBackInOut.getInstance())));
					// 3秒ストップ！
					registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							// ロゴをスライド
							クリアロゴ9.registerEntityModifier(new SequenceEntityModifier(
									new MoveModifier(1.5f, クリアロゴ9.getX(), クリアロゴ9.getX()
											- クリアロゴ9.getWidth() - 480, クリアロゴ9.getY(),
											クリアロゴ9.getY(), EaseBackInOut.getInstance())));
							// 1秒ストップ！
							registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
								public void onTimePassed(TimerHandler pTimeHandler) {
									クリアロゴ9.detachSelf();
								}
							}));
						}
					}));
				}
			}));
		} else if (コースカウンター == 3 || コースカウンター == 7
				|| コースカウンター == 11 || コースカウンター == 15
				|| コースカウンター == 19) {
			// クリアロゴ4
			final Sprite クリアロゴ4 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
					"icon_23_world_clear_3.png");
			クリアロゴ4.setPosition(800, 144);
			attachChild(クリアロゴ4);
			クリアロゴ4.setZIndex(レイヤー15ロゴ用);
			sortChildren();
			// ロゴをスライド
			クリアロゴ4.registerEntityModifier(new SequenceEntityModifier(
					new MoveModifier(1.5f, クリアロゴ4.getX(), クリアロゴ4.getX()
							- クリアロゴ4.getWidth() - 352, クリアロゴ4.getY(),
							クリアロゴ4.getY(), EaseBackInOut.getInstance())));
			// 3秒ストップ！
			registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// ロゴをスライド
					クリアロゴ4.registerEntityModifier(new SequenceEntityModifier(
							new MoveModifier(1.5f, クリアロゴ4.getX(), クリアロゴ4.getX()
									- クリアロゴ4.getWidth() - 480, クリアロゴ4.getY(),
									クリアロゴ4.getY(), EaseBackInOut.getInstance())));
					// 1秒ストップ！
					registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							クリアロゴ4.detachSelf();
						}
					}));
				}
			}));
			// 3.5秒ストップ！
			registerUpdateHandler(new TimerHandler(3.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// クリアロゴ9
					final Sprite クリアロゴ9 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
							"icon_24_world_clear_4.png");
					クリアロゴ9.setPosition(800, 144);
					attachChild(クリアロゴ9);
					クリアロゴ9.setZIndex(レイヤー15ロゴ用);
					sortChildren();
					// ロゴをスライド
					クリアロゴ9.registerEntityModifier(new SequenceEntityModifier(
							new MoveModifier(1.5f, クリアロゴ9.getX(), クリアロゴ9.getX()
									- クリアロゴ9.getWidth() - 352, クリアロゴ9.getY(),
									クリアロゴ9.getY(), EaseBackInOut.getInstance())));
					// 3秒ストップ！
					registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							// ロゴをスライド
							クリアロゴ9.registerEntityModifier(new SequenceEntityModifier(
									new MoveModifier(1.5f, クリアロゴ9.getX(), クリアロゴ9.getX()
											- クリアロゴ9.getWidth() - 480, クリアロゴ9.getY(),
											クリアロゴ9.getY(), EaseBackInOut.getInstance())));
							// 1秒ストップ！
							registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
								public void onTimePassed(TimerHandler pTimeHandler) {
									クリアロゴ9.detachSelf();
								}
							}));
						}
					}));
				}
			}));
		} else if (コースカウンター == 4 || コースカウンター == 8
				|| コースカウンター == 12 || コースカウンター == 16
				|| コースカウンター == 20) {
			// クリアロゴ4
			final Sprite クリアロゴ4 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
					"icon_24_world_clear_4.png");
			クリアロゴ4.setPosition(800, 144);
			attachChild(クリアロゴ4);
			クリアロゴ4.setZIndex(レイヤー15ロゴ用);
			sortChildren();
			// ロゴをスライド
			クリアロゴ4.registerEntityModifier(new SequenceEntityModifier(
					new MoveModifier(1.5f, クリアロゴ4.getX(), クリアロゴ4.getX()
							- クリアロゴ4.getWidth() - 352, クリアロゴ4.getY(),
							クリアロゴ4.getY(), EaseBackInOut.getInstance())));
			// 3秒ストップ！
			registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// ロゴをスライド
					クリアロゴ4.registerEntityModifier(new SequenceEntityModifier(
							new MoveModifier(1.5f, クリアロゴ4.getX(), クリアロゴ4.getX()
									- クリアロゴ4.getWidth() - 480, クリアロゴ4.getY(),
									クリアロゴ4.getY(), EaseBackInOut.getInstance())));
					// 1秒ストップ！
					registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							クリアロゴ4.detachSelf();
						}
					}));
				}
			}));
			// 3.5秒ストップ！
			registerUpdateHandler(new TimerHandler(3.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// クリアロゴ9
					final Sprite クリアロゴ9 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
							"icon_25_world_clear_S.png");
					クリアロゴ9.setPosition(800, 144);
					attachChild(クリアロゴ9);
					クリアロゴ9.setZIndex(レイヤー15ロゴ用);
					sortChildren();
					// ロゴをスライド
					クリアロゴ9.registerEntityModifier(new SequenceEntityModifier(
							new MoveModifier(1.5f, クリアロゴ9.getX(), クリアロゴ9.getX()
									- クリアロゴ9.getWidth() - 352, クリアロゴ9.getY(),
									クリアロゴ9.getY(), EaseBackInOut.getInstance())));
					// 3秒ストップ！
					registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							// ロゴをスライド
							クリアロゴ9.registerEntityModifier(new SequenceEntityModifier(
									new MoveModifier(1.5f, クリアロゴ9.getX(), クリアロゴ9.getX()
											- クリアロゴ9.getWidth() - 480, クリアロゴ9.getY(),
											クリアロゴ9.getY(), EaseBackInOut.getInstance())));
							// 1秒ストップ！
							registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
								public void onTimePassed(TimerHandler pTimeHandler) {
									クリアロゴ9.detachSelf();
								}
							}));
						}
					}));
				}
			}));
		} else if (コースカウンター == 21) {
			// クリアロゴ4
			final Sprite クリアロゴ4 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
					"icon_25_world_clear_S.png");
			クリアロゴ4.setPosition(800, 144);
			attachChild(クリアロゴ4);
			クリアロゴ4.setZIndex(レイヤー15ロゴ用);
			sortChildren();
			// ロゴをスライド
			クリアロゴ4.registerEntityModifier(new SequenceEntityModifier(
					new MoveModifier(1.5f, クリアロゴ4.getX(), クリアロゴ4.getX()
							- クリアロゴ4.getWidth() - 352, クリアロゴ4.getY(),
							クリアロゴ4.getY(), EaseBackInOut.getInstance())));
			// 3秒ストップ！
			registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// ロゴをスライド
					クリアロゴ4.registerEntityModifier(new SequenceEntityModifier(
							new MoveModifier(1.5f, クリアロゴ4.getX(), クリアロゴ4.getX()
									- クリアロゴ4.getWidth() - 480, クリアロゴ4.getY(),
									クリアロゴ4.getY(), EaseBackInOut.getInstance())));
					// 1秒ストップ！
					registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							クリアロゴ4.detachSelf();
						}
					}));
				}
			}));
			// ゲームクリア処理を後ほど記載
		}
		// クリアロゴ5
		final Sprite クリアロゴ5 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
				"icon_29_world_clear_clear.png");
		クリアロゴ5.setPosition(800, 144);
		attachChild(クリアロゴ5);
		クリアロゴ5.setZIndex(レイヤー15ロゴ用);
		sortChildren();
		// ロゴをスライド
		クリアロゴ5.registerEntityModifier(new SequenceEntityModifier(
				new MoveModifier(1.5f, クリアロゴ5.getX(), クリアロゴ5.getX()
						- クリアロゴ5.getWidth() - 192, クリアロゴ5.getY(),
						クリアロゴ5.getY(), EaseBackInOut.getInstance())));
		// 3秒ストップ！
		registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
			public void onTimePassed(TimerHandler pTimeHandler) {
				// ロゴをスライド
				クリアロゴ5.registerEntityModifier(new SequenceEntityModifier(
						new MoveModifier(1.5f, クリアロゴ5.getX(), クリアロゴ5.getX()
								- クリアロゴ5.getWidth() - 480, クリアロゴ5.getY(),
								クリアロゴ5.getY(), EaseBackInOut.getInstance())));
				// 1秒ストップ！
				registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						クリアロゴ5.detachSelf();
					}
				}));
			}
		}));
		// 3.5秒ストップ！
		registerUpdateHandler(new TimerHandler(3.5f, new ITimerCallback() {
			public void onTimePassed(TimerHandler pTimeHandler) {
				// クリアロゴ10
				final Sprite クリアロゴ10 = ResourceUtil.getInstance(getBaseActivity()).getSprite(
						"icon_28_world_clear_start.png");
				クリアロゴ10.setPosition(800, 144);
				attachChild(クリアロゴ10);
				クリアロゴ10.setZIndex(レイヤー15ロゴ用);
				sortChildren();
				// ロゴをスライド
				クリアロゴ10.registerEntityModifier(new SequenceEntityModifier(
						new MoveModifier(1.5f, クリアロゴ10.getX(), クリアロゴ10.getX()
								- クリアロゴ10.getWidth() - 192, クリアロゴ10.getY(),
								クリアロゴ10.getY(), EaseBackInOut.getInstance())));
				// 3秒ストップ！
				registerUpdateHandler(new TimerHandler(3, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						// ロゴをスライド
						クリアロゴ10.registerEntityModifier(new SequenceEntityModifier(
								new MoveModifier(1.5f, クリアロゴ10.getX(), クリアロゴ10.getX()
										- クリアロゴ10.getWidth() - 480, クリアロゴ10.getY(),
										クリアロゴ10.getY(), EaseBackInOut.getInstance())));
						// 1秒ストップ！
						registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
							public void onTimePassed(TimerHandler pTimeHandler) {
								クリアロゴ10.detachSelf();
							}
						}));
					}
				}));
			}
		}));
		// リングの中央
		if (contactLines.playerContactLineBelow.getY() <= 240
				&& contactLines.playerContactLineBelow.getY() > 208		// 下から10マス
				|| contactLines.playerContactLineBelow.getY() <= 208
				&& contactLines.playerContactLineBelow.getY() > 176		// 下から11マス
				|| contactLines.playerContactLineBelow.getY() <= 176
				&& contactLines.playerContactLineBelow.getY() > 144) {	// 下から12マス
			VoicePlay.voiceCourseClear.stop();
			VoicePlay.voiceCourseClear.play();
			現在のスコア += 5000;
			// フォントを表示
			scores.fontScore5000 = getBaseActivity().getResourceUtil()
					.getSprite("font_14_score_5000.png");
			scores.fontScore5000.setTag(
					Scores.TAG_FONT_14_SCORE_5000);
			if (グラチェンジフラグ == false) {
				scores.fontScore5000.setPosition(
						marioSets.playerMarioSet1.getX(),
						marioSets.playerMarioSet1.getY());
			} else {
				scores.fontScore5000.setPosition(
						marioSets.playerMarioSet2.getX(),
						marioSets.playerMarioSet2.getY());
			}
			attachChild(scores.fontScore5000);
			// レイヤーを入れるとなぜかバグる
			// 高得点獲得時はふぃーどばっく！
			scores.fontScore5000.registerEntityModifier(
					new LoopEntityModifier(new SequenceEntityModifier(
							new ScaleModifier(0.25f, 1.0f, 1.5f),
							new ScaleModifier(0.25f, 1.5f, 1.0f)), 12));
			// 1.5秒ストップ！
			registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					scores.fontScore5000.registerEntityModifier(new FadeOutModifier(0.5f));
					// 0.5秒ストップ！
					registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							scores.fontScore5000.detachSelf();
						}
					}));
				}
			}));
			// 中央からちょっとずれ
		} else if (contactLines.playerContactLineBelow.getY() <= 272
				&& contactLines.playerContactLineBelow.getY() > 240		// 下から9マス
				|| contactLines.playerContactLineBelow.getY() <= 144
				&& contactLines.playerContactLineBelow.getY() > 112) {	// 下から13マス
			// ボイスのランダム処理
			int r = (int)(Math.random() * 3);
			switch (r) {
			case 0:
				VoicePlay.voiceCrystalNormal1.stop();
				VoicePlay.voiceCrystalNormal1.play();
				break;
			case 1:
				VoicePlay.voiceCrystalNormal2.stop();
				VoicePlay.voiceCrystalNormal2.play();
				break;
			case 2:
				VoicePlay.voiceCrystalNormal3.stop();
				VoicePlay.voiceCrystalNormal3.play();
				break;
			}
			現在のスコア += 3000;
			// フォントを表示
			scores.fontScore3000 = getBaseActivity().getResourceUtil()
					.getSprite("font_12_score_3000.png");
			scores.fontScore3000.setTag(
					Scores.TAG_FONT_12_SCORE_3000);
			if (グラチェンジフラグ == false) {
				scores.fontScore3000.setPosition(
						marioSets.playerMarioSet1.getX(),
						marioSets.playerMarioSet1.getY());
			} else {
				scores.fontScore3000.setPosition(
						marioSets.playerMarioSet2.getX(),
						marioSets.playerMarioSet2.getY());
			}
			attachChild(scores.fontScore3000);
			// レイヤーを入れるとなぜかバグる
			// 高得点獲得時はふぃーどばっく！
			scores.fontScore3000.registerEntityModifier(
					new LoopEntityModifier(new SequenceEntityModifier(
							new ScaleModifier(0.25f, 1.0f, 1.5f),
							new ScaleModifier(0.25f, 1.5f, 1.0f)), 12));
			// 1.5秒ストップ！
			registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					scores.fontScore3000.registerEntityModifier(new FadeOutModifier(0.5f));
					// 0.5秒ストップ！
					registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							scores.fontScore3000.detachSelf();
						}
					}));
				}
			}));
			// 中央からだいぶずれ
		} else if (contactLines.playerContactLineBelow.getY() <= 304
				&& contactLines.playerContactLineBelow.getY() > 272		// 下から8マス
				|| contactLines.playerContactLineBelow.getY() <= 112
				&& contactLines.playerContactLineBelow.getY() > 80) {	// 下から14マス
			// ボイスのランダム処理
			int r = (int)(Math.random() * 3);
			switch (r) {
			case 0:
				VoicePlay.voiceCrystalNormal1.stop();
				VoicePlay.voiceCrystalNormal1.play();
				break;
			case 1:
				VoicePlay.voiceCrystalNormal2.stop();
				VoicePlay.voiceCrystalNormal2.play();
				break;
			case 2:
				VoicePlay.voiceCrystalNormal3.stop();
				VoicePlay.voiceCrystalNormal3.play();
				break;
			}
			現在のスコア += 1000;
			// フォントを表示
			scores.fontScore1000 = getBaseActivity().getResourceUtil()
					.getSprite("font_10_score_1000.png");
			scores.fontScore1000.setTag(
					Scores.TAG_FONT_10_SCORE_1000);
			if (グラチェンジフラグ == false) {
				scores.fontScore1000.setPosition(
						marioSets.playerMarioSet1.getX(),
						marioSets.playerMarioSet1.getY());
			} else {
				scores.fontScore1000.setPosition(
						marioSets.playerMarioSet2.getX(),
						marioSets.playerMarioSet2.getY());
			}
			attachChild(scores.fontScore1000);
			// レイヤーを入れるとなぜかバグる
			// 1.5秒ストップ！
			registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					scores.fontScore1000.registerEntityModifier(new FadeOutModifier(0.5f));
					// 0.5秒ストップ！
					registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							scores.fontScore1000.detachSelf();
						}
					}));
				}
			}));
			// クグルの失敗
		} else {
			// ボイスのランダム処理
			int r = (int)(Math.random() * 3);
			switch (r) {
			case 0:
				VoicePlay.voiceCrystalNormal1.stop();
				VoicePlay.voiceCrystalNormal1.play();
				break;
			case 1:
				VoicePlay.voiceCrystalNormal2.stop();
				VoicePlay.voiceCrystalNormal2.play();
				break;
			case 2:
				VoicePlay.voiceCrystalNormal3.stop();
				VoicePlay.voiceCrystalNormal3.play();
				break;
			}
			現在のスコア += 100;
			// フォントを表示
			scores.fontScore100 = getBaseActivity().getResourceUtil()
					.getSprite("font_01_score_100.png");
			scores.fontScore100.setTag(
					Scores.TAG_FONT_01_SCORE_100);
			if (グラチェンジフラグ == false) {
				scores.fontScore100.setPosition(
						marioSets.playerMarioSet1.getX(),
						marioSets.playerMarioSet1.getY());
			} else {
				scores.fontScore100.setPosition(
						marioSets.playerMarioSet2.getX(),
						marioSets.playerMarioSet2.getY());
			}
			attachChild(scores.fontScore100);
			// レイヤーを入れるとなぜかバグる
			// 1.5秒ストップ！
			registerUpdateHandler(new TimerHandler(1.5f, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					scores.fontScore100.registerEntityModifier(new FadeOutModifier(0.5f));
					// 0.5秒ストップ！
					registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							scores.fontScore100.detachSelf();
						}
					}));
				}
			}));
			// リングダミーを表示して消えてないように見せかける
			AnimatedSprite リングダミー左 = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("tile_69_goal_ring_left.png", 1, 2);
			リングダミー左.setTag(
					GoalRings.TAG_TILE_69_GOAL_RING_LEFT);
			リングダミー左.setPosition(
					getChildByIndex(タイル).getX() - 64,
					getChildByIndex(タイル).getY());
			リングダミー左.animate(ani並);
			attachChild(リングダミー左);
			AnimatedSprite リングダミー右 = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("tile_70_goal_ring_right.png", 1, 2);
			リングダミー右.setTag(
					GoalRings.TAG_TILE_69_GOAL_RING_LEFT);
			リングダミー右.setPosition(
					getChildByIndex(タイル).getX() + 0,
					getChildByIndex(タイル).getY());
			リングダミー右.animate(ani並);
			attachChild(リングダミー右);
		}
		// ここから共通処理
		// ジャンプ時はズボン関係なくバック転！
		if (プレイヤーのジャンプフラグ == true) {
			// ボイスは被るので入れない
			backFlipJumpSprite();
			// タイルに接触していない場合の処理
		} else if (フラグタイル接触 == false && 状態フラグ復活中 == true
				&& フラグバルーン掴み == true) {
			フラグバルーン掴み		= false;
			フラグバル放メッセージ		= false;
			// ボイスは被るので入れない
			backFlipJumpSprite();
			// タイルに接触している場合はフラグバルーン放したいをとぅるー！
		} else if (フラグタイル接触 == true && 状態フラグ復活中 == true
				&& フラグバルーン掴み == true && フラグバルーン放したい == false) {
			フラグバルーン放したい		= true;
			フラグバル放メッセージ		= true;
		}
		// ミュージックをストップ！
		if (状態フラグ無敵 == false) {
			musicStop();
		} else {
			MusicPlay.bgmNormalStarmanTheme.setVolume(0.5f);
			// 5秒ストップ！
			registerUpdateHandler(new TimerHandler(5, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					if (状態フラグ無敵 == true && メモリーの開放をしたかどうか == false) {
						MusicPlay.bgmNormalStarmanTheme.setVolume(1);
					}
				}
			}));
		}
		try {
			MusicPlay.bgmCouseClear = MusicFactory.createMusicFromAsset(
					getBaseActivity().getMusicManager(), getBaseActivity(),
					"bgm_08_couse_clear.mp3");
			MusicPlay.bgmCouseClear.setVolume(1);
			MusicPlay.bgmCouseClear.setLooping(false);
			MusicPlay.bgmCouseClear.play();
		} catch (final IOException e) {
			Debug.e(e);
		}
	}
	// ワールドクリア
	public void worldClear() {
		
	}
	// ゲームクリア
	public void gameClear() {
		// Sceneのタッチリスナーを解除
		setOnSceneTouchListener(null);
		// 順位に応じてレコードマークを表示
		if (ハイスコア変数 == 1) {
			AnimatedSprite 一位レコード1 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_31_data_1st_record.png", 1, 5);
			一位レコード1.setPosition(256, 176);
			一位レコード1.setScale(1);
			一位レコード1.animate(180);
			attachChild(一位レコード1);
			AnimatedSprite 一位レコード2 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_31_data_1st_record.png", 1, 5);
			一位レコード2.setPosition(512, 176);
			一位レコード2.setScale(1);
			一位レコード2.animate(180);
			attachChild(一位レコード2);
		} else if (ハイスコア変数 == 2) {
			AnimatedSprite 二位レコード1 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_32_data_2nd_record.png", 1, 5);
			二位レコード1.setPosition(256, 176);
			二位レコード1.setScale(1);
			二位レコード1.animate(180);
			attachChild(二位レコード1);
			AnimatedSprite 二位レコード2 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_32_data_2nd_record.png", 1, 5);
			二位レコード2.setPosition(512, 176);
			二位レコード2.setScale(1);
			二位レコード2.animate(180);
			attachChild(二位レコード2);
		} else if (ハイスコア変数 == 3) {
			AnimatedSprite 三位レコード1 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_33_data_3rd_record.png", 1, 5);
			三位レコード1.setPosition(256, 176);
			三位レコード1.setScale(1);
			三位レコード1.animate(180);
			attachChild(三位レコード1);
			AnimatedSprite 三位レコード2 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_33_data_3rd_record.png", 1, 5);
			三位レコード2.setPosition(512, 176);
			三位レコード2.setScale(1);
			三位レコード2.animate(180);
			attachChild(三位レコード2);
		} else if (ハイスコア変数 == 4) {
			AnimatedSprite 四位レコード1 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_34_data_4th_record.png", 1, 5);
			四位レコード1.setPosition(256, 176);
			四位レコード1.setScale(1);
			四位レコード1.animate(180);
			attachChild(四位レコード1);
			AnimatedSprite 四位レコード2 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_34_data_4th_record.png", 1, 5);
			四位レコード2.setPosition(512, 176);
			四位レコード2.setScale(1);
			四位レコード2.animate(180);
			attachChild(四位レコード2);
		} else if (ハイスコア変数 == 5) {
			AnimatedSprite 五位レコード1 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_35_data_5th_record.png", 1, 5);
			五位レコード1.setPosition(256, 176);
			五位レコード1.setScale(1);
			五位レコード1.animate(180);
			attachChild(五位レコード1);
			AnimatedSprite 五位レコード2 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_35_data_5th_record.png", 1, 5);
			五位レコード2.setPosition(512, 176);
			五位レコード2.setScale(1);
			五位レコード2.animate(180);
			attachChild(五位レコード2);
		}
		// 端末に搭載されたフォントを利用する
		Texture texture = new BitmapTextureAtlas(getBaseActivity()
				.getTextureManager(), 512, 512,
				TextureOptions.BILINEAR_PREMULTIPLYALPHA);
		Font font = new Font(getBaseActivity().getFontManager(), texture,
				Typeface.DEFAULT_BOLD, 30, true, Color.WHITE);
		getBaseActivity().getTextureManager().loadTexture(texture);
		getBaseActivity().getFontManager().loadFont(font);
		// 読み込んだフォントを利用してスコアを表示
		Text resultText = new Text(0, 0, font, "Score\n"
				+ 現在のスコア, 42, new TextOptions(HorizontalAlign.CENTER),
				getBaseActivity().getVertexBufferObjectManager());
		resultText.setPosition(getBaseActivity().getEngine().getCamera()
				.getWidth() / 2.0f - resultText.getWidth() / 2.0f, 160);
		resultText.setColor(1, 1, 0);
		attachChild(resultText);
//		// ランキングボタン（ゲームクリア時）の追加
//		ButtonSprite ランキング = getBaseActivity().getResourceUtil()
//				.getButtonSprite("button_05_data_go_to_online_ranking.png",
//						"button_05_data_go_to_online_ranking_push.png");
//		ランキング.setPosition(160, 320);
//		ランキング.setTag(Datas.TAG_BUTTON_05_DATA_GO_TO_ONLINE_RANKING);
//		ランキング.setOnClickListener(this);
//		registerTouchArea(ランキング);
//		ランキング.setScale(0.25f);
//		attachChild(ランキング);
		// トゥウィートボタン（ゲームクリア時）の追加
		ButtonSprite トゥウィート = getBaseActivity().getResourceUtil()
				.getButtonSprite("button_29_game_over_tweet.png",
						"button_29_game_over_tweet_push.png");
		placeToCenterX(トゥウィート, 320);
		トゥウィート.setTag(GameOvers.TAG_BUTTON_29_GAME_OVER_TWEET);
		トゥウィート.setOnClickListener(this);
		registerTouchArea(トゥウィート);
		attachChild(トゥウィート);
		// タイトルボタン（ゲームクリア時）の追加
		ButtonSprite タイトル = getBaseActivity().getResourceUtil()
				.getButtonSprite("button_30_game_over_title.png",
						"button_30_game_over_title_push.png");
		タイトル.setPosition(544, 320);
		タイトル.setTag(GameOvers.TAG_BUTTON_30_GAME_OVER_TITLE);
		タイトル.setOnClickListener(this);
		registerTouchArea(タイトル);
		attachChild(タイトル);
	}
	
	// ===========================================================
	// ミス系
	// ===========================================================
	
	// プレイヤーダウン
	public void playerDown() {
		SoundPlay.sePlayerMiss.stop();
		SoundPlay.sePlayerMiss.play();
		// 「エ゛エーイ！」をキャンセル
		if (エエーイ実行フラグ == true) {
			エエーイ実行フラグ		= false;
			if (グラチェンジフラグ == false) {
				marioSets.playerMarioSet1.setRotation(0);
			} else {
				marioSets.playerMarioSet2.setRotation(0);
			}
		}
		// 復活タイムアウトミスの処理
		// 復活時は再度フレームレートを呼び出す
		if (状態フラグ復活中 == true) {
			バルーンの上昇移動値1	= 5;
			バルーンの上昇移動値2	= 10;
			バルーンの下降移動値1	= 5;
			バルーンの下降移動値2	= 10;
			// 忘れずにフラグをふぁるす！
			ゲーム待機中かどうか		= false;
			出現フラグバルーン		= false;
			状態フラグ復活中			= false;
			// バルーンを消す！
			balloons.enemyBalloonNotObject.detachSelf();
			// 吹き出しを消す！
			marios.effectMarioBalloon.detachSelf();
			// テキストを消す！
			テキスト3.detachSelf();
			ライフテキスト一時.detachSelf();
			カウントダウンテキスト.detachSelf();
			// 復活時レートをストップ！
			unregisterUpdateHandler(復活時レート);
		}
		// バルーンの出現位置を乱数で
		int r = (int)(Math.random() * 2);
		switch (r) {
		case 0:
			バルーンの出現ポイント = 288;	// 下から6マス
			break;
		case 1:
			バルーンの出現ポイント = 0;	// 下から15マス
			break;
		}
		if (出現フラグバルーン == false) {
			// 忘れずにフラグをとぅるー！
			ゲーム待機中かどうか	= true;
			フラグバルーン掴み	= true;
			出現フラグバルーン	= true;
			状態フラグ復活中		= true;
			// ミス変数処理
			連続ミスカウンター++;
			復活タイムカウンター	= 0;
			復活タイムバックアップ	= 5;
			現在のライフ		-= 1;
			ライフテキスト常時.registerEntityModifier(
					new LoopEntityModifier(new SequenceEntityModifier(
							new ScaleModifier(0.25f, 1.0f, 1.5f),
							new ScaleModifier(0.25f, 1.5f, 1.0f)), 1));
			if (メット取得フラグ == true) {
				アイコンメット.registerEntityModifier(new LoopEntityModifier(
						new SequenceEntityModifier(new FadeOutModifier(
								0.125f), new FadeInModifier(0.125f)), 2));
				// 0.5秒ストップ！
				registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						アイコンメット.registerEntityModifier(new FadeOutModifier(0.125f));
					}
				}));
			}
			if (シャツ取得フラグ == true) {
				アイコンシャツ.registerEntityModifier(new LoopEntityModifier(
						new SequenceEntityModifier(new FadeOutModifier(
								0.125f), new FadeInModifier(0.125f)), 2));
				// 0.5秒ストップ！
				registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						アイコンシャツ.registerEntityModifier(new FadeOutModifier(0.125f));
					}
				}));
			}
			if (ズボン取得フラグ == true) {
				アイコンズボン.registerEntityModifier(new LoopEntityModifier(
						new SequenceEntityModifier(new FadeOutModifier(
								0.125f), new FadeInModifier(0.125f)), 2));
				// 0.5秒ストップ！
				registerUpdateHandler(new TimerHandler(0.5f, new ITimerCallback() {
					public void onTimePassed(TimerHandler pTimeHandler) {
						アイコンズボン.registerEntityModifier(new FadeOutModifier(0.125f));
					}
				}));
			}
			// グラ処理
			// 復活バルーンの追加
			balloons.enemyBalloonNotObject = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("enemy_20_balloon_not_object.png", 1, 6);
			// y座標（appPoint）はランダム
			balloons.enemyBalloonNotObject.setPosition(160, バルーンの出現ポイント);
			balloons.enemyBalloonNotObject.animate(180);
			balloons.enemyBalloonNotObject.setAlpha(0);
			attachChild(balloons.enemyBalloonNotObject);
			balloons.enemyBalloonNotObject.setZIndex(レイヤー10プレイヤー用);
			sortChildren();
			// 吹き出しの追加
			marios.effectMarioBalloon = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("effect_40_mario_balloon.png", 1, 4);
			marios.effectMarioBalloon.setPosition(
					balloons.enemyBalloonNotObject.getX() + 16,
					balloons.enemyBalloonNotObject.getY() + 16);
			marios.effectMarioBalloon.animate(ani並);
			marios.effectMarioBalloon.setAlpha(0);
			attachChild(marios.effectMarioBalloon);
			marios.effectMarioBalloon.setZIndex(レイヤー10プレイヤー用);
			sortChildren();
			// インクリ
			// マリオのグラをインクリ
			if (グラチェンジフラグ == false) {
				// 元のグラは削除
				marioSets.playerMarioSet1.detachSelf();
			} else {
				グラチェンジフラグ = false;
				// 元のグラは削除
				marioSets.playerMarioSet2.detachSelf();
			}
			// マリオのグラセット1
			marioSets.playerMarioSet1 = getBaseActivity().getResourceUtil()
					.getAnimatedSprite("player_01_mario_set_1.png", 1, 30);
			marioSets.playerMarioSet1.setPosition(160, バルーンの出現ポイント + 64);
			marioSets.playerMarioSet1.setCurrentTileIndex(3);
			marioSets.playerMarioSet1.setAlpha(0);
			attachChild(marioSets.playerMarioSet1);
			marioSets.playerMarioSet1.setZIndex(レイヤー10プレイヤー用);
			sortChildren();
			// 当たり判定をインクリ
			if (グラチェンジフラグ == false) {
				// 上の当たり判定をインクリ
				contactLines.playerContactLineAbove.setPosition(
						marioSets.playerMarioSet1.getX() + 0,
						marioSets.playerMarioSet1.getY() + 0);
				// 下の当たり判定をインクリ
				contactLines.playerContactLineBelow.setPosition(
						marioSets.playerMarioSet1.getX() + 0,
						marioSets.playerMarioSet1.getY() + 64);
				// 中の当たり判定（1つ目）をインクリ
				contactLines.playerContactLineCenter1.setPosition(
						marioSets.playerMarioSet1.getX() + 16,
						marioSets.playerMarioSet1.getY() + 24);
				// 中の当たり判定（2つ目）をインクリ
				contactLines.playerContactLineCenter2.setPosition(
						marioSets.playerMarioSet1.getX() + 16,
						marioSets.playerMarioSet1.getY() + 32);
				// 核の当たり判定をインクリ
				contactLines.playerContactLineCore.setPosition(
						marioSets.playerMarioSet1.getX() + 0,
						marioSets.playerMarioSet1.getY() + 16);
			} else {
				// 上の当たり判定をインクリ
				contactLines.playerContactLineAbove.setPosition(
						marioSets.playerMarioSet2.getX() + 0,
						marioSets.playerMarioSet2.getY() + 0);
				// 下の当たり判定をインクリ
				contactLines.playerContactLineBelow.setPosition(
						marioSets.playerMarioSet2.getX() + 0,
						marioSets.playerMarioSet2.getY() + 64);
				// 中の当たり判定（1つ目）をインクリ
				contactLines.playerContactLineCenter1.setPosition(
						marioSets.playerMarioSet2.getX() + 16,
						marioSets.playerMarioSet2.getY() + 24);
				// 中の当たり判定（2つ目）をインクリ
				contactLines.playerContactLineCenter2.setPosition(
						marioSets.playerMarioSet2.getX() + 16,
						marioSets.playerMarioSet2.getY() + 32);
				// 核の当たり判定をインクリ
				contactLines.playerContactLineCore.setPosition(
						marioSets.playerMarioSet2.getX() + 0,
						marioSets.playerMarioSet2.getY() + 16);
			}
			// 待機フラグをON！
			ゲーム待機中かどうか = true;
			// ふっか中は攻撃できない。
			unregisterTouchArea(ボール攻撃ボタン);
			unregisterTouchArea(パンチ攻撃ボタン);
			// 1秒ストップ！
			registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
				public void onTimePassed(TimerHandler pTimeHandler) {
					// 出現位置にマリオたちを表示
					balloons.enemyBalloonNotObject.registerEntityModifier(new LoopEntityModifier(
							new SequenceEntityModifier(new FadeInModifier(
									0.25f), new FadeInModifier(0.25f)), 1));
					marioSets.playerMarioSet1.registerEntityModifier(new LoopEntityModifier(
							new SequenceEntityModifier(new FadeInModifier(
									0.25f), new FadeInModifier(0.25f)), 1));
					// テキスト処理
					// 端末に搭載されたフォントを利用する
					Texture texture = new BitmapTextureAtlas(getBaseActivity()
							.getTextureManager(), 512, 512,
							TextureOptions.BILINEAR_PREMULTIPLYALPHA);
					Font font = new Font(getBaseActivity().getFontManager(), texture,
							Typeface.DEFAULT_BOLD, 24, true, Color.WHITE);
					getBaseActivity().getTextureManager().loadTexture(texture);
					getBaseActivity().getFontManager().loadFont(font);
					// テキスト3の表示
					テキスト3				= new Text(
							marios.effectMarioBalloon.getX() + 24,
							marios.effectMarioBalloon.getY() + 64,
							font, "×", 20,
							new TextOptions(HorizontalAlign.LEFT),
							getBaseActivity().getVertexBufferObjectManager());
					if (現在のライフ <= 1) {
						テキスト3.setColor(1, 0, 0);
					} else if (現在のライフ == 10) {
						テキスト3.setColor(1, 1, 0);
					} else {
						テキスト3.setColor(1, 1, 1);
					}
					attachChild(テキスト3);
					テキスト3.setZIndex(レイヤー13テキスト用);
					sortChildren();
					// ライフテキスト一時の表示
					ライフテキスト一時			= new Text(
							marios.effectMarioBalloon.getX() + 48,
							marios.effectMarioBalloon.getY() + 64,
							font, "" + 現在のライフ, 20,
							new TextOptions(HorizontalAlign.LEFT),
							getBaseActivity().getVertexBufferObjectManager());
					if (現在のライフ <= 1) {
						ライフテキスト一時.setColor(1, 0, 0);
					} else if (現在のライフ == 10) {
						ライフテキスト一時.setColor(1, 1, 0);
					} else {
						ライフテキスト一時.setColor(1, 1, 1);
					}
					attachChild(ライフテキスト一時);
					ライフテキスト一時.setZIndex(レイヤー13テキスト用);
					sortChildren();
					// ゲームをストップ
					unregisterUpdateHandler(フレームレート);
					unregisterUpdateHandler(キラー出現レート);
					// 1秒ストップ！
					registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
						public void onTimePassed(TimerHandler pTimeHandler) {
							// 待機フラグをOFF！
							ゲーム待機中かどうか = false;
							// Pアイテムを全て失う
							if (メット取得フラグ == true) {
								アイコンメット.detachSelf();
								メット取得フラグ = false;
							}
							if (シャツ取得フラグ == true) {
								アイコンシャツ.detachSelf();
								シャツ取得フラグ = false;
							}
							if (ズボン取得フラグ == true) {
								アイコンズボン.detachSelf();
								ズボン取得フラグ = false;
							}
							// 連続ミスした場合の救済措置
							if (連続ミスカウンター >= 3 || 現在のライフ == 1) {
								SoundPlay.sePowerUpItem.stop();
								SoundPlay.sePowerUpItem.play();
								// どのアイテムがもらえるかお楽しみ
								int r = (int)(Math.random() * 3);
								switch (r) {
								case 0:
									SoundPlay.sePowerUpItem.stop();
									SoundPlay.sePowerUpItem.play();
									メット取得フラグ = true;
									アイコンメット = getBaseActivity().getResourceUtil()
											.getSprite("icon_07_power-up_item_1.png");
									アイコンメット.setPosition(16 + 48 * 0, 80);
									アイコンメット.setScale(1.0f);
									attachChild(アイコンメット);
									アイコンメット.setZIndex(レイヤー12アイコン用);
									sortChildren();
									// マリオのグラをチェンジ！
									if (グラチェンジフラグ == false && 状態フラグ無敵 == false) {
										グラチェンジフラグ = true;
										// マリオのグラセット2
										marioSets.playerMarioSet2 = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("player_02_mario_set_2.png", 1, 30);
										marioSets.playerMarioSet2.setPosition(marioSets.playerMarioSet1);
										attachChild(marioSets.playerMarioSet2);
										marioSets.playerMarioSet2.setZIndex(レイヤー10プレイヤー用);
										sortChildren();
										// 元のグラは削除
										marioSets.playerMarioSet1.detachSelf();
										// MAXアイテム時は1のグラセットへ…
									} else if (メット取得フラグ == true && シャツ取得フラグ == true
											&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
										グラチェンジフラグ = false;
										// マリオのグラセット1
										marioSets.playerMarioSet1 = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("player_01_mario_set_1.png", 1, 30);
										marioSets.playerMarioSet1.setPosition(marioSets.playerMarioSet2);
										attachChild(marioSets.playerMarioSet1);
										marioSets.playerMarioSet1.setZIndex(レイヤー10プレイヤー用);
										sortChildren();
										// 元のグラは削除
										marioSets.playerMarioSet2.detachSelf();
									}
									// 攻撃時のグラ
									if (ボールハンド実行フラグ == true || パンチハンド実行フラグ == true) {
										playerAttackAnimation();
									} else {
										// ダッシュ時のグラ
										if (プレイヤーのダッシュフラグ == true && プレイヤーのジャンプフラグ == false) {
											playerDashAnimation();
											// ジャンプ時のグラ
										} else if (プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true) {
											playerJumpAnimation();
										}
									}
									アイコンメット.registerEntityModifier(
											new LoopEntityModifier(new SequenceEntityModifier(
													new ScaleModifier(0.25f, 1.0f, 1.5f),
													new ScaleModifier(0.25f, 1.5f, 1.0f)), 4));
									// 必要スプライトを2回点滅
									if (状態フラグ無敵 == true) {
										marioSets.playerMarioSet1.registerEntityModifier(new LoopEntityModifier(
												new SequenceEntityModifier(new FadeOutModifier(
														0.125f), new FadeInModifier(0.125f)), 2));
									} else {
										marioSets.playerMarioSet2.registerEntityModifier(new LoopEntityModifier(
												new SequenceEntityModifier(new FadeOutModifier(
														0.125f), new FadeInModifier(0.125f)), 2));
									}
									break;
								case 1:
									SoundPlay.sePowerUpItem.stop();
									SoundPlay.sePowerUpItem.play();
									シャツ取得フラグ = true;
									アイコンシャツ = getBaseActivity().getResourceUtil()
											.getSprite("icon_08_power-up_item_2.png");
									アイコンシャツ.setPosition(16 + 48 * 1, 80);
									アイコンシャツ.setScale(1.0f);
									attachChild(アイコンシャツ);
									アイコンシャツ.setZIndex(レイヤー12アイコン用);
									sortChildren();
									// マリオのグラをチェンジ！
									if (グラチェンジフラグ == false && 状態フラグ無敵 == false) {
										グラチェンジフラグ = true;
										// マリオのグラセット2
										marioSets.playerMarioSet2 = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("player_02_mario_set_2.png", 1, 30);
										marioSets.playerMarioSet2.setPosition(marioSets.playerMarioSet1);
										attachChild(marioSets.playerMarioSet2);
										marioSets.playerMarioSet2.setZIndex(レイヤー10プレイヤー用);
										sortChildren();
										// 元のグラは削除
										marioSets.playerMarioSet1.detachSelf();
										// MAXアイテム時は1のグラセットへ…
									} else if (メット取得フラグ == true && シャツ取得フラグ == true
											&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
										グラチェンジフラグ = false;
										// マリオのグラセット1
										marioSets.playerMarioSet1 = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("player_01_mario_set_1.png", 1, 30);
										marioSets.playerMarioSet1.setPosition(marioSets.playerMarioSet2);
										attachChild(marioSets.playerMarioSet1);
										marioSets.playerMarioSet1.setZIndex(レイヤー10プレイヤー用);
										sortChildren();
										// 元のグラは削除
										marioSets.playerMarioSet2.detachSelf();
									}
									// 攻撃時のグラ
									if (ボールハンド実行フラグ == true || パンチハンド実行フラグ == true) {
										playerAttackAnimation();
									} else {
										// ダッシュ時のグラ
										if (プレイヤーのダッシュフラグ == true && プレイヤーのジャンプフラグ == false) {
											playerDashAnimation();
											// ジャンプ時のグラ
										} else if (プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true) {
											playerJumpAnimation();
										}
									}
									アイコンシャツ.registerEntityModifier(
											new LoopEntityModifier(new SequenceEntityModifier(
													new ScaleModifier(0.25f, 1.0f, 1.5f),
													new ScaleModifier(0.25f, 1.5f, 1.0f)), 4));
									// 必要スプライトを2回点滅
									if (状態フラグ無敵 == true) {
										marioSets.playerMarioSet1.registerEntityModifier(new LoopEntityModifier(
												new SequenceEntityModifier(new FadeOutModifier(
														0.125f), new FadeInModifier(0.125f)), 2));
									} else {
										marioSets.playerMarioSet2.registerEntityModifier(new LoopEntityModifier(
												new SequenceEntityModifier(new FadeOutModifier(
														0.125f), new FadeInModifier(0.125f)), 2));
									}
									break;
								case 2:
									SoundPlay.sePowerUpItem.stop();
									SoundPlay.sePowerUpItem.play();
									ズボン取得フラグ = true;
									アイコンズボン = getBaseActivity().getResourceUtil()
											.getSprite("icon_09_power-up_item_3.png");
									アイコンズボン.setPosition(16 + 48 * 2, 80);
									アイコンズボン.setScale(1.0f);
									attachChild(アイコンズボン);
									アイコンズボン.setZIndex(レイヤー12アイコン用);
									sortChildren();
									// マリオのグラをチェンジ！
									if (グラチェンジフラグ == false && 状態フラグ無敵 == false) {
										グラチェンジフラグ = true;
										// マリオのグラセット2
										marioSets.playerMarioSet2 = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("player_02_mario_set_2.png", 1, 30);
										marioSets.playerMarioSet2.setPosition(marioSets.playerMarioSet1);
										attachChild(marioSets.playerMarioSet2);
										marioSets.playerMarioSet2.setZIndex(レイヤー10プレイヤー用);
										sortChildren();
										// 元のグラは削除
										marioSets.playerMarioSet1.detachSelf();
										// MAXアイテム時は1のグラセットへ…
									} else if (メット取得フラグ == true && シャツ取得フラグ == true
											&& ズボン取得フラグ == true && 状態フラグ無敵 == false) {
										グラチェンジフラグ = false;
										// マリオのグラセット1
										marioSets.playerMarioSet1 = getBaseActivity().getResourceUtil()
												.getAnimatedSprite("player_01_mario_set_1.png", 1, 30);
										marioSets.playerMarioSet1.setPosition(marioSets.playerMarioSet2);
										attachChild(marioSets.playerMarioSet1);
										marioSets.playerMarioSet1.setZIndex(レイヤー10プレイヤー用);
										sortChildren();
										// 元のグラは削除
										marioSets.playerMarioSet2.detachSelf();
									}
									// 攻撃時のグラ
									if (ボールハンド実行フラグ == true || パンチハンド実行フラグ == true) {
										playerAttackAnimation();
									} else {
										// ダッシュ時のグラ
										if (プレイヤーのダッシュフラグ == true && プレイヤーのジャンプフラグ == false) {
											playerDashAnimation();
											// ジャンプ時のグラ
										} else if (プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true) {
											playerJumpAnimation();
										}
									}
									アイコンズボン.registerEntityModifier(
											new LoopEntityModifier(new SequenceEntityModifier(
													new ScaleModifier(0.25f, 1.0f, 1.5f),
													new ScaleModifier(0.25f, 1.5f, 1.0f)), 4));
									// 必要スプライトを2回点滅
									if (状態フラグ無敵 == true) {
										marioSets.playerMarioSet1.registerEntityModifier(new LoopEntityModifier(
												new SequenceEntityModifier(new FadeOutModifier(
														0.125f), new FadeInModifier(0.125f)), 2));
									} else {
										marioSets.playerMarioSet2.registerEntityModifier(new LoopEntityModifier(
												new SequenceEntityModifier(new FadeOutModifier(
														0.125f), new FadeInModifier(0.125f)), 2));
									}
									break;
								}
							}
							// テキスト処理
							// 端末に搭載されたフォントを利用する
							Texture texture = new BitmapTextureAtlas(getBaseActivity()
									.getTextureManager(), 512, 512,
									TextureOptions.BILINEAR_PREMULTIPLYALPHA);
							Font font = new Font(getBaseActivity().getFontManager(), texture,
									Typeface.DEFAULT_BOLD, 24, true, Color.WHITE);
							getBaseActivity().getTextureManager().loadTexture(texture);
							getBaseActivity().getFontManager().loadFont(font);
							// カウントダウンテキストの表示
							カウントダウンテキスト			= new Text(
									marios.effectMarioBalloon.getX() + 24,
									marios.effectMarioBalloon.getY() + 16,
									font, "" + 復活タイムバックアップ, 40,
									new TextOptions(HorizontalAlign.LEFT),
									getBaseActivity().getVertexBufferObjectManager());
							カウントダウンテキスト.setColor(0, 0, 0);
							attachChild(カウントダウンテキスト);
							カウントダウンテキスト.setZIndex(レイヤー13テキスト用);
							sortChildren();
							// バルーンを表示
							marios.effectMarioBalloon.setAlpha(1);
							// ストップしたハンドラーを再度動かす
							registerUpdateHandler(復活時レート);
							registerUpdateHandler(フレームレート);
							registerUpdateHandler(キラー出現レート);
						}
					}));
				}
			}));
		}
	}
	// ゲームストップ
	public void gameStop() {
		ゲームオーバーかどうか = true;
		// 全てのアニマテッドスプライトのアニメーションをストップ！
		for (int i = 0; i < getChildCount(); i++) {
			if (getChildByIndex(i)instanceof AnimatedSprite) {
				((AnimatedSprite)getChildByIndex(i)).stopAnimation();
			}
		}
		SoundPlay.sePlayerMiss.stop();
		SoundPlay.sePlayerMiss.play();
		musicStop();
		// ハンドラーをストップ！
		unregisterUpdateHandler(復活時レート);
		unregisterUpdateHandler(キラー出現レート);
		// マリオのグラを削除
		if (グラチェンジフラグ == false) {
			marioSets.playerMarioSet1.detachSelf();
		} else {
			marioSets.playerMarioSet2.detachSelf();
		}
		// 当たり判定を削除
		contactLines.playerContactLineAbove.detachSelf();
		contactLines.playerContactLineBelow.detachSelf();
		contactLines.playerContactLineCenter1.detachSelf();
		contactLines.playerContactLineCenter2.detachSelf();
		contactLines.playerContactLineCore.detachSelf();
		// スコア（全て）の保存
		scoreSave();
		// ゲームオーバー
		gameOver();
	}
	// ゲームオーバー
	public void gameOver() {
		// ここで、中断データもデクリ
		中断セーブデータ.getInstance(getBaseActivity()).set中断セーブデータ(0);
		// Sceneのタッチリスナーを解除
		setOnSceneTouchListener(null);
		// 1秒ストップ！
		registerUpdateHandler(new TimerHandler(1, new ITimerCallback() {
			public void onTimePassed(TimerHandler pTimeHandler) {
				try {
					// No.16:ゲームオーバー
					MusicPlay.bgmGameOverTheme = MusicFactory.createMusicFromAsset(
							getBaseActivity().getMusicManager(), getBaseActivity(),
							"bgm_16_game_over.mp3");
					MusicPlay.bgmGameOverTheme.setVolume(1);
					MusicPlay.bgmGameOverTheme.setLooping(false);
					MusicPlay.bgmGameOverTheme.play();
				} catch (final IOException e) {
					Debug.e(e);
				}
				VoicePlay.voiceGameOver.stop();
				VoicePlay.voiceGameOver.play();
			}
		}));
		// 真っ黒な背景を作成
		ゲームオーバー四角形 = new Rectangle(getBaseActivity().getEngine()
				.getCamera().getWidth(), 0, getBaseActivity().getEngine()
				.getCamera().getWidth(), getBaseActivity().getEngine()
				.getCamera().getHeight(), getBaseActivity()
				.getVertexBufferObjectManager());
		ゲームオーバー四角形.setColor(0, 0, 0);
		attachChild(ゲームオーバー四角形);
		ゲームオーバー四角形.setZIndex(レイヤー16ポーズ用);
		sortChildren();
		// 端末に搭載されたフォントを利用する
		Texture texture = new BitmapTextureAtlas(getBaseActivity()
				.getTextureManager(), 512, 512,
				TextureOptions.BILINEAR_PREMULTIPLYALPHA);
		Font font = new Font(getBaseActivity().getFontManager(), texture,
				Typeface.DEFAULT_BOLD, 30, true, Color.WHITE);
		getBaseActivity().getTextureManager().loadTexture(texture);
		getBaseActivity().getFontManager().loadFont(font);
		// 読み込んだフォントを利用してスコアとかを表示
		Text resultText1 = new Text(0, 0, font, "World         "
				+ 現在のワールド + " - " + 現在のコース + "\n"
				+ "Score         " + 現在のスコア, 42,
				new TextOptions(HorizontalAlign.CENTER), getBaseActivity()
						.getVertexBufferObjectManager());
		resultText1.setPosition(getBaseActivity().getEngine().getCamera()
				.getWidth()
				/ 2.0f - resultText1.getWidth() / 2.0f, 160);
		resultText1.setColor(1, 1, 0);
		ゲームオーバー四角形.attachChild(resultText1);
		// 読み込んだフォントを利用して所持クリスタルを表示
		Text 所持クリスタルテキスト1 = new Text(0, 0, font, "×", 2042, new TextOptions(
				HorizontalAlign.CENTER), getBaseActivity()
				.getVertexBufferObjectManager());
		所持クリスタルテキスト1.setPosition(getBaseActivity().getEngine().getCamera()
				.getWidth()
				/ 2.0f - 所持クリスタルテキスト1.getWidth() / 2.0f, 256);
		ゲームオーバー四角形.attachChild(所持クリスタルテキスト1);
		Text 所持クリスタルテキスト2 = new Text(448, 256, font, "" + 合計のクリスタル, 42,
				new TextOptions(HorizontalAlign.LEFT), getBaseActivity()
						.getVertexBufferObjectManager());
		ゲームオーバー四角形.attachChild(所持クリスタルテキスト2);
		// 読み込んだフォントを利用して必要クリスタルを表示
		// 一回目のコンチに必要なクリスタル数
		if (現在のコンチニュー == 0 && コースカウンター != 0 && コースカウンター != 1) {
			Text 必要クリスタルテキスト = new Text(144, 368, font, "（     -3）", 42,
					new TextOptions(HorizontalAlign.CENTER), getBaseActivity()
					.getVertexBufferObjectManager());
			// クリスタルが3個以上の場合、アニメーション表示
			if (合計のクリスタル >= 3) {
				必要クリスタルテキスト.setColor(1, 1, 0);
			} else {
				必要クリスタルテキスト.setAlpha(0.25f);
				必要クリスタルテキスト.setColor(1, 0, 0);
			}
			ゲームオーバー四角形.attachChild(必要クリスタルテキスト);
			// 二回目のコンチに必要なクリスタル数
		} else if (現在のコンチニュー == 1 && コースカウンター != 0 && コースカウンター != 1) {
			Text 必要クリスタルテキスト = new Text(144, 368, font, "（     -5）", 42,
					new TextOptions(HorizontalAlign.CENTER), getBaseActivity()
					.getVertexBufferObjectManager());
			// クリスタルが5個以上の場合、アニメーション表示
			if (合計のクリスタル >= 5) {
				必要クリスタルテキスト.setColor(1, 1, 0);
			} else {
				必要クリスタルテキスト.setAlpha(0.25f);
				必要クリスタルテキスト.setColor(1, 0, 0);
			}
			ゲームオーバー四角形.attachChild(必要クリスタルテキスト);
			// 三回目のコンチに必要なクリスタル数
		} else if (現在のコンチニュー == 2 && コースカウンター != 0 && コースカウンター != 1) {
			Text 必要クリスタルテキスト = new Text(144, 368, font, "（     -7）", 42,
					new TextOptions(HorizontalAlign.CENTER), getBaseActivity()
					.getVertexBufferObjectManager());
			// クリスタルが7個以上の場合、アニメーション表示
			if (合計のクリスタル >= 7) {
				必要クリスタルテキスト.setColor(1, 1, 0);
			} else {
				必要クリスタルテキスト.setAlpha(0.25f);
				必要クリスタルテキスト.setColor(1, 0, 0);
			}
			ゲームオーバー四角形.attachChild(必要クリスタルテキスト);
			// 四回目のコンチに必要なクリスタル数
		} else if (現在のコンチニュー == 3 && コースカウンター != 0 && コースカウンター != 1) {
			Text 必要クリスタルテキスト = new Text(144, 368, font, "（     -10）", 42,
					new TextOptions(HorizontalAlign.CENTER), getBaseActivity()
					.getVertexBufferObjectManager());
			// クリスタルが10個以上の場合、アニメーション表示
			if (合計のクリスタル >= 10) {
				必要クリスタルテキスト.setColor(1, 1, 0);
			} else {
				必要クリスタルテキスト.setAlpha(0.25f);
				必要クリスタルテキスト.setColor(1, 0, 0);
			}
			ゲームオーバー四角形.attachChild(必要クリスタルテキスト);
			// 五回目のコンチに必要なクリスタル数
		} else if (現在のコンチニュー == 4 && コースカウンター != 0 && コースカウンター != 1) {
			Text 必要クリスタルテキスト = new Text(144, 368, font, "（     -15）", 42,
					new TextOptions(HorizontalAlign.CENTER), getBaseActivity()
					.getVertexBufferObjectManager());
			// クリスタルが15個以上の場合、アニメーション表示
			if (合計のクリスタル >= 15) {
				必要クリスタルテキスト.setColor(1, 1, 0);
			} else {
				必要クリスタルテキスト.setAlpha(0.25f);
				必要クリスタルテキスト.setColor(1, 0, 0);
			}
			ゲームオーバー四角形.attachChild(必要クリスタルテキスト);
			// 六回目以降のコンチに必要なクリスタル数
		} else if (現在のコンチニュー >= 5 && コースカウンター != 0 && コースカウンター != 1) {
			Text 必要クリスタルテキスト = new Text(144, 368, font, "（     -20）", 42,
					new TextOptions(HorizontalAlign.CENTER), getBaseActivity()
					.getVertexBufferObjectManager());
			// クリスタルが20個以上の場合、アニメーション表示
			if (合計のクリスタル >= 20) {
				必要クリスタルテキスト.setColor(1, 1, 0);
			} else {
				必要クリスタルテキスト.setAlpha(0.25f);
				必要クリスタルテキスト.setColor(1, 0, 0);
			}
			ゲームオーバー四角形.attachChild(必要クリスタルテキスト);
		}
		// 順位に応じてレコードマークを表示
		if (ハイスコア変数 == 1) {
			AnimatedSprite 一位レコード1 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_31_data_1st_record.png", 1, 5);
			一位レコード1.setPosition(208, 176);
			一位レコード1.setScale(1);
			一位レコード1.animate(180);
			ゲームオーバー四角形.attachChild(一位レコード1);
			AnimatedSprite 一位レコード2 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_31_data_1st_record.png", 1, 5);
			一位レコード2.setPosition(560, 176);
			一位レコード2.setScale(1);
			一位レコード2.animate(180);
			ゲームオーバー四角形.attachChild(一位レコード2);
		} else if (ハイスコア変数 == 2) {
			AnimatedSprite 二位レコード1 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_32_data_2nd_record.png", 1, 5);
			二位レコード1.setPosition(208, 176);
			二位レコード1.setScale(1);
			二位レコード1.animate(180);
			ゲームオーバー四角形.attachChild(二位レコード1);
			AnimatedSprite 二位レコード2 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_32_data_2nd_record.png", 1, 5);
			二位レコード2.setPosition(560, 176);
			二位レコード2.setScale(1);
			二位レコード2.animate(180);
			ゲームオーバー四角形.attachChild(二位レコード2);
		} else if (ハイスコア変数 == 3) {
			AnimatedSprite 三位レコード1 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_33_data_3rd_record.png", 1, 5);
			三位レコード1.setPosition(208, 176);
			三位レコード1.setScale(1);
			三位レコード1.animate(180);
			ゲームオーバー四角形.attachChild(三位レコード1);
			AnimatedSprite 三位レコード2 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_33_data_3rd_record.png", 1, 5);
			三位レコード2.setPosition(560, 176);
			三位レコード2.setScale(1);
			三位レコード2.animate(180);
			ゲームオーバー四角形.attachChild(三位レコード2);
		} else if (ハイスコア変数 == 4) {
			AnimatedSprite 四位レコード1 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_34_data_4th_record.png", 1, 5);
			四位レコード1.setPosition(208, 176);
			四位レコード1.setScale(1);
			四位レコード1.animate(180);
			ゲームオーバー四角形.attachChild(四位レコード1);
			AnimatedSprite 四位レコード2 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_34_data_4th_record.png", 1, 5);
			四位レコード2.setPosition(560, 176);
			四位レコード2.setScale(1);
			四位レコード2.animate(180);
			ゲームオーバー四角形.attachChild(四位レコード2);
		} else if (ハイスコア変数 == 5) {
			AnimatedSprite 五位レコード1 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_35_data_5th_record.png", 1, 5);
			五位レコード1.setPosition(208, 176);
			五位レコード1.setScale(1);
			五位レコード1.animate(180);
			ゲームオーバー四角形.attachChild(五位レコード1);
			AnimatedSprite 五位レコード2 = ResourceUtil.getInstance(getBaseActivity())
					.getAnimatedSprite("system_35_data_5th_record.png", 1, 5);
			五位レコード2.setPosition(560, 176);
			五位レコード2.setScale(1);
			五位レコード2.animate(180);
			ゲームオーバー四角形.attachChild(五位レコード2);
		}
		// アイコン
		// 所持クリスタルをアニマテッドで描画
		AnimatedSprite 所持クリスタル = getBaseActivity().getResourceUtil()
				.getAnimatedSprite("icon_10_power_crystal.png", 1, 9);
		所持クリスタル.setPosition(320, 256);
		所持クリスタル.animate(new long[] { ani遅, ani遅, ani遅, ani遅, }, 1, 4, true);
		ゲームオーバー四角形.attachChild(所持クリスタル);
		// 必要クリスタルをアニマテッドで描画
		AnimatedSprite 必要クリスタル = getBaseActivity().getResourceUtil()
				.getAnimatedSprite("icon_10_power_crystal.png", 1, 9);
		必要クリスタル.setPosition(176, 368);
		// クリスタルのアニメーション
		// 一回目のコンチに必要なクリスタル数
		if (現在のコンチニュー == 0 && コースカウンター != 0 && コースカウンター != 1) {
			if (合計のクリスタル >= 3) {
				必要クリスタル.animate(new long[] { ani遅, ani遅, ani遅, ani遅, }, 1, 4, true);
			} else {
				必要クリスタル.setCurrentTileIndex(2);
				必要クリスタル.setAlpha(0.5f);
			}
			ゲームオーバー四角形.attachChild(必要クリスタル);
			// 二回目のコンチに必要なクリスタル数
		} else if (現在のコンチニュー == 1 && コースカウンター != 0 && コースカウンター != 1) {
			if (合計のクリスタル >= 5) {
				必要クリスタル.animate(new long[] { ani遅, ani遅, ani遅, ani遅, }, 1, 4, true);
			} else {
				必要クリスタル.setCurrentTileIndex(2);
				必要クリスタル.setAlpha(0.5f);
			}
			ゲームオーバー四角形.attachChild(必要クリスタル);
			// 三回目のコンチに必要なクリスタル数
		} else if (現在のコンチニュー == 2 && コースカウンター != 0 && コースカウンター != 1) {
			if (合計のクリスタル >= 7) {
				必要クリスタル.animate(new long[] { ani遅, ani遅, ani遅, ani遅, }, 1, 4, true);
			} else {
				必要クリスタル.setCurrentTileIndex(2);
				必要クリスタル.setAlpha(0.5f);
			}
			ゲームオーバー四角形.attachChild(必要クリスタル);
			// 四回目のコンチに必要なクリスタル数
		} else if (現在のコンチニュー == 3 && コースカウンター != 0 && コースカウンター != 1) {
			if (合計のクリスタル >= 10) {
				必要クリスタル.animate(new long[] { ani遅, ani遅, ani遅, ani遅, }, 1, 4, true);
			} else {
				必要クリスタル.setCurrentTileIndex(2);
				必要クリスタル.setAlpha(0.5f);
			}
			ゲームオーバー四角形.attachChild(必要クリスタル);
			// 五回目のコンチに必要なクリスタル数
		} else if (現在のコンチニュー == 4 && コースカウンター != 0 && コースカウンター != 1) {
			if (合計のクリスタル >= 15) {
				必要クリスタル.animate(new long[] { ani遅, ani遅, ani遅, ani遅, }, 1, 4, true);
			} else {
				必要クリスタル.setCurrentTileIndex(2);
				必要クリスタル.setAlpha(0.5f);
			}
			ゲームオーバー四角形.attachChild(必要クリスタル);
			// 六回目以降のコンチに必要なクリスタル数
		} else if (現在のコンチニュー >= 5 && コースカウンター != 0 && コースカウンター != 1) {
			if (合計のクリスタル >= 20) {
				必要クリスタル.animate(new long[] { ani遅, ani遅, ani遅, ani遅, }, 1, 4, true);
			} else {
				必要クリスタル.setCurrentTileIndex(2);
				必要クリスタル.setAlpha(0.5f);
			}
			ゲームオーバー四角形.attachChild(必要クリスタル);
		}
		// ゲームオーバーロゴ1
		アイコンゲムオ1 = ResourceUtil.getInstance(getBaseActivity())
				.getSprite("icon_31_game_over_g.png");
		アイコンゲムオ1.setPosition(192, -256);
		ゲームオーバー四角形.attachChild(アイコンゲムオ1);
		アイコンゲムオ1.registerEntityModifier(new SequenceEntityModifier(
				new DelayModifier(1), new MoveModifier(1.25f, アイコンゲムオ1.getX(),
						アイコンゲムオ1.getX(), アイコンゲムオ1.getY() - 2400, アイコンゲムオ1
						.getY() + 320, EaseBackInOut.getInstance())));
		// ゲームオーバーロゴ2
		アイコンゲムオ2 = ResourceUtil.getInstance(getBaseActivity())
				.getSprite("icon_32_game_over_a.png");
		アイコンゲムオ2.setPosition(240, -256);
		ゲームオーバー四角形.attachChild(アイコンゲムオ2);
		アイコンゲムオ2.registerEntityModifier(new SequenceEntityModifier(
				new DelayModifier(1), new MoveModifier(1.50f, アイコンゲムオ2.getX(),
						アイコンゲムオ2.getX(), アイコンゲムオ2.getY() - 2400, アイコンゲムオ2
						.getY() + 320, EaseBackInOut.getInstance())));
		// ゲームオーバーロゴ3
		アイコンゲムオ3 = ResourceUtil.getInstance(getBaseActivity())
				.getSprite("icon_33_game_over_m.png");
		アイコンゲムオ3.setPosition(288, -256);
		ゲームオーバー四角形.attachChild(アイコンゲムオ3);
		アイコンゲムオ3.registerEntityModifier(new SequenceEntityModifier(
				new DelayModifier(1), new MoveModifier(1.75f, アイコンゲムオ3.getX(),
						アイコンゲムオ3.getX(), アイコンゲムオ3.getY() - 2400, アイコンゲムオ3
						.getY() + 320, EaseBackInOut.getInstance())));
		// ゲームオーバーロゴ4
		アイコンゲムオ4 = ResourceUtil.getInstance(getBaseActivity())
				.getSprite("icon_34_game_over_e.png");
		アイコンゲムオ4.setPosition(336, -256);
		ゲームオーバー四角形.attachChild(アイコンゲムオ4);
		アイコンゲムオ4.registerEntityModifier(new SequenceEntityModifier(
				new DelayModifier(1), new MoveModifier(2.00f, アイコンゲムオ4.getX(),
						アイコンゲムオ4.getX(), アイコンゲムオ4.getY() - 2400, アイコンゲムオ4
						.getY() + 320, EaseBackInOut.getInstance())));
		// ゲームオーバーロゴ5
		アイコンゲムオ5 = ResourceUtil.getInstance(getBaseActivity())
				.getSprite("icon_35_game_over_o.png");
		アイコンゲムオ5.setPosition(432, -256);
		ゲームオーバー四角形.attachChild(アイコンゲムオ5);
		アイコンゲムオ5.registerEntityModifier(new SequenceEntityModifier(
				new DelayModifier(1), new MoveModifier(2.25f, アイコンゲムオ5.getX(),
						アイコンゲムオ5.getX(), アイコンゲムオ5.getY() - 2400, アイコンゲムオ5
						.getY() + 320, EaseBackInOut.getInstance())));
		// ゲームオーバーロゴ6
		アイコンゲムオ6 = ResourceUtil.getInstance(getBaseActivity())
				.getSprite("icon_36_game_over_v.png");
		アイコンゲムオ6.setPosition(480, -256);
		ゲームオーバー四角形.attachChild(アイコンゲムオ6);
		アイコンゲムオ6.registerEntityModifier(new SequenceEntityModifier(
				new DelayModifier(1), new MoveModifier(2.50f, アイコンゲムオ6.getX(),
						アイコンゲムオ6.getX(), アイコンゲムオ6.getY() - 2400, アイコンゲムオ6
						.getY() + 320, EaseBackInOut.getInstance())));
		// ゲームオーバーロゴ7
		アイコンゲムオ7 = ResourceUtil.getInstance(getBaseActivity())
				.getSprite("icon_37_game_over_e.png");
		アイコンゲムオ7.setPosition(528, -256);
		ゲームオーバー四角形.attachChild(アイコンゲムオ7);
		アイコンゲムオ7.registerEntityModifier(new SequenceEntityModifier(
				new DelayModifier(1), new MoveModifier(2.75f, アイコンゲムオ7.getX(),
						アイコンゲムオ7.getX(), アイコンゲムオ7.getY() - 2400, アイコンゲムオ7
						.getY() + 320, EaseBackInOut.getInstance())));
		// ゲームオーバーロゴ8
		アイコンゲムオ8 = ResourceUtil.getInstance(getBaseActivity())
				.getSprite("icon_38_game_over_r.png");
		アイコンゲムオ8.setPosition(576, -256);
		ゲームオーバー四角形.attachChild(アイコンゲムオ8);
		アイコンゲムオ8.registerEntityModifier(new SequenceEntityModifier(
				new DelayModifier(1), new MoveModifier(3.00f, アイコンゲムオ8.getX(),
						アイコンゲムオ8.getX(), アイコンゲムオ8.getY() - 2400, アイコンゲムオ8
						.getY() + 320, EaseBackInOut.getInstance())));
		// リトライボタンの追加
		// 一回目のコンチに必要なクリスタル数
		if (現在のコンチニュー == 0) {
			if (合計のクリスタル >= 3 && コースカウンター != 0 && コースカウンター != 1) {
				gameOvers.buttonGameOverRetry = getBaseActivity().getResourceUtil()
						.getButtonSprite("button_28_game_over_retry.png",
								"button_28_game_over_retry_push.png");
				gameOvers.buttonGameOverRetry.setPosition(160, 320);
				gameOvers.buttonGameOverRetry.setTag(GameOvers.TAG_BUTTON_28_GAME_OVER_RETRY);
				gameOvers.buttonGameOverRetry.setOnClickListener(this);
				registerTouchArea(gameOvers.buttonGameOverRetry);
				ゲームオーバー四角形.attachChild(gameOvers.buttonGameOverRetry);
			} else {
				Sprite ダミーリトライ = getBaseActivity().getResourceUtil().getSprite(
						"button_28_game_over_retry.png");
				ダミーリトライ.setPosition(160, 320);
				ダミーリトライ.setAlpha(0.5f);
				ゲームオーバー四角形.attachChild(ダミーリトライ);
			}
			// 二回目のコンチに必要なクリスタル数
		} else if (現在のコンチニュー == 1) {
			if (合計のクリスタル >= 5 && コースカウンター != 0 && コースカウンター != 1) {
				gameOvers.buttonGameOverRetry = getBaseActivity().getResourceUtil()
						.getButtonSprite("button_28_game_over_retry.png",
								"button_28_game_over_retry_push.png");
				gameOvers.buttonGameOverRetry.setPosition(160, 320);
				gameOvers.buttonGameOverRetry.setTag(GameOvers.TAG_BUTTON_28_GAME_OVER_RETRY);
				gameOvers.buttonGameOverRetry.setOnClickListener(this);
				registerTouchArea(gameOvers.buttonGameOverRetry);
				ゲームオーバー四角形.attachChild(gameOvers.buttonGameOverRetry);
			} else {
				Sprite ダミーリトライ = getBaseActivity().getResourceUtil().getSprite(
						"button_28_game_over_retry.png");
				ダミーリトライ.setPosition(160, 320);
				ダミーリトライ.setAlpha(0.5f);
				ゲームオーバー四角形.attachChild(ダミーリトライ);
			}
			// 三回目のコンチに必要なクリスタル数
		} else if (現在のコンチニュー == 2) {
			if (合計のクリスタル >= 7 && コースカウンター != 0 && コースカウンター != 1) {
				gameOvers.buttonGameOverRetry = getBaseActivity().getResourceUtil()
						.getButtonSprite("button_28_game_over_retry.png",
								"button_28_game_over_retry_push.png");
				gameOvers.buttonGameOverRetry.setPosition(160, 320);
				gameOvers.buttonGameOverRetry.setTag(GameOvers.TAG_BUTTON_28_GAME_OVER_RETRY);
				gameOvers.buttonGameOverRetry.setOnClickListener(this);
				registerTouchArea(gameOvers.buttonGameOverRetry);
				ゲームオーバー四角形.attachChild(gameOvers.buttonGameOverRetry);
			} else {
				Sprite ダミーリトライ = getBaseActivity().getResourceUtil().getSprite(
						"button_28_game_over_retry.png");
				ダミーリトライ.setPosition(160, 320);
				ダミーリトライ.setAlpha(0.5f);
				ゲームオーバー四角形.attachChild(ダミーリトライ);
			}
			// 四回目のコンチに必要なクリスタル数
		} else if (現在のコンチニュー == 3) {
			if (合計のクリスタル >= 10 && コースカウンター != 0 && コースカウンター != 1) {
				gameOvers.buttonGameOverRetry = getBaseActivity().getResourceUtil()
						.getButtonSprite("button_28_game_over_retry.png",
								"button_28_game_over_retry_push.png");
				gameOvers.buttonGameOverRetry.setPosition(160, 320);
				gameOvers.buttonGameOverRetry.setTag(GameOvers.TAG_BUTTON_28_GAME_OVER_RETRY);
				gameOvers.buttonGameOverRetry.setOnClickListener(this);
				registerTouchArea(gameOvers.buttonGameOverRetry);
				ゲームオーバー四角形.attachChild(gameOvers.buttonGameOverRetry);
			} else {
				Sprite ダミーリトライ = getBaseActivity().getResourceUtil().getSprite(
						"button_28_game_over_retry.png");
				ダミーリトライ.setPosition(160, 320);
				ダミーリトライ.setAlpha(0.5f);
				ゲームオーバー四角形.attachChild(ダミーリトライ);
			}
			// 五回目のコンチに必要なクリスタル数
		} else if (現在のコンチニュー == 4) {
			if (合計のクリスタル >= 15 && コースカウンター != 0 && コースカウンター != 1) {
				gameOvers.buttonGameOverRetry = getBaseActivity().getResourceUtil()
						.getButtonSprite("button_28_game_over_retry.png",
								"button_28_game_over_retry_push.png");
				gameOvers.buttonGameOverRetry.setPosition(160, 320);
				gameOvers.buttonGameOverRetry.setTag(GameOvers.TAG_BUTTON_28_GAME_OVER_RETRY);
				gameOvers.buttonGameOverRetry.setOnClickListener(this);
				registerTouchArea(gameOvers.buttonGameOverRetry);
				ゲームオーバー四角形.attachChild(gameOvers.buttonGameOverRetry);
			} else {
				Sprite ダミーリトライ = getBaseActivity().getResourceUtil().getSprite(
						"button_28_game_over_retry.png");
				ダミーリトライ.setPosition(160, 320);
				ダミーリトライ.setAlpha(0.5f);
				ゲームオーバー四角形.attachChild(ダミーリトライ);
			}
			// 六回目以降のコンチに必要なクリスタル数
		} else if (現在のコンチニュー >= 5) {
			if (合計のクリスタル >= 20 && コースカウンター != 0 && コースカウンター != 1) {
				gameOvers.buttonGameOverRetry = getBaseActivity().getResourceUtil()
						.getButtonSprite("button_28_game_over_retry.png",
								"button_28_game_over_retry_push.png");
				gameOvers.buttonGameOverRetry.setPosition(160, 320);
				gameOvers.buttonGameOverRetry.setTag(GameOvers.TAG_BUTTON_28_GAME_OVER_RETRY);
				gameOvers.buttonGameOverRetry.setOnClickListener(this);
				registerTouchArea(gameOvers.buttonGameOverRetry);
				ゲームオーバー四角形.attachChild(gameOvers.buttonGameOverRetry);
			} else {
				Sprite ダミーリトライ = getBaseActivity().getResourceUtil().getSprite(
						"button_28_game_over_retry.png");
				ダミーリトライ.setPosition(160, 320);
				ダミーリトライ.setAlpha(0.5f);
				ゲームオーバー四角形.attachChild(ダミーリトライ);
			}
		}
		// トゥウィートボタンの追加
		gameOvers.buttonGameOverTweet = getBaseActivity().getResourceUtil()
				.getButtonSprite("button_29_game_over_tweet.png",
						"button_29_game_over_tweet_push.png");
		placeToCenterX(gameOvers.buttonGameOverTweet, 320);
		gameOvers.buttonGameOverTweet.setTag(GameOvers.TAG_BUTTON_29_GAME_OVER_TWEET);
		gameOvers.buttonGameOverTweet.setOnClickListener(this);
		registerTouchArea(gameOvers.buttonGameOverTweet);
		ゲームオーバー四角形.attachChild(gameOvers.buttonGameOverTweet);
		// タイトルボタン（ゲームオーバー時）の追加
		gameOvers.buttonGameOverTitle = getBaseActivity().getResourceUtil()
				.getButtonSprite("button_30_game_over_title.png",
						"button_30_game_over_title.png");
		gameOvers.buttonGameOverTitle.setPosition(544, 320);
		gameOvers.buttonGameOverTitle.setTag(GameOvers.TAG_BUTTON_30_GAME_OVER_TITLE);
		gameOvers.buttonGameOverTitle.setOnClickListener(this);
		registerTouchArea(gameOvers.buttonGameOverTitle);
		ゲームオーバー四角形.attachChild(gameOvers.buttonGameOverTitle);
//		// ランキングボタンの追加
//		datas.buttonDataGoToOnlineRanking = getBaseActivity().getResourceUtil()
//				.getButtonSprite("button_05_data_go_to_online_ranking.png",
//						"button_05_data_go_to_online_ranking_push.png");
//		placeToCenterX(datas.buttonDataGoToOnlineRanking, 0);
//		datas.buttonDataGoToOnlineRanking.setOnClickListener(this);
//		registerTouchArea(datas.buttonDataGoToOnlineRanking);
//		ゲームオーバー四角形.attachChild(datas.buttonDataGoToOnlineRanking);
		// ゲームオーバー四角形を右側からスライドイン
		ゲームオーバー四角形.registerEntityModifier(new SequenceEntityModifier(
				new DelayModifier(1.0f), new MoveModifier(1.0f,
						ゲームオーバー四角形.getX(), ゲームオーバー四角形.getX()
						- getBaseActivity().getEngine().getCamera()
						.getWidth(), ゲームオーバー四角形.getY(), ゲームオーバー四角形
						.getY(), EaseQuadOut.getInstance())));
	}
	
	// ===========================================================
	// タグ判定系
	// ===========================================================
	
	public void tileTagDecision() {							// タイル
		// タイルを特定値分移動させる
		for (タイル = 0; タイル < getChildCount(); タイル++) {
			if (getChildByIndex(タイル).getTag() ==
					// タイル
					Grasss. 				TAG_TILE_02_GRASS_LONG
					|| getChildByIndex(タイル).getTag() ==
					Mounts.					TAG_TILE_04_MOUNT_BIG
					|| getChildByIndex(タイル).getTag() ==
					TreeParts.				TAG_TILE_06_TREE_PART_2
					|| getChildByIndex(タイル).getTag() ==
					GroundBlocks.			TAG_TILE_13_GROUND_BLOCK_NORMAL_LONG_1
					|| getChildByIndex(タイル).getTag() ==
					GroundBlocks.			TAG_TILE_14_GROUND_BLOCK_NORMAL_LONG_2
					|| getChildByIndex(タイル).getTag() ==
					GroundBlocks.			TAG_TILE_16_GROUND_BLOCK_GOAL_LONG
					|| getChildByIndex(タイル).getTag() ==
					PierceBlocks.			TAG_TILE_26_PIERCE_BLOCK_LONG
					|| getChildByIndex(タイル).getTag() ==
					LiftReds.				TAG_TILE_55_LIFT_RED_1
					|| getChildByIndex(タイル).getTag() ==
					LiftReds.				TAG_TILE_56_LIFT_RED_2
					|| getChildByIndex(タイル).getTag() ==
					LiftReds.				TAG_TILE_57_LIFT_RED_3
					|| getChildByIndex(タイル).getTag() ==
					LiftBlues.				TAG_TILE_58_LIFT_BLUE_1
					|| getChildByIndex(タイル).getTag() ==
					LiftBlues.				TAG_TILE_59_LIFT_BLUE_2
					|| getChildByIndex(タイル).getTag() ==
					LiftBlues.				TAG_TILE_60_LIFT_BLUE_3
					) {
				// 移動処理
				if (コースの端っこかどうか == false) {
					if (状態フラグ無敵 == false) {
						getChildByIndex(タイル).setPosition(
								getChildByIndex(タイル).getX() - 画面のスピード,
								getChildByIndex(タイル).getY());
					} else {
						getChildByIndex(タイル).setPosition(
								getChildByIndex(タイル).getX() - 画面のスピード,
								getChildByIndex(タイル).getY());
					}
				}
				// タイルの削除処理
				if (メモリーの開放をしたかどうか == false) {
					if (getChildByIndex(タイル).getX()
							+ ((Sprite) getChildByIndex(タイル)).getWidth() < -64) {
						// すぐに削除するとインデックスがずれるため、一旦配列に追加
						収納用タイル.add((Sprite) getChildByIndex(タイル));
					}
				} else {
					// すぐに削除するとインデックスがずれるため、一旦配列に追加
					収納用タイル.add((Sprite) getChildByIndex(タイル));
				}
				// タイルの接触処理
				if (メモリーの開放をしたかどうか == false) {
					if (グラチェンジフラグ == false) {
						// 画面いっぱいに判定
						if (marioSets.playerMarioSet1.getX() < 800) {
							// タイルとプレイヤーの接触処理
							tileAndPlayerAboveContact();
							tileAndPlayerCenterContact1();
							tileAndPlayerCenterContact2();
							tileAndPlayerBelowContact();
							tileAndPlayerCoreContact();
						}
					} else {
						if (marioSets.playerMarioSet2.getX() < 800) {
							// タイルとプレイヤーの接触処理
							tileAndPlayerAboveContact();
							tileAndPlayerCenterContact1();
							tileAndPlayerCenterContact2();
							tileAndPlayerBelowContact();
							tileAndPlayerCoreContact();
						}
					}
				}
				// タイルとボールの接触処理
				tileAndNormalFireballContact();
				tileAndSuperFireballContact();
				if (ボールハンド実行フラグ == true) {
					// タイルとハンド（ボール）の接触処理
					tileAndHandFireballContact();
				}
				if (パンチハンド実行フラグ == true) {
					// タイルとハンド（パンチ）の接触処理
					tileAndHandPunchContact();
				}
			}
			// 半径1~3ブロック分のタイルはこちらで処理
			if (getChildByIndex(タイル).getTag() ==
					// タイル
					Grasss.					TAG_TILE_01_GRASS_SHORT
					|| getChildByIndex(タイル).getTag() ==
					Mounts.					TAG_TILE_03_MOUNT_SMALL
					|| getChildByIndex(タイル).getTag() ==
					TreeParts.				TAG_TILE_05_TREE_PART_1	
					|| getChildByIndex(タイル).getTag() ==
					TreeParts.				TAG_TILE_07_TREE_PART_3
					|| getChildByIndex(タイル).getTag() ==
					TreeParts.				TAG_TILE_08_TREE_PART_4
					|| getChildByIndex(タイル).getTag() ==
					Fences.					TAG_TILE_09_FENCE_SMALL
					|| getChildByIndex(タイル).getTag() ==
					Fences.					TAG_TILE_10_FENCE_BIG
					|| getChildByIndex(タイル).getTag() ==
					GroundBlocks.			TAG_TILE_11_GROUND_BLOCK_NORMAL_SHORT_1
					|| getChildByIndex(タイル).getTag() ==
					GroundBlocks.			TAG_TILE_12_GROUND_BLOCK_NORMAL_SHORT_2
					|| getChildByIndex(タイル).getTag() ==
					GroundBlocks.			TAG_TILE_15_GROUND_BLOCK_GOAL_SHORT
					|| getChildByIndex(タイル).getTag() ==
					PipeParts.				TAG_TILE_17_PIPE_PART_1	
					|| getChildByIndex(タイル).getTag() ==
					PipeParts.				TAG_TILE_18_PIPE_PART_2
					|| getChildByIndex(タイル).getTag() ==
					PipeParts.				TAG_TILE_19_PIPE_PART_3
					|| getChildByIndex(タイル).getTag() ==
					PipeParts.				TAG_TILE_20_PIPE_PART_4
					|| getChildByIndex(タイル).getTag() ==
					MushroomBlockParts.		TAG_TILE_21_MUSHROOM_BLOCK_PART_1
					|| getChildByIndex(タイル).getTag() ==
					MushroomBlockParts.		TAG_TILE_22_MUSHROOM_BLOCK_PART_2
					|| getChildByIndex(タイル).getTag() ==
					MushroomBlockParts.		TAG_TILE_23_MUSHROOM_BLOCK_PART_3
					|| getChildByIndex(タイル).getTag() ==
					MushroomBlockParts.		TAG_TILE_24_MUSHROOM_BLOCK_PART_4
					|| getChildByIndex(タイル).getTag() ==
					PierceBlocks.			TAG_TILE_25_PIERCE_BLOCK_SHORT
					|| getChildByIndex(タイル).getTag() ==
					BrickBlocks.			TAG_TILE_27_BRICK_BLOCK_SMALL
					|| getChildByIndex(タイル).getTag() ==
					BrickBlocks.			TAG_TILE_28_BRICK_BLOCK_BIG
					|| getChildByIndex(タイル).getTag() ==
					CandyBlocks.			TAG_TILE_29_CANDY_BLOCK_SMALL
					|| getChildByIndex(タイル).getTag() ==
					CandyBlocks.			TAG_TILE_30_CANDY_BLOCK_BIG
					|| getChildByIndex(タイル).getTag() ==
					HardBlocks.				TAG_TILE_31_HARD_BLOCK_SMALL
					|| getChildByIndex(タイル).getTag() ==
					HardBlocks.				TAG_TILE_32_HARD_BLOCK_BIG
					|| getChildByIndex(タイル).getTag() ==
					CastleBlocks.			TAG_TILE_33_CASTLE_BLOCK_SMALL
					|| getChildByIndex(タイル).getTag() ==
					CastleBlocks.			TAG_TILE_34_CASTLE_BLOCK_BIG
					|| getChildByIndex(タイル).getTag() ==
					HiddenBlocks.			TAG_TILE_35_HIDDEN_BLOCK_COIN_YELLOW
					|| getChildByIndex(タイル).getTag() ==
					HiddenBlocks.			TAG_TILE_36_HIDDEN_BLOCK_COIN_RED
					|| getChildByIndex(タイル).getTag() ==
					HiddenBlocks.			TAG_TILE_37_HIDDEN_BLOCK_COIN_BLUE
					|| getChildByIndex(タイル).getTag() ==
					HiddenBlocks.			TAG_TILE_38_HIDDEN_BLOCK_POWER_UP_ITEM
					|| getChildByIndex(タイル).getTag() ==
					HiddenBlocks.			TAG_TILE_39_HIDDEN_BLOCK_ONE_UP_MUSHROOM
					|| getChildByIndex(タイル).getTag() ==
					HiddenBlocks.			TAG_TILE_40_HIDDEN_BLOCK_FIRE_FLOWER_SMALL
					|| getChildByIndex(タイル).getTag() ==
					QuestionBlockShorts.	TAG_TILE_41_QUESTION_BLOCK_SHORT_COIN_YELLOW
					|| getChildByIndex(タイル).getTag() ==
					QuestionBlockShorts.	TAG_TILE_42_QUESTION_BLOCK_SHORT_COIN_RED
					|| getChildByIndex(タイル).getTag() ==
					QuestionBlockShorts.	TAG_TILE_43_QUESTION_BLOCK_SHORT_COIN_BLUE
					|| getChildByIndex(タイル).getTag() ==
					QuestionBlockShorts.	TAG_TILE_44_QUESTION_BLOCK_SHORT_POWER_UP_ITEM
					|| getChildByIndex(タイル).getTag() ==
					QuestionBlockShorts.	TAG_TILE_45_QUESTION_BLOCK_SHORT_ONE_UP_MUSHROOM
					|| getChildByIndex(タイル).getTag() ==
					QuestionBlockShorts.	TAG_TILE_46_QUESTION_BLOCK_SHORT_FIRE_FLOWER_SMALL
					|| getChildByIndex(タイル).getTag() ==
					QuestionBlockLongs.		TAG_TILE_47_QUESTION_BLOCK_LONG_COIN_YELLOW
					|| getChildByIndex(タイル).getTag() ==
					QuestionBlockLongs.		TAG_TILE_48_QUESTION_BLOCK_LONG_COIN_RED
					|| getChildByIndex(タイル).getTag() ==
					QuestionBlockLongs.		TAG_TILE_49_QUESTION_BLOCK_LONG_COIN_BLUE
					|| getChildByIndex(タイル).getTag() ==
					QuestionBlockLongs.		TAG_TILE_50_QUESTION_BLOCK_LONG_POWER_UP_ITEM
					|| getChildByIndex(タイル).getTag() ==
					QuestionBlockLongs.		TAG_TILE_51_QUESTION_BLOCK_LONG_ONE_UP_MUSHROOM
					|| getChildByIndex(タイル).getTag() ==
					QuestionBlockLongs.		TAG_TILE_52_QUESTION_BLOCK_LONG_FIRE_FLOWER_SMALL
					|| getChildByIndex(タイル).getTag() ==
					JumpingBoards.			TAG_TILE_53_JUMPING_BOARD_NORMAL
					|| getChildByIndex(タイル).getTag() ==
					JumpingBoards.			TAG_TILE_54_JUMPING_BOARD_SUPER
					|| getChildByIndex(タイル).getTag() ==
					ChangeBlocks.			TAG_TILE_61_CHANGE_BLOCK_RED
					|| getChildByIndex(タイル).getTag() ==
					ChangeBlocks.			TAG_TILE_62_CHANGE_BLOCK_GREEN
					|| getChildByIndex(タイル).getTag() ==
					Chocolates.				TAG_TILE_63_CHOCOLATE_SMALL
					|| getChildByIndex(タイル).getTag() ==
					Chocolates.				TAG_TILE_64_CHOCOLATE_BIG
					|| getChildByIndex(タイル).getTag() ==
					Needles.				TAG_TILE_65_NEEDLE_ADOVE
					|| getChildByIndex(タイル).getTag() ==
					Needles.				TAG_TILE_66_NEEDLE_LEFT
					|| getChildByIndex(タイル).getTag() ==
					Needles.				TAG_TILE_67_NEEDLE_RIGHT
					|| getChildByIndex(タイル).getTag() ==
					Needles.				TAG_TILE_68_NEEDLE_BELOW
					|| getChildByIndex(タイル).getTag() ==
					GoalRings.				TAG_TILE_69_GOAL_RING_LEFT
					|| getChildByIndex(タイル).getTag() ==
					GoalRings.				TAG_TILE_70_GOAL_RING_RIGHT
					) {
				// チェンブロのアニメ処理
				if (ジャンプカウンター == 8 && バック転実行フラグ == false) {
					// チェンジブロック（赤色）はジャンプごとにリアルタイムで変動
					if (getChildByIndex(タイル).getTag() ==
							ChangeBlocks.		TAG_TILE_61_CHANGE_BLOCK_RED
							) {
						if (フラグチェンジブロック == true) {
							((AnimatedSprite) getChildByIndex(タイル)).animate(
									new long[] { ani遅, ani遅, ani遅, ani遅, }, 0, 3, true);
							((AnimatedSprite) getChildByIndex(タイル)).registerEntityModifier(
									new LoopEntityModifier(new SequenceEntityModifier(
											new ScaleModifier(0.125f, 1.0f, 0.5f),
											new ScaleModifier(0.125f, 0.5f, 1.0f)), 1));
						} else {
							((AnimatedSprite) getChildByIndex(タイル)).stopAnimation();
							((AnimatedSprite) getChildByIndex(タイル)).setCurrentTileIndex(4);
						}
					}
					// チェンジブロック（緑色）もジャンプごとにリアルタイムで変動
					if (getChildByIndex(タイル).getTag() ==
							ChangeBlocks.		TAG_TILE_62_CHANGE_BLOCK_GREEN
							) {
						if (フラグチェンジブロック == false) {
							((AnimatedSprite) getChildByIndex(タイル)).animate(
									new long[] { ani遅, ani遅, ani遅, ani遅, }, 0, 3, true);
							((AnimatedSprite) getChildByIndex(タイル)).registerEntityModifier(
									new LoopEntityModifier(new SequenceEntityModifier(
											new ScaleModifier(0.125f, 1.0f, 0.5f),
											new ScaleModifier(0.125f, 0.5f, 1.0f)), 1));
						} else {
							((AnimatedSprite) getChildByIndex(タイル)).stopAnimation();
							((AnimatedSprite) getChildByIndex(タイル)).setCurrentTileIndex(4);
						}
					}
				}
				// 移動処理
				if (コースの端っこかどうか == false) {
					if (状態フラグ無敵 == false) {
						getChildByIndex(タイル).setPosition(
								getChildByIndex(タイル).getX() - 画面のスピード,
								getChildByIndex(タイル).getY());
					} else {
						getChildByIndex(タイル).setPosition(
								getChildByIndex(タイル).getX() - 画面のスピード,
								getChildByIndex(タイル).getY());
					}
				}
				// タイルの削除処理
				if (メモリーの開放をしたかどうか == false) {
					if (getChildByIndex(タイル).getX()
							+ ((Sprite) getChildByIndex(タイル)).getWidth() < -64) {
						// すぐに削除するとインデックスがずれるため、一旦配列に追加
						収納用タイル.add((Sprite) getChildByIndex(タイル));
					}
				} else {
					// すぐに削除するとインデックスがずれるため、一旦配列に追加
					収納用タイル.add((Sprite) getChildByIndex(タイル));
				}
				// タイルの接触処理
				if (メモリーの開放をしたかどうか == false) {
					if (コースの端っこかどうか == false) {
						// 一部の箇所でのみ判定
						if (getChildByIndex(タイル).getX()
								+ ((Sprite) getChildByIndex(タイル)).getWidth() < 288) {
							// タイルとプレイヤーの接触処理
							tileAndPlayerAboveContact();
							tileAndPlayerCenterContact1();
							tileAndPlayerCenterContact2();
							tileAndPlayerBelowContact();
							tileAndPlayerCoreContact();
						}
					} else {
						// タイルとプレイヤーの接触処理
						tileAndPlayerAboveContact();
						tileAndPlayerCenterContact1();
						tileAndPlayerCenterContact2();
						tileAndPlayerBelowContact();
						tileAndPlayerCoreContact();
					}
				}
				// タイルとボールの接触処理
				tileAndNormalFireballContact();
				tileAndSuperFireballContact();
				if (ボールハンド実行フラグ == true) {
					// タイルとハンド（ボール）の接触処理
					tileAndHandFireballContact();
				}
				if (パンチハンド実行フラグ == true) {
					// タイルとハンド（パンチ）の接触処理
					tileAndHandPunchContact();
				}
			}
		}
	}
	public void itemTagDecision() {							// アイテム
		// アイテムを特定値分移動させる
		for (アイテム = 0; アイテム < getChildCount(); アイテム++) {
			if (getChildByIndex(アイテム).getTag() ==
					// アイテム
					Coins.					TAG_ITEM_01_COIN_YELLOW
					|| getChildByIndex(アイテム).getTag() ==
					Coins.					TAG_ITEM_02_COIN_RED
					|| getChildByIndex(アイテム).getTag() ==
					Coins.					TAG_ITEM_03_COIN_BLUE
					|| getChildByIndex(アイテム).getTag() ==
					PowerUpItems.			TAG_ITEM_04_POWER_UP_ITEM_1
					|| getChildByIndex(アイテム).getTag() ==
					PowerUpItems.			TAG_ITEM_05_POWER_UP_ITEM_2
					|| getChildByIndex(アイテム).getTag() ==
					PowerUpItems.			TAG_ITEM_06_POWER_UP_ITEM_3
					|| getChildByIndex(アイテム).getTag() ==
					OneUpMushroom.			TAG_ITEM_07_ONE_UP_MUSHROOM
					|| getChildByIndex(アイテム).getTag() ==
					FireFlowers.			TAG_ITEM_08_FIRE_FLOWER_SMALL
					|| getChildByIndex(アイテム).getTag() ==
					FireFlowers.			TAG_ITEM_09_FIRE_FLOWER_BIG
					|| getChildByIndex(アイテム).getTag() ==
					PowerCrystal.			TAG_ITEM_10_POWER_CRYSTAL
					) {
				// 移動処理
				if (コースの端っこかどうか == false) {
					if (状態フラグ無敵 == false) {
						getChildByIndex(アイテム).setPosition(
								getChildByIndex(アイテム).getX() - 画面のスピード,
								getChildByIndex(アイテム).getY());
					} else {
						getChildByIndex(アイテム).setPosition(
								getChildByIndex(アイテム).getX() - 画面のスピード,
								getChildByIndex(アイテム).getY());
					}
				}
				// アイテムの削除処理
				if (メモリーの開放をしたかどうか == false) {
					if (getChildByIndex(アイテム).getX()
							+ ((Sprite) getChildByIndex(アイテム)).getWidth() < 0) {
						// すぐに削除するとインデックスがずれるため、一旦配列に追加
						収納用アイテム.add((Sprite) getChildByIndex(アイテム));
					}
				} else {
					// すぐに削除するとインデックスがずれるため、一旦配列に追加
					収納用アイテム.add((Sprite) getChildByIndex(アイテム));
				}
				// アイテムの接触処理
				if (状態フラグ復活中 == false && メモリーの開放をしたかどうか == false) {
					// 一部の箇所でのみ判定
					if (getChildByIndex(アイテム).getX()
							+ ((Sprite) getChildByIndex(アイテム)).getWidth() < 288) {
						// アイテムとプレイヤーの接触処理
						itemAndPlayerCoreContact();
					}
				}
				// アイテムとボールの接触処理
				itemAndNormalFireballContact();
				itemAndSuperFireballContact();
				// アイテムとハンドの接触処理
				itemAndHandPunchContact();
			}
		}
	}
	public void enemyTagDecision() {						// 敵キャラ
		// 敵キャラを特定値分移動させる
		for (敵キャラ = 0; 敵キャラ < getChildCount(); 敵キャラ++) {
			if (getChildByIndex(敵キャラ).getTag() ==
					// 敵キャラ
					Goomba.					TAG_ENEMY_01_GOOMBA
					|| getChildByIndex(敵キャラ).getTag() ==
					KoopaParatroopas.		TAG_ENEMY_02_KOOPA_PARATROOPA_GREEN
					|| getChildByIndex(敵キャラ).getTag() ==
					KoopaParatroopas.		TAG_ENEMY_03_KOOPA_PARATROOPA_RED
					|| getChildByIndex(敵キャラ).getTag() ==
					BulletBills.			TAG_ENEMY_04_BULLET_BILL_BLUE
					|| getChildByIndex(敵キャラ).getTag() ==
					BulletBills.			TAG_ENEMY_05_BULLET_BILL_YELLOW
					|| getChildByIndex(敵キャラ).getTag() ==
					BulletBills.			TAG_ENEMY_06_BULLET_BILL_RED
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_07_PIRANHA_PLANT_GREEN_NORMAL_0
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_08_PIRANHA_PLANT_GREEN_UPSIDE_0
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_09_PIRANHA_PLANT_GREY_NORMAL_0
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_10_PIRANHA_PLANT_GREY_UPSIDE_0
					|| getChildByIndex(敵キャラ).getTag() ==
					BuzzyBeetle.			TAG_ENEMY_11_BUZZY_BEETLE
					|| getChildByIndex(敵キャラ).getTag() ==
					Spinys.					TAG_ENEMY_12_SPINY_NORMAL
					|| getChildByIndex(敵キャラ).getTag() ==
					Spinys.					TAG_ENEMY_13_SPINY_EGG
					|| getChildByIndex(敵キャラ).getTag() ==
					CheepCheep.				TAG_ENEMY_14_CHEEP_CHEEP
					|| getChildByIndex(敵キャラ).getTag() ==
					Balloons.				TAG_ENEMY_15_BALLOON_COIN_YELLOW
					|| getChildByIndex(敵キャラ).getTag() ==
					Balloons.				TAG_ENEMY_16_BALLOON_COIN_RED
					|| getChildByIndex(敵キャラ).getTag() ==
					Balloons.				TAG_ENEMY_17_BALLOON_COIN_BLUE
					|| getChildByIndex(敵キャラ).getTag() ==
					Balloons.				TAG_ENEMY_18_BALLOON_ONE_UP_MUSHROOM
					|| getChildByIndex(敵キャラ).getTag() ==
					Balloons.				TAG_ENEMY_19_BALLOON_FIRE_FLOWER_SMALL
					|| getChildByIndex(敵キャラ).getTag() ==
					Balloons.				TAG_ENEMY_20_BALLOON_NOT_OBJECT
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_21_PIRANHA_PLANT_GREEN_NORMAL_1
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_22_PIRANHA_PLANT_GREEN_NORMAL_2
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_23_PIRANHA_PLANT_GREEN_NORMAL_3
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_24_PIRANHA_PLANT_GREEN_NORMAL_4
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_25_PIRANHA_PLANT_GREEN_NORMAL_5
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_26_PIRANHA_PLANT_GREEN_UPSIDE_1
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_27_PIRANHA_PLANT_GREEN_UPSIDE_2
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_28_PIRANHA_PLANT_GREEN_UPSIDE_3
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_29_PIRANHA_PLANT_GREEN_UPSIDE_4
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_30_PIRANHA_PLANT_GREEN_UPSIDE_5
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_31_PIRANHA_PLANT_GREY_NORMAL_1
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_32_PIRANHA_PLANT_GREY_NORMAL_2
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_33_PIRANHA_PLANT_GREY_NORMAL_3
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_34_PIRANHA_PLANT_GREY_NORMAL_4
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_35_PIRANHA_PLANT_GREY_NORMAL_5
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_36_PIRANHA_PLANT_GREY_UPSIDE_1
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_37_PIRANHA_PLANT_GREY_UPSIDE_2
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_38_PIRANHA_PLANT_GREY_UPSIDE_3
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_39_PIRANHA_PLANT_GREY_UPSIDE_4
					|| getChildByIndex(敵キャラ).getTag() ==
					PiranhaPlants.			TAG_ENEMY_40_PIRANHA_PLANT_GREY_UPSIDE_5
					|| getChildByIndex(敵キャラ).getTag() ==
					Bowsers.				TAG_ENEMY_41_BOWSER_NORMAL_LEVEL_1
					|| getChildByIndex(敵キャラ).getTag() ==
					Bowsers.				TAG_ENEMY_42_BOWSER_NORMAL_LEVEL_2
					|| getChildByIndex(敵キャラ).getTag() ==
					Bowsers.				TAG_ENEMY_43_BOWSER_NORMAL_LEVEL_3
					|| getChildByIndex(敵キャラ).getTag() ==
					Bowsers.				TAG_ENEMY_44_BOWSER_NORMAL_LEVEL_4
					|| getChildByIndex(敵キャラ).getTag() ==
					Bowsers.				TAG_ENEMY_45_BOWSER_FINAL
					) {
				// 移動速度が"速い"の敵キャラたち
				if (getChildByIndex(敵キャラ).getTag() ==
						BulletBills.		TAG_ENEMY_05_BULLET_BILL_YELLOW
						) {
					// 移動処理
					if (コースの端っこかどうか == false) {
						if (状態フラグ無敵 == false) {
							getChildByIndex(敵キャラ).setPosition(
									getChildByIndex(敵キャラ).getX() - 敵キャラ速い,
									getChildByIndex(敵キャラ).getY());
						} else {
							getChildByIndex(敵キャラ).setPosition(
									getChildByIndex(敵キャラ).getX() - 敵キャラ速い,
									getChildByIndex(敵キャラ).getY());
						}
					}
					// 移動速度が"ちょっと速い"の敵キャラたち
				} else if (getChildByIndex(敵キャラ).getTag() ==
						BuzzyBeetle.		TAG_ENEMY_11_BUZZY_BEETLE
						) {
					// 移動処理
					if (コースの端っこかどうか == false) {
						if (状態フラグ無敵 == false) {
							getChildByIndex(敵キャラ).setPosition(
									getChildByIndex(敵キャラ).getX() - 敵キャラちょっと速い,
									getChildByIndex(敵キャラ).getY());
						} else {
							getChildByIndex(敵キャラ).setPosition(
									getChildByIndex(敵キャラ).getX() - 敵キャラちょっと速い,
									getChildByIndex(敵キャラ).getY());
						}
					}
					// 移動速度が"普通"の敵キャラたち
				} else if (getChildByIndex(敵キャラ).getTag() ==
						KoopaParatroopas.	TAG_ENEMY_03_KOOPA_PARATROOPA_RED
						|| getChildByIndex(敵キャラ).getTag() ==
						BulletBills.		TAG_ENEMY_04_BULLET_BILL_BLUE
						) {
					// 移動処理
					if (コースの端っこかどうか == false) {
						if (状態フラグ無敵 == false) {
							getChildByIndex(敵キャラ).setPosition(
									getChildByIndex(敵キャラ).getX() - 敵キャラ普通,
									getChildByIndex(敵キャラ).getY());
						} else {
							getChildByIndex(敵キャラ).setPosition(
									getChildByIndex(敵キャラ).getX() - 敵キャラ普通,
									getChildByIndex(敵キャラ).getY());
						}
					}
					// 移動速度が"ちょっと遅い"の敵キャラたち
				} else if (getChildByIndex(敵キャラ).getTag() ==
						BulletBills.		TAG_ENEMY_06_BULLET_BILL_RED
						|| getChildByIndex(敵キャラ).getTag() ==
						Spinys.				TAG_ENEMY_12_SPINY_NORMAL
						) {
					// 移動処理
					if (コースの端っこかどうか == false) {
						if (状態フラグ無敵 == false) {
							getChildByIndex(敵キャラ).setPosition(
									getChildByIndex(敵キャラ).getX() - 敵キャラちょっと遅い,
									getChildByIndex(敵キャラ).getY());
						} else {
							getChildByIndex(敵キャラ).setPosition(
									getChildByIndex(敵キャラ).getX() - 敵キャラちょっと遅い,
									getChildByIndex(敵キャラ).getY());
						}
					}
					// 移動速度が"遅い"の敵キャラたち
				} else if (getChildByIndex(敵キャラ).getTag() ==
						Goomba.				TAG_ENEMY_01_GOOMBA
						|| getChildByIndex(敵キャラ).getTag() ==
						KoopaParatroopas.	TAG_ENEMY_02_KOOPA_PARATROOPA_GREEN
						) {
					// 移動処理
					if (コースの端っこかどうか == false) {
						if (状態フラグ無敵 == false) {
							getChildByIndex(敵キャラ).setPosition(
									getChildByIndex(敵キャラ).getX() - 敵キャラ遅い,
									getChildByIndex(敵キャラ).getY());
						} else {
							getChildByIndex(敵キャラ).setPosition(
									getChildByIndex(敵キャラ).getX() - 敵キャラ遅い,
									getChildByIndex(敵キャラ).getY());
						}
					}
					// 自身は動かない敵キャラ
				} else if (getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_07_PIRANHA_PLANT_GREEN_NORMAL_0
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_08_PIRANHA_PLANT_GREEN_UPSIDE_0
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_09_PIRANHA_PLANT_GREY_NORMAL_0
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_10_PIRANHA_PLANT_GREY_UPSIDE_0
						|| getChildByIndex(敵キャラ).getTag() ==
						Spinys.				TAG_ENEMY_13_SPINY_EGG
						|| getChildByIndex(敵キャラ).getTag() ==
						CheepCheep.			TAG_ENEMY_14_CHEEP_CHEEP
						|| getChildByIndex(敵キャラ).getTag() ==
						Balloons.			TAG_ENEMY_15_BALLOON_COIN_YELLOW
						|| getChildByIndex(敵キャラ).getTag() ==
						Balloons.			TAG_ENEMY_16_BALLOON_COIN_RED
						|| getChildByIndex(敵キャラ).getTag() ==
						Balloons.			TAG_ENEMY_17_BALLOON_COIN_BLUE
						|| getChildByIndex(敵キャラ).getTag() ==
						Balloons.			TAG_ENEMY_18_BALLOON_ONE_UP_MUSHROOM
						|| getChildByIndex(敵キャラ).getTag() ==
						Balloons.			TAG_ENEMY_19_BALLOON_FIRE_FLOWER_SMALL
						|| getChildByIndex(敵キャラ).getTag() ==
						Balloons.			TAG_ENEMY_20_BALLOON_NOT_OBJECT
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_21_PIRANHA_PLANT_GREEN_NORMAL_1
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_22_PIRANHA_PLANT_GREEN_NORMAL_2
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_23_PIRANHA_PLANT_GREEN_NORMAL_3
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_24_PIRANHA_PLANT_GREEN_NORMAL_4
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_25_PIRANHA_PLANT_GREEN_NORMAL_5
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_26_PIRANHA_PLANT_GREEN_UPSIDE_1
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_27_PIRANHA_PLANT_GREEN_UPSIDE_2
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_28_PIRANHA_PLANT_GREEN_UPSIDE_3
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_29_PIRANHA_PLANT_GREEN_UPSIDE_4
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_30_PIRANHA_PLANT_GREEN_UPSIDE_5
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_31_PIRANHA_PLANT_GREY_NORMAL_1
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_32_PIRANHA_PLANT_GREY_NORMAL_2
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_33_PIRANHA_PLANT_GREY_NORMAL_3
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_34_PIRANHA_PLANT_GREY_NORMAL_4
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_35_PIRANHA_PLANT_GREY_NORMAL_5
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_36_PIRANHA_PLANT_GREY_UPSIDE_1
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_37_PIRANHA_PLANT_GREY_UPSIDE_2
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_38_PIRANHA_PLANT_GREY_UPSIDE_3
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_39_PIRANHA_PLANT_GREY_UPSIDE_4
						|| getChildByIndex(敵キャラ).getTag() ==
						PiranhaPlants.		TAG_ENEMY_40_PIRANHA_PLANT_GREY_UPSIDE_5
						) {
					// 移動処理
					if (コースの端っこかどうか == false) {
						if (状態フラグ無敵 == false) {
							getChildByIndex(敵キャラ).setPosition(
									getChildByIndex(敵キャラ).getX() - 画面のスピード,
									getChildByIndex(敵キャラ).getY());
						} else {
							getChildByIndex(敵キャラ).setPosition(
									getChildByIndex(敵キャラ).getX() - 画面のスピード,
									getChildByIndex(敵キャラ).getY());
						}
					}
				}
				// パタパタ（赤色）のみプレイヤーの上空から滑空させる
				if (getChildByIndex(敵キャラ).getTag() ==
						KoopaParatroopas.	TAG_ENEMY_03_KOOPA_PARATROOPA_RED
						) {
					if (getChildByIndex(敵キャラ).getX() < 640
							== getChildByIndex(敵キャラ).getX() > 480) {
						getChildByIndex(敵キャラ).setY(
								getChildByIndex(敵キャラ).getY() + 4);
					}
				}
				// プクプクは遅く上昇させる
				if (getChildByIndex(敵キャラ).getTag() ==
						CheepCheep.			TAG_ENEMY_14_CHEEP_CHEEP
						) {
					getChildByIndex(敵キャラ).setY(
							getChildByIndex(敵キャラ).getY() - 1.5f);
				}
				// バルーンは速く上昇させる
				if (getChildByIndex(敵キャラ).getTag() ==
						Balloons.			TAG_ENEMY_15_BALLOON_COIN_YELLOW
						|| getChildByIndex(敵キャラ).getTag() ==
						Balloons.			TAG_ENEMY_16_BALLOON_COIN_RED
						|| getChildByIndex(敵キャラ).getTag() ==
						Balloons.			TAG_ENEMY_17_BALLOON_COIN_BLUE
						|| getChildByIndex(敵キャラ).getTag() ==
						Balloons.			TAG_ENEMY_18_BALLOON_ONE_UP_MUSHROOM
						|| getChildByIndex(敵キャラ).getTag() ==
						Balloons.			TAG_ENEMY_19_BALLOON_FIRE_FLOWER_SMALL
						) {
					// ※アイテムの余白分、+16座標
					if (getChildByIndex(敵キャラ).getX() < 656) {
						getChildByIndex(敵キャラ).setY(
								getChildByIndex(敵キャラ).getY() - 4);
					}
				}
				if (getChildByIndex(敵キャラ).getTag() ==
						Balloons.			TAG_ENEMY_20_BALLOON_NOT_OBJECT
						) {
					// ※本体なのでアイテムの余白分はなし
					if (getChildByIndex(敵キャラ).getX() < 640) {
						getChildByIndex(敵キャラ).setY(
								getChildByIndex(敵キャラ).getY() - 4);
					}
				}
				// 敵キャラをインクリ
				enemyIncrement();
				// ボスキャラをインクリ
				bossIncrement();
				// 敵キャラの削除処理
				if (メモリーの開放をしたかどうか == false) {
					if (getChildByIndex(敵キャラ).getX()
							+ ((Sprite) getChildByIndex(敵キャラ)).getWidth() < 0
							|| getChildByIndex(敵キャラ).getY()
							+ ((Sprite) getChildByIndex(敵キャラ)).getWidth() > 544) {
						// すぐに削除するとインデックスがずれるため、一旦配列に追加
						収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
						// キラー青色が画面端っこに行ったらボーナスを戻す
						if (getChildByIndex(敵キャラ).getTag() ==
								BulletBills.	TAG_ENEMY_04_BULLET_BILL_BLUE
								) {
							キラー青色連続ヒット = 0;
						}
					}
				} else {
					// すぐに削除するとインデックスがずれるため、一旦配列に追加
					収納用敵キャラ.add((Sprite) getChildByIndex(敵キャラ));
				}
				// 敵キャラの接触処理
				if (状態フラグ復活中 == false && メモリーの開放をしたかどうか == false) {
					// 一部の箇所でのみ判定
					if (getChildByIndex(敵キャラ).getX()
							+ ((Sprite) getChildByIndex(敵キャラ)).getWidth() < 288) {
						// 敵キャラとプレイヤーの接触処理
						enemyAndPlayerCoreContact();
						if (バック転実行フラグ == false) {
							enemyAndPlayerBelowContact();
						}
					}
				}
				// 敵キャラとボールの接触処理
				enemyAndNormalFireballContact();
				enemyAndSuperFireballContact();
				// 敵キャラと衝撃波（上）の接触処理
				enemyAndShockWaveAdoveContact();
				// 敵キャラと衝撃波（下）の接触処理
				enemyAndShockWaveBelowContact();
				if (ボールハンド実行フラグ == true) {
					// 敵キャラとハンド（ボール）の接触処理
					enemyAndHandFireballContact();
				}
				if (パンチハンド実行フラグ == true) {
					// 敵キャラとハンド（パンチ）の接触処理
					enemyAndHandPunchContact();
				}
				// 敵キャラとエフェクトの接触処理
				enemyAndEffectContact();
			}
		}
	}
	public void playerTagDecision() {						// プレイヤー
		// プレイヤーを特定値分移動させる
		for (プレイヤー = 0; プレイヤー < getChildCount(); プレイヤー++) {
			if (getChildByIndex(プレイヤー).getTag() ==
					// プレイヤー
					Fireballs.				TAG_PLAYER_07_FIREBALL_NORMAL_1
					|| getChildByIndex(プレイヤー).getTag() ==
					Fireballs.				TAG_PLAYER_08_FIREBALL_NORMAL_2
					|| getChildByIndex(プレイヤー).getTag() ==
					Fireballs.				TAG_PLAYER_09_FIREBALL_SUPER_1
					|| getChildByIndex(プレイヤー).getTag() ==
					Fireballs.				TAG_PLAYER_10_FIREBALL_SUPER_2
					|| getChildByIndex(プレイヤー).getTag() ==
					Fireballs.				TAG_PLAYER_11_FIREBALL_FINAL
					|| getChildByIndex(プレイヤー).getTag() ==
					Fireballs.				TAG_PLAYER_12_FIREBALL_SHOCK_WAVE_ADOVE
					|| getChildByIndex(プレイヤー).getTag() ==
					Fireballs.				TAG_PLAYER_13_FIREBALL_SHOCK_WAVE_BELOW
					) {
				// ボールたち
				if (getChildByIndex(プレイヤー).getTag() ==
						Fireballs.			TAG_PLAYER_07_FIREBALL_NORMAL_1
						|| getChildByIndex(プレイヤー).getTag() ==
						Fireballs.			TAG_PLAYER_08_FIREBALL_NORMAL_2
						|| getChildByIndex(プレイヤー).getTag() ==
						Fireballs.			TAG_PLAYER_09_FIREBALL_SUPER_1
						|| getChildByIndex(プレイヤー).getTag() ==
						Fireballs.			TAG_PLAYER_10_FIREBALL_SUPER_2
						|| getChildByIndex(プレイヤー).getTag() ==
						Fireballs.			TAG_PLAYER_11_FIREBALL_FINAL
						) {
					// 移動処理
					if (状態フラグ無敵 == false) {
						getChildByIndex(プレイヤー).setPosition(
								getChildByIndex(プレイヤー).getX() + ボールの移動速度,
								getChildByIndex(プレイヤー).getY());
					} else {
						getChildByIndex(プレイヤー).setPosition(
								getChildByIndex(プレイヤー).getX() + ボールの移動速度,
								getChildByIndex(プレイヤー).getY());
					}
					// 衝撃波（上）
				} else if (getChildByIndex(プレイヤー).getTag() ==
						Fireballs.				TAG_PLAYER_12_FIREBALL_SHOCK_WAVE_ADOVE
						) {
					// 移動処理
					if (状態フラグ無敵 == false) {
						getChildByIndex(プレイヤー).setPosition(
								getChildByIndex(プレイヤー).getX() + 衝撃波の移動速度,
								getChildByIndex(プレイヤー).getY() - 衝撃波の移動速度);
					} else {
						getChildByIndex(プレイヤー).setPosition(
								getChildByIndex(プレイヤー).getX() + 衝撃波の移動速度,
								getChildByIndex(プレイヤー).getY() - 衝撃波の移動速度);
					}
					// 衝撃波（下）
				} else if (getChildByIndex(プレイヤー).getTag() ==
						Fireballs.				TAG_PLAYER_13_FIREBALL_SHOCK_WAVE_BELOW
						) {
					// 移動処理
					if (状態フラグ無敵 == false) {
						getChildByIndex(プレイヤー).setPosition(
								getChildByIndex(プレイヤー).getX() + 衝撃波の移動速度,
								getChildByIndex(プレイヤー).getY() + 衝撃波の移動速度);
					} else {
						getChildByIndex(プレイヤー).setPosition(
								getChildByIndex(プレイヤー).getX() + 衝撃波の移動速度,
								getChildByIndex(プレイヤー).getY() + 衝撃波の移動速度);
					}
				}
				// プレイヤーの削除処理
				if (メモリーの開放をしたかどうか == true) {
					// すぐに削除するとインデックスがずれるため、一旦配列に追加
					収納用プレイヤー.add((Sprite) getChildByIndex(プレイヤー));
				}
			}
		}
	}
	public void effectTagDecision() {						// エフェクト
		for (エフェクト = 0; エフェクト < getChildCount(); エフェクト++) {
			if (getChildByIndex(エフェクト).getTag() ==
					// エフェクト
					Bombs.						TAG_EFFECT_04_BOMB_ENEMY
					|| getChildByIndex(エフェクト).getTag() ==
					Bombs.						TAG_EFFECT_05_BOMB_FIREBALL_1
					|| getChildByIndex(エフェクト).getTag() ==
					Bombs.						TAG_EFFECT_06_BOMB_FIREBALL_2
					|| getChildByIndex(エフェクト).getTag() ==
					Fonts.						TAG_EFFECT_07_FONT_FIREBALL_ADD_8
					|| getChildByIndex(エフェクト).getTag() ==
					Fonts.						TAG_EFFECT_08_FONT_FIREBALL_ADD_MAX
					|| getChildByIndex(エフェクト).getTag() ==
					Fonts.						TAG_EFFECT_09_FONT_POWER_UP_BOUNS
					|| getChildByIndex(エフェクト).getTag() ==
					Fonts.						TAG_EFFECT_10_FONT_ONE_UP
					|| getChildByIndex(エフェクト).getTag() ==
					EmptyBlock.					TAG_EFFECT_11_EMPTY_BLOCK_SHORT
					|| getChildByIndex(エフェクト).getTag() ==
					EmptyBlock.					TAG_EFFECT_12_EMPTY_BLOCK_LONG
					|| getChildByIndex(エフェクト).getTag() ==
					TileBreaks.					TAG_EFFECT_13_TILE_BREAK_BRICK_BLOCK_SMALL
					|| getChildByIndex(エフェクト).getTag() ==
					TileBreaks.					TAG_EFFECT_14_TILE_BREAK_BRICK_BLOCK_BIG
					|| getChildByIndex(エフェクト).getTag() ==
					TileBreaks.	 				TAG_EFFECT_15_TILE_BREAK_HARD_BLOCK_SMALL
					|| getChildByIndex(エフェクト).getTag() ==
					TileBreaks.	 				TAG_EFFECT_16_TILE_BREAK_HARD_BLOCK_BIG
					|| getChildByIndex(エフェクト).getTag() ==
					TileBreaks.					TAG_EFFECT_17_TILE_BREAK_QUESTION_BLOCK_SHORT
					|| getChildByIndex(エフェクト).getTag() ==
					TileBreaks.					TAG_EFFECT_18_TILE_BREAK_QUESTION_BLOCK_LONG
					|| getChildByIndex(エフェクト).getTag() ==
					ItemBreaks.	 				TAG_EFFECT_19_ITEM_BREAK_FIRE_FLOWER_SMALL
					|| getChildByIndex(エフェクト).getTag() ==
					ItemBreaks.	 				TAG_EFFECT_20_ITEM_BREAK_FIRE_FLOWER_BIG
					|| getChildByIndex(エフェクト).getTag() ==
					EnemyDefeats.				TAG_EFFECT_21_ENEMY_DEFEAT_GOOMBA
					|| getChildByIndex(エフェクト).getTag() ==
					EnemyDefeats.				TAG_EFFECT_22_ENEMY_DEFEAT_KOOPA_PARATROOPA_GREEN
					|| getChildByIndex(エフェクト).getTag() ==
					EnemyDefeats.				TAG_EFFECT_23_ENEMY_DEFEAT_KOOPA_PARATROOPA_RED
					|| getChildByIndex(エフェクト).getTag() ==
					EnemyDefeats.				TAG_EFFECT_24_ENEMY_DEFEAT_BULLET_BILL_BLUE
					|| getChildByIndex(エフェクト).getTag() ==
					EnemyDefeats.				TAG_EFFECT_25_ENEMY_DEFEAT_BULLET_BILL_YELLOW
					|| getChildByIndex(エフェクト).getTag() ==
					EnemyDefeats.				TAG_EFFECT_26_ENEMY_DEFEAT_BUZZY_BEETLE
					|| getChildByIndex(エフェクト).getTag() ==
					EnemyDefeats.				TAG_EFFECT_27_ENEMY_DEFEAT_SPINY_NORMAL
					|| getChildByIndex(エフェクト).getTag() ==
					EnemyDefeats.				TAG_EFFECT_28_ENEMY_DEFEAT_CHEEP_CHEEP
					|| getChildByIndex(エフェクト).getTag() ==
					EnemyDefeats.				TAG_EFFECT_29_ENEMY_DEFEAT_BOWSER_FINAL_1
					|| getChildByIndex(エフェクト).getTag() ==
					EnemyDefeats.				TAG_EFFECT_30_ENEMY_DEFEAT_BOWSER_FINAL_2
					|| getChildByIndex(エフェクト).getTag() ==
					EnemyAttacks.				TAG_EFFECT_31_ENEMY_ATTACK_THUNDER
					|| getChildByIndex(エフェクト).getTag() ==
					EnemyAttacks.				TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE
					|| getChildByIndex(エフェクト).getTag() ==
					EnemyAttacks.				TAG_EFFECT_33_ENEMY_ATTACK_COUNTER
					|| getChildByIndex(エフェクト).getTag() ==
					Marios.						TAG_EFFECT_35_MARIO_BACK_FLIP
					|| getChildByIndex(エフェクト).getTag() ==
					Marios.						TAG_EFFECT_36_MARIO_GLITTERING
					|| getChildByIndex(エフェクト).getTag() ==
					Marios.						TAG_EFFECT_37_MARIO_MISS_NORMAL
					|| getChildByIndex(エフェクト).getTag() ==
					Marios.						TAG_EFFECT_38_MARIO_MISS_NEEDLE
					|| getChildByIndex(エフェクト).getTag() ==
					Marios.						TAG_EFFECT_39_MARIO_TEXIUN_TEXIUN
					|| getChildByIndex(エフェクト).getTag() ==
					Marios.						TAG_EFFECT_40_MARIO_BALLOON
					) {
				// 爆発エフェクトの移動処理
				if (getChildByIndex(エフェクト).getTag() ==
						Bombs.					TAG_EFFECT_04_BOMB_ENEMY
						|| getChildByIndex(エフェクト).getTag() ==
						Bombs.					TAG_EFFECT_05_BOMB_FIREBALL_1
						|| getChildByIndex(エフェクト).getTag() ==
						Bombs.					TAG_EFFECT_06_BOMB_FIREBALL_2
						) {
					if (ゲームオーバーかどうか == false) {
						// 移動処理
						getChildByIndex(エフェクト).setX(
								getChildByIndex(エフェクト).getX() - 画面のスピード);
					} else {
						// 移動処理
						getChildByIndex(エフェクト).setX(
								(getChildByIndex(エフェクト).getX() - 画面のスピード)/* + 画面のスピード */);
					}
					// 爆発エフェクトの削除処理
					if (getChildByIndex(エフェクト).getX()
							+ ((Sprite) getChildByIndex(エフェクト)).getWidth() < 96) {
						// すぐに削除するとインデックスがずれるため、一旦配列に追加
						収納用エフェクト.add((Sprite) getChildByIndex(エフェクト));
					}
				}
				// エフェクフォントの移動処理
				if (getChildByIndex(エフェクト).getTag() ==
						Fonts.					TAG_EFFECT_07_FONT_FIREBALL_ADD_8
						|| getChildByIndex(エフェクト).getTag() ==
						Fonts.					TAG_EFFECT_08_FONT_FIREBALL_ADD_MAX
						|| getChildByIndex(エフェクト).getTag() ==
						Fonts.					TAG_EFFECT_09_FONT_POWER_UP_BOUNS
						|| getChildByIndex(エフェクト).getTag() ==
						Fonts.					TAG_EFFECT_10_FONT_ONE_UP
						) {
					// 移動処理
					getChildByIndex(エフェクト).setY(
							getChildByIndex(エフェクト).getY() - 1.2f);
					// エフェクフォントの削除処理
					if (getChildByIndex(エフェクト).getY()
							+ ((Sprite) getChildByIndex(エフェクト)).getHeight() < 0) {
						// すぐに削除するとインデックスがずれるため、一旦配列に追加
						収納用エフェクト.add((Sprite) getChildByIndex(エフェクト));
					}
				}
				// カラエフェクトの移動処理
				if (getChildByIndex(エフェクト).getTag() ==
						EmptyBlock.				TAG_EFFECT_11_EMPTY_BLOCK_SHORT
						|| getChildByIndex(エフェクト).getTag() ==
						EmptyBlock.				TAG_EFFECT_12_EMPTY_BLOCK_LONG
						) {
					if (ゲームオーバーかどうか == false && コースの端っこかどうか == false) {
						// 移動処理
						getChildByIndex(エフェクト).setX(
								getChildByIndex(エフェクト).getX() - 画面のスピード);
					} else {
						// 移動処理
						getChildByIndex(エフェクト).setX(
								(getChildByIndex(エフェクト).getX() - 画面のスピード) + 画面のスピード);
					}
					// カラエフェクトの削除処理
					if (getChildByIndex(エフェクト).getX()
							+ ((Sprite) getChildByIndex(エフェクト)).getWidth() < 0) {
						// すぐに削除するとインデックスがずれるため、一旦配列に追加
						収納用エフェクト.add((Sprite) getChildByIndex(エフェクト));
					}
				}
				// 破壊エフェクトの移動処理
				if (getChildByIndex(エフェクト).getTag() ==
						TileBreaks.				TAG_EFFECT_13_TILE_BREAK_BRICK_BLOCK_SMALL
						|| getChildByIndex(エフェクト).getTag() ==
						TileBreaks.				TAG_EFFECT_14_TILE_BREAK_BRICK_BLOCK_BIG
						|| getChildByIndex(エフェクト).getTag() ==
						TileBreaks.	 			TAG_EFFECT_15_TILE_BREAK_HARD_BLOCK_SMALL
						|| getChildByIndex(エフェクト).getTag() ==
						TileBreaks.	 			TAG_EFFECT_16_TILE_BREAK_HARD_BLOCK_BIG
						|| getChildByIndex(エフェクト).getTag() ==
						TileBreaks.				TAG_EFFECT_17_TILE_BREAK_QUESTION_BLOCK_SHORT
						|| getChildByIndex(エフェクト).getTag() ==
						TileBreaks.				TAG_EFFECT_18_TILE_BREAK_QUESTION_BLOCK_LONG
						|| getChildByIndex(エフェクト).getTag() ==
						ItemBreaks.	 			TAG_EFFECT_19_ITEM_BREAK_FIRE_FLOWER_SMALL
						|| getChildByIndex(エフェクト).getTag() ==
						ItemBreaks.	 			TAG_EFFECT_20_ITEM_BREAK_FIRE_FLOWER_BIG
						) {
					// 移動処理
					if (ゲームオーバーかどうか == false) {
						// 移動処理
						getChildByIndex(エフェクト).setX(
								getChildByIndex(エフェクト).getX() + 画面のスピード);
					} else {
						// 移動処理
						getChildByIndex(エフェクト).setX(
								(getChildByIndex(エフェクト).getX() + 画面のスピード)/* - 画面のスピード */);
					}
					getChildByIndex(エフェクト).setY((
							getChildByIndex(エフェクト).getY() + 1.032f) * 1.032f);
					getChildByIndex(エフェクト).setRotation(
							getChildByIndex(エフェクト).getRotation() - 40);
					// 破壊エフェクトの削除処理
					if (getChildByIndex(エフェクト).getY()
							+ ((Sprite) getChildByIndex(エフェクト)).getHeight() > 544) {
						// すぐに削除するとインデックスがずれるため、一旦配列に追加
						収納用エフェクト.add((Sprite) getChildByIndex(エフェクト));
					}
				}
				// 敵やっつけエフェクトの移動処理
				if (getChildByIndex(エフェクト).getTag() ==
						EnemyDefeats.			TAG_EFFECT_21_ENEMY_DEFEAT_GOOMBA
						|| getChildByIndex(エフェクト).getTag() ==
						EnemyDefeats.			TAG_EFFECT_22_ENEMY_DEFEAT_KOOPA_PARATROOPA_GREEN
						|| getChildByIndex(エフェクト).getTag() ==
						EnemyDefeats.			TAG_EFFECT_23_ENEMY_DEFEAT_KOOPA_PARATROOPA_RED
						|| getChildByIndex(エフェクト).getTag() ==
						EnemyDefeats.			TAG_EFFECT_24_ENEMY_DEFEAT_BULLET_BILL_BLUE
						|| getChildByIndex(エフェクト).getTag() ==
						EnemyDefeats.			TAG_EFFECT_25_ENEMY_DEFEAT_BULLET_BILL_YELLOW
						|| getChildByIndex(エフェクト).getTag() ==
						EnemyDefeats.			TAG_EFFECT_26_ENEMY_DEFEAT_BUZZY_BEETLE
						|| getChildByIndex(エフェクト).getTag() ==
						EnemyDefeats.			TAG_EFFECT_27_ENEMY_DEFEAT_SPINY_NORMAL
						|| getChildByIndex(エフェクト).getTag() ==
						EnemyDefeats.			TAG_EFFECT_28_ENEMY_DEFEAT_CHEEP_CHEEP
						|| getChildByIndex(エフェクト).getTag() ==
						EnemyDefeats.			TAG_EFFECT_29_ENEMY_DEFEAT_BOWSER_FINAL_1
						|| getChildByIndex(エフェクト).getTag() ==
						EnemyDefeats.			TAG_EFFECT_30_ENEMY_DEFEAT_BOWSER_FINAL_2
						) {
					// 敵やっつけエフェクト（プクプクとクッパ以外）の移動処理
					if (getChildByIndex(エフェクト).getTag() ==
							EnemyDefeats.		TAG_EFFECT_21_ENEMY_DEFEAT_GOOMBA
							|| getChildByIndex(エフェクト).getTag() ==
							EnemyDefeats.		TAG_EFFECT_22_ENEMY_DEFEAT_KOOPA_PARATROOPA_GREEN
							|| getChildByIndex(エフェクト).getTag() ==
							EnemyDefeats.		TAG_EFFECT_23_ENEMY_DEFEAT_KOOPA_PARATROOPA_RED
							|| getChildByIndex(エフェクト).getTag() ==
							EnemyDefeats.		TAG_EFFECT_24_ENEMY_DEFEAT_BULLET_BILL_BLUE
							|| getChildByIndex(エフェクト).getTag() ==
							EnemyDefeats.		TAG_EFFECT_25_ENEMY_DEFEAT_BULLET_BILL_YELLOW
							|| getChildByIndex(エフェクト).getTag() ==
							EnemyDefeats.		TAG_EFFECT_26_ENEMY_DEFEAT_BUZZY_BEETLE
							|| getChildByIndex(エフェクト).getTag() ==
							EnemyDefeats.		TAG_EFFECT_27_ENEMY_DEFEAT_SPINY_NORMAL
							) {
						// 移動処理
						if (ゲームオーバーかどうか == false) {
							// 移動処理
							getChildByIndex(エフェクト).setX(
									getChildByIndex(エフェクト).getX() + 画面のスピード);
						} else {
							// 移動処理
							getChildByIndex(エフェクト).setX(
									(getChildByIndex(エフェクト).getX() + 画面のスピード)/* - 画面のスピード */);
						}
						getChildByIndex(エフェクト).setY((
								getChildByIndex(エフェクト).getY() + 1.032f) * 1.032f);
						getChildByIndex(エフェクト).setRotation(
								getChildByIndex(エフェクト).getRotation() - 40);
					// 敵やっつけエフェクト（プクプクのみ）の移動処理
					} else if (getChildByIndex(エフェクト).getTag() ==
							EnemyDefeats.		TAG_EFFECT_28_ENEMY_DEFEAT_CHEEP_CHEEP
							) {
						// 移動処理
						if (ゲームオーバーかどうか == false) {
							// 移動処理
							getChildByIndex(エフェクト).setX(
									getChildByIndex(エフェクト).getX() - 画面のスピード);
						} else {
							// 移動処理
							getChildByIndex(エフェクト).setX(
									(getChildByIndex(エフェクト).getX() - 画面のスピード)/* + 画面のスピード */);
						}
						getChildByIndex(エフェクト).setY((
								getChildByIndex(エフェクト).getY() + 1.032f) * 1.032f);
					}
					// 敵やっつけエフェクトの削除処理
					if (getChildByIndex(エフェクト).getY() >= 480) {
						// すぐに削除するとインデックスがずれるため、一旦配列に追加
						収納用エフェクト.add((Sprite) getChildByIndex(エフェクト));
					}
				}
				// エネミー攻撃の移動処理
				if (getChildByIndex(エフェクト).getTag() ==
						EnemyAttacks.			TAG_EFFECT_31_ENEMY_ATTACK_THUNDER
						|| getChildByIndex(エフェクト).getTag() ==
						EnemyAttacks.			TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE
						|| getChildByIndex(エフェクト).getTag() ==
						EnemyAttacks.			TAG_EFFECT_33_ENEMY_ATTACK_COUNTER
						) {
					// ビリビリ攻撃の移動処理
					if (getChildByIndex(エフェクト).getTag() ==
							EnemyAttacks.		TAG_EFFECT_31_ENEMY_ATTACK_THUNDER
							) {
						// 移動処理
						if (ゲームオーバーかどうか == false) {
							// 移動処理
							getChildByIndex(エフェクト).setX(
									getChildByIndex(エフェクト).getX() - 敵キャラ速い);
						} else {
							// 移動処理
							getChildByIndex(エフェクト).setX(
									(getChildByIndex(エフェクト).getX() - 敵キャラ速い)/* + 画面のスピード */);
						}
						// ビリビリ攻撃の削除処理
						if (getChildByIndex(エフェクト).getX()
								+ ((Sprite) getChildByIndex(エフェクト)).getHeight() < -64) {
							// すぐに削除するとインデックスがずれるため、一旦配列に追加
							収納用エフェクト.add((Sprite) getChildByIndex(エフェクト));
						}
						// ニードル攻撃の移動処理
					} else if (getChildByIndex(エフェクト).getTag() ==
							EnemyAttacks.		TAG_EFFECT_32_ENEMY_ATTACK_NEEDLE
							) {
						// 移動処理
						if (ゲームオーバーかどうか == false) {
							// 移動処理
							getChildByIndex(エフェクト).setX(
									getChildByIndex(エフェクト).getX() - 敵キャラ普通);
						} else {
							// 移動処理
							getChildByIndex(エフェクト).setX(
									(getChildByIndex(エフェクト).getX() - 敵キャラ普通)/* + 画面のスピード */);
						}
						// ニードル攻撃の削除処理
						if (getChildByIndex(エフェクト).getX()
								+ ((Sprite) getChildByIndex(エフェクト)).getHeight() < -64) {
							// すぐに削除するとインデックスがずれるため、一旦配列に追加
							収納用エフェクト.add((Sprite) getChildByIndex(エフェクト));
						}
						// カウンター攻撃の移動処理
					} else if (getChildByIndex(エフェクト).getTag() ==
							EnemyAttacks.		TAG_EFFECT_33_ENEMY_ATTACK_COUNTER
							) {
						// 移動処理
						if (ゲームオーバーかどうか == false) {
							// 移動処理
							getChildByIndex(エフェクト).setX(
									getChildByIndex(エフェクト).getX() + ボールの移動速度);
						} else {
							// 移動処理
							getChildByIndex(エフェクト).setX(
									(getChildByIndex(エフェクト).getX() + ボールの移動速度)/* - 画面のスピード */);
						}
						// カウンター攻撃の削除処理
						if (getChildByIndex(エフェクト).getX()
								+ ((Sprite) getChildByIndex(エフェクト)).getHeight() > 880) {
							// すぐに削除するとインデックスがずれるため、一旦配列に追加
							収納用エフェクト.add((Sprite) getChildByIndex(エフェクト));
						}
					}
				}
				// ノーマルミスエフェクトの移動処理
				if (getChildByIndex(エフェクト).getTag() ==
						Marios.					TAG_EFFECT_37_MARIO_MISS_NORMAL
						) {
					// 移動処理
					getChildByIndex(エフェクト).setX(
							getChildByIndex(エフェクト).getX() - 8);
					getChildByIndex(エフェクト).setY(
							getChildByIndex(エフェクト).getY() * 0.945f);
					getChildByIndex(エフェクト).setRotation(
							getChildByIndex(エフェクト).getRotation() - 40);
					// ノーマルミスエフェクトの削除処理
					if (getChildByIndex(エフェクト).getX()
							+ ((Sprite) getChildByIndex(エフェクト)).getWidth() < -64) {
						// すぐに削除するとインデックスがずれるため、一旦配列に追加
						収納用エフェクト.add((Sprite) getChildByIndex(エフェクト));
					}
				}
				// ティウンティウンエフェクトの移動処理
				if (getChildByIndex(エフェクト).getTag() ==
						Marios.					TAG_EFFECT_39_MARIO_TEXIUN_TEXIUN
						) {
					// 上移動
					if (getChildByIndex(エフェクト).getY()
							+ ((Sprite) getChildByIndex(エフェクト)).getWidth()
							<= marios.effectMarioMissNeedle.getY()) {
						// 移動処理
						getChildByIndex(エフェクト).setX(
								getChildByIndex(エフェクト).getX());
						getChildByIndex(エフェクト).setY(
								getChildByIndex(エフェクト).getY() - 2);
					}
					// 左移動
					if (getChildByIndex(エフェクト).getX()
							+ ((Sprite) getChildByIndex(エフェクト)).getWidth()
							<= marios.effectMarioMissNeedle.getX()) {
						// 移動処理
						getChildByIndex(エフェクト).setX(
								getChildByIndex(エフェクト).getX() - 2);
						getChildByIndex(エフェクト).setY(
								getChildByIndex(エフェクト).getY());
					}
					// 右移動
					if (getChildByIndex(エフェクト).getX()
							+ ((Sprite) getChildByIndex(エフェクト)).getWidth()
							> marios.effectMarioMissNeedle.getX() + 32) {
						// 移動処理
						getChildByIndex(エフェクト).setX(
								getChildByIndex(エフェクト).getX() + 2);
						getChildByIndex(エフェクト).setY(
								getChildByIndex(エフェクト).getY());
					}
					// 下移動
					if (getChildByIndex(エフェクト).getY()
							+ ((Sprite) getChildByIndex(エフェクト)).getWidth()
							> marios.effectMarioMissNeedle.getY() + 32) {
						// 移動処理
						getChildByIndex(エフェクト).setX(
								getChildByIndex(エフェクト).getX());
						getChildByIndex(エフェクト).setY(
								getChildByIndex(エフェクト).getY() + 2);
					}
					// ティウンティウンエフェクトの削除処理
					if (getChildByIndex(エフェクト).getY()
							+ ((Sprite) getChildByIndex(エフェクト)).getWidth() < 0) {
						// すぐに削除するとインデックスがずれるため、一旦配列に追加
						収納用エフェクト.add((Sprite) getChildByIndex(エフェクト));
					} else if (getChildByIndex(エフェクト).getX()
							+ ((Sprite) getChildByIndex(エフェクト)).getWidth() < 0) {
						// すぐに削除するとインデックスがずれるため、一旦配列に追加
						収納用エフェクト.add((Sprite) getChildByIndex(エフェクト));
					} else if (getChildByIndex(エフェクト).getX()
							+ ((Sprite) getChildByIndex(エフェクト)).getWidth() > 800) {
						// すぐに削除するとインデックスがずれるため、一旦配列に追加
						収納用エフェクト.add((Sprite) getChildByIndex(エフェクト));
					} else if (getChildByIndex(エフェクト).getY()
							+ ((Sprite) getChildByIndex(エフェクト)).getWidth() > 480) {
						// すぐに削除するとインデックスがずれるため、一旦配列に追加
						収納用エフェクト.add((Sprite) getChildByIndex(エフェクト));
					}
				}
				// エフェクトの削除処理
				if (メモリーの開放をしたかどうか == true) {
					// すぐに削除するとインデックスがずれるため、一旦配列に追加
					収納用エフェクト.add((Sprite) getChildByIndex(エフェクト));
				}
				// エフェクトの接触処理
				if (状態フラグ復活中 == false && メモリーの開放をしたかどうか == false) {
					// エフェクトとプレイヤーの接触処理
					effectAndPlayerCoreContact();
				}
				// エフェクトとボールの接触処理
				effectAndNormalFireballContact();
				effectAndSuperFireballContact();
				// エフェクトとハンドの接触処理
				effectAndHandPunchContact();
				// エフェクトとエフェクトの接触処理
				effectAndEffectContact();
			}
		}
	}
	public void fontTagDecision() {							// フォント
		// フォントを特定値分移動させる
		for (フォント = 0; フォント < getChildCount(); フォント++) {
			if (getChildByIndex(フォント).getTag() ==
					// フォント
					Scores.					TAG_FONT_01_SCORE_100
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_02_SCORE_200
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_03_SCORE_300
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_04_SCORE_400
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_05_SCORE_500
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_06_SCORE_600
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_07_SCORE_700
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_08_SCORE_800
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_09_SCORE_900
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_10_SCORE_1000
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_11_SCORE_2000
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_12_SCORE_3000
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_13_SCORE_4000
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_14_SCORE_5000
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_15_SCORE_6000
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_16_SCORE_7000
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_17_SCORE_8000
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_18_SCORE_9000
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_19_SCORE_10000
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_20_SCORE_99990
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_21_SCORE_X1
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_22_SCORE_X2
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_23_SCORE_X3
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_24_SCORE_X4
					|| getChildByIndex(フォント).getTag() ==
					Scores.					TAG_FONT_25_SCORE_X5
					) {
				// 移動処理
				getChildByIndex(フォント).setY(
						getChildByIndex(フォント).getY() - 2.1f);
				// フォントの削除処理
				if (メモリーの開放をしたかどうか == false) {
					if (getChildByIndex(フォント).getY()
							+ ((Sprite) getChildByIndex(フォント)).getHeight() < 0) {
						// すぐに削除するとインデックスがずれるため、一旦配列に追加
						収納用フォント.add((Sprite) getChildByIndex(フォント));
					}
				} else {
					// すぐに削除するとインデックスがずれるため、一旦配列に追加
					収納用フォント.add((Sprite) getChildByIndex(フォント));
				}
			}
		}
	}
	
	// ===========================================================
	// 接触処理系
	// ===========================================================
	
	// タイルとプレイヤーの接触処理
	public void tileAndPlayerAboveContact() {				// ※上
		if (((Sprite) getChildByIndex(タイル)).collidesWith(
				contactLines.playerContactLineAbove)) {
			float 判定遊び = 0;
			float 接触距離 = Math.abs((getChildByIndex(タイル)
					.getY() + ((Sprite) getChildByIndex(タイル))
					.getHeight() / 2) - (contactLines.playerContactLineAbove
							.getY() + (contactLines.playerContactLineAbove
									.getHeight() / 2)));
			// 11.地面ブロック（ノーマル／短い1）
			// 12.地面ブロック（ノーマル／短い2）
			// 13.地面ブロック（ノーマル／長い1）
			// 14.地面ブロック（ノーマル／長い2）
			// 15.地面ブロック（ゴール／短い）
			// 16.地面ブロック（ゴール／長い）
			// 17.ドカンパーツ（1/4）
			// 18.ドカンパーツ（2/4）
			// 19.ドカンパーツ（3/4）
			// 20.ドカンパーツ（4/4）
			// 31.ハードブロック（小さい）
			// 32.ハードブロック（大きい）
			// 33.お城ブロック（小さい）
			// 34.お城ブロック（大きい）
			if (getChildByIndex(タイル).getTag() ==
					GroundBlocks.TAG_TILE_11_GROUND_BLOCK_NORMAL_SHORT_1
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true
					|| getChildByIndex(タイル).getTag() ==
					GroundBlocks.TAG_TILE_12_GROUND_BLOCK_NORMAL_SHORT_2
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true
					|| getChildByIndex(タイル).getTag() ==
					GroundBlocks.TAG_TILE_13_GROUND_BLOCK_NORMAL_LONG_1
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true
					|| getChildByIndex(タイル).getTag() ==
					GroundBlocks.TAG_TILE_14_GROUND_BLOCK_NORMAL_LONG_2
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true
					|| getChildByIndex(タイル).getTag() ==
					GroundBlocks.TAG_TILE_15_GROUND_BLOCK_GOAL_SHORT
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true
					|| getChildByIndex(タイル).getTag() ==
					GroundBlocks.TAG_TILE_16_GROUND_BLOCK_GOAL_LONG
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true
					|| getChildByIndex(タイル).getTag() ==
					PipeParts.TAG_TILE_17_PIPE_PART_1
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true
					|| getChildByIndex(タイル).getTag() ==
					PipeParts.TAG_TILE_18_PIPE_PART_2
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true
					|| getChildByIndex(タイル).getTag() ==
					PipeParts.TAG_TILE_19_PIPE_PART_3
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true
					|| getChildByIndex(タイル).getTag() ==
					PipeParts.TAG_TILE_20_PIPE_PART_4
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true
					|| getChildByIndex(タイル).getTag() ==
					HardBlocks.TAG_TILE_31_HARD_BLOCK_SMALL
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true
					|| getChildByIndex(タイル).getTag() ==
					HardBlocks.TAG_TILE_32_HARD_BLOCK_BIG
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true
					|| getChildByIndex(タイル).getTag() ==
					CastleBlocks.TAG_TILE_33_CASTLE_BLOCK_SMALL
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true
					|| getChildByIndex(タイル).getTag() ==
					CastleBlocks.TAG_TILE_34_CASTLE_BLOCK_BIG
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true) {
				フラグタイル接触 = true;
				if (接触距離 < contactLines.playerContactLineAbove.getHeight()
						/ 2 + ((Sprite) getChildByIndex(タイル)).getHeight()
						/ 2 - 判定遊び && 状態フラグ復活中 == false) {
					tileAndContactLineAboveDecision();
				}
				// 27.レンガブロック（小さい）
			} else if (getChildByIndex(タイル).getTag() ==
					BrickBlocks.TAG_TILE_27_BRICK_BLOCK_SMALL
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true) {
				// ※フラグタイル接触はふぁるすのまま！
				if (接触距離 < contactLines.playerContactLineAbove.getHeight()
						/ 2 + ((Sprite) getChildByIndex(タイル)).getHeight()
						/ 2 - 判定遊び && 状態フラグ復活中 == false) {
					現在のスコア += 50;
					SoundPlay.seBlockBreak.stop();
					SoundPlay.seBlockBreak.play();
					収納用タイル.add((Sprite) getChildByIndex(タイル));
				}
				// 28.レンガブロック（大きい）
			} else if (getChildByIndex(タイル).getTag() ==
					BrickBlocks.TAG_TILE_28_BRICK_BLOCK_BIG
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true) {
				// ※フラグタイル接触はふぁるすのまま！
				if (接触距離 < contactLines.playerContactLineAbove.getHeight()
						/ 2 + ((Sprite) getChildByIndex(タイル)).getHeight()
						/ 2 - 判定遊び && 状態フラグ復活中 == false) {
					現在のスコア += 100;
					SoundPlay.seBlockBreak.stop();
					SoundPlay.seBlockBreak.play();
					収納用タイル.add((Sprite) getChildByIndex(タイル));
				}
				// 29.キャンディブロック（小さい）
			} else if (getChildByIndex(タイル).getTag() ==
					CandyBlocks.TAG_TILE_29_CANDY_BLOCK_SMALL
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true) {
				// ※フラグタイル接触はふぁるすのまま！
				if (接触距離 < contactLines.playerContactLineAbove.getHeight()
						/ 2 + ((Sprite) getChildByIndex(タイル)).getHeight()
						/ 2 - 判定遊び && 状態フラグ復活中 == false) {
					// キャンディブロックは、メット取得時と無敵時のみ破壊できる、あと「エ゛エーイ！」もっ！
					if (メット取得フラグ == true || 状態フラグ無敵 == true || エエーイ実行フラグ == true) {
						現在のスコア += 50;
						SoundPlay.seBlockBreak.stop();
						SoundPlay.seBlockBreak.play();
						収納用タイル.add((Sprite) getChildByIndex(タイル));
					} else {
						tileAndContactLineAboveDecision();
					}
				}
				// 30.キャンディブロック（大きい）
			} else if (getChildByIndex(タイル).getTag() ==
					CandyBlocks.TAG_TILE_30_CANDY_BLOCK_BIG
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true) {
				// ※フラグタイル接触はふぁるすのまま！
				if (接触距離 < contactLines.playerContactLineAbove.getHeight()
						/ 2 + ((Sprite) getChildByIndex(タイル)).getHeight()
						/ 2 - 判定遊び && 状態フラグ復活中 == false) {
					// キャンディブロックは、メット取得時と無敵時のみ破壊できる、あと「エ゛エーイ！」もっ！
					if (メット取得フラグ == true || 状態フラグ無敵 == true || エエーイ実行フラグ == true) {
						現在のスコア += 100;
						SoundPlay.seBlockBreak.stop();
						SoundPlay.seBlockBreak.play();
						収納用タイル.add((Sprite) getChildByIndex(タイル));
					} else {
						tileAndContactLineAboveDecision();
					}
				}
				// 35.隠しブロック（きいろコイン）
				// 41.ハテナブロック（短い／きいろコイン）
			} else if (getChildByIndex(タイル).getTag() ==
					HiddenBlocks.TAG_TILE_35_HIDDEN_BLOCK_COIN_YELLOW
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true
					|| getChildByIndex(タイル).getTag() ==
					QuestionBlockShorts.TAG_TILE_41_QUESTION_BLOCK_SHORT_COIN_YELLOW
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true) {
				// ※フラグタイル接触はふぁるすのまま！
				if (接触距離 < contactLines.playerContactLineAbove.getHeight()
						/ 2 + ((Sprite) getChildByIndex(タイル)).getHeight()
						/ 2 - 判定遊び && 状態フラグ復活中 == false) {
					収納用タイル.add((Sprite) getChildByIndex(タイル));
					// そして、エフェクトも表示
					emptyBlock.effectEmptyBlockShort = getBaseActivity().getResourceUtil()
							.getAnimatedSprite("effect_11_empty_block_short.png", 1, 11);
					emptyBlock.effectEmptyBlockShort.setTag(
							EmptyBlock.TAG_EFFECT_11_EMPTY_BLOCK_SHORT);
					emptyBlock.effectEmptyBlockShort.setPosition(
							getChildByIndex(タイル).getX(),
							getChildByIndex(タイル).getY() - 32);
					emptyBlock.effectEmptyBlockShort.animate(
							new long[] { aniスター, aniスター, aniスター, aniスター, aniスター, aniスター,
									aniスター, aniスター, aniスター, aniスター, aniスター, }, 0, 10, false);
					attachChild(emptyBlock.effectEmptyBlockShort);
					emptyBlock.effectEmptyBlockShort.setZIndex(レイヤー02タイル用);
					sortChildren();
					// 最後にアイテム獲得メソッドの呼び出し
					contactLineAboveAndBlocksCoinYellowDecision();
				}
				// 36.隠しブロック（あかコイン）
				// 42.ハテナブロック（短い／あかコイン）
			} else if (getChildByIndex(タイル).getTag() ==
					HiddenBlocks.TAG_TILE_36_HIDDEN_BLOCK_COIN_RED
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true
					|| getChildByIndex(タイル).getTag() ==
					QuestionBlockShorts.TAG_TILE_42_QUESTION_BLOCK_SHORT_COIN_RED
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true) {
				// ※フラグタイル接触はふぁるすのまま！
				if (接触距離 < contactLines.playerContactLineAbove.getHeight()
						/ 2 + ((Sprite) getChildByIndex(タイル)).getHeight()
						/ 2 - 判定遊び && 状態フラグ復活中 == false) {
					収納用タイル.add((Sprite) getChildByIndex(タイル));
					// そして、エフェクトも表示
					emptyBlock.effectEmptyBlockShort = getBaseActivity().getResourceUtil()
							.getAnimatedSprite("effect_11_empty_block_short.png", 1, 11);
					emptyBlock.effectEmptyBlockShort.setTag(
							EmptyBlock.TAG_EFFECT_11_EMPTY_BLOCK_SHORT);
					emptyBlock.effectEmptyBlockShort.setPosition(
							getChildByIndex(タイル).getX(),
							getChildByIndex(タイル).getY() - 32);
					emptyBlock.effectEmptyBlockShort.animate(
							new long[] { aniスター, aniスター, aniスター, aniスター, aniスター, aniスター,
									aniスター, aniスター, aniスター, aniスター, aniスター, }, 0, 10, false);
					attachChild(emptyBlock.effectEmptyBlockShort);
					emptyBlock.effectEmptyBlockShort.setZIndex(レイヤー02タイル用);
					sortChildren();
					// 最後にアイテム獲得メソッドの呼び出し
					contactLineAboveAndBlocksCoinRedDecision();
				}
				// 37.隠しブロック（あおコイン）
				// 43.ハテナブロック（短い／あおコイン）
			} else if (getChildByIndex(タイル).getTag() ==
					HiddenBlocks.TAG_TILE_37_HIDDEN_BLOCK_COIN_BLUE
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true
					|| getChildByIndex(タイル).getTag() ==
					QuestionBlockShorts.TAG_TILE_43_QUESTION_BLOCK_SHORT_COIN_BLUE
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true) {
				// ※フラグタイル接触はふぁるすのまま！
				if (接触距離 < contactLines.playerContactLineAbove.getHeight()
						/ 2 + ((Sprite) getChildByIndex(タイル)).getHeight()
						/ 2 - 判定遊び && 状態フラグ復活中 == false) {
					収納用タイル.add((Sprite) getChildByIndex(タイル));
					// そして、エフェクトも表示
					emptyBlock.effectEmptyBlockShort = getBaseActivity().getResourceUtil()
							.getAnimatedSprite("effect_11_empty_block_short.png", 1, 11);
					emptyBlock.effectEmptyBlockShort.setTag(
							EmptyBlock.TAG_EFFECT_11_EMPTY_BLOCK_SHORT);
					emptyBlock.effectEmptyBlockShort.setPosition(
							getChildByIndex(タイル).getX(),
							getChildByIndex(タイル).getY() - 32);
					emptyBlock.effectEmptyBlockShort.animate(
							new long[] { aniスター, aniスター, aniスター, aniスター, aniスター, aniスター,
									aniスター, aniスター, aniスター, aniスター, aniスター, }, 0, 10, false);
					attachChild(emptyBlock.effectEmptyBlockShort);
					emptyBlock.effectEmptyBlockShort.setZIndex(レイヤー02タイル用);
					sortChildren();
					// 最後にアイテム獲得メソッドの呼び出し
					contactLineAboveAndBlocksCoinBlueDecision();
				}
				// 38.隠しブロック（パワーアップアイテム）
				// 44.ハテナブロック（短い／パワーアップアイテム）
			} else if (getChildByIndex(タイル).getTag() ==
					HiddenBlocks.TAG_TILE_38_HIDDEN_BLOCK_POWER_UP_ITEM
					// ※ブロックはジャンプ時のみ判定
					&& プレイヤーのダッシュフラグ == false && プレイヤーのジャンプフラグ == true
					&& プレイヤーの上昇移動フラグ == true
					|| getChildB