shiny-cuty-excel-chiffon/data/Sprite.tjs


var peopleCount = 0;

class MovingTable
{
	var x;
	var y;
	var h;

	function MovingTable(x1=0, y1=0, h1=0){
		if(typeof x1 == "Object"){
			x = x1.x;
			y = x1.y;
			h = x1.h;
		}else{
			x = x1;
			y = y1;
			h = h1;
		}
	}

	function set(x1, y1, h1){
		if(typeof x1 == "void") return;
		if(typeof x1 == "Object"){
			x = x1.x;
			y = x1.y;
			h = x1.h;
		}else{
			x = x1;
			y = y1;
			h = h1;
		}
	}

	function copy(m){
		x = m.x;
		y = m.y;
		h = m.h;
	}

	function add(x1, y1, h1){
		if(typeof x1 == "Object"){
			x += x1.x;
			y += x1.y;
			h += x1.h;
		}else{
			x += x1;
			y += y1;
			h += h1;
		}
	}

	function reset(){
		x = 0;
		y = 0;
		h = 0;
	}

	function dm(){
		Debug.message("mt.x : " + x + " / mt.y : " + y + " / mt.h : " + h);
	}

	function store()
	{
		var dic = %[];

		dic.x = x;
		dic.y = y;
		dic.h = h;
		return dic;
	}

	function restore(dic)
	{
		x = dic.x;
		y = dic.y;
		h = dic.h;
	}

}


class ObjectReference
{

	var owner;
	var objectClass;
	var index;

	function ObjectReference(o)
	{
		owner = o.owner;
		if(o instanceof "Sprite"){
			objectClass = o.objectClass;
			index = owner.getIndex(o);
		}else if(o instanceof "Dictionary"){
			restore(o);
		}
	}

	function finalize()
	{
		objectClass = void;
		index = void;
	}

	function store()
	{
		var dic = %[];
		if(owner == bao){
			dic.owner = "bao";
		}else if(typeof(global.dho) != 'undefined' && isvalid dho && owner == dho){
			dic.owner = "dho";
		}else{
			dic.owner = "other";
		}
		dic.objectClass = objectClass;
		dic.index = index;
		return dic;
	}

	function restore(dic)
	{
		switch(dic.owner){
			case "bao":
				owner = bao;
				break;
			case "dho":
				if(typeof(global.dho) != 'undefined' && dho !== void && isvalid dho){
					owner = dho;
				}
				break;
		}
		objectClass = dic.objectClass;
		index = dic.index;
	}

	function getObject()
	{
		if(objectClass === void && index === void) return void;
		if(owner === void) return void;
		return owner.getObjectFromClassAndIndex(objectClass, index);
	}

}


function copyMovingTable(m1, m2)
{
	for(var i=0; i<m1.count; i++){
		m2[i] = new MovingTable(m1[i]);
	}
}


class SpriteConductor extends KAGParser
{
	var owner;
	var running = false; // 実行中か
	var count = 0;
	var executing = false;

	var kind = cndNormal;

	var mp = %[];
	var layer;
	var sprite;

	var handlers;
	var subHandlers;

	var currentLabel = "";

	function SpriteConductor(owner)
	{
		// コンストラクタ
		super.KAGParser(...);

		ignoreCR = true; // CR は無視
		debugLevel = tkdlNone;
//		debugLevel = tkdlVerbose;
		this.owner = owner;

		// スプライトスクリプト中で参照できるように
		layer = owner;
		sprite = owner.owner;

		handlers = getHandlers();
	}

	function finalize()
	{
		owner = void; // owner への参照を切る
		super.finalize(...);
	}

	function clear()
	{
		// clear オーバーライド
		super.clear();
	}

	function frameProcess()
	{
		var obj;
//dm("running : " + running);
		// もし他から呼び出されてたら処理しない
		if(executing) return;
		executing = true;

		if(count > 0){
			count --;
			executing = false;
			return;
		}
		if(!running){
			executing = false;
			return;
		}

		try
		{
			for(;;)
			{
				// 次のタグを得る
				obj = getNextTag();

				if(obj === void)
				{
					// シナリオ終了
					onStop();
					executing = false;
					return;
				}
				else
				{
					// onTag を呼ぶ
					var step = onTag(obj);
					if(step === void)
						throw new Exception("onTag が void を返しました (" + obj.tagname + ")"
							"( おそらくタグハンドラの戻り値を返し忘れた )");
					step = int step; // step を数値に

					if(step == 0){
						continue;
					}else if(step < 0){
						onStop();
						executing = false;
						return;
					}else{
						count = step - 1;
						executing = false;
						return;
					}
				}
			}
		}
		catch(e)
		{
//			Debug.logAsError();
			onStop();
			if(tf.debugMode){
				var msg = "エラーが発生しました\n"
					"ファイル : " + curStorage + "   行 : " + (curLine+1) + "\n"
					"タグ : " + (obj === void ? "不明" : obj.tagname)
					+ " ( ← エラーの発生した前後のタグを示している場合もあります )\n"
					+ e.message;
				if((typeof e.trace) != "undefined") dm("trace : " + e.trace);
				dm(msg);
				throw new ConductorException(msg);
			}
//			System.inform(msg, "エラー");
		}
	}

	function start()
	{
		running = true;
	}

	function stop()
	{
		running = false;
	}

	function onStop()
	{
		running = false;
//		// 実行停止
//		var elm = %[];
//		elm.context = this;
//		owner.s(elm); // s タグを呼ぶ
	}

	function onTag(obj)
	{
		// タグが実行されるとき
		var func = handlers[obj.tagname];
		if(func === void){
			if(subHandlers === void){
				dm("未知のタグ : " + obj.tagname);
				return 0;
			}else{
				func = subHandlers[obj.tagname];
				if(func == void){
					dm("未知のタグ : " + obj.tagname);
					return 0;
				}
			}
		}
		return func(obj);
	}

	function onScript(script, scriptname, lineofs)
	{
		// iscript が実行されるとき
		try
		{
			Scripts.exec(script, scriptname, lineofs, this);
		}
		catch(e)
		{
			throw new Exception(scriptname + " の 行 " + lineofs + " から始まる"
				" iscript ブロックでエラーが発生しました。"
				"\n( 詳細はコンソールを参照してください )\n" + e.message);
		}
		return true;
	}

	function onLabel(label)
	{
		currentLabel = label;
	}

	function onScenarioLoaded()
	{
		currentLabel = "";
	}

	function jump(target)
	{
		goToLabel(target);
		running = true;
		count = 0;
		frameProcess();
	}

	function assign(src)
	{
		// src の状態をこのオブジェクトにコピー
		super.assign(src);
		stopping = src.stopping;
		running = src.running;
	}

	function store()
	{
		var dic = super.store();

		if(mp !== void){
			dic.mp = %[];
			(Dictionary.assign incontextof dic.mp)(mp);
		}else{
			dic.mp = void;
		}

		dic.running = running;
		dic.count = count;
		dic.executing = executing;
		dic.currentLabel = currentLabel;

		return dic;
	}

	function restore(dic)
	{
		try{
			dic.storageName = dic.storageShortName;
			if(dic.storageName!=""){
				super.restore(dic);
			}
		}catch(e){
//			var array = [];
//			array.assign(dic);
//			for(var i=0; i<array.count; i+=2){
//				dm(array[i] + " : " + array[i+1]);
//			}
			dm("SpriteConductor restore error : " + e.message);

			return;
		}

		if(dic.mp !== void){
			(Dictionary.assign incontextof mp)(dic.mp);
		}else{
			mp = %[];
		}

		running = dic.running;
		count = dic.count;
		executing = dic.executing;

		currentLabel = dic.currentLabel;
		if(currentLabel != ""){
			goToLabel(currentLabel);
		}
//dm("■■ curStorage : " + curStorage + " / dic.curLine : " + dic.curLine);
		if(sprite instanceof "PlayerSprite") goToLine(dic.curLine);
//dm("■■ curLine : " + curLine);
	}


	function goToLine(l){
		var cl = currentLabel;
		var i = 0;
		while(curLine < l - 1){
			var obj = getNextTag();
			i++;
//dm(curLine + " : " + i + " tagname : "+ obj.tagname);
			if(i > 1000 || obj === void){
				if(currentLabel != "") goToLabel(currentLabel);
//dm("break " + curLine);
				break;
			}
		}
//dm("return");
	}


	function executeEval(elm)
	{
//		var f = Scripts.eval("function(){" + elm.exp + ";}");
//		(f incontextof this)();
//dm("exp : " + elm.exp);
		try{
			var flg = true;
			if(elm.expcond !== void && elm.expcond != ""){
//dm("cond : " + elm.expcond + " / getDistance(sprite,sprite.targetPlayer) : " + (getDistance(sprite,sprite.targetPlayer)));
				flg = Scripts.eval(elm.expcond,,,this);
//dm("flg : " + flg + " / exp : " + elm.exp);
			}
			if(flg) return Scripts.eval(elm.exp,,,this);
		}catch(e){
		}
	}

	function getHandlers()
	{
		return %[

			s : function(elm)
			{
				// 停止
//				elm.context.running = false;
				return -1; // 停止
			} incontextof this,

			dispsize : function(elm)
			{
				owner.tag_dispsize(elm);
				return 0;
			} incontextof this,

			centerpos : function(elm)
			{
				owner.tag_centerpos(elm);
				return 0;
			} incontextof this,

			state : function(elm)
			{
				owner.tag_state(elm);
				return 0;
			} incontextof this,

//			baseline : function(elm)
//			{
//				owner.tag_state(elm);
//				return 0;
//			} incontextof this,

			foot : function(elm)
			{
				owner.tag_foot(elm);
				return 0;
			} incontextof this,

			hit : function(elm)
			{
				owner.tag_hit(elm);
				return 0;
			} incontextof this,

			attack : function(elm)
			{
				owner.tag_attack(elm);
				return 0;
			} incontextof this,

			disp : function(elm)
			{
				owner.tag_disp(elm);
				return 0;
			} incontextof this,

			load : function(elm)
			{
				owner.tag_load(elm);
				return 0;
			} incontextof this,

			image : function(elm)
			{
				// レイヤー画像の変更
				owner.tag_image(elm);
				return 0;
			} incontextof this,

			move : function(elm)
			{
				owner.tag_move(elm);
				return 0;
			} incontextof this,

			del : function(elm)
			{
				// 削除
				owner.tag_del(elm);
				return 0;
			} incontextof this,

			setface : function(elm)
			{
				// 表情の変更
				owner.owner.owner.informLayer.setFace(owner.owner, +elm.num);
				return 0;
			} incontextof this,

			wait : function(elm)
			{
				return +elm.frame;
			} incontextof this,

			eval : function(elm)
			{
//				Scripts.eval(elm.exp); // elm.exp を式として実行
				executeEval(elm);
				return 0;
			} incontextof this,

			ch : function(elm)
			{
				// 何もしない
				return 0;
			} incontextof this,

			waittrig : function(elm)
			{
				if(elm.name !== void) owner.waitTrig(elm.name);
				return -1;
			} incontextof this,

			ontrigger : function(elm)
			{
				if(elm.name !== void) owner.setOnTrigger(elm);
				return 0;
			} incontextof this,

			playse : function(elm)
			{
				// 効果音の再生
//				if(f.inHScene) return 0;
				owner.tag_playse(elm);
				return 0;
			} incontextof this,

			playdamagese : function(elm)
			{
				// 効果音の再生
//				if(f.inHScene) return 0;
				owner.tag_playdamagese(elm);
				return 0;
			} incontextof this,

			playguardse : function(elm)
			{
				// 効果音の再生
//				if(f.inHScene) return 0;
				owner.tag_playguardse(elm);
				return 0;
			} incontextof this,

			fadeinse : function(elm)
			{
				// 効果音の再生
				owner.window.se[+elm.buf].fadeIn(elm);
				return 0;
			} incontextof this,

			fadese : function(elm)
			{
				// 効果音の再生
				owner.window.se[+elm.buf].fade(elm);
				return 0;
			} incontextof this,

			fadeoutse : function(elm)
			{
				// 効果音の再生
				owner.window.se[+elm.buf].fadeOut(elm);
				return 0;
			} incontextof this,

			quake : function(elm)
			{
				// 揺れ
				sprite.owner.doQuake(elm);
				return 0;
			} incontextof this,

			stopquake : function(elm)
			{
				// 揺れの停止
				sprite.owner.stopQuake();
				return 0;
			} incontextof this,

			fosize : function(elm)
			{
				// FloorObject用
				owner.tag_fosize(elm);
				return 0;
			} incontextof this,

			fosetcommand : function(elm)
			{
				// FloorObject用
				owner.tag_fosetcommand(elm);
				return 0;
			} incontextof this,

			collision : function(elm)
			{
				// FloorObject用
				owner.tag_collision(elm);
				return 0;
			} incontextof this,

			addlayer : function(elm)
			{
				owner.addLayer(elm);
				return 0;
			} incontextof this,

			dellayer : function(elm)
			{
				owner.delLayer(elm);
				return 0;
			} incontextof this,

			zoom : function(elm)
			{
				owner.setZoom(+elm.rate, +elm.internalrate);
				return 0;
			} incontextof this,

			adjustx : function(elm)
			{
				owner.owner.adjustX(+elm.d);
				return 0;
			} incontextof this,

			object : function(elm)
			{
				setObject(elm);
				return 0;
			} incontextof this,

			effect : function(elm)
			{
				setEffect(elm);
				return 0;
			} incontextof this,

			fukidashi : function(elm)
			{
				bao.fukidashi.add(elm);
				return 0;
			} incontextof this,

			fukidashireset : function(elm)
			{
				bao.fukidashi.clear();
				return 0;
			} incontextof this,

			voice : function(elm)
			{
				// ボイスの再生
//				if(f.inHScene) return 0;
				owner.tag_voice(elm);
				return 0;
			} incontextof this,

			tentaclemove : function(elm)
			{
				// 触手専用
				owner.startTentacleMove(elm);
				return 0;
			} incontextof this,

			tentacleattack : function(elm)
			{
				// 触手専用
				owner.setTentacleAttack(elm);
				return 0;
			} incontextof this,

		];
	}

	function setObject(elm)
	{
		elm.generatedFrom = this;
//		if(typeof(owner.owner) != 'undefined'){
//			elm.originObjectClass = owner.owner.objectClass;
//			elm.originIndex = bao.getIndex(owner.owner);
//		}
		return bao.setObject(elm);
	}

	function setEffect(elm)
	{
		elm.generatedFrom = this;
//		if(typeof(owner.owner) != 'undefined'){
//			elm.originObjectClass = owner.owner.objectClass;
//			elm.originIndex = bao.getIndex(owner.owner);
//		}
		if(elm.parent === void){
			var parent = this.owner.owner;
			elm.parent = parent;
		}

		return bao.setEffect(elm);
	}

	property originSprite
	{
		getter (){
			var ret = void;
			try{
				ret = owner.owner.generatedFrom.owner.owner;
			}catch(e){}
			return ret;

//			return owner.owner.generatedFrom.owner.owner;
		}
	}

	property originLayer
	{
		getter (){
			return owner.owner.generatedFrom.owner;
		}
	}

}


class FrameAnimeLayer extends Layer
{
	var window;
	var owner;
	var root;

	var conductor;

	var graphic;
	var asd;
	var orgGraphic;
	var noHeaderGraphicName;
	var orgAsd;

	var dispWidth;
	var dispHeight;
	var dispTop = 0;
	var dispLeft = 0;

	var dl;
	var dt;

	var loadParams = void;
	var colorParams = void;

	var mp = %[];

	var waitUntil = [];
	var onTriggerTarget = %[];

	//サブレイヤー
	var layers = [];

	var asdWidth;
	var asdHeight;
	var internalWidth;
	var internalHeight;

	var bufLayer;
	var zoomMode = false;
	var noZoom = false;

	var asdOpacity;
	var opacity2 = 100;
	var dOpacity2 = 0;

	// 画像ファイルは定義ファイル上の大きさの何倍か
	var internalZoomRate = 1;
	// 表示する大きさは定義ファイル上の大きさの何倍か
	var dispZoomRate = 1;

	// 逆を向いているかどうか
	var inverse = false;
	var setInverseFlag = false;

	function FrameAnimeLayer(window, parent, owner, root)
	{
		// AnimationLayer コンストラクタ
		super.Layer(window, parent); // スーパークラスのコンストラクタを呼ぶ

		this.window = window;
		this.parent = parent;
		this.owner = owner;
		this.root = root;
		conductor = new SpriteConductor(this);

	}

	function finalize()
	{
		clearImage();
		invalidate conductor;
		super.finalize(...);
	}

	function clearImage()
	{
		visible = false;
		setSize(32, 32);
		setImageSize(32, 32);
		face = dfAlpha;
		fillRect(0, 0, 32, 32, 0);

//		type = ltOpaque;
//		face = dfAuto;

		for(var i=0; i<layers.count; i++){
			invalidate layers[i];
			layers.erase(i);
		}

		if(bufLayer !== void) invalidate bufLayer;

		inverse = false;
	}

	function freeImage()
	{
		conductor.stop();
		clearImage();
	}

	function startAnimation(str, label='')
	{
		var asdFile = Storages.getPlacedPath(Storages.chopStorageExt(str) + ".asd");
		if(asdFile == '')
			throw new Exception(str + "に対するアニメーション情報 " + asdFile +" がありません");

		conductor.stop();
		conductor.count = 0;

		conductor.loadScenario(asdFile);
		if(label != '') conductor.goToLabel(label);
		conductor.start();
		conductor.frameProcess();
	}

	function stopAnimation(segment)
	{
		conductor.stop();
	}

	function loadImages(elm)
	{
		visible = false;
		waitUntil = [];
		onTriggerTarget = %[];
		type = ltAlpha;

		if(elm === void)
		{
			freeImage();
			return;
		}
//		dm("1 owner : " + owner + " / asd : " + elm.asd + " / graphic : " + elm.graphic + " / storage : " + elm.storage);

		graphic = elm.graphic;
		if(graphic === void) graphic = elm.storage;
		if(name == "") name = graphic;
		orgGraphic = noHeaderGraphicName = graphic;
		orgAsd = asd = elm.storage;

//		dm("2 owner : " + owner + " / asd : " + elm.asd + " / graphic : " + graphic);

		if(!(+elm.noZoom)) graphic = checkImageAndSetZoom(graphic);
		if(graphic !== void){
			loadImagesSub(graphic, elm);
		}else{
			if(typeof(inverse)!="undefined" && typeof(owner.inverse)!="undefined"){
				inverse = owner.inverse;
			}
		}
//		dm("3 owner : " + owner + " / asd : " + asd + " / graphic : " + graphic + " / orgGraphic : " + orgGraphic);

		if(Storages.isExistentStorage(root.fHeader + asd + ".asd")){
			asd = root.fHeader + asd;
		}

		// パラメータを待避
		loadParams = %[];
		(Dictionary.assign incontextof loadParams)(elm);

		if(elm.type!== void) type = +elm.type;

		try{
			startAnimation(asd, elm.label);
		}catch(e){
			return;
		}

	}

	function checkImageAndSetZoom(g){

		if(typeof(global.dho) != 'undefined' && isvalid dho && dho.enabled){
			if(g !== void && owner.owner instanceof "DotHScene_Plugin" && g[0].toLowerCase() == "p" && g[3].toLowerCase() == "h"){
				var s1 = g.substring(0, 2);
				var s2 = g.substring(2);
				var p = int(g.substring(1, 1));
				var storage;

				var c = owner.owner.cos[p];
				if(c != 0){
					if(Storages.isExistentStorage(s1 + c + s2 + ".png")){
						g = s1 + c + s2;
					}else{
					}
				}
			}
		}

		if(Storages.isExistentStorage(root.fHeader + g + ".png") || noZoom){
			zoomMode = false;
			if(bufLayer !== void) invalidate bufLayer;
			g = root.fHeader + g;
			internalZoomRate = dispZoomRate = root.cZoomRate;
			return g;
		}else{
			if(root.mode==3){
				if(Storages.isExistentStorage(fHeaderMatrix[2] + g +".png")){
					g = fHeaderMatrix[2] + g;
					zoomMode = true;
					dispZoomRate = root.cZoomRate; //3
					internalZoomRate = 1.5;
					return g;
				}else if(Storages.isExistentStorage(g+".png")){
					zoomMode = true;
					dispZoomRate = root.cZoomRate; //3
					internalZoomRate = 1;
					return g;
				}
			}else if(root.mode==2){
				if(Storages.isExistentStorage(g+".png")){
					zoomMode = true;
					dispZoomRate = root.cZoomRate; //1.5
					internalZoomRate = 1;
					return g;
				}
			}
			dispZoomRate = root.cZoomRate; //3
			internalZoomRate = 1;
		}
		return void;
	}


	function loadImagesSub(str, elm)
	{
		if(str===void || str=="")return;
		// 画像を読み込む
		var taginfo = super.loadImages(checkAndGetCosVariation(str, elm.directspecify), elm.key);
		graphic = str;

		// 画像のタグ情報をデフォルト値として採用
		if(taginfo)
		{
			(Dictionary.assign incontextof taginfo)(elm, false);
			elm = taginfo;
		}

		// 色補正
		face = dfAuto;
		if(colorParams !== void) applyColorCorrection(this, colorParams);

		if(elm.left !== void) left = +elm.left;
		if(elm.top !== void) top = +elm.top;
		if(elm.opacity !== void) asdOpacity = opacity = +elm.opacity;
		absolute = +elm.index if elm.index !== void;

		if(elm.visible !== void){
			visible = +elm.visible;
		}else{
			visible = true;
		}

		if(debugMode){
			fillRect(0, 0, imageWidth, 1, 0x44000000);
			fillRect(0, imageHeight-1, imageWidth, imageHeight, 0x44000000);
		}

		if(internalZoomRate != dispZoomRate){
			prepareZoom();
		}

		inverse = false;
		if(elm.inverse !== void && +elm.inverse) setInverseFlag = true;
	}

	function loadImagesSub2(str){
		if(str===void || str=="")return;
		super.loadImages(checkAndGetCosVariation(str));
		if(colorParams !== void) applyColorCorrection(this, colorParams);
		if(inverse) execInverse();
	}


	function checkAndGetCosVariation(s, flag=false){

		if(flag){
//dm("return " + s);
			return s;
		}

		var storage = s;
//		if(owner instanceof "PlayerSprite" && (owner.name=="エクセルシフォン"||owner.name=="エクセルショコラ")){
		if(asd[0].toLowerCase() == 'p' && (asd[1] == '0' || asd[1] == '1')){
//dm("■ " + storage);
			var s1, s2;
			if(typeof(global.dho) != 'undefined' && isvalid dho){
				if(dho.mode == 1 || asd[2] == '_'){
					s1 = s.substring(0, 2);
					s2 = s.substring(3);
				}else{
					s1 = s.substring(0, fHeaderMatrix[dho.mode].length + 2);
					s2 = s.substring(fHeaderMatrix[dho.mode].length + 3);
				}
			}else{
				if(bao.mode == 1){
					s1 = s.substring(0, 2);
					s2 = s.substring(3);
				}else{
					s1 = s.substring(0, fHeaderMatrix[bao.mode].length + 2);
					s2 = s.substring(fHeaderMatrix[bao.mode].length + 3);
				}
			}
//dm("s1 : " + s1);
//dm("s2 : " + s2);

//dm("sf.adjEvilCosMode : " + sf.adjEvilCosMode + " / cosState : " + owner.cosState + " / sf.adjCosVariation : " + sf.adjCosVariation);
			var cosState = 0;
			if(owner instanceof "PlayerSprite"){
				cosState = owner.cosState;
			}else if(owner instanceof "CharacterSprite" && owner.parentSprite !== void && isvalid owner.parentSprite && owner.parentSprite instanceof "PlayerSprite"){
				cosState = owner.parentSprite.cosState;
			}

//			if(sf.adjEvilCosMode && cosState!=0){
			if(sf.adjEvilCosMode){
				switch(sf.adjCosVariation){
					case 4:
					case 6:
						if(cosState == 5){
							storage = s1 + string(sf.adjCosVariation+1) + s2;
						}else{
							storage = s1 + string(sf.adjCosVariation) + s2;
						}
						break;
					case 9:
						storage = s1 + string(sf.adjCosVariation) + s2;
						break;
				}
			}else{
				if(cosState == 4 && !f.inRouteB) cosState = 0;
				storage = s1 + string(cosState) + s2;
			}
//dm("■■ " + storage);
			if(!Storages.isExistentStorage(storage + ".png")) storage = s;
//dm("■■■ " + storage);
		}

		return storage;
	}


	function prepareZoom(){
		zoomMode = true;
		if(bufLayer === void || !isvalid bufLayer) bufLayer =  new .Layer(window, this);
		bufLayer.setImageSize(imageWidth, imageHeight);
		bufLayer.copyRect(0, 0, this, 0, 0, imageWidth, imageHeight);
		bufLayer.visible = false;
		bufLayer.name = 'bufLayer';
	}

	function setZoom(z, iz=1)
	{
		if(iz==0) iz=1;

		dispZoomRate = z;
		internalZoomRate = iz;

		if(!zoomMode){
			prepareZoom();
		}

		internalWidth = int(asdWidth * internalZoomRate);
		internalHeight = int(asdHeight * internalZoomRate);

		dispWidth = int(asdWidth * dispZoomRate);
		dispHeight = int(asdHeight * dispZoomRate);
		setSize(dispWidth, dispHeight);

//		stretchCopy(0, 0, dispWidth, dispHeight, bufLayer, internalWidth*dispLeft, internalHeight*dispTop, internalWidth, internalHeight, stNearest);
	}

	function resumeZoom()
	{
		if(!zoomMode) return;
		setImageSize(bufLayer.imageWidth, bufLayer.imageHeight);
		copyRect(0, 0, bufLayer, 0, 0, bufLayer.imageWidth, bufLayer.imageHeight);
		zoomMode = false;
		invalidate bufLayer;
		internalZoomRate = dispZoomRate = root.cZoomRate;
	}

	function applyColorCorrection(layer, param)
	{
		// layer に対して色補正を行う
		var orgface = layer.face;
		var orgholdlpha = layer.holdAlpha;
		layer.face = dfAuto;
		if(param.grayscale !== void && +param.grayscale) layer.doGrayScale();
		layer.adjustGamma(
			param.rgamma, param.rfloor, param.rceil,
			param.ggamma, param.gfloor, param.gceil,
			param.bgamma, param.bfloor, param.bceil);
		if(param.mcolor !== void)
		{
			// 色重ね合わせ
			layer.face = dfOpaque;
			layer.holdAlpha = true;
			layer.colorRect(0, 0, layer.imageWidth, layer.imageHeight, +param.mcolor,
				+param.mopacity);
		}
		if (param.lightcolor !== void) {
			// レイヤ合成
			var mode = ltAlpha;
			if(param.lighttype !== void)
			{
				var layertypeinfo = imageTagLayerType[param.lighttype];
				if(layertypeinfo !== void)
					mode = layertypeinfo.type;
			}
			layer.holdAlpha = true;
			layer.fillOperateRect(0,0,layer.imageWidth, layer.imageHeight,
								  +param.lightcolor,
								  mode);
		}
		layer.face = orgface;
		layer.holdAlpha = orgholdlpha;
	}

	function setInverse(){
		execInverse();
		try{
			if(typeof(owner.centerPos)!='undefined'){
				owner.centerPos = asdWidth - owner.centerPos;
			}
		}catch(e){
			dm("owner : " + owner);
			dm("???");
		}
		inverse = !inverse;
	}

	function execInverse()
	{
		if(graphic === void) return;

		var tLayer;
		if(zoomMode){
			tLayer = bufLayer;
		}else{
			tLayer = this;
		}

		var tmpLayer = new .Layer(window, this);
		tmpLayer.setImageSize(tLayer.imageWidth, tLayer.imageHeight);
		tmpLayer.copyRect(0, 0, tLayer, 0, 0, tLayer.imageWidth, tLayer.imageHeight);
		var w = internalWidth;
		if(w==0) w = tLayer.imageWidth;
		var wi = tLayer.imageWidth \ w - 1;

		tmpLayer.flipLR();

//		dm("graphic : " + graphic + " / w : " + w + " / wi : " + wi + " / tLayer : " + tLayer);
//		kag.fore.layers[0].visible = true;
//		kag.fore.layers[0].loadImages(%['storage'=>'_tr']);
//		//kag.fore.layers[0].setSize(1366,768);
//		kag.fore.layers[0].fillRect(0,0,1366,768,0x88ff0000);
//		//kag.fore.layers[0].opacity = 128;

		for(var i=0 ; i<=wi ; i++){
			tLayer.copyRect(w*(wi-i) , 0 , tmpLayer , w*i , 0 , w , imageHeight);
		}

//		kag.fore.layers[0].copyRect(0,0,tLayer,0,0,tLayer.imageWidth,tLayer.imageHeight);
		invalidate tmpLayer;
	}

	function onRefreshFrame(){
		conductor.frameProcess();

		for(var i=0; i<layers.count; i++){
			layers[i].onRefreshFrame();
		}

		if(dOpacity2 != 0){
			opacity2 += dOpacity2;
			if(opacity2 > 100){
				opacity2 = 100;
				dOpacity2 = 0;
			}
			if(opacity2 < 0){
				opacity2 = 0;
				dOpacity2 = 0;
			}
			opacity = int(asdOpacity * opacity2/100);
		}

	}

	function waitTrig(name)
	{
		conductor.running = false;
		waitUntil.add(name);
	}

	function setOnTrigger(elm)
	{
		if(elm.target === void){
			dm("targetが指定されていません。");
		}else{
			onTriggerTarget[elm.name] = elm.target;
		}
	}

	function trigger(name, obj){
		if(onTriggerTarget[name] !== void){
			if(obj !== void){
				owner.triggeredBy = obj;
			}else{
				owner.triggeredBy = owner;
			}
			var label = onTriggerTarget[name];
			clearTrigger(name);
			conductor.jump(label);
			return;
		}

		var i = waitUntil.find(name);
		if(i == -1) return;
		waitUntil.erase(i);
		if(waitUntil.count == 0) conductor.running = true;
	}

	function clearTrigger(name){
		if(onTriggerTarget[name] !== void){
			onTriggerTarget[name] = void;
		}
	}

	function store()
	{
		var dic = %[];

		dic.inverse = inverse;
		dic.setInverseFlag = setInverseFlag;

		if(mp !== void){
			dic.mp = %[];
			(Dictionary.assign incontextof dic.mp)(mp);
		}else{
			dic.mp = void;
		}

		dic.conductor = conductor.store();

		if(loadParams !== void){
			dic.loadParams = %[];
			(Dictionary.assign incontextof dic.loadParams)(loadParams);
		}else{
			dic.loadParams = void;
		}

		if(colorParams !== void){
			dic.colorParams = %[];
			(Dictionary.assign incontextof dic.colorParams)(colorParams);
		}else{
			dic.colorParams = void;
		}

		dic.waitUntil = [];
		dic.waitUntil.assignStruct(waitUntil);

		if(onTriggerTarget !== void){
			dic.onTriggerTarget = %[];
			(Dictionary.assign incontextof dic.onTriggerTarget)(onTriggerTarget);
		}else{
			dic.onTriggerTarget = void;
		}

		dic.graphic = graphic;
		dic.asd = asd;
		dic.orgGraphic = orgGraphic;
		dic.noHeaderGraphicName = noHeaderGraphicName;
		dic.orgAsd = orgAsd;

		dic.dispLeft = dispLeft;
		dic.dispTop = dispTop;

		dic.left = left;
		dic.top = top;
		dic.width = width;
		dic.height = height;
		dic.dispWidth = dispWidth;
		dic.dispHeight = dispHeight;
		dic.imageWidth = imageWidth;
		dic.imageHeight = imageHeight;
		dic.opacity = opacity;
		dic.visible = visible;
		dic.imageLeft = imageLeft;
		dic.imageTop = imageTop;
		dic.absolute = absolute;
		dic.type = type;
		dic.noZoom = noZoom;

		dic.asdWidth = asdWidth;
		dic.asdHeight = asdHeight;

		dic.layers = [];
		for(var i=0; i<layers.count; i++){
			dic.layers[i] = layers[i].store();
		}

		dic.zoomMode = zoomMode;
		dic.dispZoomRate = dispZoomRate;
		dic.internalZoomRate = internalZoomRate;

		dic.opacity2 = opacity2;
		dic.dOpacity2 = dOpacity2;
		dic.asdOpacity = asdOpacity;

		return dic;
	}

	function restore(dic)
	{
		inverse = dic.inverse;
		setInverseFlag = dic.setInverseFlag;

		if(dic.loadParams !== void){
			loadParams = %[];
			(Dictionary.assign incontextof loadParams)(dic.loadParams);
		}
		if(dic.colorParams !== void){
			colorParams = %[];
			(Dictionary.assign incontextof colorParams)(dic.colorParams);
		}
		if(dic.mp !== void) (Dictionary.assign incontextof mp)(dic.mp);

//		if(dic.graphic !== void) dic.graphic = dic.graphic;
		if(dic.orgGraphic !== void) orgGraphic = dic.orgGraphic;
		if(dic.noHeaderGraphicName !== void) noHeaderGraphicName = dic.noHeaderGraphicName;
		if(dic.orgAsd !== void) orgAsd = dic.orgAsd;
		asd = dic.asd;

		if(dic.asdWidth !== void){
			asdWidth = dic.asdWidth;
		}else{
			asdWidth = dic.width;
		}
		if(dic.asdHeight !== void){
			asdHeight = dic.asdHeight;
		}else{
			asdHeight = dic.height;
		}
		noZoom = false;
		if(dic.noZoom !== void) noZoom = dic.noZoom;
		graphic = noHeaderGraphicName;
//dm("■ restore noHeaderGraphicName : "+ noHeaderGraphicName);
		if(!noZoom) graphic = checkImageAndSetZoom(graphic);
//dm("■ restore graphic : "+ graphic);


		if(graphic !== void){
			loadImagesSub(graphic, loadParams);
		}

		try{
			conductor.restore(dic.conductor);
		}catch(e){}

//		internalZoomRate = dic.internalZoomRate;
		internalWidth = int(asdWidth * internalZoomRate);
		internalHeight = int(asdHeight * internalZoomRate);
		dispWidth = int(asdWidth * dispZoomRate);
		dispHeight = int(asdHeight * dispZoomRate);
		setSize(dispWidth, dispHeight);

		if(dic.dispLeft !== void){
			dispLeft = dic.dispLeft;
		}else{
			dispLeft = -dic.imageLeft;
		}
		if(dic.dispTop !== void){
			dispTop = dic.dispTop;
		}else{
			dispTop = -dic.imageTop;
		}

		if(!zoomMode){
			try{
				setImagePos(-int((dispLeft*internalZoomRate)/internalWidth)*internalWidth, -int(dispTop*internalZoomRate/internalHeight)*internalHeight);
			}catch(e){
				dm(e.message);
				dm("asd : " + asd + " / graphic : " + graphic + " / imageWidth : " + imageWidth + " / internalWidth : " + internalWidth + " / dispWidth : " + dispWidth + " / dispLeft : " + dispLeft + " / dl : " + ((dispLeft*internalZoomRate)/internalWidth)*internalWidth );
			}
		}else{
			try{
				setImagePos(0, 0);
				stretchCopy(0, 0, dispWidth, dispHeight, bufLayer, int((dispLeft*internalZoomRate)/internalWidth)*internalWidth, int(dispTop*internalZoomRate/internalHeight)*internalHeight, internalWidth, internalHeight, stNearest);
			}catch(e){
				dm(e.message);
				dm("asd : " + asd + " / graphic : " + graphic + " / imageWidth : " + imageWidth + " / internalWidth : " + internalWidth + " / dispWidth : " + dispWidth + " / dispLeft : " + dispLeft + " / dl : " + ((dispLeft*internalZoomRate)/internalWidth)*internalWidth );
			}
		}

		left = dic.left;
		top = dic.top;

		opacity = dic.opacity;
		visible = dic.visible;

		if(dic.opacity2 !== void) opacity2 = dic.opacity2;
		if(dic.dOpacity2 !== void) dOpacity2 = dic.dOpacity2;
		if(dic.asdOpacity !== void) asdOpacity = dic.asdOpacity;

		absolute = dic.absolute;
		type = dic.type;

		for(var i=0; i<dic.layers.count; i++){
			var l = new .SpriteLayer(window, this, this, root);
			l.restore(dic.layers[i]);
			layers.add(l);
		}

		waitUntil = [];
		waitUntil.assignStruct(dic.waitUntil);

		if(dic.onTriggerTarget !== void) (Dictionary.assign incontextof onTriggerTarget)(dic.onTriggerTarget);

		if(typeof(parent.objectClass) == 'undefined' && conductor.running){
			conductor.start();
			conductor.frameProcess();
		}

		if(setInverseFlag){
			setInverseFlag = false;
			setInverse();
		}
	}

	function tag_dispsize(elm)
	{
		asdWidth = +elm.width;
		asdHeight = +elm.height;

		internalWidth = int(asdWidth * internalZoomRate);
		internalHeight = int(asdHeight * internalZoomRate);

		dispWidth = int(asdWidth * dispZoomRate);
		dispHeight = int(asdHeight * dispZoomRate);

		setSize(dispWidth, dispHeight);

//		if(imageWidth % asdWidth != 0){
//			dm("■" + asd + " : " + conductor.curLine + " / graphic : " + graphic + " / 指定サイズがおかしい？" + " / imageWidth : " + imageWidth + " / asdWidth : " + asdWidth);
//		}

//if(graphic===void){
//	fillRect(0,0,dispWidth,dispHeight,0x8800ff00);
//	visible = true;
//	opacity = 255;
//}

		if(zoomMode){
			stretchCopy(0, 0, dispWidth, dispHeight, bufLayer, 0, 0, internalWidth, internalHeight, stNearest);
		}

		if(setInverseFlag) setInverse();
		setInverseFlag = false;
	}

	function tag_disp(elm)
	{
		if(elm.left!==void){
			dl = +elm.left;
			dispLeft = dl * asdWidth;
		}
		if(elm.top!==void){
			dt = +elm.top;
			dispTop = dt * asdHeight;
		}
		if(elm.left!==void || elm.top!==void){
			if(!zoomMode){
				try{
					setImagePos(-int((dispLeft*internalZoomRate)/internalWidth)*internalWidth, -int(dispTop*internalZoomRate/internalHeight)*internalHeight);
				}catch(e){
					dm(e.message);
					dm("asd : " + asd + " / graphic : " + graphic + " / imageWidth : " + imageWidth + " / internalWidth : " + internalWidth + " / dispWidth : " + dispWidth + " / dispLeft : " + dispLeft + " / dl : " + int((dispLeft*internalZoomRate)/internalWidth) );
					dm("imageHeight : " + imageHeight + " / internalHeight : " + internalHeight + " / dispHeight : " + dispHeight + " / dispTop : " + dispTop + " / dt : " + int((dispTop*internalZoomRate)/internalHeight) );
					dm("index : " + bao.getIndex(owner) + " / cosState : " + owner.cosState + " / currentLine : " + conductor.curLine);
				}
			}else{
				setImagePos(0, 0);
				stretchCopy(0, 0, dispWidth, dispHeight, bufLayer, int((dispLeft*internalZoomRate)/internalWidth)*internalWidth, int(dispTop*internalZoomRate/internalHeight)*internalHeight, internalWidth, internalHeight, stNearest);
			}
		}
		if(elm.leftpix!==void) dispLeft = +elm.leftpix;
		if(elm.toppix!==void) dispTop = +elm.toppix;
		if(elm.leftpix!==void || elm.toppix!){
			if(!zoomMode){
				setImagePos(-dispLeft*internalZoomRate, -dispTop*internalZoomRate);
			}else{
				stretchCopy(0, 0, dispWidth, dispHeight, bufLayer, dispLeft*internalZoomRate, dispTop*internalZoomRate, internalWidth, internalHeight, stNearest);
			}
		}
		if(elm.opacity !== void){
			asdOpacity = +elm.opacity;
			opacity = int(asdOpacity * opacity2/100);
		}

		if(setInverseFlag){
			setInverse();
		}
		setInverseFlag = false;
	}

	function tag_image(elm)
	{
		loadParams.inverse = inverse;
		// レイヤー画像の変更
		if(elm.storage!==void) loadImagesSub(elm.storage, loadParams);
	}

	function tag_playse(elm)
	{
		if(!bao.timer.enabled && typeof(global.dho) == 'undefined') return;

		// 効果音の再生
		var buf = +elm.buf;
		if((buf==2 || buf == 5) && tf.voiceLessMode) return;

		// バッファを順繰りでずらして使用する。
		if(buf==0||buf==1||buf==9||buf==10||buf==11||buf==12){
			buf = -1;
			// 同じSEが重複して鳴るとエコーっぽくなってウザいのでそうしないための仕掛け
			if(bao.seStorage[0]  == elm.storage) buf = 0;
			if(bao.seStorage[1]  == elm.storage) buf = 1;
//			if(bao.seStorage[9]  == elm.storage) buf = 9;
			if(bao.seStorage[10] == elm.storage) buf = 10;
			if(bao.seStorage[11] == elm.storage) buf = 11;
			if(bao.seStorage[12] == elm.storage) buf = 12;

			if(buf < 0){
				switch (bao.seBuf){
					case 0:
						bao.seBuf = 1;
						break;
					case 1:
//						bao.seBuf = 9;
//						break;
//					case 9:
						bao.seBuf = 10;
						break;
					case 10:
						bao.seBuf = 11;
						break;
					case 11:
						bao.seBuf = 12;
						break;
					case 12:
						bao.seBuf = 0;
						break;
				}
				buf = bao.seBuf;
			}
		}
		bao.seStorage[buf] = elm.storage;

		var fs = (bao.fukidashi.showing)? 0.5: 1;
		var vol = 100 * fs;
		if(elm.volume!==void) vol = (+elm.volume) * fs;

		window.se[buf].play(elm, false);
		window.se[buf].volume = vol;
	}

	function tag_playdamagese(elm){
		if((owner.damage.kind & atkSlash)==atkSlash){
			tag_playse(%["storage"=>damageSeSlash]);
		}else{
			tag_playse(%["storage"=>damageSeNormal]);
		}
	}

	function tag_playguardse(elm){
		if((owner.damage.kind & atkSlash)==atkSlash){
			tag_playse(%["storage"=>guardSeSlash]);
		}else{
			tag_playse(%["storage"=>guardSeNormal]);
		}
	}

	function tag_voice(elm)
	{
		if(tf.voiceLessMode) return;

		if(elm.buf === void){
			if(owner.objectClass == clPlayer){
				elm.buf = (owner.chara == 0)? 2 : 5;
				if(elm.target === void) elm.target = owner.chara;
			}else{
				elm.buf = 3;
			}
		}
		if(elm.target !== void && !elm.forced && bao.fukidashi.showing) return;
		tag_playse(elm);
	}


	function addLayer(elm){
		if(elm.storage !== void){
			var l = new .SpriteLayer(window, this, this, root);
			if(elm.inverse !== void){
				if(inverse) elm.inverse = true;
			}
			l.loadImages(elm);
			l.name = "layers[" +layers.count + "] : " + elm.storage;
			l.absolute = layers.count;
			layers.add(l);
//dm("elm.inverse : " + elm.inverse);
//dm("l.inverse : " + l.inverse);
			if(elm.inverse !== void) l.inverse = elm.inverse;
			if(elm.exp !== void) l.conductor.executeEval(elm);
		}
	}

	function delLayer(elm){
		if(elm.id !== void){
			invalidate layers[+elm.id];
			if(+elm.id<layers.count){
				layers.erase(+elm.id);
			}
		}
	}

}


class SpriteLayer extends FrameAnimeLayer
{
	var rectLayer = void;
	var rectLayerDraw = false;

	var triggerRect = %[];

	// asd中の[move]を無視するかどうか
	var ignoreMoveTag = false;

	function SpriteLayer(window, parent, owner, root)
	{
		// AnimationLayer コンストラクタ
		super.FrameAnimeLayer(...); // スーパークラスのコンストラクタを呼ぶ
	}

	function finalize()
	{
		super.finalize(...);
		if(rectLayer !== void && isvalid rectLayer){
			invalidate rectLayer;
		}
	}

	function onRefreshFrame(){
		super.onRefreshFrame();

		if(debugMode){
			if(rectLayer === void || !isvalid rectLayer){
				rectLayer = new .Layer(window, root.srcLayer);
				rectLayer.opacity = 256;
				rectLayer.visible = true;
				rectLayer.setSize(root.width, root.height);
			}

			if(rectLayerDraw){
				rectLayer.fillRect(0, 0, rectLayer.width, rectLayer.height, 0x00000000);
			}

			if(typeof owner.hitRect != 'undefined' && !owner.hitRect.isEmpty()){
				var r = toGlobalRect2(owner.hitRect);
				r.multi(root.cZoomRate);
				rectLayer.colorRect(r.left, r.top, r.width, r.height, 0xff0000, 64);
				invalidate r;
				rectLayerDraw = true;
			}

			if(typeof owner.attackRect != 'undefined' && !owner.attackRect.isEmpty()){
				var r = toGlobalRect2(owner.attackRect);
				r.multi(root.cZoomRate);
				rectLayer.colorRect(r.left, r.top, r.width, r.height, 0x0000ff, 64);
				invalidate r;
				rectLayerDraw = true;
			}
		}else{
			if(rectLayer !== void && isvalid rectLayer){
				invalidate rectLayer;
			}
		}
	}

	function loadImages(elm)
	{
		triggerRect = %[];
		if(elm.staymove === void || elm.staymove==false){
			owner.movingLastTarget = void;
			owner.movingTable = [];
		}

		super.loadImages(...);
	}

	function setOnTrigger(elm)
	{
		if(elm.target === void){
			dm("targetが指定されていません。");
		}else{
			super.setOnTrigger(elm);
			if(elm.rect !== void){
				var r = new Rect2();
				r.setFromStr(elm.rect);
				triggerRect[elm.name] = r;
			}
		}
	}

	function clearTrigger(name){
		if(onTriggerTarget[name] !== void){
			onTriggerTarget[name] = void;
			delete triggerRect[name];
		}
	}

	function store()
	{
		var dic = super.store();

		if(onTriggerTarget !== void){
			dic.onTriggerTarget = %[];
			(Dictionary.assign incontextof dic.onTriggerTarget)(onTriggerTarget);
		}else{
			dic.onTriggerTarget = void;
		}

		if(triggerRect !== void){
			dic.triggerRect = %[];
			var ary = [];
			ary.assign(triggerRect);
			for(var i=0; i<ary.count; i+=2){
				dic.triggerRect[ary[i]] = ary[i+1].store();
			}
		}else{
			dic.triggerRect = void;
		}

		dic.ignoreMoveTag = ignoreMoveTag;

		return dic;
	}

	function restore(dic)
	{
		if(dic.triggerRect !== void){
			var ary = [];
			ary.assign(dic.triggerRect);
			for(var i=0; i<ary.count; i+=2){
				var r = new Rect2();
				r.restore(ary[i+1]);
				triggerRect[ary[i]] = r;
			}
		}

		ignoreMoveTag = dic.ignoreMoveTag;

		super.restore(dic);
	}

	function  tag_centerpos(elm)
	{
		if(elm.pos !== void){
			if(inverse){
				owner.centerPos = asdWidth - elm.pos;
			}else{
				owner.centerPos = +elm.pos;
			}
		}else{
			owner.centerPos = asdWidth / 2;
		}
	}

	function tag_dispsize(elm)
	{
		super.tag_dispsize(...);

		if(elm.centerpos !== void){
			if(inverse){
				owner.centerPos = asdWidth - elm.centerpos;
			}else{
				owner.centerPos = +elm.centerpos;
			}
		}else{
			owner.centerPos = asdWidth / 2;
		}
		if(elm.baseline !== void){
			owner.baseLine = +elm.baseline;
		}else{
			owner.baseLine = 0;
		}
		if(elm.shadowoffset !== void){
			owner.shadowOffset = +elm.shadowoffset;
		}else{
			owner.shadowOffset = 0;
		}
		if(elm.indicatoroffset !== void){
			owner.selectIndicatorOffset = +elm.indicatoroffset;
		}else{
			owner.selectIndicatorOffset = 0;
		}

		if(typeof owner.footRect!='undefined' && owner.footRect.isEmpty()) owner.footRect.set(asdWidth\5, asdHeight-4, (asdWidth\5)*4, asdHeight-3);
	}

	function tag_state(elm)
	{
		owner.noGravity = false;
		owner.ignoreMovableRect = false;
		owner.enableDoubleJump = false;
		owner.enableCounter = false;
		if(elm.enablemove !== void) owner.enableMove = +elm.enablemove;
		if(elm.enableattack !== void){
			owner.enableAttack = +elm.enableattack;
			owner.enableCommand = +elm.enableattack;
		}
		if(elm.enablecommand !== void) owner.enableCommand = +elm.enablecommand;
		if(elm.enabledoublejump !== void) owner.enableDoubleJump = +elm.enabledoublejump;
		if(elm.enablecounter !== void) owner.enableCounter = +elm.enablecounter;
		if(elm.nogravity !== void) owner.noGravity = +elm.nogravity;
		if(elm.ignoremovablerect !== void) owner.ignoreMovableRect = +elm.ignoremovablerect;
		if(elm.floorobjectcollision !== void) owner.floorObjectCollision = +elm.floorobjectcollision;

		if(elm.inversemode !== void) owner.inverseMode = +elm.inversemode;
		if(elm.nozoom !== void) resumeZoom();

		owner.otherState = "";
		if(elm.other !== void) owner.otherState = elm.other.toLowerCase();
	}

	function tag_foot(elm)
	{
		owner.footRect.setFromStr(elm.rect);
		// 現在のところ、footタグで指定してもtopとbottomは無視している
		owner.footRect.top =  asdHeight - 5;
		owner.footRect.bottom = asdHeight - 3;

		if(owner.inverse) owner.footRect.inverse(asdWidth, asdHeight);
	}

	function tag_hit(elm)
	{
		owner.hitRect.setFromStr(elm.rect);
		if(owner.inverse) owner.hitRect.inverse(asdWidth, asdHeight);
		owner.damageRate = 1;
		if(elm.damagerate !== void) owner.damageRate = +elm.damagerate;
//		if(debugMode) rectLayer.fillRect(owner.hitRect.left, owner.hitRect.top, owner.hitRect.width, owner.hitRect.height, 0x88ff0000);
	}

	function tag_attack(elm)
	{
		owner.attackRect.setFromStr(elm.rect);
		if(inverse) owner.attackRect.inverse(asdWidth, asdHeight);
		if(elm.strength !== void) owner.attack.strength = +elm.strength;
		if(elm.depth !== void){
			var array = [].split("(), ", elm.depth, , true);
			owner.depth1 = +array[0];
			owner.depth2 = +array[1];
		}else{
			owner.depth1 = owner.depth2 = owner.depth / 2;
		}
		if(elm.kind !== void) owner.attack.kind = Scripts.eval(elm.kind);
		if(elm.tags !== void) owner.attack.tags = elm.tags;
		if(elm.exp !== void){
			owner.attack.exp = elm.exp;
		}
		if(elm.expcond !== void){
			owner.attack.expcond = elm.expcond;
		}
		if(elm.score !== void) owner.attack.score = elm.score; else owner.attack.score = 100;
		owner.attack.tick = owner.owner.tickCount;
//		if(debugMode) rectLayer.fillRect(owner.attackRect.left, owner.attackRect.top, owner.attackRect.width, owner.attackRect.height, 0x880000ff);
	}

	function tag_disp(elm)
	{
		super.tag_disp(...);

		owner.clearCollisionRect();
		if(elm.shadow!==void){
			owner.shadowSize = +elm.shadow;
		}else{
			owner.shadowSize = asdWidth;
		}
	}

	function tag_load(elm)
	{
		ignoreMoveTag = false;
		if(elm.ignoremovetag !== void) ignoreMoveTag = +elm.ignoremovetag;

		// 新しいスプライト画像の読み込み
		if(owner.inverse) elm.inverse = true;
		if(elm.target !== void) elm.label = elm.target;
		if(elm.id !== void) owner.loadSprite(Scripts.eval(elm.id), +elm.staymove, elm.label);
		if(elm.storage !== void) owner.loadImages(elm);
	}

	function tag_image(elm)
	{
//dm("elm.storage : " + elm.storage + " / elm.num : " + elm.num + " / elm.id : " + elm.id + " / asd : " + asd + " / orgGraphic : " + orgGraphic + " / cosState : " + owner.cosState);
		// レイヤー画像の変更
		loadParams.inverse = inverse;
		if(elm.storage!==void){
			orgGraphic = graphic = noHeaderGraphicName = elm.storage;
			graphic = checkImageAndSetZoom(graphic);
			loadImagesSub(graphic, loadParams);
		}
		if(elm.num!==void){
			if(elm.id===void){
				if(orgGraphic !== void){
					noHeaderGraphicName = orgGraphic + "_" + elm.num;
				}else{
					orgGraphic = asd;
					noHeaderGraphicName = orgGraphic + "_" + elm.num;
				}
			}else{
				var id = Scripts.eval(elm.id);
				if(typeof owner.sprites[id] == "Object"){
					elm.storage = owner.sprites[id][owner.cosState];
				}else{
					elm.storage = owner.sprites[id];
				}
//				orgGraphic = elm.storage;
				noHeaderGraphicName = elm.storage + "_" + elm.num;
			}

			graphic = checkImageAndSetZoom(noHeaderGraphicName);
//dm("■asd : "+ asd + " / orgGraphic : " + orgGraphic + " / graphic : " + graphic + " / noHeaderGraphicName : " + noHeaderGraphicName);
			loadImagesSub(graphic, loadParams);
		}else if(elm.id!==void){
			var id = Scripts.eval(elm.id);
			if(typeof owner.sprites[id] == "Object"){
				elm.storage = owner.sprites[id][owner.cosState];
			}else{
				elm.storage = owner.sprites[id];
			}

			noHeaderGraphicName = elm.storage;
			graphic = checkImageAndSetZoom(noHeaderGraphicName);
//dm("■asd : "+ asd + " / orgGraphic : " + orgGraphic + " / graphic : " + graphic + " / noHeaderGraphicName : " + noHeaderGraphicName);
			loadImagesSub(graphic, loadParams);
		}

		if(typeof owner.footRect!='undefined') owner.footRect.clear();
	}

	function tag_move(elm)
	{
		// ignoreMoveが指定されていたら処理しない
		if(ignoreMoveTag) return 0;

		// 移動用テーブルの作成
		owner.toGround = false;
		owner.setMovingTable(elm, owner.movingTable);
	}

	function tag_del(elm)
	{
		// 削除
		owner.onDeleteTag();
		owner.deleteFlag = true;
		if(typeof owner.atDeleteExp=="undefined") return;
		if(owner.atDeleteExp != "") conductor.executeEval(%[exp:owner.atDeleteExp]);
		if(owner.atDeleteTag != "") owner.addQueue(owner.atDeleteTag);
	}

	function tag_playse(elm)
	{
		// 効果音の再生
		var buf = +elm.buf;
		var vol = 100;
		var fs = (bao.fukidashi.showing)? 0.5: 1;
		if(elm.volume!==void) vol = +elm.volume;

		super.tag_playse(...);

		// 画面外で発生した音は小さくする
		if(typeof(owner.rootX)!="undefined"){
			var x = owner.rootX;
			var w = bao.internalWidth;

			var v;
			if(buf>=2 && buf<=6){
				if(sf.voiceSetting3[getVoiceIndex(elm.storage[0])]){
					v = f.volumeMatrix[sf.actVoiceVolume] * sf.voiceVolume2[getVoiceIndex(elm.storage[0])] * fs / 10000;
				}else{
					v = 0;
				}
			}else{
				v = 1 * fs ;
			}

			if(-100<x && x<w+100){
				window.se[buf].volume = int(100 * v) * (vol / 100);
			}else if(x < -200 || x > w+200){
				window.se[buf].volume = 0;
			}else{
				if(x < 0){
					window.se[buf].volume = int((200 + x) * v) * (vol / 100);
				}else{
					window.se[buf].volume = int((200 + (x-w)) * v) * (vol / 100);
				}
			}
		}else{
			window.se[buf].volume = vol * fs ;
		}

	}


	function tag_fosize(elm)
	{
		// FloorObject用
		if(elm.depth !== void) owner.objDepth = +elm.depth;
		if(elm.height !== void) owner.objHeight = +elm.height;

		if(owner.objDepth>0) owner.setBaseLayer();
		if(+elm.cancelhoffset) {
			owner.hOffset = 0;
		}else{
			owner.hOffset = owner.objHeight + owner.objDepth - asdHeight;
		}
	}

//	function tag_fosize(elm)
//	{
//		// FloorObject用
//		if(elm.depth !== void) owner.objDepth = +elm.depth;
//		if(elm.height !== void) owner.objHeight = +elm.height;
//
//		if(owner.objDepth>0) owner.setBaseLayer();
//	}

	function tag_fosetcommand(elm)
	{
		// FloorObject用
		if(elm.tags !== void) owner.tags = elm.tags;
	}

	function tag_collision(elm){
		// FloorObject用
		if(elm.player !== void) owner.collisionPlayer = +elm.player;
		if(elm.enemy !== void) owner.collisionEnemy = +elm.enemy;
		if(elm.object !== void) owner.collisionObject = +elm.object;
	}

	function clearCollisionRect()
	{
	}

	function toGlobalRect(rect)
	{
		var r = new Rect2(left/root.cZoomRate+rect.left, top/root.cZoomRate+rect.top, left/root.cZoomRate+rect.right, top/root.cZoomRate+rect.bottom);
		return r;
	}

	function toGlobalRect2(rect)
	{
		var l = owner.rootX - owner.centerPos;
		var t = owner.rootY - owner.altitude - asdHeight + owner.baseLine;

		var r = new Rect2(l+rect.left, t+rect.top, l+rect.right, t+rect.bottom);
		return r;
	}

}


class Sprite
{
	var window;
	var owner;
	var layer;

//	// 現在表示中のスプライトの幅と高さ
//	var width;
//	var height;

	// スクリプトによる制御用キュー
	var scriptQueue = [];
	var queueWaitFrame = 0;
	var queueWaitStanding = false;
	var queueStop = false;

	// 逆（右）を向いているかどうか（左向きが基本）
	var inverse = false;

	// 削除フラグ
	var deleteFlag = false;
	// 削除時実行コマンド
	var atDeleteExp = "";
	var atDeleteTag = "";

	var fixedAbsolute = 0;

	var noRestoreFlag = false;

	// トリガー発動したオブジェクト
	var triggeredBy = void;
	var triggeredBy_reference;

	var objectClass = clOther;

	// スクリプトによって操作中であるか
	var movingByScript = false;

	function Sprite(window, owner, elm)
	{
		this.window = window;
		this.owner = owner;

		layer = new SpriteLayer(window, owner.srcLayer, this, owner);
		layer.visible = false;
		if(elm.inverse === void) elm.inverse = false;

		if(elm !== void){
			layer.colorParams = %[];
			(Dictionary.assign incontextof layer.colorParams)(elm);

			if(elm.type !== void) layer.type = elm.type;
			if(elm.visible !== void) layer.visible = +elm.visible;
		}

		layer.type = dfAuto;
		loadImages(elm);

		if(elm.atdelexp !== void) atDeleteExp = elm.atdelexp;
		if(elm.atdeltag !== void) atDeleteTag = elm.atdeltag;

		if(elm.exp !== void) executeEval(elm);

	}

	function finalize()
	{
		layer.visible = false;
		invalidate layer;
		delete layer;
	}

	function loadImages(elm){
		if(elm.inverse === void){
			inverse = false;
		}else{
			inverse = +elm.inverse;
		}
		layer.loadImages(elm);
	}

	function onRefreshFrame(){
		layer.onRefreshFrame();
	}

	function addQueue(str)
	{
		var ary = str.split("[]",, true);
		for(var i=0; i<ary.count; i++){
//			dm("■ary[" + i + "] : " + ary[i]);
			scriptQueue.add(ary[i].trim());
		}
	}

	function executeQueue()
	{
		while(scriptQueue.count!=0){
			var dic = str2dic(scriptQueue.shift());

			var array = [];
			array.assign(dic);
//			dm("scriptQueue.count : "+scriptQueue.count);
//			for(var i=0; i<array.count; i+=2){
//				dm(array[i] + " : " + array[i+1]);
//			}

			switch(dic.tagname){
				case "eval":
//					Scripts.eval(dic.exp,,,this);
					executeEval(dic);
					break;
				case "trigger":
					var o = owner.getObject(dic);
					o.layer.trigger(dic.name, this);
					break;
				case "wait":
					if(dic.frame !== void) queueWaitFrame = +dic.frame;
					return;
				case "waitaction":
					queueWaitStanding = true;
					return;
				case "stop":
				case "s":
					queueWaitFrame = 0;
					queueStop = true;
					return;
				case "move":
					layer.ignoreMoveTag = false;
					if(dic.ignoremovetag !== void) layer.ignoreMoveTag = +dic.ignoremovetag;

					movingByScript = true;
					setMoveByScript(dic);
					break;
				case "load":
					layer.ignoreMoveTag = false;
					if(dic.ignoremovetag !== void) layer.ignoreMoveTag = +dic.ignoremovetag;

					if(dic.id !== void) loadSprite(Scripts.eval(dic.id), +dic.staymove, dic.label);
					if(dic.storage !== void){
						dic.inverse = inverse;
						loadImages(dic);
					}
					break;
				case "object":
					owner.setObject(dic);
					break;
				case "playse":
					layer.tag_playse(dic);
					break;
				case "state":
					setState(dic);
					break;
				case "run":
					owner.scenarioRun();
					break;
			}
		}
	}

	function executeEval(elm)
	{
////		var f = Scripts.eval("function(){" + elm.exp + ";}");
////		(f incontextof this)();
//		Scripts.eval(elm.exp,,,this);
		layer.conductor.executeEval(...);
	}

	function resumeQueue()
	{
		queueStop = false;
	}

	function clearCollisionRect()
	{
	}

	function setState(elm)
	{
		if(elm.visible !== void) layer.visible = +elm.visible;
		if(elm.inverse !== void){
			inverse = +elm.inverse;
			if(inverse != layer.inverse) layer.setInverse();
		}
		if(elm.exp !== void){
			executeEval(elm);
		}
		if(elm.atdelexp !== void) atDeleteExp = elm.atdelexp;
		if(elm.absolute !== void) {
			layer.absolute = fixedAbsolute = +elm.absolute;
		}
	}

	function onDeleteTag()
	{
	}

	function store()
	{
		var dic = %[];

		dic.layer = layer.store();

//		dic.width = width;
//		dic.height = height;

		dic.scriptQueue = [];
		dic.scriptQueue.assignStruct(scriptQueue);
		dic.queueWaitFrame = queueWaitFrame;
		dic.queueWaitStanding = queueWaitStanding;
		dic.queueStop = queueStop;

		dic.inverse = inverse;

		dic.deleteFlag = deleteFlag;
		dic.atDeleteExp = atDeleteExp;
		dic.atDeleteTag = atDeleteTag;
		dic.movingByScript = movingByScript;

//		dic.triggeredByObjectClass = triggeredBy.objectClass;
//		dic.triggeredByIndex = bao.getObjectIndex(triggeredBy);

		if(triggeredBy !== void && isvalid triggeredBy){
			triggeredBy_reference = new ObjectReference(triggeredBy);
			dic.triggeredBy_reference = triggeredBy_reference.store();
		}

		dic.noRestoreFlag = noRestoreFlag;

		return dic;
	}

	function restore(dic)
	{
		if(dic.noRestoreFlag!==void && dic.noRestoreFlag){
			dic.deleteFlag = true;
			return;
		}

		layer.restore(dic.layer);

//		width = dic.width;
//		height = dic.height;

		scriptQueue = [];
		scriptQueue.assignStruct(dic.scriptQueue);
		queueWaitFrame = dic.queueWaitFrame;
		queueWaitStanding = dic.queueWaitStanding;
		queueStop = dic.queueStop;

		inverse = dic.inverse;
		if(inverse !== layer.inverse){
			layer.inverse = inverse;
			layer.execInverse();
		}

		deleteFlag = dic.deleteFlag;
		atDeleteExp = dic.atDeleteExp;
		atDeleteTag = dic.atDeleteTag;
		movingByScript = dic.movingByScript;

//		triggeredBy = dic.triggeredBy;
		if(dic.triggeredBy_reference !== void){
			triggeredBy_reference = new ObjectReference(dic.triggeredBy_reference);
//			triggeredBy = triggeredBy_reference.getObject();
		}else{
			triggeredBy_reference = void;
		}

	}

	function restore2()
	{
		if(triggeredBy_reference !== void){
			triggeredBy = triggeredBy_reference.getObject();
			invalidate triggeredBy_reference;
			triggeredBy_reference = void;
		}
	}


}


class CharacterSprite extends Sprite
{

	var kind = "";
	var name = "";

	var params;

	// フィールドにおけるこのスプライトの基準点（足位置）の座標
	var rootX;
	var rootY;
	// 地上高（ジャンプしたとき等のrootYからの距離）
	var altitude = 0;
	var vOffset = 0;

	var fAltitude = 0;

	// 表示するスプライトの中心位置
	var centerPos;
	var baseLine;

	// z方向の攻撃判定幅
	var depth = 16;
	var depth1; // 手前方向
	var depth2; // 奥方向

	var attackRect;
	var hitRect;
	var footRect;

	// 与える攻撃
	var attack;
	// 受けた攻撃
	var damage;
	// ダメージ倍率
	var damageRate;
	//
	var damageFrom;
	var damageFromStr = "";

	// 移動できる状態か
	var enableMove = false;
	// 攻撃可能な状態か
	var enableAttack = false;
	// コマンド技が可能な状態か
	var enableCommand = false;
	// 二段ジャンプが可能な状態か
	var enableDoubleJump = false;
	// 反撃可能な状態か
	var enableCounter = false;

	// その他の状態
	var otherState = "";

	var bEnableMove = false;
	var bEnableAttack = false;
	var bEnableCommand = false;
	var bEnableDoubleJump = false;
	var bEnableCounter = false;
	var bOtherState = "";
	var bNoGravity = false;

	// その他の状態
	var otherState = "";

	// 自由に移動できるか（スクリプトに拘束されないか）
	var enableFreeMove = false;

	// 移動速度
	var moveSpeed = 1.0;
	// 移動可能範囲
	var movableRect;

	// 移動用テーブル
	var movingTable = [];
	var movingLastTarget;
	var lastMovingTable;

	// 待機状態
	var waiting = false;

	var toGround = false;
	var noGravity = false;
	var ignoreMovableRect = false;

//	var tickCount = 0;

	var attackIndex = 0;
	var attackTick = 0;
	var attackIndexCountUpTick = 0;

	// 体力・魔力
	var maxHP;
	var maxMP;
	var HP;
	var MP;
	var recoveryMP = 0;

	// 無敵時間
	var invincibleCount = 0;
	// （主人公に）掴まれることが可能かどうか
	var enableClinched = true;

	// 常に主人公の方を向くかどうか
	var inverseMode = true;

	// パターン格納用
	var sprites = [];
	var cosState = 0;

	// その画像を読み込んでからのフレーム数
	var frameCount = 0;

	// 現在のスプライトファイル
	var nowSpriteId = 0;
	var nowSpriteFile = "";

	// 一つ前のスプライトファイル
	var lastSpriteId = 0;
	var lastSpriteFile = "";

	// floorObjectの上に乗っている場合
	var onFloorObject;

	// 影サイズ
	var shadowSize;
	var shadow = true;
	var shadowStorage = "";
	var shadowOffset = 0;
	var shadowOpacity = 255;

	//
	var hScrollVal = 0;
	var vScrollVal = 0;

	// スクロールを無視するか
	var ignoreScroll = false;

	var lastAltitude = 0;

	var floorObjectCollision = true;

	var noStore = false;

	var parentSprite = void;
	var parentSprite_reference;
	var childSprites = [];
	var childSprites_reference = [];;

	var underFloorFlag = false;

	// 追撃について
	var pursueCount = 1;
	var pursueFrom = void;

	var noMaskByFloorLayer = false;

	// storeMovingTable==trueならmovingTableを貯めておく
	var movingTableBuffer = [];
	var storeMovingTable = false;

	// movingTableCopyFromのオブジェクトのmovingTableBufferをmovingTableに使用する
	var movingTableCopyFrom = void;
	var movingTableCopyIndex = 0;
	var lastX, lastY, lastA;

	var state = stateNormal;

	// lockedCount > 0 の間動けない
	var lockedCount = 0;
	var lockedChangeColor = false;

	function CharacterSprite(window, owner, elm)
	{
//		elm.storage = initialSprite;

		attackRect = new Rect2();
		hitRect = new Rect2();
		footRect = new Rect2();
		attack = new Attack();
		damage = new Attack();

		lastMovingTable = new MovingTable();

		super.Sprite(window, owner, elm);
		layer.name = name;

		params = %[];
		(Dictionary.assign incontextof params)(elm);

		toCache();
		adjustDisp();
	}

	function adjustDisp(){
		// 表示位置調整
		layer.left = internalLayerLeft * owner.cZoomRate;
		layer.top = internalLayerTop * owner.cZoomRate;
	}

	property internalLayerLeft{
		getter{
			return rootX - int(centerPos * layer.dispZoomRate / owner.cZoomRate);
		}
	}

	property internalLayerTop{
		getter{
			return rootY + baseLine - altitude + vOffset - layer.asdHeight * layer.dispZoomRate / owner.cZoomRate;
		}
	}

	function finalize()
	{
		if(parentSprite !== void && isvalid parentSprite){
			parentSprite.childSprites.remove(this);
		}

		super.finalize();

		invalidate attackRect;
		invalidate hitRect;
		invalidate footRect;
		invalidate attack;
		invalidate damage;

		invalidate parentSprite_reference;
		invalidate childSprites_reference;

		sprites = void;
	}

	function loadImages(elm){
		shadowStorage = "";
		if(elm.shadowstorage!==void) shadowStorage = elm.shadowstorage;
		lastSpriteFile = nowSpriteFile;
		nowSpriteFile = elm.storage;
		clearCollisionRect();
		super.loadImages(...);
		underFloorFlag = false;
	}

	function toCache(){
		if(typeof sprites[0] == "Object"){
			touchImages(sprites[cosState]);
		}else{
			touchImages(sprites);
		}
	}

	function touchImages(sp){
		var a = [];
		for(var i=0; i++; i<100){
			if(sp[i]!==void){
				System.touchImages(sp[i]);
			}
		}
	}

	function loadSprite(id=0, mode=false, label=""){
		frameCount = 0;
		if(typeof sprites != "Object") return;
		if(sprites[id] === void) return;
		lastSpriteId = nowSpriteId;
		nowSpriteId = id;
		footRect.clear();
		if(typeof sprites[id] == "Object"){
			// スプライト定義テーブルが配列になっている
			if(Storages.isExistentStorage(sprites[id][cosState]+".asd")){
				// 個別の定義ファイルがある
				loadImages(%["storage" => sprites[id][cosState], "graphic" => sprites[id][cosState], "inverse" => inverse, "staymove" => mode, "label" => label]);
			}else{
				// 個別の定義ファイルがない
				loadImages(%["storage" => sprites[id][0], "graphic" => sprites[id][cosState], "inverse" => inverse, "staymove" => mode, "label" => label]);
			}
		}else{
			// スプライト定義テーブルが配列になっていない
			loadImages(%["storage" => sprites[id], "inverse" => inverse, "staymove" => mode, "label" => label]);
		}
	}

	function onRefreshFrame(h, v){
		if(!ignoreScroll) hScrollVal = h;
		if(!ignoreScroll) vScrollVal = v;

		if(lockedCount == 0 && movingTableCopyFrom !== void && movingTableCopyFrom.movingTableBuffer[movingTableCopyIndex] !== void){
			movingTable[0].copy(movingTableCopyFrom.movingTableBuffer[movingTableCopyIndex]);
			movingTableCopyIndex ++;
//		}else{
//			movingTableCopyIndex = 0;
		}

		super.onRefreshFrame();
		routineProcess();

		if(invincibleCount > 0) invincibleCount--;
		if(lockedCount > 0){
			lockedCount--;
		}else{
			lockedCount = 0;
		}
		checkAttackCollision();

		vOffset -= vScrollVal;
		adjustDisp();

		if(storeMovingTable){
			var m = new MovingTable(rootX-lastX, rootY-lastY, altitude-lastA);
			movingTableBuffer.add(m);
//dm("store / x:" + movingTable[0].x + " / movingTableBuffer.count:" + movingTableBuffer.count);
		}
		lastX = rootX;
		lastY = rootY;
		lastA = altitude;
		if(movingTable.count>0 && lockedCount==0) movingTable.erase(0);

		if(footRect.isEmpty()){
			setAbsolute(int(rootY));
		}else{
			setAbsolute(int(rootY) - layer.asdHeight + footRect.bottom);
		}
	}

	function routineProcess(){
		if(!queueStop && queueWaitFrame==0 && scriptQueue.count>0){
			if(queueWaitStanding){
				if(nowSpriteId == stStanding || nowSpriteId == stStanding2 || nowSpriteId == stStanding3 || nowSpriteId == stClinching || nowSpriteId == stBackClinch){
					queueWaitStanding = false;
					executeQueue();
				}
			}else{
				executeQueue();
			}
		}
		if(queueWaitFrame > 0) queueWaitFrame--;
		frameCount++;

		if(enableMove){
			state = stateNormal;
		}else if(!attackRect.isEmpty()){
			state = stateAttack;
		}else if(HP <= 0){
			state = stateDead;
		}

		//オーバーライドする
	}

	function clearCollisionRect()
	{
		hitRect.clear();
//		footRect.clear();
		attackRect.clear();
		attack.clear();
	}

	function setState(elm)
	{
		super.setState(elm);

//		if(elm.rootx !== void){
//			if(elm.rootx == "left" || elm.rootx == "l"){
//				rootX = movableRect.left + 1;
//			}else if(elm.rootx == "right" || elm.rootx == "r"){
//				rootX = movableRect.right - 1;
//			}else{
//				rootX = +elm.rootx;
//			}
//		}
		if(elm.rootx !== void) rootX = +elm.rootx;
		if(elm.rooty !== void) rootY = +elm.rooty;
		if(elm.altitude !== void) altitude = +elm.altitude;

		if(elm.ax !== void) rootX = +elm.ax - owner.stageLayer.dispLeft;

		if(elm.maxhp !== void) maxHP = +elm.maxhp;
		if(elm.maxmp !== void) maxMP = +elm.maxmp;
		if(elm.hp !== void){
			HP = +elm.hp;
			if(HP > maxHP) HP = maxHP;
		}

		if(elm.mp !== void){
			MP = +elm.mp;
			if(MP > maxMP) MP = maxMP;
		}
		if(elm.addhp !== void){
			HP += +elm.addhp;
			if(HP > maxHP) HP = maxHP;
		}
		if(elm.addmp !== void){
			HP += +elm.addmp;
			if(HP > maxHP) HP = maxHP;
		}

		if(elm.enablemove !== void){
			enableFreeMove = +elm.enablemove;
			if(enableFreeMove){
				layer.ignoreMoveTag = false;
				scriptQueue.clear();
				queueWaitFrame = 0;
				queueStop = false;
			}
		}
		if(elm.shadow !== void) shadow = +elm.shadow;
		if(elm.inversemode !== void) inverseMode = +elm.inversemode;
		if(elm.nogravity !== void) noGravity = +elm.nogravity;
		if(elm.floorobjectcollision !== void) floorObjectCollision = +elm.floorobjectcollision;
		if(elm.ignoremovablerect !== void) ignoreMovableRect = +elm.ignoremovablerect;
		if(elm.parent !== void) parentSprite = elm.parent;
		if(elm.parentsprite !== void) parentSprite = elm.parentsprite;

	}


	function pathAbsoluteToRelative(p, dMode = false){

		var a = [];
		var tmp = [].split("(), ", p, , true);
		var path = "";

		if(dMode){
			a[0] = int(+tmp[0] - rootX);
		}else{
			a[0] = int(+tmp[0] - rootX) * xDirection(inverse);
		}

		a[1] = int(+tmp[1] - rootY);
		a[2] = int(+tmp[2] - altitude);
		path += "(" + a[0] + "," + a[1] + "," + a[2] + ")";

		for(var i=3;i<=tmp.count-3; i+=3){
			a[i] = int(+tmp[i] - tmp[i-3]);
			a[i+1] = int(+tmp[i+1] - tmp[i-2]);
			a[i+2] = int(+tmp[i+2] - tmp[i-1]);
			path += "(" + a[i] + "," + a[i+1] + "," + a[i+2] + ")";
		}

//dm("rootX :" + rootX + " / rootY : " + rootY + " / aa path : " + path);
		return path;
	}


	function setMoveByScript(elm)
	{
		// asd中のmoveタグを無視するかどうか
		if(+elm.ignoremovetag) layer.ignoreMoveTag = true;

		// 絶対座標指定の場合、相対指定に直す
		if(elm.mode !== void && elm.mode=="absolute" && +elm.spline==false){
			elm.path = pathAbsoluteToRelative(elm.path, true);
			elm.mode = void;
		}
		var a = [].split("(), ", elm.path, , true);

		if(+elm.spline){
			var tmp = [].split("(), ", elm.path, , true);
			elm.path = "";
			for(var i=0;i<tmp.count; i+=3){
				a[i] = int(+tmp[i] - rootX);
				a[i+1] = int(+tmp[i+1] - rootY);
				a[i+2] = int(+tmp[i+2] - altitude);
				elm.path += "(" + a[i] + "," + a[i+1] + "," + a[i+2] + ")";
			}
		}

		// 移動速度指定の場合、フレーム数を算出
		if(elm.speed !== void || elm.frame === void){
			var d = 0;
			for(var i=0;i<a.count; i+=3){
				d += Math.sqrt((a[i])*(a[i]) + (a[i+1])*(a[i+1]));
			}
			if(elm.speed === void){
				elm.frame = int(d / (moveSpeed));
			}else{
				elm.frame = int(d / (+elm.speed));
			}
		}
		if(elm.frame == 0) elm.frame = 1;

		scriptQueue.insert(0, "wait frame="+elm.frame);

		// trueの場合指定した方向へそのまま進む。falseの場合現在の向きに左右される。
		if(elm.dmode === void){
			elm.dmode = true;
		}else{
			elm.dmode = +elm.dmode;
		}

		if(elm.inversemode !== void){
			inverseMode = +elm.inversemode;
		}

		if(elm.frame === void || +elm.frame == 0){
			if(elm.dmode){
				rootX += a[0];
			}else{
				rootX += a[0] * xDirection(inverse);
			}
			rootY += a[1];
			altitude += a[2];
		}else{
			if(elm.add !==void && elm.add){
				var tmp = [];
				setMovingTable(elm, tmp, +elm.dmode);

//				for(var i=0; i<movingTable.count; i++){
//					dm("1 movingTable[" + i + "].x : " + movingTable[i].x + " / movingTable[" + i + "].y : " + movingTable[i].y + " / movingTable[" + i + "].h : " + movingTable[i].h);
//				}
//				dm("");

				for(var i=0; i<tmp.count; i++){
					if(movingTable[i] !== void){
						movingTable[i].add(tmp[i]);
//						dm("2 movingTable[" + i + "].x : " + movingTable[i].x + " / movingTable[" + i + "].y : " + movingTable[i].y + " / movingTable[" + i + "].h : " + movingTable[i].h);
					}else{
						if(tmp[i] !== void) movingTable.add(tmp[i]);
					}
				}
//				dm("");

//				for(var i=0; i<movingTable.count; i++){
//					dm("3 movingTable[" + i + "].x : " + movingTable[i].x + " / movingTable[" + i + "].y : " + movingTable[i].y + " / movingTable[" + i + "].h : " + movingTable[i].h);
//				}
			}else{
				movingTable = [];
				if(+elm.spline){
					setSplineMovingTable(elm, movingTable, elm.dmode);
				}else{
					setMovingTable(elm, movingTable, +elm.dmode);
				}
			}
		}

	}

	function getAltitude(x, y)
	{
//		return owner.stageLayer.getAltitude(x, y, objectClass);
		if(owner.stageLayer!==void){
			return owner.stageLayer.getAltitude(x, y, objectClass);
		}else{
			return 0;
		}
	}

	function getObject(x, y)
	{
//		return owner.stageLayer.getObject(x, y, objectClass);
		if(owner.stageLayer!==void){
			return owner.stageLayer.getObject(x, y, objectClass);
		}else{
			return void;
		}
	}

	function getFloorAltitude(x=rootX, y=rootY)
	{
		x = int x;
		y = int y;

		var fa1t = getAltitude(x-15, y-layer.asdHeight+footRect.top);
		var fa1b = getAltitude(x-15, y-layer.asdHeight+footRect.bottom);
		var fa1 = (fa1t > fa1b)? fa1t: fa1b;

		var fa2t = getAltitude(x+15, y-layer.asdHeight+footRect.top);
		var fa2b = getAltitude(x+15, y-layer.asdHeight+footRect.bottom);
		var fa2 = (fa2t > fa2b)? fa2t: fa2b;

		var fa3t = getAltitude(x, y-layer.asdHeight+footRect.top);
		var fa3b = getAltitude(x, y-layer.asdHeight+footRect.bottom);
		var fa3 = (fa3t > fa3b)? fa3t: fa3b;

		if(fa1 == fa2){
//			dm("fa1 : " + fa1 + " / fa2 : " + fa2 + " / fa3 : " + fa3);
			if(fa1 > fa3){
				return fa1;
			}else{
				return fa3;
			}
		}else{
//			dm("getAltitude(int rootX, (int rootY)-layer.asdHeight+footRect.top) : " + getAltitude(int rootX, (int rootY)-layer.asdHeight+footRect.top));
			return fa3;
		}
	}

	function checkFall(m)
	{

		fAltitude = getFloorAltitude();
		var mt = new MovingTable(m);

		if(mt.h <= 0){
			var d = altitude - fAltitude;
			if(toGround){
//dm(bao.tickCount + " altitude : " + altitude + " / fAltitude : " + fAltitude + " / mt.h : " + mt.h);
				// 地面に向けて落下中
				if(d == 0){
					// 着地
					altitude = (int) fAltitude;
					toGround = false;
					layer.trigger("landing", this);
					if(movingTable[0] !== void && isvalid movingTable[0]){
						for(var i=0; i<movingTable.count; i++){
							if(movingTable[i].h < 0){
								movingTable[i].h = 0;
							}else{
								break;
							}
						}
						mt = movingTable[0];
					}else{
						mt.reset();
					}
				}else if(d > 0){
					// 落下中
					if(mt.x == 0) mt.x = lastMovingTable.x;
					if(mt.h == 0) mt.h = lastMovingTable.h - 2;
					if(d + mt.h < 0 && lastAltitude >= fAltitude){
						// 今回で地面に接触
						mt.h = 0;
						altitude = (int) fAltitude;
					}else{
						switch(nowSpriteId){
							case stStanding:
							case stWalk:
							case stDash:
								loadSprite(stFalling);
						}
					}
				}else{
					// 入れてみた。様子見（シャインミラージュまではこの行は無かった）
					if(altitude < fAltitude) altitude = fAltitude;

					fallAdjustY();
					mt.h = 0;
					altitude = getFloorAltitude();
				}
			}else{
				// 地面に向けて落下中ではない
				if(d > 0){
					// 落下開始
					toGround = true;
					enableMove = false;
					switch(nowSpriteId){
						case stStanding:
						case stWalk:
						case stDash:
							loadSprite(stFalling);
							break;
//						case stDamage1:
//							loadSprite(stDamage2);
//							break;
					}
					if(mt.x == 0) mt.x = lastMovingTable.x;
					if(mt.h == 0) mt.h = lastMovingTable.h - 2;
				}else if(d < 0){
//					fallAdjustY();
				}

			}
		}else{
			if(mt.h == 0 && altitude <= fAltitude && layer.onTriggerTarget['landing'] !== void){
				layer.trigger("landing", this);
			}
		}

//if(layer.onTriggerTarget['landing'] !== void){
//	dm("mt.h : " + mt.h + " / altitude : " + altitude + " / fAltitude : " + fAltitude);
//}

		lastAltitude = altitude;
		return mt;
	}

	function fallAdjustY(){
		var dy1 = 0;
		var dy2 = 0;
		if(!ignoreMovableRect && movableRect !== void){
			while(getFloorAltitude(rootX, rootY - dy1) > altitude){
				if(rootY-dy1 <= movableRect.top){
					dy1 = 999;
					break;
				}
				dy1++;
			}
			while(getFloorAltitude(rootX, rootY + dy2) > altitude){
				if((rootY+dy2 >= movableRect.bottom)||(movableRect === void  && (rootY+dy2 >= owner.internalHeight))){
					dy2 = 999;
					break;
				}
				dy2++;
			}
		}

		if(dy1 < dy2){
			if(getFloorAltitude(rootX, rootY - dy1) > altitude){
				fallAdjustX();
			}else{
				rootY -= dy1;
			}
		}else{
			if(getFloorAltitude(rootX, rootY + dy2) > altitude){
				fallAdjustX();
			}else{
				rootY += dy2;
			}
		}
	}

	function fallAdjustX(){
		var dx1 = 0;
		var dx2 = 0;
		while((int(getFloorAltitude(rootX - dx1, rootY) > altitude)) && (dx1 < 200)){
			dx1 += 4;
		}
		while((int(getFloorAltitude(rootX + dx2, rootY) > altitude)) && (dx2 < 200)){
			dx2 += 4;
		}
		if(dx1 < dx2){
			rootX -= dx1;
		}else{
			rootX += dx2;
		}
	}



	// 移動用テーブルのセット
	function setMovingTable(elm, mt, dMode=false)
	{

		// 絶対座標指定の場合、相対指定に直す
		if(elm.mode !== void && elm.mode=="absolute"){
			elm.path = pathAbsoluteToRelative(elm.path, dMode);
		}

		var x1 = 0;
		var y1 = 0;
		var h1 = 0;
		var x2, y2, h2;

		var a;
		if(elm.path != ""){
			a = [].split("(), ", elm.path, , true);
		}else{
			a[0] = elm.x;
			a[1] = elm.y;
			a[2] = elm.h;
		}

		if(!dMode){
			x2 = +checkTarget(a[0]) * xDirection(inverse);
		}else{
			x2 = +checkTarget(a[0]);
		}
		y2 = +checkTarget(a[1]);
		h2 = +checkTarget(a[2]);
		if(h2 < 0) toGround = true;

		if(movingLastTarget===void){
			movingLastTarget = new MovingTable(x2, y2, h2);
		}else{
			x1 = movingLastTarget.x;
			y1 = movingLastTarget.y;
			h1 = movingLastTarget.h;
			movingLastTarget.set(x1+x2, y1+y2, h1+h2);
		}

//		if(this!==owner.players[0]){
//			dm("---------------------------");
//			dm("this : " + this);
//			dm("a[0] : " + a[0] + " / a[1] : " + a[1] + " / a[2] : " + a[2]);
//			dm("x1 : " + x1+ " / y1 : " + y1 + " / h1 : " + h1);
//			dm("movingLastTarget : " + movingLastTarget.x + " / " + movingLastTarget.y + " / " + movingLastTarget.h);
//			dm("x2 : " + x2 + " / y2 : " + y2 + " / h2 : " + h2);
//			dm("---------------------------");
//		}

		var x = [];
		var y = [];
		var h = [];

		var frame = +elm.frame;

		x = getMovePoints(0 , x2, frame, elm.xaccel);
		y = getMovePoints(0 , y2, frame, elm.yaccel);
		h = getMovePoints(0 , h2, frame, elm.haccel);

		for(var i=0; i<frame; i++){
			var m = new MovingTable(x[i], y[i], h[i]);
			mt.add(m);
		}

//		if(objectClass == clEnemy){
//			for(var i=0; i<mt.count; i++){
//				dm("mt[" + i + "].x : " + mt[i].x + " / mt[" + i + "].y : " + mt[i].y + " / mt[" + i + "].h : " + mt[i].h);
//			}
//		}
	}

	function setSplineMovingTable(elm, mt, dMode=false)
	{
		var x = rootX;
		var y = rootY;

		// path の分解
		var a1 = [].split("(), ", elm.path, , true);
		var a2 = [];

		a2[0] = 0;
		a2[1] = 0;
		a2[2] = 255;
		for(var i=0; i<a1.count; i+=3){
			if(!dMode){
				a2[i+3] = int(+a1[i] * xDirection(inverse));
			}else{
				a2[i+3] = int(+a1[i]);
			}
			a2[i+4] = +a1[i+1];
			a2[i+5] = 255;
		}

		var frame = +elm.frame;
		var mo = new SplineMover(layer, a2, frame\3, elm.accel === void ? 0 : +elm.accel, void);

		var lx = 0;
		var ly = 0;
		for (var i=0; i<frame; i++){
			mo.handler(i);
			var m = new MovingTable(internalLayerLeft - lx, internalLayerTop - ly, 0);
			lx = internalLayerLeft;
			ly = internalLayerTop;
			mt.add(m);
		}

	}


	function getMovePoints(p1, p2, frame, accel=0)
	{
		var p = [];
		var a = [];

		if(accel == 0){
			var d = (p2 - p1) / frame;
			for(var i=0; i<frame; i++){
				p[i] = d;
			}
		}else{
			var d = (p2 - p1) / Math.pow(frame, Math.abs(accel)+1);
			for(var i=0; i<=frame; i++){
				a[i] = d * Math.pow(i, Math.abs(accel)+1);
			}
			if(accel > 0){
				for(var i=0; i<frame; i++){
					p[i] = a[i+1] - a[i];
				}
			}else{
				for(var i=0; i<frame; i++){
					p[i] = a[frame - i] - a[frame - i - 1];
				}
			}
		}
		return p;
	}

	function checkTarget(t)
	{
		switch(t.toLowerCase())
		{
			case "leftlimit":
				if(movingLastTarget !== void){
					return movableRect.left - (rx + movingLastTarget.x);
				}else{
					return movableRect.left - rx;
				}

			case "rightlimit":
				if(movingLastTarget !== void){
					return movableRect.right - (rx + movingLastTarget.x);
				}else{
					return movableRect.right - rx;
				}

			default:
				return t;
		}
	}

	function checkFloorObjectCollision(mt)
	{
		//フロアオブジェクトにめり込んでしまう場合に排出する処理

//		fallAdjustX();

		var lLeft  = rootX - centerPos;
		var lRight = lLeft + layer.asdWidth;

		var r = new Rect2(footRect);
		r.addOffset(rootX - centerPos, rootY - layer.asdHeight);

		var dx = 0;

		if(int(altitude) < getAltitude(rootX, rootY) || (int(altitude) < getAltitude(r.right, r.bottom)) || (int(altitude) < getAltitude(r.left, r.bottom)) || (int(altitude) < getAltitude(r.right, r.top)) || (int(altitude) < getAltitude(r.left, r.top))){
			if(int(altitude)>=getAltitude(lLeft, r.bottom) || int(altitude)>=getAltitude(lLeft, r.top)){
				while(int(altitude) < getAltitude(r.right+dx, r.bottom) && int(altitude) < getAltitude(r.right+dx, r.top)&& int(altitude) >= getAltitude(lLeft+dx, r.bottom) && int(altitude) >= getAltitude(lLeft+dx, r.top)){
					dx -= 4;
//					if(dx < -40) break;
				}
			}else if(int(altitude)>=getAltitude(lRight, r.bottom) || int(altitude)>=getAltitude(lRight, r.top)){
				while(int(altitude) < getAltitude(r.left+dx, r.bottom) && int(altitude) < getAltitude(r.left+dx, r.top) && int(altitude) >= getAltitude(lRight+dx, r.bottom) && int(altitude) >= getAltitude(lRight+dx, r.top)){
					dx += 4;
//					if(dx > 40) break;
				}
			}else{
				if(getAltitude(rootX, rootY) > altitude){
					if(int(altitude)>=getAltitude(lLeft-40, r.bottom)){
						dx = -40;
					}else if(int(altitude)>=getAltitude(lRight+40, r.bottom)){
						dx = 40;
					}else{
						if(getAltitude(rootX, rootY) > 0){
							dx = -xDirection(inverse) * 40;
							if(altitude < 0) altitude = 0;
						}
					}
				}
			}
		}
		rootX += dx;
	}

	function checkAttackCollision()
	{
		// オーバーライドする
	}

	function setAbsolute(y)
	{
		// 表示のプライオリティ設定。

		if(fixedAbsolute > 0){
			layer.absolute = fixedAbsolute;
			return;
		}

		var s = owner.stageLayer;
		if(s === void){
			layer.absolute = rootY * 2 + 200;
			return;
		}

//		if(onFloorObject!==void && onFloorObject.objHeight>0){
//			// 高さが１以上の床オブジェクトの上にいる
//			for(var i=0; i<s.floorObjects.count; i++){
//				var o = s.floorObjects[i];
//				if(o.layer.absolute < onFloorObject.layer.absolute) break;
//				if(o.objHeight==onFloorObject.objHeight){
//					layer.absolute = o.layer.absolute + (y - o.baseTop) * 2 + 1;
//					return;
//				}
//			}
//			layer.absolute = onFloorObject.layer.absolute + (y - onFloorObject.baseTop) * 2 + 1;
//			return;
//		}else{
			if(s.floorObjects.count > 0){
				// フロアオブジェクトが存在する
				var flag = false;
				for(var i=0; i<s.floorObjects.count; i++){
					var o = s.floorObjects[i];
					if(o.objHeight > 0){
						if(y > (o.baseTop+o.objDepth)){
							// 床オブジェクトの下ラインよりも手前側にいる
							layer.absolute = o.layer.absolute + (y - o.baseTop) * 2 + 1;
							flag = true;
							break;
						}else{
							if((internalLayerLeft < o.baseLeft+o.layer.asdWidth) && (y > o.baseTop)){
								if(altitude >= o.objHeight){
									if(i > 0 && s.floorObjects[i-1].objHeight==o.objHeight
											&& s.floorObjects[i-1].baseLeft+s.floorObjects[i-1].layer.asdWidth > s.floorObjects[i].baseLeft
											&& s.floorObjects[i-1].baseTop < s.floorObjects[i].objTop+s.floorObjects[i].layer.asdHeight){
										// 高さが同じオブジェクトがある場合（ざっくりした判定なので不具合あるかも）
										layer.absolute = s.floorObjects[i-1].layer.absolute + (y - s.floorObjects[i-1].baseTop) * 2 + 1;
										flag = true;
										break;
									}else{
										layer.absolute = o.layer.absolute + (y - o.baseTop) * 2 + 1;
										flag = true;
										break;
									}
								}else{
									// 床オブジェクトの上にいるか、手前にいるか、もしく左側が引っ掛かっている場合
									var d = o.objDepth / o.layer.asdWidth;
									var x = rootX;
									if(d * (x - o.baseLeft) + o.baseTop < rootY){
										// 対角線を考えて、手前側であればabsoluteを設定
										layer.absolute = o.layer.absolute + (y - o.baseTop) * 2 + 1;
										flag = true;
										break;
									}
								}
							}
						}
					}
				}
				if(!flag){
					layer.absolute = 200 + y * 2;
				}
			}else{
				// フロアオブジェクトが存在しない
				layer.absolute = 200 + y * 2;
			}

			// 0と比較するとゴミが出やすいので-10でやってみる
			if(int(altitude) < -10 && s.floorLayers.count > 0 && !noMaskByFloorLayer){
				// 床面よりも下にいる→被さる部分のフロアレイヤーをコピーする
				for(var i=0; i<s.floorLayers.count; i++){
					var l = s.floorLayers[i];
					if(owner.stageLayer.dispLeft+rootX < l.xOffset+l.width\3 ){ // ここでの3という数値は場合によって変える必要があるかも。
						if(i==0) break;
						var l2 = s.floorLayers[i-1];
						var sLeft = (owner.stageLayer.dispLeft + internalLayerLeft - l2.xOffset) * (owner.cZoomRate/owner.sZoomRate);
						var sTop  = (internalLayerTop - l2.yOffset) * (owner.cZoomRate/owner.sZoomRate);
						if(!layer.zoomMode && layer.graphic!==void){
							layer.loadImagesSub(layer.graphic, %[]);
							if(inverse){
								layer.execInverse();
								layer.setInverseFlag = false;
								layer.inverse = true;
							}
						}
						var w = layer.asdWidth * (owner.cZoomRate/owner.sZoomRate);
						var h = layer.asdHeight * (owner.cZoomRate/owner.sZoomRate);

						var tmpLayer = new Layer(window, layer);
						tmpLayer.setSize(w, h);
						tmpLayer.face = dfAlpha;
						tmpLayer.type = ltAlpha;
						tmpLayer.operateRect(0, 0, l2, sLeft, sTop, w, h, omAuto, 255);

						if(!layer.zoomMode){
							layer.operateStretch(-layer.imageLeft, -layer.imageTop, layer.dispWidth, layer.dispHeight, tmpLayer, 0, 0, w, h, omAuto, 255, stNearest);
							layer.type = ltAlpha; // 下手に覆い焼きとかになると不都合なので
						}else{
//							layer.stretchCopy(0, 0, layer.dispWidth, layer.dispHeight, layer.bufLayer, int((layer.dispLeft*layer.internalZoomRate)/layer.internalWidth)*layer.internalWidth, int(layer.dispTop*layer.internalZoomRate/layer.internalHeight)*layer.internalHeight, layer.internalWidth, layer.internalHeight, stNearest);
							layer.stretchCopy(0, 0, layer.dispWidth, layer.dispHeight, layer.bufLayer, layer.dl*layer.internalWidth, layer.dt*layer.internalHeight, layer.internalWidth, layer.internalHeight, stNearest);
							layer.operateStretch(0, 0, layer.dispWidth, layer.dispHeight, tmpLayer, 0, 0, w, h, omAuto, 255, stNearest);
							layer.type = ltAlpha; // 下手に覆い焼きとかになると不都合なので
						}
						invalidate tmpLayer;

						underFloorFlag = true;
						break;
					}
				}
			}else{
				if(underFloorFlag){
					underFloorFlag = false;
					if(!layer.zoomMode){
						layer.loadImagesSub(layer.graphic, %[]);
						if(inverse){
							layer.execInverse();
							layer.setInverseFlag = false;
							layer.inverse = true;
						}
					}else{
						layer.stretchCopy(0, 0, layer.dispWidth, layer.dispHeight, layer.bufLayer, layer.dl*layer.internalWidth, layer.dt*layer.internalHeight, layer.internalWidth, layer.internalHeight, stNearest);
					}
				}
			}
			return;
//		}

	}

	function setHitMark(x, y, h)
	{
		damage.hitPos.x = x;
		damage.hitPos.y = y;
		damage.hitPos.altitude = h;
//		damage.hitPos.inverse = inverse;
	}

	function shadowToFloorObject()
	{
		if(!shadow) return;
		if(owner.stageLayer===void) return;
		// フロアオブジェクトへの影の処理
		for(var i=0; i<owner.stageLayer.floorObjects.count; i++){
			var o = owner.stageLayer.floorObjects[i];
			if(o.objHeight == 0 && !o.enforceDrawShadow) continue;
			if(altitude < o.objHeight+o.altitude-10) continue;
			if(o.shadowLayer === void) continue;
			var l = owner.shadowLayer.getShadow(this, shadowStorage);
			var x = (rootX - centerPos + layer.asdWidth/2) * owner.sZoomRate2 - l.width/2 - (shadowOffset*xDirection(inverse) * owner.sZoomRate2);
			var y = (rootY - 4) * owner.sZoomRate2 - l.height/2;
			var r1 = new Rect2(o.objLeft*owner.sZoomRate2, o.baseTop*owner.sZoomRate2, o.objLeft*owner.sZoomRate2+o.layer.width, o.baseTop*owner.sZoomRate2+o.objDepth*owner.sZoomRate2);
			var r2 = new Rect2(x, y, x+l.width, y+l.height);
			if(r1.intersects(r2)){
				if(owner.sZoomRate==1){
					o.shadowLayer.operateRect(x-o.objLeft*owner.sZoomRate2, y-(o.objTop+o.objHeight+o.altitude)*owner.sZoomRate2, l, 0, 0, l.width, l.height, omAuto, layer.opacity);
				}else{
					o.shadowLayer.operateStretch(x*owner.sZoomRate-o.objLeft*owner.cZoomRate, y*owner.sZoomRate-(o.objTop+o.objHeight+o.altitude)*owner.cZoomRate, l.width*2, l.height*2, l, 0, 0, l.width, l.height, omAuto, layer.opacity, stNearest);
				}
			}
		}
	}

	function putHitMark(pos, storage=hitMarkStorage[1])
	{
		owner.putHitMark(pos.x, pos.y, pos.altitude, storage);
	}

	function setLayerInverse()
	{
		if(inverseMode && inverse != layer.inverse) layer.setInverse();
	}

	function getOtherState(s){
		s.toLowerCase();
		return (otherState.indexOf(s)>=0);
	}

	function setChildSprite(obj){
		childSprites.add(obj);
		obj.parentSprite = this;
	}

	function store()
	{
		var dic = super.store();

		if(params !== void){
			dic.params = %[];
			(Dictionary.assign incontextof dic.params)(params);
		}else{
			dic.params = void;
		}

		if(parentSprite !== void && isvalid parentSprite){
			parentSprite_reference = new ObjectReference(parentSprite);
			dic.parentSprite_reference = parentSprite_reference.store();
		}
		if(childSprites.count != 0){
			dic.childSprites_reference = [];
			for(var i=0; i<childSprites.count; i++){
				var tmp = new ObjectReference(childSprites[i]);
				dic.childSprites_reference[i] = tmp;
			}
		}

		dic.kind = kind;
		dic.name = name;
		dic.objectClass = objectClass;
		dic.rootX = rootX;
		dic.rootY = rootY;
		dic.altitude = altitude;
		dic.centerPos = centerPos;
		dic.baseLine = baseLine;

		dic.depth = depth;
		dic.depth1 = depth1;
		dic.depth2 = depth2;

		dic.attackRect = attackRect.store();
		dic.hitRect = hitRect.store();
		dic.footRect = footRect.store();
		dic.attack = attack.store();
		dic.damage = damage.store();

		dic.enableMove = enableMove;
		dic.enableAttack = enableAttack;
		dic.enableCommand = enableCommand;
		dic.enableFreeMove = enableFreeMove;
		dic.enableDoubleJump = enableDoubleJump;
		dic.enableCounter = enableCounter;

		if(dic.otherState !== void) otherState = dic.otherState;

		dic.moveSpeed = moveSpeed;
		if(movableRect !== void) dic.movableRect = movableRect.store();
		dic.movingTable = [];
		for(var i=0; i<movingTable.count; i++){
			if(isvalid movingTable[i]) dic.movingTable[i] = movingTable[i].store();
		}
		if(movingLastTarget !== void) dic.movingLastTarget = movingLastTarget.store();
		dic.lastMovingTable = lastMovingTable.store();

		dic.toGround = toGround;
		dic.noGravity = noGravity;
		dic.ignoreMovableRect = ignoreMovableRect;
		dic.waiting = waiting;

		dic.attackIndex = attackIndex;
		dic.attackTick = attackTick;
		dic.attackIndexCountUpTick = attackIndexCountUpTick;
		dic.invincibleCount = invincibleCount;
		dic.enableClinched = enableClinched;

		dic.maxHP = maxHP;
		dic.maxMP = maxMP;
		dic.HP = HP;
		dic.MP = MP;

		dic.inverseMode = inverseMode;

		dic.cosState = cosState;
		dic.nowSpriteId = nowSpriteId;
		dic.nowSpriteFile = nowSpriteFile;
		dic.lastSpriteId = lastSpriteId;
		dic.lastSpriteFile = lastSpriteFile;
		dic.shadow = shadow;
		dic.shadowSize = shadowSize;
		dic.shadowOffset = shadowOffset;
		dic.shadowStorage = shadowStorage;
		dic.shadowOpacity = shadowOpacity;
		dic.floorObjectCollision = floorObjectCollision;
		dic.noStore = noStore;
		dic.fixedAbsolute = fixedAbsolute;
		dic.vOffset = vOffset;
		dic.ignoreScroll = ignoreScroll;

		return dic;
	}

	function restore(dic)
	{
		cosState = dic.cosState;
		super.restore(dic);

		if(dic.params !== void) (Dictionary.assign incontextof params)(dic.params);

		parentSprite_reference = void;
		if(dic.parentSprite_reference !== void){
			parentSprite_reference = new ObjectReference(dic.parentSprite_reference);
		}

		childSprites_reference = [];
		for(var i=0; i<childSprites_reference.count; i++){
			childSprites_reference[i] = new ObjectReference(dic.childSprites_reference[i]);
		}

		objectClass = dic.objectClass;
		kind = dic.kind;
		name = dic.name;
		rootX = dic.rootX;
		rootY = dic.rootY;
		altitude = dic.altitude;
		centerPos = dic.centerPos;
		baseLine = dic.baseLine;
		depth = dic.depth;
		depth1 = dic.depth1;
		depth2 = dic.depth2;

		attackRect.restore(dic.attackRect);
		hitRect.restore(dic.hitRect);
		footRect.restore(dic.footRect);
		attack.restore(dic.attack);
		damage.restore(dic.damage);

		enableMove = dic.enableMove;
		enableAttack = dic.enableAttack;
		enableCommand = dic.enableCommand;
		enableDoubleJump = dic.enableDoubleJump;
		enableCounter = dic.enableCounter;
		enableFreeMove = dic.enableFreeMove;

		dic.otherState = otherState;

		moveSpeed = dic.moveSpeed;

		if(dic.movableRect !== void){
			if(movableRect === void) movableRect = new Rect2();
			movableRect.restore(dic.movableRect);
		}
		movingTable = [];
		for(var i=0; i<dic.movingTable.count; i++){
			var m = new MovingTable();
			m.restore(dic.movingTable[i]);
			movingTable.add(m);
		}
		if(dic.movingLastTarget !== void){
			movingLastTarget = new MovingTable();
			movingLastTarget.restore(dic.movingLastTarget);
		}
		lastMovingTable.restore(dic.lastMovingTable);

		toGround = dic.toGround;
		noGravity = dic.noGravity;
		ignoreMovableRect = dic.ignoreMovableRect;
		waiting = dic.waiting;

		attackIndex = dic.attackIndex;
		attackTick = dic.attackTick;
		attackIndexCountUpTick = dic.attackIndexCountUpTick;
		invincibleCount = dic.invincibleCount;
		enableClinched = dic.enableClinched;

		maxHP = dic.maxHP;
		maxMP = dic.maxMP;
		HP = dic.HP;
		MP = dic.MP;

		inverseMode = dic.inverseMode;

		nowSpriteId = dic.nowSpriteId;
		nowSpriteFile = dic.nowSpriteFile;
		lastSpriteId = dic.lastwSpriteId;
		lastSpriteFile = dic.lastSpriteFile;

		shadow = dic.shadow;
		shadowSize = dic.shadowSize;
		shadowStorage = dic.shadowStorage;
		shadowOffset = dic.shadowOffset;
		if(dic.opacity !== void) shadowOpacity = dic.shadowOpacity;
		floorObjectCollision = dic.floorObjectCollision;
		noStore = dic.noStore;
		fixedAbsolute = dic.fixedAbsolute;
		vOffset = dic.vOffset;
		ignoreScroll = dic.ignoreScroll;

	}

	function restore2(){
		super.restore2();
		if(parentSprite_reference !== void){
			parentSprite = parentSprite_reference.getObject();
			invalidate parentSprite_reference;
			parentSprite_reference = void;
		}

		for(var i=0; i<childSprites_reference.count; i++){
			if(childSprites_reference[i] !== void){
				childSprites[i] = childSprites_reference[i].getObject();
				invalidate childSprites_reference[i];
				childSprites_reference[i] = void;
			}
			childSprites_reference = [];
		}

		if(layer.conductor.running){
			layer.conductor.start();
			layer.conductor.frameProcess();
		}
	}


	function toGlobalRect(rect)
	{
//		var r = new Rect2();
//		r.left   = rootX - centerPos + rect.left;
//		r.top    = rootY - height + rect.top - altitude;
//		r.right  = r.left + rect.width;
//		r.bottom = r.top + rect.height;
//		var r = new Rect2(rootX-centerPos+rect.left, rootY-layer.asdHeight+rect.top-altitude, rootX-centerPos+rect.left+rect.width, rootY-layer.asdHeight+rect.top-altitude+rect.height);
		var r = new Rect2(internalLayerLeft+rect.left, internalLayerTop+rect.top, internalLayerLeft+rect.left+rect.width, internalLayerTop+rect.top+rect.height);
		return r;
	}

	function toGlobalRectFromRoot(rect)
	{
//		var r = new Rect2();
//		r.left   = rootX + rect.left;
//		r.top    = rootY + rect.top;
//		r.right  = r.left + rect.width;
//		r.bottom = r.top + rect.height;
		var r = new Rect2(rootX+rect.left, rootY+rect.top, rootX+rect.right, rootY+rect.bottom);
		return r;
	}

	function getMovingTableLast()
	{
		var t = new MovingTable();
		for(var i=0; i<movingTable.count; i++){
			t.add(movingTable[i]);
		}
		return t;
	}

	function adjustX(d){
		if(!inverse){
			rootX += d;
		}else{
			rootX -= d;
		}
	}

	function turnToRight(){
		if(!inverse){
			layer.execInverse();
			inverse = true;
			layer.inverse = true;
		}
	}

	function turnToLeft(){
		if(inverse){
			layer.execInverse();
			inverse = false;
			layer.inverse = false;
		}
	}

	function lookTo(o){
		if(rootX < o.rootX){
			turnToRight();
		}else{
			turnToLeft();
		}
	}

}


class ChiffonSprite extends PlayerSprite
{
	function ChiffonSprite(window, owner, elm){
		super.PlayerSprite(...);

		comboAttackList = [stAttack1, stAttack6, stAttack2, stAttack3, stAttack4];
		clinchAttackList = [stClinchAttack1, stClinchAttack1, stClinchAttack2, stClinchAttack3];

		if(!sf.adjEnableNewArts){
			attackListForPc = %[
				stStanding		=> [	stAttack1,		stDashAttack,	stAttack5,		stCommand2,		stAttack7],
				stAttack1		=> [	stAttack6,		stDashAttack,	stCommand2,		stCommand1,		stSpecial2],
				stAttack6		=> [	stAttack2,		stDashAttack,	stCommand2,		stCommand1],
				stAttack2		=> [	stAttack3,		stDashAttack,	stCommand2,		stCommand1],
				stAttack3		=> [	stAttack4,		stDashAttack,	stCommand2,		stCommand1],
				stAttack4		=> [	stCommand2,		stCommand3,		stCommand1],
				stAttack5		=> [	stCommand2	],
				stDashAttack	=> [	stDashAttack2,	stCommand1,		stSpecial2],
				stDashAttack2	=> [	stDashAttack3,	stCommand1	],
				stDashAttack3	=> [	stCommand1,		stCommand2	],
				stCommand1		=> [	stCommand2	],
				stCommand2		=> [	stCommand3	],
				stCommand3		=> [	stCommand2	],
				stSpecial1		=> [	stCommand3,		stSpecial3	],
				stSpecial2		=> [	stCommand2,		stSpecial1,		stSpecial3	]
			];
		}else{
			attackListForPc = %[
				stStanding		=> [	stAttack1,		stDashAttack,	stAttack5,		stCommand2,		stAttack7,		stCommand4],
				stAttack1		=> [	stAttack6,		stDashAttack,	stCommand2,		stCommand1,		stSpecial2],
				stAttack6		=> [	stAttack2,		stDashAttack,	stCommand2,		stCommand1],
				stAttack2		=> [	stAttack3,		stDashAttack,	stCommand2,		stCommand1],
				stAttack3		=> [	stAttack4,		stDashAttack,	stCommand2,		stCommand1],
				stAttack4		=> [	stCommand2,		stCommand3,		stCommand1],
				stAttack5		=> [	stCommand2	],
				stDashAttack	=> [	stDashAttack2,	stCommand1,		stSpecial2,		stCommand4],
				stDashAttack2	=> [	stDashAttack3,	stCommand1,		stCommand4],
				stDashAttack3	=> [	stCommand1,		stCommand2,		stSpecial5],
				stCommand1		=> [	stCommand2,		stSpecial5],
				stCommand2		=> [	stCommand3,		stSpecial5],
				stCommand3		=> [	stCommand2	],
				stCommand4		=> [	stCommand2,		stSpecial5],
				stSpecial1		=> [	stCommand3,		stSpecial5,		stSpecial3	],
				stSpecial2		=> [	stCommand2,		stSpecial1,		stSpecial3	],
				stSpecial4		=> [	stDashAttack,	stSpecial5,		stCommand1]
			];
		}

		attackListCommand = %[
			stAttack1		=> "input.set(keyAttack), pc.attackWait=8",
			stAttack2		=> "input.set(keyAttack), pc.attackWait=8",
			stAttack3		=> "input.set(keyAttack), pc.attackWait=8",
			stAttack4		=> "input.set(keyAttack), pc.attackWait=12",
			stAttack5		=> "input.command[cmdSonicBoom]=true, input.set(keyAttack), pc.attackWait=10",
			stAttack6		=> "input.set(keyAttack), pc.attackWait=8",
			stAttack7		=> "input.set(keyAttack), input.set(keyJump), pc.attackWait=12",
			stDashAttack	=> "input.command[cmdDash]=true, input.set(keyAttack), pc.attackWait=5",
			stDashAttack2	=> "input.set(keyAttack), pc.attackWait=5",
			stDashAttack3	=> "input.set(keyAttack), pc.attackWait=5",
			stCommand1		=> "input.command[cmdHadouken]=true, input.set(keyAttack)",
			stCommand2		=> "input.command[cmdSomersault]=true, input.set(keyAttack)",
			stCommand3		=> "(int(altitude)-fAltitude==0)?(input.set(keyJump),pc.attackWait=10):(input.command[cmdSonicBoom]=true,input.set(keyAttack))",
			stCommand4		=> "input.command[cmdYogaFlame]=true, input.set(keyAttack)",
			stVerticalJump	=> "input.set(keyJump), pc.attackWait = 6",
			stJumpAttack1	=> "input.set(keyJump), pc.attackWait = 5",
			stJumpAttack2	=> "input.direction=((inverse)?dRight:dLeft),input.set(keyJump), pc.attackWait = 5",
			stSpecial1		=> "input.set(keyEscAttack), pc.attackWait=5",
			stSpecial2		=> "input.command[cmdGenocidePhantom]=true, input.set(keySpecial), pc.attackWait=60",
			stSpecial3		=> "input.command[cmdDash]=true, input.set(keySpecial)",
			stSpecial4		=> "input.command[cmdDash]=true, input.set(keyAttack), input.set(keyJump)",
			stSpecial5		=> "input.command[cmdHadouken]=true, input.set(keySpecial)",
			stRecovery		=> "input.set(keyAttack), input.set(keyJump), pc.attackWait=3"
		];

		name = "エクセルシフォン";
		chara = chrChiffon;
		depth = 22;

		faceStorage = "face1";
		selectIndicatorStorage = "selectIndicator01";

		maxHP = HP = f.maxHP;
		maxMP = MP = 200;
		recoveryMP = 0.05;

		moveSpeed = 3.2;
	}

	function initSpriteTable()
	{
		sprites[stStanding]			 = ["p00_standing",			"p01_standing",			"p02_standing",			"p03_standing",			"p04_standing"];
		sprites[stWalk]				 = ["p00_walk",				"p01_walk",				"p02_walk",				"p03_walk",				"p04_walk"];
		sprites[stFalling]			 = ["p00_falling",			"p01_falling",			"p02_falling",			"p03_falling",			"p04_falling"];
		sprites[stDash]				 = ["p00_dash",				"p01_dash",				"p02_dash",				"p03_dash",				"p04_dash"];
		sprites[stRoll1]			 = ["p00_roll1",			"p01_roll1",			"p02_roll1",			"p03_roll1",			"p04_roll1"];
		sprites[stRoll2]			 = ["p00_roll2",			"p01_roll2",			"p02_roll2",			"p03_roll2",			"p04_roll2"];
		sprites[stLanding]			 = ["p00_landing",			"p01_landing",			"p02_landing",			"p03_landing",			"p04_landing"];
		sprites[stLanding2]			 = ["p00_landing2",			"p01_landing2",			"p02_landing2",			"p03_landing2",			"p04_landing2"];
		sprites[stStandUp]			 = ["p00_standup",			"p01_standup",			"p02_standup",			"p03_standup",			"p04_standup"];
		sprites[stStandUp2]			 = ["p00_standup2",			"p01_standup2",			"p02_standup2",			"p03_standup2",			"p04_standup2"];
		sprites[stStandUp3]			 = ["p00_standup3",			"p01_standup3",			"p02_standup3",			"p03_standup3",			"p04_standup3"];
		sprites[stSitDown]			 = ["p00_sitdown",			"p01_sitdown",			"p02_sitdown",			"p03_sitdown",			"p04_sitdown"];
		sprites[stSitDown2]			 = ["p00_sitdown2",			"p01_sitdown2",			"p02_sitdown2",			"p03_sitdown2",			"p04_sitdown2"];
		sprites[stStanding2]		 = ["p00_standing2",		"p01_standing2",		"p02_standing2",		"p03_standing2",		"p04_standing2"];
		sprites[stStanding3]		 = ["p00_standing3",		"p01_standing3",		"p02_standing3",		"p03_standing3",		"p04_standing3"];
		sprites[stExtasy]			 = ["p00_extasy",			"p01_extasy",			"p02_extasy",			"p03_extasy",			"p04_extasy"];
		sprites[stVerticalJump]		 = ["p00_verticaljump",		"p01_verticaljump",		"p02_verticaljump",		"p03_verticaljump",		"p04_verticaljump"];
		sprites[stForwardJump]		 = ["p00_forwardjump",		"p01_forwardjump",		"p02_forwardjump",		"p03_forwardjump",		"p04_forwardjump"];
		sprites[stDashJump]			 = ["p00_dashjump",			"p01_dashjump",			"p02_dashjump",			"p03_dashjump",			"p04_dashjump"];
	// パンチ１
		sprites[stAttack1]			 = ["p00_punch1",			"p01_punch1",			"p02_punch1",			"p03_punch1",			"p04_punch1"];
	// パンチ２
		sprites[stAttack2]			 = ["p00_punch2",			"p01_punch2",			"p00_punch2",			"p03_punch2",			"p04_punch2"];
	// キック１
		sprites[stAttack3]			 = ["p00_kick1",			"p01_kick1",			"p02_kick1",			"p03_kick1",			"p04_kick1"];
	// キック２
		sprites[stAttack4]			 = ["p00_kick2",			"p01_kick2",			"p02_kick2",			"p03_kick2",			"p04_kick2"];
	// スライディング
		sprites[stAttack5]			 = ["p00_kick3",			"p01_kick3",			"p02_kick3",			"p03_kick3",			"p04_kick3"];
	// PlayerController用二回目パンチ
		sprites[stAttack6]			 = ["p00_punch1",			"p01_punch1",			"p02_punch1",			"p03_punch1",			"p04_punch1"];
	// 足払い
		sprites[stAttack7]			 = ["p00_kick4",			"p01_kick4",			"p02_kick4",			"p03_kick4",			"p04_kick4"];
		sprites[stDashAttack]		 = ["p00_dashattack",		"p01_dashattack",		"p02_dashattack",		"p03_dashattack",		"p04_dashattack"];
		sprites[stDashAttack2]		 = ["p00_dashattack2",		"p01_dashattack2",		"p02_dashattack2",		"p03_dashattack2",		"p04_dashattack2"];
		sprites[stDashAttack3]		 = ["p00_dashattack3",		"p01_dashattack3",		"p02_dashattack3",		"p03_dashattack3",		"p04_dashattack3"];
		sprites[stJumpAttack1]		 = ["p00_jumpkick1",		"p01_jumpkick1",		"p02_jumpkick1",		"p03_jumpkick1",		"p04_jumpkick1"];
		sprites[stJumpAttack2]		 = ["p00_jumpkick2",		"p01_jumpkick2",		"p02_jumpkick2",		"p03_jumpkick2",		"p04_jumpkick2"];
		sprites[stDamage1]			 = ["p00_damage1",			"p01_damage1",			"p02_damage1",			"p03_damage1",			"p04_damage1"];
		sprites[stDamage2]			 = ["p00_damage2",			"p01_damage2",			"p02_damage2",			"p03_damage2",			"p04_damage2"			,"p05_damage2"];
		sprites[stDown]				 = ["p00_down",				"p01_down",				"p02_down",				"p03_down",				"p04_down"				,"p05_down"];
		sprites[stClinching]		 = ["p00_clinching",		"p01_clinching",		"p02_clinching",		"p03_clinching",		"p04_clinching"];
		sprites[stClinchAttack1]	 = ["p00_clinchattack1",	"p01_clinchattack1",	"p02_clinchattack1",	"p03_clinchattack1",	"p04_clinchattack1"];
		sprites[stClinchAttack2]	 = ["p00_clinchattack2",	"p01_clinchattack2",	"p02_clinchattack2",	"p03_clinchattack2",	"p04_clinchattack2"];
		sprites[stClinchAttack3]	 = ["p00_clinchattack3",	"p01_clinchattack3",	"p02_clinchattack3",	"p03_clinchattack3",	"p04_clinchattack3"];
		sprites[stClinched]			 = ["p00_clinched1a",		"p01_clinched1a",		"p02_clinched1a",		"p03_clinched1a",		"p04_clinched1a"];
		sprites[stClinchedStruggle]	 = ["p00_clinched1b",		"p01_clinched1b",		"p02_clinched1b",		"p03_clinched1b",		"p04_clinched1b"];
		sprites[stUntangle]			 = ["p00_standing",			"p01_standing",			"p02_standing",			"p03_standing",			"p04_standing"];
		sprites[stRelease]			 = ["p00_release",			"p01_release",			"p02_release",			"p03_release",			"p04_release"];
		sprites[stGoAround]			 = ["p00_goaround",			"p01_goaround",			"p02_goaround",			"p03_goaround",			"p04_goaround"];
		sprites[stRecovery]			 = ["p00_recovery",			"p01_recovery",			"p02_recovery",			"p03_recovery",			"p04_recovery"];
		sprites[stBackClinch]		 = ["p00_backClinch",		"p01_backClinch",		"p02_backClinch",		"p03_backClinch",		"p04_backClinch"];
		sprites[stThrow1]			 = ["p00_throw1",			"p01_throw1",			"p02_throw1",			"p03_throw1",			"p04_throw1"];
		sprites[stThrow2]			 = ["p00_throw2",			"p01_throw2",			"p02_throw2",			"p03_throw2",			"p04_throw2"];
		sprites[stThrown1]			 = ["p00_thrown1",			"p01_thrown1",			"p02_thrown1",			"p03_thrown1",			"p04_thrown1"];
		sprites[stThrown2]			 = ["p00_thrown2",			"p01_thrown2",			"p02_thrown2",			"p03_thrown2",			"p04_thrown2"];
		sprites[stThrown3]			 = ["p00_thrown3",			"p01_thrown3",			"p02_thrown3",			"p03_thrown3",			"p04_thrown3"];
		sprites[stThrown4]			 = ["p00_thrown4",			"p01_thrown4",			"p02_thrown4",			"p03_thrown4",			"p04_thrown4"];
		sprites[stThrown5]			 = ["p00_thrown5",			"p01_thrown5",			"p02_thrown5",			"p03_thrown5",			"p04_thrown5"];
		sprites[stThrown6]			 = ["p00_thrown6",			"p01_thrown6",			"p02_thrown6",			"p03_thrown6",			"p04_thrown6"];
		sprites[stThrown7]			 = ["p00_thrown7",			"p01_thrown7",			"p02_thrown7",			"p03_thrown7",			"p04_thrown7"];
		sprites[stThrown8]			 = ["p00_thrown8",			"p01_thrown8",			"p02_thrown8",			"p03_thrown8",			"p04_thrown8"];
		sprites[stThrown9]			 = ["p00_thrown9",			"p01_thrown9",			"p02_thrown9",			"p03_thrown9",			"p04_thrown9"];
	// 無敵技
		sprites[stSpecial1]			 = ["p00_special1",			"p01_special1",			"p02_special1",			"p03_special1",			"p04_special1"];
	// シフォンインフェルノ　乱舞技
		sprites[stSpecial2]			 = ["p00_special2",			"p01_special2",			"p02_special2",			"p03_special2",			"p04_special2"];
	// ライトニングピアース　ビーム
		sprites[stSpecial3]			 = ["p00_special3",			"p01_special3",			"p02_special3",			"p03_special3",			"p04_special3"];
	// ウォールブレイカー　ガード崩し
		sprites[stSpecial4]			 = ["p00_special4",			"p01_special4",			"p02_special4",			"p03_special4",			"p04_special4"];
	// バーティカルスラッシュ
		sprites[stSpecial5]			 = ["p00_special5",			"p01_special5",			"p02_special5",			"p03_special5",			"p04_special5"];
	// スターライトエクスキューション
		sprites[stSpecial9]			 = ["p00_special9",			"p01_special9",			"p02_special9",			"p03_special9",			"p04_special9"];

	// スラッシュウェーブ
		sprites[stCommand1]			 = ["p00_command1",			"p01_command1",			"p02_command1",			"p03_command1",			"p04_command1"];
	// サマソ
		sprites[stCommand2]			 = ["p00_command2",			"p01_command2",			"p02_command2",			"p03_command2",			"p04_command2"];
	// ホーミングキック
		sprites[stCommand3]			 = ["p00_command3",			"p01_command3",			"p02_command3",			"p03_command3",			"p04_command3"];
	// スピニングバードキック
		sprites[stCommand4]			 = ["p00_command4",			"p01_command4",			"p02_command4",			"p03_command4",			"p04_command4"];
		sprites[stEtc1]				 = ["p00_etc1",				"p01_etc1",				"p02_etc1",				"p03_etc1",				"p04_etc1"];
		sprites[stEtc2]				 = ["p00_etc2",				"p01_etc2",				"p02_etc2",				"p03_etc2",				"p04_etc2"];
		sprites[stEtc3]				 = ["p00_etc3",				"p01_etc3",				"p02_etc3",				"p03_etc3",				"p00_etc3"];
		sprites[stEtc4]				 = ["p00_etc4",				"p00_etc4",				"p00_etc4",				"p00_etc4",				"p00_etc4"];
		sprites[stEtc5]				 = ["p00_etc8b",			"p00_etc8b",			"p00_etc8b",			"p00_etc8b",			"p04_etc8b"];
		sprites[stEtc7]				 = ["p00_etc7",				"p00_etc7",				"p00_etc7",				"p00_etc7",				"p04_etc7"];
		sprites[stEtc8]				 = ["p00_etc8",				"p00_etc8",				"p00_etc8",				"p00_etc8",				"p04_etc8"];
		sprites[stEtc9]				 = ["p00_etc9",				"p01_etc9",				"p02_etc9",				"p03_etc9",				"p04_etc9"];
		sprites[stWinning]			 = ["p00_win",				"p01_win",				"p02_win",				"p03_win",				"p04_win"];
		sprites[stDummy]			 = ["dummy",				"dummy",				"dummy",				"dummy",				"dummy"];

		if(extasyGauge !==void && extasyGauge.enabled){
			sprites[stWalk]			 = ["p00_walk2",			"p01_walk2",			"p02_walk2",			"p03_walk2",			"p04_walk"];
		}

		spriteTableChangeFlag = false;
	}

	function inputProcess(mt)
	{
		// 入力に応じた行動をさせる

		var inkey = new MovingTable();
		if(enableFreeMove) inkey.set(checkDirection(input.direction));

		var nsp = owner.notSelectingPlayer;
		if(enableFreeMove && nowSpriteId!=stLocked && extasyGauge.value<extasyGauge.maxValue){
//			if(nsp !== void && nsp.HP > 0 && input.get(keySpecial) && input.command[cmdExcution] && (nowNearbyOtherPlayer(50) || sf.adjSinglePlayMode) && altitude == fAltitude && enableCommand && nsp.enableCommand){
			var nmp = bao.players[!id];
			if(nmp !== void && nmp.HP > 0 && input.get(keySpecial) && input.command[cmdExcution] && altitude == fAltitude && enableCommand){
				// スターライトエクスキューション
				input.done(keySpecial);
				if(sf.adjSinglePlayMode){
					nmp.rootX = (rootX < bao.internalWidth / 2)? rootX + 40: rootX - 40;
					nmp.rootY = (rootY < (nmp.movableRect.top + nmp.movableRect.bottom) / 2)? rootY + 8: rootY - 8;
				}
				if(checkMP(150) && nmp.checkMP(150)){
					input.done(keyEscAttack);
					input.history.clear();
					reduceMP(150);
					if(!sf.adjSinglePlayMode){
						nmp.reduceMP(150);
					}else{
						nmp.reduceMP(75);
					}
					loadSprite(stSpecial9);
					nmp.loadSprite(stSpecial9);
					if((sf.actionSceneCutin)&&(!sf.sameCutinDisable||(owner.tickCount - lastCutinTick > 900))){
						owner.cutinLayer[0].loadImages(%["storage"=>"cutin21","inverse"=>inverse,"caller"=>this]);
						lastCutinTick = owner.tickCount;
					}
				}

			}else if(input.get(keySpecial) && input.command[cmdGenocidePhantom] && enableCommand && (altitude == fAltitude || nowSpriteId==stDashAttack || nowSpriteId==stDashAttack2)){ 
				// 必殺技 シフォンインフェルノ
				input.history.clear();
				input.done(keySpecial);
				if(checkMP(100)){
					input.done(keyEscAttack);
					reduceMP(100);
					special2Tick = owner.tickCount;
					loadSprite(stSpecial2);
					if((sf.actionSceneCutin)&&(!sf.sameCutinDisable||(owner.tickCount - lastCutinTick > 900))){
						owner.cutinLayer[0].loadImages(%["storage"=>"cutin01","inverse"=>inverse,"caller"=>this]);
						lastCutinTick = owner.tickCount;
					}
				}
			}else if(input.get(keySpecial) && nowSpriteId == stDash){
				// 必殺技 ライトニングピアース
				input.done(keySpecial);
				if(checkMP(80)){
					input.done(keyEscAttack);
					reduceMP(80);
					inverse = (input.lastInputLeftRight == 1);
					loadSprite(stSpecial3);
					ext += 9;
				}

			}else if(sf.adjEnableNewArts && (enableCommand || getOtherState('enablespecial5')) && input.get(keySpecial) && (input.command[cmdHadouken]||input.command[cmdRHadouken])){
				// 追撃技
				input.done(keySpecial);
				if(checkMP(20)){
					input.done(keyEscAttack);
					reduceMP(20);
					inverse = (input.lastInputLeftRight == 1);
					rootY -= 2;
					loadSprite(stSpecial5);
					ext += 9;
				}
			}else if(sf.adjEnableNewArts && enableCommand && input.get(keyAttack) && input.get(keyJump) && (input.command[cmdDash] || nowSpriteId == stDash) && nowSpriteId != stSpecial4 && clinchEnemy === void && ((int(altitude)-fAltitude)<15)){
				// ガード崩し
				if(checkMP(20)){
					input.done(keyAttack);
					input.done(keyJump);
					reduceMP(20);
					loadSprite(stSpecial4);
					ext += 9;
				}

			}else if(input.get(keySpecial) && (input.command[cmdDash] || input.command[cmdDash2])
				&& ((enableCommand && ((nowSpriteId >= stDashAttack && nowSpriteId <= stDashAttack3) || (nowSpriteId >= stSpecial1 && nowSpriteId <= stCommand6))) || (getOtherState('enablespecial3') && nowSpriteId>=stFalling && nowSpriteId<=stRecovery))){
					// 必殺技 キャンセルからのライトニングピアース
					input.done(keySpecial);
					if(checkMP(80)){
						input.done(keyEscAttack);
						reduceMP(80);
						inverse = (input.lastInputLeftRight == 1);
						loadSprite(stSpecial3);
						ext += 9;
					}

			}else if(input.get(keyEscAttack) && ((int(altitude)-fAltitude)==0 || getOtherState('enablespecial1')) && nowSpriteId!=stDash){
				input.done(keySpecial);
				input.done(keyEscAttack);
				// 緊急回避技
				switch(nowSpriteId){
					case stDamage2:
					case stCommand5:
					case stSpecial1:
					case stSpecial3:
//					case stSpecial4:
					case stSpecial9:
					case stThrow1:
					case stThrow2:
					case stThrown1:
					case stThrown2:
					case stThrown3:
					case stThrown4:
					case stExtasy:
					case stDummy:
					case stUntangle:
					case stStandUp:
						break;
					case stClinched:
					case stClinchedStruggle:
						// イッてるときは無効
						if(inExtasy > 0) break;
//						if(owner.informLayer.extasyGaugeLayer.enabled) break;
						if(clinchedBy !== void && isvalid clinchedBy && clinchedBy.kind == "人造人間" && clinchedBy.nowSpriteId == stThrow1) break;
					default:
//						// ジェノサイドファントム発動後15フレーム以内ならMP消費無し
//						if(owner.tickCount-special2Tick>15){
//							reduceMP(50);
//						}
						if(checkMP(50)){
							reduceMP(50);
							mt.y = 0;
							loadSprite(stSpecial1);
							initSpriteTable();
							ext += 6;
							attackTick = owner.tickCount; 
						}
				}

			}else if(enableAttack){
				if(input.get(keyAttack)){
					// 通常技
					input.done(keyAttack);
					ext += 1.5;
					switch(nowSpriteId)
					{
						case stStanding:
						case stStanding2:
						case stWalk:
							if(input.get(keyJump)){
								input.done(keyJump);
								ext += 2.2;
								loadSprite(stAttack7);
								break;
							}
						case stAttack1:
						case stAttack2:
						case stAttack3:
						case stSpecial4:
							if(input.command[cmdDash]){
								checkInverse(inkey);
								loadSprite(stDashAttack);
								break;
							}else if(input.command[cmdSonicBoom]){
//								if(!inverse&&input.lastInputLeftRight==1 || inverse&&input.lastInputLeftRight==-1) inverse = !inverse;
//								input.history.clear();
								checkInverse(input.lastInputLeftRight);
								loadSprite(stAttack5);
//								if(inverse != layer.inverse) layer.setInverse();
								break;
							}else if(sf.adjEnableNewArts && input.command[cmdYogaFlame]){
//								input.history.clear();
								checkInverse(input.lastInputLeftRight);
								loadSprite(stCommand4);
								break;
							}else if(input.command[cmdHadouken] && checkMP(20)){
//								input.history.clear();
								checkInverse(inkey);
								reduceMP(20);
								loadSprite(stCommand1);
								break;
							}else if(input.command[cmdSomersault]){
//								input.history.clear();
								loadSprite(stCommand2);
								break;
							}

							if(attackIndex > comboAttackList.count-1) attackIndex = 0;
							if(attackIndex > 0 && attackIndex == lastAttackIndex){
								if(attackIndex == 1) attackIndex = 0;
								if(nowSpriteId >= stAttack2) attackIndex++;
							}
							checkInverse(inkey);
//							if(inverse != layer.inverse) layer.setInverse();
							loadSprite(comboAttackList[attackIndex]);
							lastAttackIndex = attackIndex;
							attackTick = owner.tickCount; 
							break;
						case stDash:
							checkInverse(inkey);
							loadSprite(stDashAttack);
							mt.y = 0;
							break;
						case stVerticalJump:
						case stForwardJump:
						case stDashJump:
							if(sf.adjEnableNewArts && input.command[cmdYogaFlame]){
								ext += 6;
								loadSprite(stCommand4);
								break;
							}else if(input.command[cmdSomersault]){
								loadSprite(stCommand2);
								break;
							}else if(input.command[cmdSonicBoom]){
								ext += 4.5;
								
								checkInverse(input.lastInputLeftRight);
								if(inkey.x != 0) checkInverse(inkey.x);
//								inverse = !input.commandNum;
								loadSprite(stCommand3);
							}else{
								if(input.direction == 2){
									loadSprite(stJumpAttack2, true);
								}else{
									loadSprite(stJumpAttack1, true);
								}
							}
							break;
						case stClinching:
							if((inverse!=clinchEnemy.inverse) && ((inverse && inkey.x==-1)||(!inverse && inkey.x==1))){
								clinchEnemy.lockedCount = 0;
								loadSprite(stThrow1);
								clinchEnemy.loadSprite(stThrown1);
							}else{
								if(attackIndex > clinchAttackList.count-1) attackIndex = 0;
								loadSprite(clinchAttackList[attackIndex]);
								if(attackIndex == clinchAttackList.count-1) attackIndex = -1;
								attackTick = owner.tickCount; 
							}
							break;
						case stBackClinch:
							clinchEnemy.lockedCount = 0;
							loadSprite(stThrow2);
							clinchEnemy.loadSprite(stThrown2);
							break;
					}
				}
			}else if(enableCommand){
				if(input.get(keyAttack)){
					input.done(keyAttack);
					if(sf.adjEnableNewArts && input.command[cmdYogaFlame]){
						switch(nowSpriteId)
						{
							case stCommand4:
//								layer.conductor.mp.command4redo = true;
								break;
							default:
								ext += 6;
//									checkInverse(inkey);
								// レッグトルネード
								loadSprite(stCommand4);
								break;
						}
					}else if(input.command[cmdHadouken]){
						switch(nowSpriteId)
						{
							case stCommand1:
								//何もしない
								break;
							default:
								if(checkMP(20)){
									ext += 4.5;
									reduceMP(20);
//									checkInverse(inkey);
									// スラッシュウェーブ
									loadSprite(stCommand1);
								}
								break;
						}
					}else if(input.command[cmdSomersault]){
						switch(nowSpriteId)
						{
							case stAttack1:
							case stAttack2:
							case stAttack3:
							case stAttack4:
							case stAttack5:
							case stAttack7:
							case stDashAttack:
							case stDashAttack2:
							case stDashAttack3:
							case stSpecial1:
							case stSpecial5:
							case stCommand1:
							case stCommand3:
							case stCommand4:
							case stRecovery:
							case stRelease:
								ext += 4.5;
								loadSprite(stCommand2);
								break;
							case stFalling:
							case stLanding:
//								if(checkMP(20)){
//									reduceMP(20);
//									ext += 5;
//									loadSprite(stCommand2);
//								}
								break;
						}
					}else if(input.command[cmdSonicBoom]){
						switch(nowSpriteId)
						{
							case stDashAttack:
								ext += 4.5;
//								checkInverse(input.lastInputLeftRight);
								loadSprite(stAttack5);
								break;
							case stCommand3:
							case stAttack5:
								break;
							case stCommand2:
//								checkInverse(input.lastInputLeftRight);
							default:
								ext += 4.5;
//								checkInverse(input.lastInputLeftRight);
								loadSprite(stCommand3);
								break;
						}
					}else{
						switch(nowSpriteId)
						{
							case stCommand3:
									if(input.direction == 2){
										ext += 4.5;
										loadSprite(stCommand2);
									}
									break;
							case stDashAttack:
									ext += 4.5;
									loadSprite(stDashAttack2);
									break;
							case stDashAttack2:
									ext += 4.5;
									loadSprite(stDashAttack3);
									break;
						}
					}
				}else if(sf.adjEnableNewArts && input.get(keySpecial) && checkMP(20)){
					input.done(keySpecial);
					input.done(keyEscAttack);
					reduceMP(20);
					loadSprite(stSpecial5);
					ext += 9;
				}
			}else{
				if(input.get(keyAttack)){
//					if(getOtherState('enablecommand3') && (input.command[cmdSonicBoom] || (inkey.x != 0 && nowSpriteId == stCommand2))){
					if(getOtherState('enablecommand3') && (input.inputRight || input.inputLeft)){
						// 流星脚的なやつ
						input.done(keyAttack);
						ext += 4.5;
//						checkInverse(input.lastInputLeftRight);
						loadSprite(stCommand3);
					}
				}
				if(((owner.tickCount-input.state[keyJump].tick<2)&&input.get(keyAttack)) || ((owner.tickCount-input.state[keyAttack].tick<2)&&input.get(keyJump))){
					if((nowSpriteId >= stClinching && nowSpriteId <= stClinchAttack3) || nowSpriteId == stThrow2){
						// 突き放し
						input.done(keyAttack);
						input.done(keyJump);
						ext += 3.5;
						loadSprite(stRelease);
						var e= clinchEnemy;
						if(e === void) e = lastClinchEnemy;
						e.invincibleCount = 10;
						e.lockedCount = 0;
						if(inverse == e.inverse) e.inverse = !e.inverse;
						e.loadSprite(stDamage1);
						e.movingTable = [];
						e.enableMove = false;
						e.setMovingTable(%["path" => "(-50,0,0)" , "xaccel" => -1 , "frame" => 15], e.movingTable);
					}else if((nowSpriteId == stStanding || nowSpriteId == stAttack1 || nowSpriteId == stVerticalJump || nowSpriteId == stForwardJump) && (int(altitude)-fAltitude)==0){
						// 立ち、あるいは攻撃しかけやジャンプしかけの場合
						// 足払い
						input.done(keyAttack);
						input.done(keyJump);
						ext += 3.5;
						loadSprite(stAttack7);
					}else if(sf.adjEnableNewArts && lastSpriteId != stDashAttack && (nowSpriteId == stDashJump || nowSpriteId == stDashAttack) && (int(altitude)-fAltitude)==0){
						if(checkMP(20)){
							input.done(keyAttack);
							input.done(keyJump);
							reduceMP(20);
							loadSprite(stSpecial4);
							ext += 9;
						}
					}
				}

			}
		}

		if(enableMove){
			clinchedStrength = 0;
			releaseStrength = 0;
//			if(spriteTableChangeFlag) initSpriteTable();
			checkInverse(inkey);
			if(input.get(keyJump)){
				input.done(keyJump);
				// ジャンプキーが押された
				if(inkey.x == 0){
					loadSprite(stVerticalJump);
				}else{
					if(nowSpriteId == stDash){
						loadSprite(stDashJump);
						mt.y = 0;
					}else{
						loadSprite(stForwardJump);
					}
				}
			}else{
				// クリンチ（掴み）判定
				var cl = checkOverlap(rootX, rootY);
				if(enableFreeMove && cl !== void && !input.command[cmdRoll]){
					switch(nowSpriteId)
					{
						case stDash:
							if(inkey.x == 0) {
								loadSprite(stStanding);
							}
							if((inkey.x>0 && rootX<cl.rootX-20)||(inkey.x<0 && cl.rootX+20<rootX)) inkey.x = 0;
//							mt.x = 0;
//							return;
						default:
							if(cl.enableClinched && cl.nowSpriteId!=stAttack1 && cl.nowSpriteId!=stAttack2){
								attackIndex = 0;
//								comboCount = 0;
								clinchEnemy = cl;
								clinch(cl);
								mt.reset();
								return mt;
							}else{
								if(cl.altitude == 0){
									if(inkey.x==0 && inkey.y==0 && nowSpriteId!=stStanding) {
										loadSprite(stStanding);
									}
									if((inkey.x>0 && rootX<cl.rootX-20)||(inkey.x<0 && cl.rootX+20<rootX)) inkey.x = 0;
									if((inkey.y>0 && rootY<cl.rootY)||(inkey.y<0 && cl.rootY<rootY)) inkey.y = 0;
								}
							}
					}
				}
				if(inkey.x==0 & inkey.y==0){
					// レバー中立状態
					if(nowSpriteId != stStanding && (nowSpriteId < stStanding2 || nowSpriteId > stStanding4)) {
						loadSprite(stStanding);
					}
					mt.set(0, 0, 0);
					ext -= 0.2;
				}else{
					// レバーが倒されている
					if(input.command[cmdDash]){
						// ダッシュコマンドが入力された
						input.done(keyDash);
						if(nowSpriteId != stDash){
							loadSprite(stDash);
						}
						mt.set(Math.abs(mt.x)*inkey.x, Math.abs(mt.y)*inkey.y, 0);
						ext += 0.45;
					}else if(input.command[cmdRoll]){
						// ロールコマンドが入力された
						if(nowSpriteId != stRoll1 && nowSpriteId != stRoll2){
							if(input.direction == 8){
								loadSprite(stRoll1);
							}else{
								loadSprite(stRoll2);
							}
							ext += 3.5;
						}
					}else{
						if(nowSpriteId == stDash && inkey.x!=0 && (inkey.y==0 || sf.adjSlantDash)){
							// ダッシュ中
							mt.set(Math.abs(mt.x)*inkey.x, Math.abs(mt.y)*inkey.y, 0);
							ext += 0.45;
						}else{
							// 通常の歩き
							ext += 0.12;
							switch (nowSpriteId){
								case stStanding:
								case stStanding2:
								case stDash:
								case stUntangle:
									loadSprite(stWalk);
									mt.set(inkey.x, inkey.y, 0);
									break;
								case stWalk:
									attackIndex = 0;
									mt.set(Math.abs(mt.x)*inkey.x, Math.abs(mt.x)*inkey.y/1.5, 0);
									break;
							}
						}
					}
//					if(inverse != layer.inverse) layer.setInverse();
				}
			}
		}else{
			switch (nowSpriteId){
				case stVerticalJump:
				case stDoubleJump:
					if(nowSpriteId==stVerticalJump || lastSpriteId==stVerticalJump){
						// 垂直ジャンプ中はenableMove==falseであっても左右に動ける
						checkInverse(inkey);
						if(inkey.x < 0){
							mt.x = -moveSpeed / 2;
							ext += 0.15;
						}
						if(inkey.x > 0){
							mt.x = moveSpeed / 2;
							ext += 0.15;
						}
					}
					break;
				case stDashAttack:
				case stDashAttack2:
					if(inkey.y < 0){
						mt.y = -moveSpeed / 4;
						ext += 0.15;
					}
					if(inkey.y > 0){
						mt.y = moveSpeed / 4;
						ext += 0.15;
					}
					break;
				case stClinching:
					ext -= 0.25;
					if(input.get(keyJump)){
						input.done(keyJump);
						lastClinchEnemy = clinchEnemy;
						loadSprite(stGoAround);
						mt.set(movingTable[0]);
						ext += 3.5;
					}
					break;
				case stBackClinch:
					ext -= 0.25;
					break;
				case stClinched:
					if(clinchedBy === void || !isvalid clinchedBy){
						untangle();
						break;
					}
					if(input.direction != 0 && input.direction != lastInputDirection){
						releaseStrength += 10;
						if(releaseStrength > clinchedStrength){
//							layer.tag_playse(%['storage'=>'a0000','buf'=>2]);
							if(inExtasy > 0){
								extasyGauge.value /= 3;
							}
							untangle();
						}else{
							if(sprites[stClinchedStruggle]!==void) loadSprite(stClinchedStruggle, true);
							lastInputDirection = input.direction;
						}
//						ext -= 1;
						break;
					}
					if(!inExtasy) ext += 0.20;
					break;
				case stLocked:
					hitRect.set(0, 0, layer.asdWidth, layer.asdHeight);
					if(input.direction != 0 && input.direction != lastInputDirection){
						lastInputDirection = input.direction;
						lockedCount -= 2;
					}
					if(lockedCount <= 0){
						lockedCancel();
					}
					mt.reset();
					break;
				case stGoAround:
					if(input.get(keyAttack)) input.done(keyAttack);
					break;
				case stFalling:
					if(input.get(keyAttack) && input.command[cmdSomersault] && getOtherState("enablecommand2")){
						input.done(keyAttack);
						ext += 4.5;
						loadSprite(stCommand2);
					}
				case stExtasy:
					if(input.direction != 0 && input.direction != lastInputDirection){
						ext -= 0.8;
					}else{
						ext -= 0.25;
					}
					if(extasyGauge.value < extasyGauge.maxValue*0.3){
						layer.trigger('recover');
					}
					break;
				case stStanding3:
					ext -= 0.2;
					break;
				case stDamage2:
					ext -= 0.25;
				case stDamage1:
//					if(inkey.y < 0 && (input.get(keyJump)||input.get(keyAttack)) && enableCounter && checkMP(20)){
					if(input.get(keyJump) && input.get(keyAttack) && enableCounter && checkMP(20) && HP > 0){
						// リカバリー
						input.done(keyJump);
						input.done(keyAttack);
						reduceMP(20);
						ext += 3.5;
						loadSprite(stRecovery);
					}
					break;
				case stSpecial2:
				case stSpecial3:
				case stSpecial9:
				case stSpecial4:
				case stSpecial5:
					ext += 0.18;
					break;
				case stUntangle:
					ext -= 0.7;
					break;
			}
		}

		return mt;
	}


}


class ChocolatSprite extends PlayerSprite
{
	function ChocolatSprite(window, owner, elm){
		super.PlayerSprite(...);

		comboAttackList = [stAttack1, stAttack5, stAttack2, stAttack3];
		clinchAttackList = [stClinchAttack1, stClinchAttack1, stClinchAttack2];

		if(!sf.adjEnableNewArts){
			attackListForPc = %[
				stStanding		=> [	stAttack1,		stDashAttack,		stHolding,		stAttack4,		stCommand1,		stCommand2,		stCommand3],
				stAttack1		=> [	stAttack5,		stDashAttack,		stCommand1,		stCommand2,		stCommand3	],
				stAttack5		=> [	stAttack2,		stDashAttack,		stCommand1,		stCommand2,		stCommand3	],
				stAttack2		=> [	stAttack3,		stDashAttack,		stCommand1,		stCommand2,		stCommand3	],
				stDashAttack	=> [	stCommand1,		stCommand2,			stCommand3	],
				stCommand1		=> [	stCommand3,		stCommand2	],
				stCommand2		=> [	stCommand3,		stCommand1	],
				stCommand3		=> [	stSpecial5	],
				stAttack4		=> [	stCommand3	],
				stAttack3		=> [	stSpecial5	],
				stRecovery		=> [	stHolding,		stAttack4,		stSpecial5]
			];
		}else{
			attackListForPc = %[
				stStanding		=> [	stAttack1,		stDashAttack,		stHolding,		stAttack4,		stCommand1,		stCommand2,		stCommand3],
				stAttack1		=> [	stAttack5,		stDashAttack,		stCommand1,		stCommand2,		stCommand3	],
				stAttack5		=> [	stAttack2,		stDashAttack,		stCommand1,		stCommand2,		stCommand3	],
				stAttack2		=> [	stAttack3,		stDashAttack,		stCommand1,		stCommand2,		stCommand3	],
				stDashAttack	=> [	stCommand1,		stCommand2,			stCommand3	],
				stCommand1		=> [	stCommand3,		stCommand2	],
				stCommand2		=> [	stCommand3,		stCommand1	],
				stCommand3		=> [	stSpecial6,		stSpecial5	],
				stAttack4		=> [	stCommand3	],
				stAttack3		=> [	stSpecial5	],
				stFalling		=> [	stSpecial6	],
				stRecovery		=> [	stHolding,		stAttack4,		stSpecial5]
			];
		}

		attackListCommand = %[
			stAttack1		=> "input.set(keyAttack), pc.attackWait=8",
			stAttack2		=> "input.set(keyAttack), pc.attackWait=8",
			stAttack3		=> "input.set(keyAttack), pc.attackWait=8",
			stAttack4		=> "input.command[cmdSonicBoom]=true, input.set(keyAttack), pc.attackWait=10",
			stAttack5		=> "input.set(keyAttack), pc.attackWait=8",
			stDashAttack	=> "input.command[cmdDash]=true, input.set(keyAttack), pc.attackWait=12",
			stCommand1		=> "input.command[cmdRHadouken]=true, input.set(keyAttack), pc.attackWait=14",
			stCommand2		=> "input.command[cmdHadouken]=true,  input.set(keyAttack), pc.attackWait=14",
			stCommand3		=> "input.command[cmdSomersault]=true, input.set(keyAttack), pc.attackWait=intrandom(14,20)",
			stVerticalJump	=> "input.set(keyJump), pc.attackWait = 3",
			stJumpAttack1	=> "input.set(keyJump), pc.attackWait = 5",
			stJumpAttack2	=> "input.direction=((inverse)?dRight:dLeft),input.set(keyJump), pc.attackWait = 5",
			stSpecial1		=> "input.set(keyEscAttack), pc.attackWait=10",
			stSpecial2		=> "input.command[cmdGenocidePhantom]=true, input.set(keySpecial), pc.attackWait=60",
			stSpecial3		=> "input.command[cmdSomersault]=true, input.set(keySpecial)",
			stSpecial4		=> "input.command[cmdSomersault]=true, input.set(keySpecial)",
			stSpecial5		=> "input.command[cmdDash]=true, input.set(keySpecial)",
			stSpecial6		=> "input.command[cmdHadouken]=true, input.set(keySpecial)",
			stSpecial7		=> "input.command[cmdYogaFlame]=true, input.set(keySpecial)",
			stSpecial8		=> "input.command[cmdSomersault]=true, input.set(keyJump), input.set(keyAttack)",
			stRecovery		=> "input.set(keyJump), input.set(keyAttack), pc.attackWait=5",
			stHolding		=> "input.set(keyJump), input.set(keyAttack), pc.attackWait=5"
		];

		name = "エクセルショコラ";
		chara = chrChocolat;
		depth = 20;

		faceStorage = "face2";
		selectIndicatorStorage = "selectIndicator02";

		maxHP = HP = f.maxHP;
		maxMP = MP = 200;
		recoveryMP = 0.05;

		moveSpeed = 2.8;
	}

	function initSpriteTable()
	{
		sprites[stStanding]			 = ["p10_standing",			"p11_standing",			"p12_standing",			"p13_standing",			"p14_standing"];
		sprites[stWalk]				 = ["p10_walk",				"p11_walk",				"p12_walk",				"p13_walk",				"p14_walk"];
		sprites[stFalling]			 = ["p10_falling",			"p11_falling",			"p12_falling",			"p13_falling",			"p14_falling"];
		sprites[stDash]				 = ["p10_dash",				"p11_dash",				"p12_dash",				"p13_dash",				"p14_dash"];
		sprites[stRoll1]			 = ["p10_roll1",			"p11_roll1",			"p12_roll1",			"p13_roll1",			"p14_roll1"];
		sprites[stRoll2]			 = ["p10_roll2",			"p11_roll2",			"p12_roll2",			"p13_roll2",			"p14_roll2"];
		sprites[stLanding]			 = ["p10_landing",			"p11_landing",			"p12_landing",			"p13_landing",			"p14_landing"];
		sprites[stLanding2]			 = ["p10_landing2",			"p11_landing2",			"p12_landing2",			"p13_landing2",			"p14_landing2"];
		sprites[stStandUp]			 = ["p10_standup",			"p11_standup",			"p12_standup",			"p13_standup",			"p14_standup"];
		sprites[stStandUp2]			 = ["p10_standup2",			"p11_standup2",			"p12_standup2",			"p13_standup2",			"p14_standup2"];
		sprites[stSitDown]			 = ["p10_sitdown",			"p11_sitdown",			"p12_sitdown",			"p13_sitdown",			"p14_sitdown"];
		sprites[stSitDown2]			 = ["p10_sitdown2",			"p11_sitdown2",			"p12_sitdown2",			"p13_sitdown2",			"p14_sitdown2"];
		sprites[stStanding2]		 = ["p10_standing2",		"p11_standing2",		"p12_standing2",		"p13_standing2",		"p14_standing2"];
		sprites[stStanding3]		 = ["p10_standing3",		"p11_standing3",		"p12_standing3",		"p13_standing3",		"p14_standing3"];
		sprites[stExtasy]			 = ["p10_extasy",			"p11_extasy",			"p12_extasy",			"p13_extasy",			"p14_extasy"];
		sprites[stVerticalJump]		 = ["p10_verticaljump",		"p11_verticaljump",		"p12_verticaljump",		"p13_verticaljump",		"p14_verticaljump"];
		sprites[stForwardJump]		 = ["p10_forwardjump",		"p11_forwardjump",		"p12_forwardjump",		"p13_forwardjump",		"p14_forwardjump"];
		sprites[stDashJump]			 = ["p10_dashjump",			"p11_dashjump",			"p12_dashjump",			"p13_dashjump",			"p14_dashjump"];
	// パンチ１
		sprites[stAttack1]			 = ["p10_punch1",			"p11_punch1",			"p12_punch1",			"p13_punch1",			"p14_punch1"];
	// パンチ２
		sprites[stAttack2]			 = ["p10_punch2",			"p11_punch2",			"p12_punch2",			"p13_punch2",			"p14_punch2"];
	// キック
		sprites[stAttack3]			 = ["p10_kick1",			"p11_kick1",			"p12_kick1",			"p13_kick1",			"p14_kick1"];
	// スライディング
		sprites[stAttack4]			 = ["p10_kick2",			"p11_kick2",			"p12_kick2",			"p13_kick2",			"p14_kick2"];
		sprites[stAttack5]			 = ["p10_punch1",			"p11_punch1",			"p12_punch1",			"p13_punch1",			"p14_punch1"];
		sprites[stDashAttack]		 = ["p10_dashattack",		"p11_dashattack",		"p12_dashattack",		"p13_dashattack",		"p14_dashattack"];
		sprites[stJumpAttack1]		 = ["p10_jumpkick1",		"p11_jumpkick1",		"p12_jumpkick1",		"p13_jumpkick1",		"p14_jumpkick1"];
		sprites[stJumpAttack2]		 = ["p10_jumpkick2",		"p11_jumpkick2",		"p12_jumpkick2",		"p13_jumpkick2",		"p14_jumpkick2"];
		sprites[stDamage1]			 = ["p10_damage1",			"p11_damage1",			"p12_damage1",			"p13_damage1",			"p14_damage1"];
		sprites[stDamage2]			 = ["p10_damage2",			"p11_damage2",			"p12_damage2",			"p13_damage2",			"p14_damage2"			,"p15_damage2"];
		sprites[stDown]				 = ["p10_down",				"p11_down",				"p12_down",				"p13_down",				"p14_down"				,"p15_down"];
		sprites[stClinching]		 = ["p10_clinching",		"p11_clinching",		"p12_clinching",		"p13_clinching",		"p14_clinching"];
		sprites[stClinchAttack1]	 = ["p10_clinchattack1",	"p11_clinchattack1",	"p12_clinchattack1",	"p13_clinchattack1",	"p14_clinchattack1"];
		sprites[stClinchAttack2]	 = ["p10_clinchattack2",	"p11_clinchattack2",	"p12_clinchattack2",	"p13_clinchattack2",	"p14_clinchattack2"];
		sprites[stClinched]			 = ["p10_clinched1a",		"p11_clinched1a",		"p12_clinched1a",		"p13_clinched1a",		"p14_clinched1a"];
		sprites[stClinchedStruggle]	 = ["p10_clinched1b",		"p11_clinched1b",		"p12_clinched1b",		"p13_clinched1b",		"p14_clinched1b"];
		sprites[stUntangle]			 = ["p10_standing",			"p11_standing",			"p12_standing",			"p13_standing",			"p14_standing"];
		sprites[stRelease]			 = ["p10_release",			"p11_release",			"p12_release",			"p13_release",			"p14_release"];
		sprites[stHolding]			 = ["p10_holding",			"p11_holding",			"p12_holding",			"p13_holding",			"p14_holding"];
		sprites[stHolding2]			 = ["p10_holding2",			"p11_holding2",			"p12_holding2",			"p13_holding2",			"p14_holding2"];
		sprites[stGoAround]			 = ["p10_goaround",			"p11_goaround",			"p12_goaround",			"p13_goaround",			"p14_goaround"];
		sprites[stRecovery]			 = ["p10_recovery",			"p11_recovery",			"p12_recovery",			"p13_recovery",			"p14_recovery"];
		sprites[stBackClinch]		 = ["p10_backClinch",		"p11_backClinch",		"p12_backClinch",		"p13_backClinch",		"p14_backClinch"];
		sprites[stThrow1]			 = ["p10_throw1",			"p11_throw1",			"p12_throw1",			"p13_throw1",			"p14_throw1"];
		sprites[stThrow2]			 = ["p10_throw2",			"p11_throw2",			"p12_throw2",			"p13_throw2",			"p14_throw2"];
		sprites[stThrown1]			 = ["p10_thrown1",			"p11_thrown1",			"p12_thrown1",			"p13_thrown1",			"p14_thrown1"];
		sprites[stThrown2]			 = ["p10_thrown2",			"p11_thrown2",			"p12_thrown2",			"p13_thrown2",			"p14_thrown2"];
		sprites[stThrown3]			 = ["p10_thrown3",			"p11_thrown3",			"p12_thrown3",			"p13_thrown3",			"p14_thrown3"];
		sprites[stThrown4]			 = ["p10_thrown4",			"p11_thrown4",			"p12_thrown4",			"p13_thrown4",			"p14_thrown4"];
		sprites[stThrown5]			 = ["p10_thrown5",			"p11_thrown5",			"p12_thrown5",			"p13_thrown5",			"p14_thrown5"];
		sprites[stThrown6]			 = ["p10_thrown6",			"p11_thrown6",			"p12_thrown6",			"p13_thrown6",			"p14_thrown6"];
		sprites[stThrown7]			 = ["p10_thrown7",			"p11_thrown7",			"p12_thrown7",			"p13_thrown7",			"p14_thrown7"];
		sprites[stThrown8]			 = ["p10_thrown8",			"p11_thrown8",			"p12_thrown8",			"p13_thrown8",			"p14_thrown8"];
		sprites[stThrown9]			 = ["p10_thrown9",			"p11_thrown9",			"p12_thrown9",			"p13_thrown9",			"p14_thrown9"];
	// 無敵技
		sprites[stSpecial1]			 = ["p10_special1",			"p11_special1",			"p12_special1",			"p13_special1",			"p14_special1"];
	// パニッシュメントハンマー
		sprites[stSpecial2]			 = ["p10_special2",			"p11_special2",			"p12_special2",			"p13_special2",			"p14_special2"];
	// ショコラコレダー
		sprites[stSpecial3]			 = ["p10_special3",			"p11_special3",			"p12_special3",			"p13_special3",			"p14_special3"];
	// ブリザーディックダウナー
		sprites[stSpecial4]			 = ["p10_special4",			"p11_special4",			"p12_special4",			"p13_special4",			"p14_special4"];
	// Exフォースジャベリン
		sprites[stSpecial5]			 = ["p10_special5",			"p11_special5",			"p12_special5",			"p13_special5",			"p14_special5"];
	// ヘルダイブボマー
		sprites[stSpecial6]			 = ["p10_special6",			"p11_special6",			"p12_special6",			"p13_special6",			"p14_special6"];
	// 波動拳
		sprites[stSpecial7]			 = ["p10_special7",			"p11_special7",			"p12_special7",			"p13_special7",			"p14_special7"];
	// プラズマバインド
		sprites[stSpecial8]			 = ["p10_special8",			"p11_special8",			"p12_special8",			"p13_special8",			"p14_special8"];
	// スターライトエクスキューション
		sprites[stSpecial9]			 = ["p10_special9",			"p11_special9",			"p12_special9",			"p13_special9",			"p14_special9"];
	// 波動拳コマンド１
		sprites[stCommand1]			 = ["p10_command1",			"p11_command1",			"p12_command1",			"p13_command1",			"p14_command1"];
	// 波動拳コマンド２
		sprites[stCommand2]			 = ["p10_command2",			"p11_command2",			"p12_command2",			"p13_command2",			"p14_command2"];
	// 対空技
		sprites[stCommand3]			 = ["p10_command3",			"p11_command3",			"p12_command3",			"p13_command3",			"p14_command3"];
		sprites[stEtc1]				 = ["p10_etc1",				"p11_etc1",				"p12_etc1",				"p13_etc1",				"p14_etc1"];
		sprites[stEtc2]				 = ["p10_etc2",				"p11_etc2",				"p12_etc2",				"p13_etc2",				"p14_etc2"];
		sprites[stEtc3]				 = ["p10_etc3",				"p11_etc3",				"p12_etc3",				"p13_etc3",				"p10_etc3"];
		sprites[stEtc4]				 = ["p10_etc4",				"p10_etc4",				"p10_etc4",				"p10_etc4",				"p10_etc4"];
		sprites[stEtc8]				 = ["p10_etc8",				"p10_etc8",				"p10_etc8",				"p10_etc8",				"p14_etc8"];
		sprites[stEtc9]				 = ["p10_etc9",				"p11_etc9",				"p12_etc9",				"p13_etc9",				"p14_etc9"];
		sprites[stWinning]			 = ["p10_winning",			"p11_winning",			"p12_winning",			"p13_winning",			"p14_winning"];
		sprites[stDummy]			 = ["dummy",				"dummy",				"dummy",				"dummy",				"dummy"];

		if(extasyGauge !==void && extasyGauge.enabled){
			sprites[stWalk]			 = ["p10_walk2",			"p11_walk2",			"p12_walk2",			"p13_walk2",			"p14_walk"];
		}

		spriteTableChangeFlag = false;
	}

	function inputProcess(mt)
	{
		// 入力に応じた行動をさせる

		var inkey = new MovingTable();
		if(enableFreeMove) inkey.set(checkDirection(input.direction));

		var nsp = owner.notSelectingPlayer;
		if(enableFreeMove && nowSpriteId!==stLocked && extasyGauge.value<extasyGauge.maxValue){
//			if(nsp !== void && nsp.HP > 0 && input.get(keySpecial) && input.command[cmdExcution] && (nowNearbyOtherPlayer(50) || sf.adjSinglePlayMode) && altitude == fAltitude && enableCommand && nsp.enableCommand){
			var nmp = bao.players[!id];
			if(nmp !== void && nmp.HP > 0 && input.get(keySpecial) && input.command[cmdExcution] && altitude == fAltitude && enableCommand){
				// スターライトエクスキューション
				input.done(keySpecial);
				if(sf.adjSinglePlayMode){
					nmp.rootX = (rootX < bao.internalWidth / 2)? rootX + 40: rootX - 40;
					nmp.rootY = (rootY < (nmp.movableRect.top + nmp.movableRect.bottom) / 2)? rootY + 8: rootY - 8;
				}
				if(checkMP(150) && nmp.checkMP(150)){
					input.done(keyEscAttack);
					input.history.clear();
					reduceMP(150);
					if(!sf.adjSinglePlayMode){
						nmp.reduceMP(150);
					}else{
						nmp.reduceMP(75);
					}
					loadSprite(stSpecial9);
					bao.players[!id].loadSprite(stSpecial9);
					if((sf.actionSceneCutin)&&(!sf.sameCutinDisable||(owner.tickCount - lastCutinTick > 900))){
						owner.cutinLayer[1].loadImages(%["storage"=>"cutin21","inverse"=>inverse,"caller"=>this]);
						lastCutinTick = owner.tickCount;
					}
				}

			}else if(input.get(keySpecial) && (int(altitude)-fAltitude)==0 && input.command[cmdGenocidePhantom] && nowSpriteId != stDamage2 && (nowSpriteId < stSpecial1 || nowSpriteId > stSpecial9) && nowSpriteId != stClinching && nowSpriteId != stBackClinch){
				input.done(keySpecial);
				if(checkMP(150)){
					// パニッシュメントハンマー
					input.done(keyEscAttack);
					reduceMP(150);
					special2Tick = owner.tickCount;
					loadSprite(stSpecial2);
					initSpriteTable();
					if((sf.actionSceneCutin)&&(!sf.sameCutinDisable||(owner.tickCount - lastCutinTick > 900))){
						owner.cutinLayer[1].loadImages(%["storage"=>"cutin11","inverse"=>inverse,"caller"=>this]);
						lastCutinTick = owner.tickCount;
					}
				}
			}else if(input.get(keySpecial) && (int(altitude)-fAltitude)==0 && input.command[cmdSomersault] && checkMP(50) && (nowSpriteId == stClinching || nowSpriteId == stBackClinch)){
				// 必殺技 投げ
				switch(nowSpriteId){
					clinchEnemy.lockedCount = 0;
					case stClinching:
						// ショコラコレダー
						input.done(keySpecial);
						input.done(keyEscAttack);
						reduceMP(50);
						loadSprite(stSpecial3);
						clinchEnemy.loadSprite(stThrown5);
//						layer.conductor.mp.throwEnemy = clinchEnemy;
						break;
					case stBackClinch:
						// ブリザーディックダウナー
						input.done(keySpecial);
						input.done(keyEscAttack);
						reduceMP(50);
						loadSprite(stSpecial4);
						clinchEnemy.loadSprite(stThrown6);
//						layer.conductor.mp.throwEnemy = clinchEnemy;
						break;
				}
			}else if(input.get(keySpecial) && nowSpriteId == stSpecial3 && !layer.conductor.mp.sp3repeat && checkMP(20)){
				// ショコラコレダー延長
				input.done(keySpecial);
				input.done(keyEscAttack);
				layer.conductor.mp.sp3repeat = true;
			}else if(sf.adjEnableNewArts && (enableAttack || enableCommand) && input.get(keySpecial) && checkMP(25) && input.command[cmdYogaFlame] && (altitude - fAltitude == 0)){
				// ポジトロンキャノン
				input.done(keySpecial);
				input.done(keyEscAttack);
				reduceMP(25);
				inverse = (input.lastInputLeftRight == 1);
				loadSprite(stSpecial7);
				ext += 9;
			}else if(sf.adjEnableNewArts && (enableAttack || enableCommand) && input.get(keyAttack) && input.get(keyJump) && input.command[cmdSomersault] && checkMP(50) && (altitude - fAltitude == 0)){
				// プラズマバインド
				input.done(keyAttack);
				input.done(keyJump);
				reduceMP(50);
				inverse = (input.lastInputLeftRight == 1);
				loadSprite(stSpecial8);
				ext += 9;
			}else if(input.get(keySpecial) && ((nowSpriteId == stDash || input.command[cmdDash] || input.command[cmdDash2]) && checkMP(50))
				&& (enableMove || (enableCommand && ((nowSpriteId >= stDashAttack && nowSpriteId <= stDashAttack3) || (nowSpriteId >= stSpecial1 && nowSpriteId <= stCommand6))) || getOtherState('enablespecial5'))){
					// 必殺技 Exフォースジャベリン
					input.done(keySpecial);
					input.done(keyEscAttack);
					reduceMP(50);
					inverse = (input.lastInputLeftRight == 1);
					loadSprite(stSpecial5);
//					ext += 9;
			}else if(input.get(keyAttack) && (input.command[cmdSomersault] || input.command[cmdGenocidePhantom]) && getOtherState('enablecommand3')){
				//
				input.done(keyAttack);
				inverse = (input.lastInputLeftRight == 1);
				loadSprite(stCommand3);
				ext += 4.5;
			}else if(sf.adjEnableNewArts && input.get(keySpecial) && inkey.x != 0 && checkMP(10) && (((altitude - fAltitude > 60) && (enableAttack || enableCommand)) || getOtherState('enablespecial5') || getOtherState('enablespecial6'))){
				// 空中ヘルダイブボマー
				input.done(keySpecial);
				input.done(keyEscAttack);
				reduceMP(10);
				inverse = (input.lastInputLeftRight == 1);
				if(altitude - fAltitude == 0){
					loadSprite(stSpecial6, , "*altitude0");
				}else{
					loadSprite(stSpecial6);
				}
				ext += 9;
			}else if(sf.adjEnableNewArts && input.get(keySpecial) && input.command[cmdHadouken] && checkMP(10) && (((altitude - fAltitude == 0) && (enableAttack || enableCommand)) || getOtherState('enablespecial5') || getOtherState('enablespecial6'))){
				// 地上ヘルダイブボマー
				input.done(keySpecial);
				input.done(keyEscAttack);
				reduceMP(10);
				inverse = (input.lastInputLeftRight == 1);
				loadSprite(stSpecial6, , "*altitude0");
				ext += 9;
			}else if(input.get(keyEscAttack) && ((int(altitude)-fAltitude)==0 || getOtherState('enablespecial1'))){
				input.done(keySpecial);
				input.done(keyEscAttack);
				// 緊急回避技
				switch(nowSpriteId){
					case stDamage2:
					case stCommand5:
					case stSpecial1:
					case stSpecial2:
					case stSpecial3:
					case stSpecial5:
					case stSpecial9:
//					case stSpecial4:
					case stThrow1:
					case stThrow2:
					case stThrown1:
					case stThrown2:
					case stThrown3:
					case stThrown4:
					case stExtasy:
					case stDummy:
					case stUntangle:
					case stStandUp:
						break;
					case stClinched:
					case stClinchedStruggle:
						// イッてるときは無効
						if(inExtasy > 0) break;
//						if(owner.informLayer.extasyGaugeLayer.enabled) break;
						if(clinchedBy !== void && isvalid clinchedBy && clinchedBy.kind == "人造人間" && clinchedBy.nowSpriteId == stThrow1) break;
					default:
//						// ジェノサイドファントム発動後15フレーム以内ならMP消費無し
//						if(owner.tickCount-special2Tick>15){
//							reduceMP(50);
//						}
						if(checkMP(50)){
							reduceMP(50);
							mt.y = 0;
							loadSprite(stSpecial1);
							initSpriteTable();
							ext += 6;
							attackTick = owner.tickCount;
						}
				}

			}else if(enableAttack){
				if(input.get(keyAttack)){
					if(input.get(keyJump)){
						if((nowSpriteId >= stClinching && nowSpriteId <= stClinchAttack3) || nowSpriteId == stThrow2){
							// 突き放し
							input.done(keyAttack);
							input.done(keyJump);
							ext += 3.5;
							loadSprite(stRelease);
							var e= clinchEnemy;
							if(e === void) e = lastClinchEnemy;
							e.invincibleCount = 10;
							e.lockedCount = 0;
							if(inverse == e.inverse) e.inverse = !e.inverse;
							e.loadSprite(stDamage1);
							e.movingTable = [];
							e.enableMove = false;
							e.setMovingTable(%["path" => "(-50,0,0)" , "xaccel" => -1 , "frame" => 15], e.movingTable);
						}else if((nowSpriteId == stAttack1 || nowSpriteId == stVerticalJump || nowSpriteId == stForwardJump) && (int(altitude)-fAltitude)==0 && checkMP(30)){
							// 攻撃しかけやジャンプしかけの場合
							// 掴みに行く
							input.done(keyAttack);
							input.done(keyJump);
							reduceMP(30);
							ext += 3.5;
							loadSprite(stHolding);
						}
					}else{
						// 通常技
						input.done(keyAttack);
						ext += 1.5;
						switch(nowSpriteId)
						{
							case stStanding:
							case stStanding2:
							case stWalk:
							case stAttack1:
							case stAttack2:
							case stAttack3:
								if(input.command[cmdDash]){
									loadSprite(stDashAttack);
									break;
								}else if(input.command[cmdSonicBoom]){
	//								if(!inverse&&input.lastInputLeftRight==1 || inverse&&input.lastInputLeftRight==-1) inverse = !inverse;
									checkInverse(input.lastInputLeftRight);
									loadSprite(stAttack4);
	//								if(inverse != layer.inverse) layer.setInverse();
									break;
								}else if(input.command[cmdHadouken]){
									checkInverse(input.lastInputLeftRight);
									loadSprite(stCommand2);
									break;
								}else if(input.command[cmdRHadouken]){
									checkInverse(input.lastInputLeftRight);
									loadSprite(stCommand1);
									break;
								}else if(input.command[cmdSomersault] || input.command[cmdGenocidePhantom]){
	//								checkInverse(input.lastInputLeftRight);
									loadSprite(stCommand3);
									break;
								}else if(input.get(keyJump) && checkMP(20) && (int(altitude)-fAltitude)<15){
									input.done(keyJump);
									reduceMP(30);
									ext += 3.5;
									loadSprite(stHolding);
									break;
								}

								if(attackIndex > comboAttackList.count-1) attackIndex = 0;
	//							if(attackIndex > 0 && attackIndex == lastAttackIndex){
	//								if(attackIndex == 1) attackIndex = 0;
	//								if(nowSpriteId >= stAttack2) attackIndex++;
	//							}
								checkInverse(inkey);
	//							if(inverse != layer.inverse) layer.setInverse();
								loadSprite(comboAttackList[attackIndex]);
								lastAttackIndex = attackIndex;
								attackTick = owner.tickCount;
								break;
							case stDash:
								checkInverse(inkey);
								loadSprite(stDashAttack);
								mt.y = 0;
								break;
							case stForwardJump:
							case stVerticalJump:
							case stFalling:
							case stDashJump:
								if(input.direction == 2){
									loadSprite(stJumpAttack2, true);
								}else{
									loadSprite(stJumpAttack1, true);
								}
								break;
							case stClinching:
								if((inverse!=clinchEnemy.inverse) && ((inverse && inkey.x==-1)||(!inverse && inkey.x==1))){
									clinchEnemy.lockedCount = 0;
									loadSprite(stThrow1);
									clinchEnemy.loadSprite(stThrown3);
								}else{
									if(attackIndex > clinchAttackList.count-1) attackIndex = 0;
									loadSprite(clinchAttackList[attackIndex]);
									if(attackIndex == clinchAttackList.count-1) attackIndex = -1;
									attackTick = owner.tickCount;
								}
								break;
							case stBackClinch:
								clinchEnemy.lockedCount = 0;
								loadSprite(stThrow2);
								clinchEnemy.loadSprite(stThrown4);
								break;
						}
					}
				}
			}else if(enableCommand){
				if(input.get(keyAttack)){
					if(input.command[cmdHadouken]){
						switch(nowSpriteId)
						{
							case stCommand2:
								//何もしない
								break;
							default:
								ext += 4.5;
								input.done(keyAttack);
//								checkInverse(input.lastInputLeftRight);
								loadSprite(stCommand2);
								break;
						}
					}else if(input.command[cmdRHadouken]){
						switch(nowSpriteId)
						{
							case stCommand1:
								//何もしない
								break;
							default:
								ext += 4.5;
//								checkInverse(input.lastInputLeftRight);
								input.done(keyAttack);
								loadSprite(stCommand1);
								break;
						}
					}else if(input.command[cmdGenocidePhantom] || input.command[cmdSomersault]){
						if(nowSpriteId != stCommand3){
							ext += 4.5;
//							checkInverse(input.lastInputLeftRight);
							input.done(keyAttack);
							loadSprite(stCommand3);
						}
					}else if(input.command[cmdSonicBoom]){
						switch(nowSpriteId)
						{
							case stDashAttack:
								ext += 4.5;
								input.done(keyAttack);
								loadSprite(stAttack4);
								break;
//							case stAttack5:
//								ext += 4.5;
//								loadSprite(stAttack5);
//								break;
							default:
//								ext += 4.5;
//								checkInverse(input.lastInputLeftRight);
//								loadSprite(stCommand3);
//								break;
						}
					}if(input.get(keyJump)){
						if((nowSpriteId == stRecovery || nowSpriteId == stFalling || nowSpriteId == stLanding) && checkMP(30) && (int(altitude)-fAltitude)<15){
							input.done(keyAttack);
							input.done(keyJump);
							reduceMP(30);
							ext += 3.5;
							loadSprite(stHolding);
						}
					}

				}
			}else{
				if(((owner.tickCount-input.state[keyJump].tick<2)&&input.get(keyAttack)) || ((owner.tickCount-input.state[keyAttack].tick<2)&&input.get(keyJump))){
					if((lastHoldingTick < owner.tickCount - 30) && ((nowSpriteId >= stClinching && nowSpriteId <= stClinchAttack3) || nowSpriteId == stThrow2)){
						// 突き放し
						input.done(keyAttack);
						input.done(keyJump);
						ext += 3.5;
						loadSprite(stRelease);
						var e= clinchEnemy;
						if(e === void) e = lastClinchEnemy;
						e.invincibleCount = 10;
						e.lockedCount = 0;
						if(inverse == e.inverse) e.inverse = !e.inverse;
						e.loadSprite(stDamage1);
						e.movingTable = [];
						e.enableMove = false;
						e.setMovingTable(%["path" => "(-50,0,0)" , "xaccel" => -1 , "frame" => 15], e.movingTable);
					}else if(sf.adjEnableNewArts && (nowSpriteId == stAttack1 || nowSpriteId == stCommand3 || nowSpriteId == stVerticalJump || nowSpriteId == stForwardJump) && (int(altitude)-fAltitude)<10){
						// 攻撃しかけやジャンプしかけの場合
						if(input.command[cmdSomersault] && checkMP(50)){
							input.done(keyAttack);
							input.done(keyJump);
							reduceMP(50);
							inverse = (input.lastInputLeftRight == 1);
							loadSprite(stSpecial8);
							ext += 9;
						}else if(checkMP(30)){
							// 掴みに行く
							input.done(keyAttack);
							input.done(keyJump);
							reduceMP(30);
							ext += 3.5;
							loadSprite(stHolding);
						}
//					}else if((nowSpriteId == stAttack1 || nowSpriteId == stVerticalJump || nowSpriteId == stForwardJump) && (int(altitude)-fAltitude)==0 && checkMP(30)){
//						// 攻撃しかけやジャンプしかけの場合
//						// 掴みに行く
//						input.done(keyAttack);
//						input.done(keyJump);
//						reduceMP(30);
//						ext += 3.5;
//						loadSprite(stHolding);
					}
				}
			}
		}

		if(enableMove){
			clinchedStrength = 0;
			releaseStrength = 0;
//			if(spriteTableChangeFlag) initSpriteTable();
			checkInverse(inkey);
			if(input.get(keyJump)){
				input.done(keyJump);
				// ジャンプキーが押された
				if(input.get(keyAttack)){
					input.done(keyAttack);
					if((nowSpriteId >= stClinching && nowSpriteId <= stClinchAttack3) || nowSpriteId == stThrow2){
						// 突き放し
						ext += 3.5;
						loadSprite(stRelease);
						var e= clinchEnemy;
						if(e === void) e = lastClinchEnemy;
						e.invincibleCount = 10;
						e.lockedCount = 0;
						if(inverse == e.inverse) e.inverse = !e.inverse;
						e.loadSprite(stDamage1);
						e.movingTable = [];
						e.enableMove = false;
						e.setMovingTable(%["path" => "(-50,0,0)" , "xaccel" => -1 , "frame" => 15], e.movingTable);
					}else if((int(altitude)-fAltitude)==0 && checkMP(30)){
						// 掴みに行く
						reduceMP(30);
						ext += 3.5;
						loadSprite(stHolding);
					}else{
						if(attackIndex > comboAttackList.count-1) attackIndex = 0;
						loadSprite(comboAttackList[attackIndex]);
						lastAttackIndex = attackIndex;
						attackTick = owner.tickCount;
						ext += 1.5;
					}
				}else{
					if(inkey.x == 0){
						loadSprite(stVerticalJump);
					}else{
						if(nowSpriteId == stDash){
							loadSprite(stDashJump);
							mt.y = 0;
						}else{
							loadSprite(stForwardJump);
						}
					}
				}
			}else{
				// クリンチ（掴み）判定
				var cl = checkOverlap(rootX, rootY);
				if(enableFreeMove && cl !== void && !input.command[cmdRoll]){
					switch(nowSpriteId)
					{
						case stDash:
							if(inkey.x == 0) loadSprite(stStanding);
							if((inkey.x>0 && rootX<cl.rootX-20)||(inkey.x<0 && cl.rootX+20<rootX)) inkey.x = 0;
//							mt.x = 0;
//							return;
						default:
							if(cl.enableClinched && cl.nowSpriteId!=stAttack1 && cl.nowSpriteId!=stAttack2){
								attackIndex = 0;
//								comboCount = 0;
								clinchEnemy = cl;
								clinch(cl);
								mt.reset();
								return mt;
							}else{
								if(cl.altitude == 0){
									if(inkey.x==0 && inkey.y==0 && nowSpriteId!=stStanding) loadSprite(stStanding);
									if((inkey.x>0 && rootX<cl.rootX-20)||(inkey.x<0 && cl.rootX+20<rootX)) inkey.x = 0;
									if((inkey.y>0 && rootY<cl.rootY)||(inkey.y<0 && cl.rootY<rootY)) inkey.y = 0;
								}
							}
					}
				}
				if(inkey.x==0 & inkey.y==0){
					// レバー中立状態
					if(nowSpriteId != stStanding && (nowSpriteId < stStanding2 || nowSpriteId > stStanding4)) loadSprite(stStanding);
					mt.set(0, 0, 0);
					ext -= 0.2;
				}else{
					// レバーが倒されている
					if(input.command[cmdDash]){
						// ダッシュコマンドが入力された
						input.done(keyDash);
						if(nowSpriteId != stDash){
							loadSprite(stDash);
						}
						mt.set(Math.abs(mt.x)*inkey.x, Math.abs(mt.y)*inkey.y, 0);
						ext += 0.45;
					}else if(input.command[cmdRoll]){
						// ロールコマンドが入力された
						if(nowSpriteId != stRoll1 && nowSpriteId != stRoll2){
							if(input.direction == 8){
								loadSprite(stRoll1);
							}else{
								loadSprite(stRoll2);
							}
							ext += 3.5;
						}
					}else{
						if(nowSpriteId == stDash && inkey.x!=0 && (inkey.y==0 || sf.adjSlantDash)){
							// ダッシュ中
							mt.set(Math.abs(mt.x)*inkey.x, Math.abs(mt.y)*inkey.y, 0);
							ext += 0.45;
						}else{
							// 通常の歩き
							ext += 0.12;
							switch (nowSpriteId){
								case stStanding:
								case stStanding2:
								case stDash:
									loadSprite(stWalk);
									mt.set(inkey.x, inkey.y, 0);
									break;
								case stWalk:
									attackIndex = 0;
									mt.set(Math.abs(mt.x)*inkey.x, Math.abs(mt.x)*inkey.y/1.5, 0);
									break;
							}
						}
					}
//					if(inverse != layer.inverse) layer.setInverse();
				}
			}
		}else{
			switch (nowSpriteId){
				case stVerticalJump:
				case stDoubleJump:
					if(nowSpriteId==stVerticalJump || lastSpriteId==stVerticalJump){
						// 垂直ジャンプ中はenableMove==falseであっても左右に動ける
						checkInverse(inkey);
						if(inkey.x < 0){
							mt.x = -moveSpeed / 2;
							ext += 0.15;
						}
						if(inkey.x > 0){
							mt.x = moveSpeed / 2;
							ext += 0.15;
						}
					}
					break;
				case stClinching:
					ext -= 0.25;
					if(input.get(keyJump) && !input.get(keyAttack)){
						input.done(keyJump);
						lastClinchEnemy = clinchEnemy;
						loadSprite(stGoAround);
						mt.set(movingTable[0]);
						ext += 3.5;
					}
					break;
				case stBackClinch:
					ext -= 0.25;
					break;
				case stClinched:
					if(clinchedBy === void || !isvalid clinchedBy){
						untangle();
						break;
					}
					if(input.direction != 0 && input.direction != lastInputDirection){
						releaseStrength += 10;
						if(releaseStrength > clinchedStrength){
//							layer.tag_playse(%['storage'=>'a0000','buf'=>3]);
							if(inExtasy > 0){
								extasyGauge.value /= 3;
							}
							untangle();
						}else{
							if(sprites[stClinchedStruggle]!==void) loadSprite(stClinchedStruggle, true);
							lastInputDirection = input.direction;
						}
//						ext -= 1;
						break;
					}
					ext += 0.20;
					break;
				case stLocked:
					if(input.direction != 0 && input.direction != lastInputDirection){
						lastInputDirection = input.direction;
						lockedCount -= 2;
					}
					hitRect.set(0, 0, layer.asdWidth, layer.asdHeight);
					if(lockedCount <= 0){
						lockedCancel();
					}
					mt.reset();
					break;
				case stGoAround:
					if(input.get(keyAttack)) input.done(keyAttack);
					break;
				case stExtasy:
					if(input.direction != 0 && input.direction != lastInputDirection){
						ext -= 0.8;
					}else{
						ext -= 0.25;
					}
					if(extasyGauge.value < extasyGauge.maxValue*0.3){
						layer.trigger('recover');
					}
					break;
				case stStanding3:
					ext -= 0.2;
					break;
				case stDamage2:
					ext -= 0.25;
				case stDamage1:
					if(input.get(keyJump) && input.get(keyAttack) && enableCounter && checkMP(20) && HP > 0){
						input.done(keyJump);
						input.done(keyAttack);
						reduceMP(20);
						ext += 3.5;
						loadSprite(stRecovery);
					}
					break;
				case stDashAttack:
				case stAttack4:
				case stCommand1:
				case stCommand2:
				case stDashJump:
					if(((owner.tickCount-input.state[keyJump].tick<2)&&input.get(keyAttack)) || ((owner.tickCount-input.state[keyAttack].tick<2)&&input.get(keyJump))){
						// 掴みに行く
						input.done(keyAttack);
						input.done(keyJump);
						ext += 3.5;
						loadSprite(stHolding);
						break;
					}

				case stSpecial2:
				case stSpecial3:
				case stSpecial4:
				case stSpecial5:
				case stSpecial9:
					ext += 0.18;
					break;
				case stUntangle:
					ext -= 0.7;
					break;
			}
		}

		return mt;
	}


}


class DummyPlayerSprite extends PlayerSprite
{
	function DummyPlayerSprite(window, owner, elm){
		super.PlayerSprite(...);

		name = "ダミー";
		chara = chrChiffon;
		depth = 22;

		faceStorage = "face1";
		selectIndicatorStorage = "selectIndicator01";

		maxHP = HP = f.maxHP;
		maxMP = MP = 200;
		recoveryMP = 0.05;

		moveSpeed = 4;
		shadow = false;

	}


	function initSpriteTable()
	{
		sprites[stStanding]			 = ["dummyplayer_standing"];
		sprites[stWalk]				 = ["dummyplayer_walk"];
		spriteTableChangeFlag = false;
	}


	function inputProcess(mt)
	{
		var inkey = new MovingTable();
		if(enableFreeMove) inkey.set(checkDirection(input.direction));

		if(inkey.x==0 && inkey.y==0){
			var x = owner.dispLayer2.cursorX;
			var y = owner.dispLayer2.cursorY;

			if(x > 0 && x < owner.dispLayer2.width && y > 0 && y < owner.dispLayer2.height-100){
				if(x < 300) inkey.x = -1;
				if(x > owner.dispLayer2.width-300) inkey.x = 1;
			}

		}

		if(enableMove){
			if(inkey.x==0 & inkey.y==0){
				// レバー中立状態
				loadSprite(stStanding);
				mt.set(0, 0, 0);
			}else{
				// レバーが倒されている
				loadSprite(stWalk);
				mt.set(Math.abs(mt.x)*inkey.x,0, 0);
			}
		}
		return mt;
	}

}


class PlayerSprite extends CharacterSprite
{

	// 攻撃リスト
	var comboAttackList = [];
	var clinchAttackList = [];

	// プレイヤーがクリンチしている敵
	var clinchEnemy = void;
	// 最後にクリンチした敵
	var lastClinchEnemy = void;
	// プレイヤーがクリンチされている敵
	var clinchedBy = void;
	// クリンチされているかどうか
	var nowClinched = false;

	// 敵への参照用
	var lastClinchEnemy_reference;
	var clinchedBy_reference;

	// スプライトテーブルが一時書き換えられているかどうか
	var spriteTableChangeFlag = false;

	// 最後にカットインを表示したtick
	var lastCutinTick = -1800;

	// レバガチャ用に最後に入力された方向を保持
	var lastInputDirection = 0;
	// クリンチされている強さ
	var clinchedStrength = 0;
	// クリンチを振りほどく為の強さ（レバガチャ毎に増加してclinchedStrengthの値を超えると脱出）
	var releaseStrength = 0;

	var extasyGauge;
	var ext;

	// イッてるかどうかの状態（0:イッてない 1:イッた 2:イッてる上に組み敷かれてる）
	var inExtasy = 0;

	// 連続で喰らったダメージ回数
	var comboDamageCount = 0;

	// 最後にstSpecial2の攻撃をした時のtick
	var special2Tick = 0;

	// 最後に放った攻撃のindex
	var lastAttackIndex = 0;

	// PlayerCotroller用コンボ定義リスト
	var attackListForPc;
	var attackListForPcArray =[];
	var attackListCommand;

	// PlayerController
	var pc = void;

	// プレイヤーキャラのIDナンバー（基本的に０か１か。いわゆる１Ｐ／２Ｐ）
	var id = 0;

	var kind = "";

	// キャラ判別用（chrChiffon か chrChocolat）
	var chara = 0;

	// 入力オブジェクト
	var input;

	// コンボカウント
	var comboCount = 0;

	// 攻撃が当たったか
	var attackHitFlag = false;

	// 表情ファイル
	var faceStorage = "face";
	var defaultFaceNum = 0;

	// 選択インジケーター
	var selectIndicatorStorage = "selectIndicator01";

	// インジケーターの表示オフセット
	var selectIndicatorOffset = 0;

	// 死んだとき
	var killedBy = void;
	var killedByKind = '';
	var killedBy_reference;

	var dOpacity2Auto = true;

	var comboCountFlag = true;
	var lastHoldingTick = 0;

	var lockedVoiceFlag = false;

	function PlayerSprite(window, owner, elm)
	{
		objectClass = clPlayer;
		kind = elm.kind;

		// スプライトテーブル初期化
		initSpriteTable();

		// 移動可能範囲設定
		movableRect = new Rect2(48, 0, 408, 256);
		if(owner.stageLayer !== void){
			if(movableRect.y1 < owner.stageLayer.topLine) movableRect.y1 = owner.stageLayer.topLine;
			if(movableRect.y2 > owner.stageLayer.bottomLine) movableRect.y2 = owner.stageLayer.bottomLine;
		}

		if(elm.id !== void) id = +elm.id;
		if(elm.cosstate !== void) cosState = +elm.cosstate;
		if(elm.cosState !== void ){
			if(sf.adjCosBreakCount == 99999){
				cosState = 0;
			}else{
				cosState = elm.cosState;
			}
		}
		if(sf.adjEvilCosMode) cosState = 4;

		elm.storage = sprites[stStanding][0];
		elm.graphic = sprites[stStanding][cosState];

		super.CharacterSprite(window, owner, elm);

		// 性感ゲージ作成
		extasyGauge = new NormalGaugeLayer(window, layer);
		extasyGauge.setGauge("gaugeFrame03", "gauge03", 50, 50, 0);
		extasyGauge.enabled = false;

		input = owner.inputs[id];

		// PlayerController
		pc = new PlayerController(this);
	}

	function finalize()
	{
		invalidate pc;
		super.finalize();
	}

	function loadSprite(id, mode=false, label){
//		dm(layer.asd + "/" + getConstFromSpriteId(lastSpriteId) + "(" + layer.conductor.curLine + ") → " + getConstFromSpriteId(id));
		shadowStorage = "";

		if(id!==stClinched && id!==stClinchedStruggle){
			if(chara == chrChiffon){
				kag.se[4].stop();
			}else{
				kag.se[6].stop();
			}
			kag.bgVoice[chara] = '';
		}
		
		super.loadSprite(...);
		attackHitFlag = false;
	}


	function routineProcess(){

//if(nowSpriteId == stClinched && !layer.conductor.running) dm("!!!!");

		if(nowSpriteId == stClinched && !layer.conductor.running){
			// 何かよく分からんが固まってしまう
			loadSprite(stClinchedStruggle);
		}

		// ＭＰ自然回復
		if(!owner.scenarioPaused && HP > 0){
			MP += recoveryMP * sf.adjMPRecoveryRate * ((cosState>2)?1.2:1);
			if(MP > maxMP || sf.adjMPInfinute) MP = maxMP;
		}

//		if(tf.debugMode && owner.nowSelectingPlayer===this && input.get(keyAttack)){
//			dm(input.history.join(""));
//		}

		// シングルプレイモード
		if(dOpacity2Auto){
			if(sf.adjSinglePlayMode && this === bao.getOtherPlayer(bao.nowSelectingPlayer)){
				enableFreeMove = false;
//				if(tf.inRescueMode || tf.toRescueMode || tf.defeated || !owner.informLayer.visible || nowSpriteId==stSpecial1 || nowSpriteId==stSpecial9 || invincibleCount > 0){
				if((!tf.defeated && !owner.informLayer.visible) || nowSpriteId==stSpecial1 || nowSpriteId==stSpecial9 || nowSpriteId==stDown || invincibleCount > 0){
					// レスキューモード、または敗北処理中
					if(layer.opacity2 < 100){
						altitude = fAltitude;
						layer.dOpacity2 = 10;
					}
				}else{
					// 通常時
					if(nowSpriteId != stStanding && nowSpriteId < stEtc1) {
						loadSprite(stStanding);
					}
					if(layer.opacity2 > 0){
						// 表示をフェードアウト
						layer.dOpacity2 = -10;
					}else{
//						rootX = owner.internalWidth / 2;
						altitude = 500;
					}
					return;
				}
			}else{
				if(pc.leaveItMode && bao.informLayer.visible){
					if(layer.opacity2 > 50){
						layer.dOpacity2 = -20;
					}else{
						layer.dOpacity2 = 0;
						layer.opacity2 = 50;
					}
				}else{
					if(layer.opacity2 < 100){
						enableFreeMove = true;
						layer.dOpacity2 = 10;
					}
				}
			}
		}

		super.routineProcess();

		var mt = new MovingTable();
		ext = 0;

		if(clinchEnemy !== void) lastClinchEnemy = clinchEnemy;
//		clinchEnemy = void;
		// クリンチしてるはずの敵をチェック
		var clinchCheckFlag = false;
		if(nowSpriteId == stClinching || nowSpriteId == stBackClinch){
			for(var i=0; i<owner.enemies.count; i++){
				if((owner.enemies[i].nowSpriteId == stClinched || owner.enemies[i].nowSpriteId == stClinchedDamage) && altitude == owner.enemies[i].altitude){

					// その敵をクリンチしてるのは自分
					if(owner.enemies[i].targetPlayer === this){
						if(owner.enemies[i].enableClinched){
							clinchEnemy = owner.enemies[i];
							clinchCheckFlag = true;
						}
						break;
					}

					// その敵をクリンチしてるのは相方
					if(owner.enemies[i] === clinchEnemy && owner.enemies[i].targetPlayer !== void && owner.enemies[i].targetPlayer !== this){
						clinchEnemy = void;
					}

				}
			}
			if(!clinchCheckFlag){
				// クリンチしてるはずの相手がいない（死んだか、もう一人の相方にダメージを受けた）／もしくは高さが違う
				clinchEnemy = void;
				loadSprite(stStanding);
				attackIndex = 0;
			}
		}else if(owner.tickCount - attackTick > 20){
			clinchEnemy = void;
			attackIndex = 0;
			if(owner.tickCount - attackTick > 60 && comboCount > 0){
				if(nowSpriteId == stWalk || nowSpriteId == stStanding){
					addComboScore();
				}
			}
		}


		if(nowSpriteId == stClinched || nowSpriteId == stClinchedStruggle || nowSpriteId == stDown || nowSpriteId == stDamage3){
			addComboScore();
			if(clinchedBy !== void && isvalid clinchedBy){
				// 自分をクリンチしてる（してた）敵がいる
				switch (clinchedBy.nowSpriteId){
					case stStanding:
					case stDamage1:
					case stDamage2:
					case stStandUp:
					case stWalk:
						// しかし今はクリンチしていない
						clinchedBy.clinchPlayer = void;
						clinchedBy = void;
						clinchedStrength = 0;
						releaseStrength = 0;
				}
			}
			if(clinchedBy === void){
				clinchedStrength = 0;
				releaseStrength = 0;
				if(HP > 0){
					loadSprite(stUntangle);
					untangle(false);
				}
			}else{
				for(var i=0; i<owner.enemies.count; i++){
					var e = owner.enemies[i];
					if(e !== clinchedBy && e.clinchPlayer === this && (!clinchedBy.multiClinch || clinchedBy.kind != e.kind)){
						// 多重抱き付きを解除（最初から多重抱き付きにならないようにするべきではある）
						e.clinchPlayer = void;
						e.clearHoldPlayer();
						if(nowSpriteId !== stDown){
							e.state = stateDamage;
							e.loadSprite(stDamage1);
							e.movingTable = [];
							e.setMovingTable(%["path" => "(-80,0,0)" , "xaccel" => -1 , "frame" => 15], movingTable);
						}else{
							e.loadSprite(stStanding);
						}
					}
				}
			}
		}else{
			clinchedBy = void;
		}


		// ダメージ処理
		if(!enableFreeMove) damage.strength = 0;
		if((damage.strength != 0 || damage.kind == atkParalysis) && HP > 0 && invincibleCount == 0) {
			if(nowSpriteId==stDamage2 && (damage.kind&0xf0)!=atkEnablePursue){
				damage.strength = 0;
				return;
			}

			layer.conductor.start();

			lockedCount = 0;

			switch ((damage.kind & 0x0f)){
				case atkNormal:
				case atkBrowOut:
					HP -= damage.strength * damageRate * getDamageRate(this) * ((nowSpriteId==stLocked)?1.5:1);
					ext = damage.strength / 10;
					putHitMark(damage.hitPos, hitMarkStorage[1]);
					break;
				case atkHold:
					break;
			}
			addComboScore();

			if(damage.kind == atkParalysis && state != stateDamage && state != stateDead){
				// 麻痺
				if(rootX < damageFrom.rootX) inverse = true; else inverse = false;
				loadSprite(stDamage1);
				damage.kind = atkNoDamage;
			}else if((damage.kind&0xf)==atkNormal && int(altitude)==0 && HP > 0 && nowSpriteId!=stExtasy && nowSpriteId!=stClinched && nowSpriteId!=stClinchedStruggle){
				// 通常ダメージ
				if(rootX < damageFrom.rootX) inverse = true; else inverse = false;
				loadSprite(stDamage1);
			}else{
				switch ((damage.kind & 0x0f)){
					case atkHold:
						// 抱きつかれ
						// 多重抱き付きのチェック
						if(clinchAbled(damageFrom)){
//if(clinchedBy !== void) dm(bao.tickCount + "atkHold " + damageFrom + " / clinchedBy.kind : " + clinchedBy.kind  + " / damageFrom.kind : " + damageFrom.kind);
							ext = 3;
							owner.informLayer.setFace(this, 1);
							clinchedStrength += damage.strength;
							clinchedBy = damageFrom;
							loadSprite(stClinched);
							movingTable = [];
//							setMovingTable(%["path" => "(0,0,-40)" , "frame" => 2], movingTable);
						}else{
							damage.strength = 0;
						}
						break;
					default:
						// 吹っ飛ばされ
						if(nowSpriteId == stExtasy){
							extasyGauge.value = 0;
							ext = 0;
						}
						if(isvalid damageFrom && nowSpriteId != stDamage2){
							if(damageFrom.movingTable.count>0 && Math.abs(damageFrom.movingTable[0].x)>5){
								if(damageFrom.movingTable[0].x < 0) inverse = true; else inverse = false;
							}else{
								if(rootX < damageFrom.rootX) inverse = true; else inverse = false;
							}
						}
						loadSprite(stDamage2);
						break;
				}
			}

			if(damage.tags != ""){
				addQueue(damage.tags);
				executeQueue();
				damage.tags = "";
			}

			if(damage.exp != ""){
				executeEval(damage);
				damage.exp = "";
			}

			if(HP <= 0) miss((nowClinched)?clinchedBy:void);

			damage.strength = 0;
			state = stateDamage;
		}
		if(HP <= 0 && nowSpriteId != stDamage2 && nowSpriteId != stDamage3 && nowSpriteId != stDown) miss((nowClinched)?clinchedBy:void);
		damage.kind = atkNoDamage;


		// バトルモード中
		if(f.inBattleMode && sf.bmPlayerHPInfinite){
			if(HP < 100 || owner.tickCount - damage.tick > 30 || owner.tickCount % 5000 == 0){
				HP = maxHP;
			}
		}


		if(lockedCount == 0){
			if(movingTable[0] !== void) mt.set(movingTable[0]);
			if(floorObjectCollision) checkFloorObjectCollision(mt);
			if(!noGravity) mt.set(checkFall(mt));
		}

		var rgl = owner.informLayer.rescueGaugeLayer;
		if(tf.livingPlayer === this){
			if(tf.inRescueMode && nowNearbyOtherPlayer(16)){
				var oPlayer = owner.getOtherPlayer(this);
				if(input.get(keyAttack) && oPlayer.clinchedBy !== void && isvalid oPlayer.clinchedBy){
					oPlayer.clinchedBy.loadSprite(stDamage2);
					oPlayer.clinchedStrength = 0;
					oPlayer.releaseStrength = 0;
				}
				if(((input.inputAttackTick > 0 && owner.tickCount - input.inputAttackTick > 15) || (sf.adjAIAssist && bao.tickCount - pc.lastManualControlTick > 15))
						 && (nowSpriteId == stStanding || nowSpriteId == stAttack1 || nowSpriteId == stSitDown || nowSpriteId == stSitDown2)){
					// 長押し
					if(!rgl.enabled){
						if(rootX < owner.internalWidth/2){
							rgl.left = (rootX + 22) * owner.cZoomRate;
							rgl.top = (rootY - 28) * owner.cZoomRate;
						}else{
							rgl.left = (rootX - 22 - rgl.gaugeLayer.gWidth / owner.cZoomRate) * owner.cZoomRate;
							rgl.top = (rootY - 28) * owner.cZoomRate;
						}
						rgl.enabled = true;
					}

					if(nowSpriteId != stSitDown && nowSpriteId != stSitDown2){
						rootX = oPlayer.rootX - xDirection(oPlayer.inverse) * 10;
						inverse = !oPlayer.inverse;
						if(rootY < oPlayer.rootY){
							rootY = oPlayer.rootY - 4;
							loadSprite(stSitDown);
						}else{
							rootY = oPlayer.rootY + 4;
							loadSprite(stSitDown2);
						}
					}

					if(HP < maxHP * 0.1){
						rgl.value += 1.0;
					}else if(HP < maxHP * 0.2){
						rgl.value += 1.8;
					}else{
						rgl.value += 2.5;
					}
					if(rgl.value >= rgl.maxValue && rgl.enabled){
dm("■救出ゲージFULL");
						sf.rescueCount++;
						if(sf.rescueCount >= 3){
							bao.checkMission('救助');
						}

						if(owner.conductor.curStorage == 'rescueMode.ssd'){
//							owner.trigger("rescue");
							owner.conductor.goToLabel("*end");
							owner.conductor.startProcess();
						}
//						rgl.value = 0;
						rgl.enabled = false;
					}
				}else{
					if(nowSpriteId == stSitDown)  loadSprite(stStandUp, , "*fromSitDown");
					if(nowSpriteId == stSitDown2) loadSprite(stStandUp, , "*fromSitDown2");
					if(rgl.enabled){
						rgl.value = 0;
						rgl.enabled = false;
					}
				}
			}else{
				if(nowSpriteId == stSitDown)  loadSprite(stStandUp, , "*fromSitDown");
				if(nowSpriteId == stSitDown2) loadSprite(stStandUp, , "*fromSitDown2");
				if(rgl.enabled){
					rgl.value = 0;
					rgl.enabled = false;
				}
			}
		}

		mt = inputProcess(mt);

		if(inverse != layer.inverse){
			layer.setInverse();
		}

		var y = int(rootY) - layer.asdHeight + footRect.bottom;
		onFloorObject = getObject(rootX, y);
		if(onFloorObject!==void){
			// 床オブジェクトの上に乗っているとき、特定の動作が存在すればそうする
			if(int(altitude)==onFloorObject.objHeight+onFloorObject.altitude){
				onFloorObject.onObjects.add(this);
				onFloorObject.layer.trigger("ontop");
				if(onFloorObject.tags!=""){
					addQueue(onFloorObject.tags);
					if(clinchEnemy!==void && clinchEnemy.onFloorObject===void){
						// 掴んでいる敵が乗っていない場合にも適用する。
						clinchEnemy.addQueue(onFloorObject.tags);
					}
					for(var i=0;i<childSprites.count;i++){
						if(isvalid childSprites[i]){
							childSprites[i].addQueue(onFloorObject.tags);
						}else{
							childSprites.erase(i);
						}
					}
				}
				onFloorObject.layer.trigger("on");
			}
		}else{
			// 床オブジェクトの上に乗っていないが、掴んでいる敵が乗っている
			if(clinchEnemy!==void && isvalid clinchEnemy && clinchEnemy.onFloorObject!==void && clinchEnemy.onFloorObject.tags!=""){
				addQueue(clinchEnemy.onFloorObject.tags);
				clinchEnemy.addQueue(clinchEnemy.onFloorObject.tags);
			}
		}

		// 影の処理
		shadowToFloorObject();

//if(mt.x !=0) dm(st(nowSpriteId) + " / mt.x : " + mt.x + " / mt.y : " + mt.y + " / mt.h : " + mt.h + " / altitude : " + altitude);
		move(mt);
		lastMovingTable.set(mt);

		if(extasyGauge.enabled){
//			if(ext > 0) ext /= 1.5;
			extasyGauge.value += ext;
			extasyGauge.setPos((layer.width-extasyGauge.width)\2, 0);
			extasyGauge.draw();
			if(extasyGauge.value>extasyGauge.maxValue){
				// イッてしまった
				if(inExtasy == 0 && (nowSpriteId==stStanding || nowSpriteId==stWalk || nowSpriteId==stDash || nowSpriteId==stClinched)){
					inExtasy = 1;
					loadSprite(stExtasy);
				}
			}
		}


//		vScrollVal = owner.vScrollVal;
	}

	function clinchAbled(e)
	{
		return (clinchedBy === void || (clinchedBy.multiClinch && clinchedBy.kind == e.kind));
	}

	function nowNearbyOtherPlayer(n=20){
		var op = bao.getOtherPlayer(this);
		if(op === void) return false;

		var d = getDistance(this, op);
		if(d < n * n){
			return true;
		}
		return false;
	}

	function locked(cnt = 90)
	{
		bEnableMove 		 = enableMove;
		bEnableAttack		 = enableAttack;
		bEnableCommand		 = enableCommand;
		bEnableDoubleJump	 = enableDoubleJump;
		bEnableCounter		 = enableCounter;
		bOtherState			 = otherState;

		enableMove 			 = false;
		enableAttack		 = false;
		enableCommand		 = false;
		enableDoubleJump	 = false;
		enableCounter		 = false;
		otherState			 = "";

		lastSpriteId = nowSpriteId;
		nowSpriteId = stLocked;
		layer.conductor.stop();
		lockedCount = cnt;

		layer.doGrayScale();

		if(!bao.fukidashi.showing){
			if(intrandom(0,4) < 1) lockedVoiceFlag = false;
			if(!lockedVoiceFlag){
        lockedVoiceFlag = true;
				if(chara == chrChiffon){
					bao.fukidashi.add(%['chara'=>chrChiffon, 'storage'=>'a9005', 'text'=>"Ugh, my body...!?"]);
				}else{
					bao.fukidashi.add(%['chara'=>chrChocolat, 'storage'=>'b9011', 'align'=>!(sf.adjSinglePlayMode||f.inBattleMode), 'text'=>"My body won't move...!?"]);
        }
			}else{
				if(chara == chrChiffon){
					if(intrandom(0, 1)){
						bao.fukidashi.add(%['chara'=>chrChiffon, 'storage'=>'a9006', 'text'=>"Ugh!"]);
					}else{
						bao.fukidashi.add(%['chara'=>chrChiffon, 'storage'=>'a9007', 'text'=>"Ughh!"]);
            }
				}else{
					if(intrandom(0, 1)){
						bao.fukidashi.add(%['chara'=>chrChocolat, 'storage'=>'b9008', 'align'=>!(sf.adjSinglePlayMode||f.inBattleMode), 'text'=>"Ugh...!"]);
					}else{
						bao.fukidashi.add(%['chara'=>chrChocolat, 'storage'=>'b9013', 'align'=>!(sf.adjSinglePlayMode||f.inBattleMode), 'text'=>"Kuu!"]);
            }
        }
    }
}

	}


	function lockedCancel()
	{
		enableMove 			 = bEnableMove;
		enableAttack		 = bEnableAttack;
		enableCommand		 = bEnableCommand;
		enableDoubleJump	 = bEnableDoubleJump;
		enableCounter		 = bEnableCounter;

		nowSpriteId = lastSpriteId;
		layer.conductor.start();
		lockedCount = 0;

		layer.loadImagesSub2(layer.graphic);
	}


	function inputProcess(){
		// オーバーライドする
	}

	function extasyDeltaRate(){
		switch (f.difficulty){
			case 0:
				return 0.5;
			case 1:
				return 0.65;
			case 2:
				return 0.7;
			case 3:
				return 0.8;
			case 4:
				return 1;
			default:
				return 1;
		}
	}

//	function resumeExtasy(){
//		extasyGauge.enabled = true;
//		extasyGauge.value *= 0.3;
////		owner.iconLayers.trigger("end");
////		owner.informLayer.extasyGaugeLayer.enabled = false;
//		if(nowSpriteId == stExtasy){
//			if(chara === chrChiffon){
//				sprites[stUntangle] = ["p00_standup2",		"p1_standup2",		"p2_standup2",		"p3_standup2"];
//			}else{
//				sprites[stUntangle] = ["p10_standup2",		"p1_standup2",		"p2_standup2",		"p3_standup2"];
//			}
//		}
//		loadSprite(stUntangle);
//		inExtasy = 0;
//		lastInputDirection = 0;
//		clinchedStrength = 0;
//		releaseStrength = 0;
//		initSpriteTable();
//		invincibleCount = 20;
//	}


	function untangle(load = true){
		if(load) loadSprite(stUntangle);
		invincibleCount = 10;
		inExtasy = 0;
		lastInputDirection = 0;
		clinchedStrength = 0;
		releaseStrength = 0;
		initSpriteTable();
	}


	function checkMP(p, flag = true){
		if(!pc.nowManualControl) flag = false;
		if(sf.adjReduceHpInstedOfMp){
			if(MP > p * sf.reduceMpRate || HP > int(p*0.8 * ((p-MP) / p))){
				return true;
			}else{
				if(flag) owner.informLayer.playerInformLayers[id].showMpIndicatorLayer("empty");
				return false;
			}
		}else{
			if(MP > p * sf.reduceMpRate){
				return true;
			}else{
				if(flag) owner.informLayer.playerInformLayers[id].showMpIndicatorLayer("empty");
				return false;
			}
		}
	}

	function reduceMP(p){
		MP -= p * sf.reduceMpRate;
		if(MP < 0){
			if(sf.adjReduceHpInstedOfMp){
				HP += int(p*0.8 * (MP / p));
			}
			MP = 0;
		}
	}

	function miss(clinchedBy, noLoadSprite=false){

		// バトルモード中
		if(f.inBattleMode && sf.bmPlayerHPInfinite){
			HP = maxHP;
			return;
		}


		dm("■player" + id + " miss!");

		// 体力が無くなった
		HP = 0;
		state = stateDead;
		if(!noLoadSprite){
			if(sprites[stDamage2] !== void){
				loadSprite(stDamage2);
			}else{
				if(nowSpriteId == stClinched){
					layer.conductor.goToLabel("*miss");
					layer.conductor.start();
				}else{
					loadSprite(stClinched,, "*miss");
				}
				nowSpriteId = stDamage3;
			}

			sf.killedCount++;
		}

		owner.returnState = "miss";
		owner.killedPlayerId = id;
		if(clinchedBy === void){
			killedBy = damageFrom;
			killedByKind = damageFromStr;
		}else{
			switch (clinchedBy.kind){
				case "ネット":
					killedBy = damageFrom;
					killedByKind = damageFromStr;
					break;
				default:
					killedBy = clinchedBy;
					killedByKind = clinchedBy.kind;
			}
		}
		dm("killed by" + killedBy + " / " + killedByKind);
		owner.returnKag3();
	}

	function setMoveByScript(elm){

		if(!+elm.spritestay){
			var id = stWalk;
			if(elm.id !== void) id = Scripts.eval(elm.id);
			loadSprite(id);
		}

		enableMove = false;
		enableAttack = false;

		super.setMoveByScript(elm);

		if(+elm.noinverse !== true){
			if(movingTable[0].x < 0 && inverse || movingTable[0].x>0 && !inverse){
				inverse = !inverse;
				layer.setInverse();
			}
		}
	}

	function addComboScore(){

		if(this === bao.nowSelectingPlayer){
			if(comboCount > sf.maxCombo) sf.maxCombo = comboCount;

			if(comboCount >= 25){
				owner.checkMission("25コンボ");
			}
			if(comboCount >= 50){
				owner.checkMission("50コンボ");
			}
			if(comboCount >= 75){
				owner.checkMission("75コンボ");
			}
		}

		if(comboCount > 0 && this === owner.nowSelectingPlayer){
			f.score += comboCount * Math.round(Math.log(comboCount)*5) * 200;
		}

//		if(comboCount >= 5) MP += int((comboCount)*1.0);
		if(comboCount >= 2){
			if(MP < maxMP) owner.informLayer.playerInformLayers[id].showMpIndicatorLayer("combobonus");
//var tmp = MP;
			if(comboCount <= 5){
				MP += int((comboCount)*1.2);
			}else if(comboCount <= 15){
				MP += int((comboCount)*1.3);
			}else if(comboCount <= 25){
				MP += int((comboCount)*1.5);
			}else{
				MP += int((comboCount)*1.75);
			}
//dm("■ " + ((!chara)?"シフォン":"ショコラ") + " / combo : " + comboCount + " / MP : " + int(tmp) + " → " + int(MP));
		}
		comboCount = 0;
	}

	function checkDirection(d){
		var mt = new MovingTable();
		var x = 0;
		var y = 0;

		switch(d)
		{
			case 0:
				break;
			case 1:
				x = -1;
				y = 1;
				break;
			case 2:
				y = 1;
				break;
			case 3:
				x = 1;
				y = 1;
				break;
			case 4:
				x = -1;
				break;
			case 6:
				x = 1;
				break;
			case 7:
				x = -1;
				y = -1;
				break;
			case 8:
				y = -1;
				break;
			case 9:
				x = 1;
				y = -1;
				break;
		}
		mt.set(x, y ,0);
		return mt;
	}

	function checkInverse(inkey)
	{
		if(typeof(inkey) == 'Object'){
			if(inkey.x == -1) inverse = false;
			if(inkey.x ==  1) inverse = true;
		}else{
			if(inkey == -1) inverse = false;
			if(inkey ==  1) inverse = true;
		}
		return;
	}

	function setInverseByLastInputLeftRight(){
		if(input.lastInputLeftRight == -1) inverse = false;
		if(input.lastInputLeftRight ==  1) inverse = true;
	}

	function move(mt)
	{
		var r = new Rect2(footRect);
		r.addOffset(rootX - centerPos, rootY - layer.asdHeight);

		if(floorObjectCollision){

			if((mt.x > 0 && int(altitude) < getAltitude(r.right+mt.x, r.top))||(mt.x > 0 && int(altitude) < getAltitude(r.right+mt.x, r.bottom))) mt.x = 0;
			if((mt.x < 0 && int(altitude) < getAltitude(r.left +mt.x, r.top))||(mt.x > 0 && int(altitude) < getAltitude(r.left +mt.x, r.bottom))) mt.x = 0;

			if((mt.y > 0 && int(altitude) < getAltitude(r.left, r.bottom+mt.y))
						|| (mt.y > 0 && int(altitude) < getAltitude(r.right, r.bottom+mt.y))
						|| (mt.y < 0 && int(altitude) < getAltitude(r.left, r.top+mt.y))
						|| (mt.y < 0 && int(altitude) < getAltitude(r.right, r.top+mt.y))) mt.y = 0;

			if(int(altitude) < getAltitude(rootX+mt.x, r.bottom+mt.y) || int(altitude) < getAltitude(rootX+mt.x, r.top+mt.y)){
				mt.x = 0;
				mt.y = 0;
			}
		}

		var x = mt.x + rootX;
		var y = mt.y + rootY;
		var h = mt.h + altitude;

		// スクロール
		
//		x = owner.bgScroll(rootX, mt.x) + rootX;

		// 移動可能領域からはみ出ないように
		if(!movableRect.includedPos(x, y) && !ignoreMovableRect){
			if(x < movableRect.left)   x = movableRect.left;
			if(x > movableRect.right)  x = movableRect.right;
			if(y < movableRect.top)    y = movableRect.top;
			if(y > movableRect.bottom) y = movableRect.bottom;
		}
		if(h < -500){
			h = -500; // -100は暫定的で適当な数字
			owner.returnState = "fall";
			owner.returnKag3();
		}

		rootX = x;
		rootY = y;
		altitude = h;

	}

	function checkOverlap(x, y)
	{
		// 判定範囲
		var r = new Rect2(x-centerPos+hitRect.left, y-depth/4, x-centerPos+hitRect.left+hitRect.width, y+depth/4);

//		kag.fore.layers[0].type = ltAlpha;
//		kag.fore.layers[0].visible = true;
//		kag.fore.layers[0].fillRect(0, 0, kag.innerWidth, kag.innerHeight, 0x00000000);
//		kag.fore.layers[0].fillRect(r.left, r.top, r.width, r.height, 0x8800ff00);

		for(var i=0; i<owner.enemies.count; i++){
			var e = owner.enemies[i];
			if(e !== this){
				// 無敵時間なら判定しない
				if(e.invincibleCount > 0) continue;
//				// 高さが違えば判定しない
//				if(int(altitude) != int(e.altitude)) continue;
//				// 画面外なら判定しない
//				if(e.rootX < 0 || e.rootX > owner.internalWidth) continue;
				// 相手が死んでたら判定しない
				if(e.HP <= 0) continue;
				// 当たり判定が存在しなくても判定しない
				if(e.hitRect.isEmpty()) continue;
				// 立っているか歩いているときだけ
				switch(e.nowSpriteId){
					case stStanding:
					case stWalk:
					case stAttack1:
					case stAttack2:
					case stDamage1:
					case stLocked:
						break;
					default:
						continue;
				}
//				if(e.nowSpriteId != stStanding && e.nowSpriteId != stWalk && e.nowSpriteId != stDamage1) continue;
				var er = new Rect2(e.rootX-e.centerPos+e.hitRect.left, e.rootY, e.rootX-e.centerPos+e.hitRect.left+e.hitRect.width, e.rootY);
//				kag.fore.layers[0].fillRect(er.left, er.top, er.width ,er.height, 0xffff00ff);

				if(r.intersects(er)){
					return e;
				}
			}
		}
		return void;
	}

	function clinch(cl)
	{
		if(!cl.enableClinched) return;
		cl.targetPlayer = this;
		if(inverse){
			if(rootX < cl.rootX){
				if(!cl.inverse){
					loadSprite(stClinching);
					rootX = cl.clinched();
				}else{
					loadSprite(stBackClinch);
					rootX = cl.clinched();
				}
			}else{
				inverse = false;
				if(inverse != layer.inverse) layer.setInverse();
				if(cl.inverse){
					loadSprite(stClinching);
					rootX = cl.clinched();
				}else{
					loadSprite(stBackClinch);
					rootX = cl.clinched();
				}
			}
			return;
		}else{
			if(cl.rootX < rootX){
				if(cl.inverse){
					loadSprite(stClinching);
					rootX = cl.clinched();
				}else{
					loadSprite(stBackClinch);
					rootX = cl.clinched();
				}
			}else{
				inverse = true;
				if(inverse != layer.inverse) layer.setInverse();
				if(!cl.inverse){
					loadSprite(stClinching);
					rootX = cl.clinched();
				}else{
					loadSprite(stBackClinch);
					rootX = cl.clinched();
				}
			}
			return;
		}
	}

	function checkAttackCollision()
	{
		if(attackRect.isEmpty()) return;

//		var r1 = new Rect2(attackRect);
//		r1.addOffset(layer.left, layer.top);
//		r1.bottom += depth2;

//		kag.fore.layers[0].type = ltAlpha;
//		kag.fore.layers[0].visible = true;
//		kag.fore.layers[0].fillRect(0, 0, kag.innerWidth, kag.innerHeight, 0x00000000);
//		kag.fore.layers[0].fillRect(r1.left, r1.top, r1.width, r1.height, 0x8800ff00);

		var line = new Rect2(-80, rootY - depth1, owner.internalWidth+80, rootY + depth2);
		for(var i=0; i<owner.enemies.count; i++){
			var e = owner.enemies[i];
			// 敵が無敵時間なら処理しない
			if(e.invincibleCount > 0) continue;
			// 敵が投げられてたら処理しない
			if(e.nowSpriteId>=stThrown1 && e.nowSpriteId<=stThrown6) continue;
			// 敵が判定範囲外なら処理しない
			if(!line.includedPos(e.rootX, e.rootY)) continue;
			// 死んでるなら処理しない
			if(e.HP<=0 && e.nowSpriteId==stDamage2) continue;
			checkAttackCollisionSub(e);
		}
		for(var i=0; i<owner.objects.count; i++){
			var o = owner.objects[i];
			// 無敵時間なら処理しない
			if(o.invincibleCount > 0) continue;
			// 判定範囲外なら処理しない
			if(!line.includedPos(o.rootX, o.rootY)) continue;
			checkAttackCollisionSub(o);
		}
		for(var i=0; i<owner.stageLayer.floorObjects.count; i++){
			var o = owner.stageLayer.floorObjects[i];
			if(o.hitCollision) 	checkAttackCollisionSub2(o);
		}

	}

	function checkAttackCollisionSub(obj)
	{
		// 既にダメージ処理済み？
		if(obj.damage.tick == attack.tick){
			if(obj.damageFrom !== this){
				// 自分の攻撃でなければ次のフレームへ
				attack.tick++;
			}
			return;
		}

		// 敵が吹っ飛ばされ状態なら追撃攻撃以外は処理しない
		if(obj.nowSpriteId == stDamage2 && (attack.kind&atkEnablePursue)!=atkEnablePursue) return;

		// 当たり判定矩形が無ければ処理しない
		var r2 = new Rect2(obj.hitRect);
		if(r2.isEmpty()) return;
		r2.addOffset(obj.internalLayerLeft, obj.internalLayerTop);
		r2.addOffset(0, rootY-obj.rootY);

		// 攻撃判定矩形と当たり判定矩形が交差するなら
		var r1 = new Rect2(attackRect);
		r1.addOffset(internalLayerLeft, internalLayerTop+obj.rootY-rootY);
		r1.top -= depth2;
		if(r1.intersects(r2)){
			if(obj.HP > 0 && comboCountFlag) comboCount++;
			if(this === owner.nowSelectingPlayer) f.score += attack.score * 2;

			obj.targetPlayer = this;
			obj.damageFrom = this;
			obj.damageFromStr = name;
			obj.damage.set(attack);
			obj.damage.strength = getAttackStrength(obj.damage.strength);
			if(attackTick != attackIndexCountUpTick){
				attackIndexCountUpTick = attackTick;
				attackIndex++;
			}
			var tmp1 = getIntersectRect(r1, r2);
			var tmp2 = (rootY > obj.rootY)? rootY : obj.rootY;
			obj.setHitMark(tmp1.centerX, tmp2, tmp2-tmp1.centerY);

			attackHitFlag = true;

			if(nowSpriteId == stJumpAttack2){
				attackTick = owner.tickCount;
			}
		}
	}

	function checkAttackCollisionSub2(o)
	{

		// 攻撃判定矩形がフロアオブジェクトのベースレイヤー上にあるかどうか
		var r1 = new Rect2(attackRect);
		r1.addOffset(internalLayerLeft, internalLayerTop);
		var y = int(rootY) - layer.asdHeight + footRect.bottom;

		if(owner.stageLayer.checkObject(o, r1.left, y)||owner.stageLayer.checkObject(o, (r1.right+r1.left)/2, y)||owner.stageLayer.checkObject(o, r1.right, y)){
			// 高さはどうか
			var r2 = new Rect2(0, -o.objHeight, o.layer.asdWidth, 0);
			r2.addOffset(o.baseLeft, o.baseTop+o.objDepth);
			if(r1.intersects(r2)){
				var r3 = new Rect2(o.baseLeft, o.baseTop-o.objHeight+o.objDepth, o.baseLeft+o.layer.asdWidth, o.baseTop+o.objDepth);
				var tmp1 = getIntersectRect(r1, r3);
				if(tmp1 !== void){
					owner.putHitMark(tmp1.centerX, o.baseTop+o.objDepth, (o.baseTop+o.objDepth)-tmp1.centerY, hitMarkStorage[0]);
				}
				o.hitPlayer = this;
				o.layer.trigger('hit');
			}
		}

	}

	property extasyGaugeEnabled{
		getter(){
			return extasyGauge.enabled;
		}
		setter(flg){
			extasyGauge.enabled = flg;
			owner.informLayer.resetFace();
			initSpriteTable();
		}
	}


	function store()
	{
		var dic = super.store();

		dic.lastCutinTick = lastCutinTick;

		dic.extasyGauge = extasyGauge.enabled;
		dic.inExtasy = inExtasy;
		dic.defaultFaceNum = defaultFaceNum;

		dic.spriteTableChangeFlag = spriteTableChangeFlag;
		if(spriteTableChangeFlag){
			dic.sprites = [];
			for(var i=0;i<0x9999; i++){
				if(sprites[i] !== void){
					dic.sprites[i] = [];
					dic.sprites[i].assignStruct(sprites[i]);
				}
			}
		}

		// 保存する必要があるかはわからん
		if(killedBy !== void && isvalid killedBy){
			killedBy_reference = new ObjectReference(killedBy);
			dic.killedBy_reference = killedBy_reference.store();
		}
		dic.killedByKind = killedByKind;

		if(lastClinchEnemy !== void && isvalid lastClinchEnemy){
			lastClinchEnemy_reference = new ObjectReference(lastClinchEnemy);
			dic.lastClinchEnemy_reference = lastClinchEnemy_reference.store();
		}

		if(clinchedBy !== void && isvalid clinchedBy){
			clinchedBy_reference = new ObjectReference(clinchedBy);
			dic.clinchedBy_reference = clinchedBy_reference.store();
		}

		dic.dOpacity2Auto = dOpacity2Auto;

		return dic;
	}

	function restore(dic)
	{
		super.restore(dic);

		lastCutinTick = dic.lastCutinTick;

		extasyGauge.enabled = dic.extasyGauge;
		if(dic.inExtasy !== void) inExtasy = dic.inExtasy;
		if(dic.defaultFaceNum !== void) defaultFaceNum = dic.defaultFaceNum;
		if(dic.spriteTableChangeFlag){
			sprites = [];
			for(var i=0;i<0x9999; i++){
				if(dic.sprites[i] !== void){
					sprites[i] = [];
					sprites[i].assignStruct(dic.sprites[i]);
				}
			}
		}else{
			initSpriteTable();
		}
		// falseでいいの？？？
		spriteTableChangeFlag = false;

		// コスが破損しない設定の場合
		if(sf.adjCosBreakCount == 99999){
			cosState = 0;
			if(nowSpriteId==stStanding) loadSprite(nowSpriteId);
		}
		// 悪堕ちモードの場合
		if(sf.adjEvilCosMode){
			cosState = 4;
			if(nowSpriteId==stStanding) loadSprite(nowSpriteId);
			if(defaultFaceNum == 0){
				defaultFaceNum = owner.informLayer.getDefaultFaceNum(dic.id);
				owner.informLayer.setFace(this, defaultFaceNum);
			}
		}else{
			if(cosState == 4 && !f.inRouteB){
				cosState = 0;
				if(nowSpriteId==stStanding) loadSprite(nowSpriteId);
			}
		}
//dm("■■■■ cosState : " + cosState);

		killedBy_reference = void;
		if(dic.killedBy_reference !== void){
			killedBy_reference = new ObjectReference(dic.killedBy_reference);
		}
		killedByKind = dic.killedByKind;

		lastClinchEnemy_reference = void;
		if(dic.lastClinchEnemy_reference !== void){
			lastClinchEnemy_reference = new ObjectReference(dic.lastClinchEnemy_reference);
		}

		clinchedBy_reference = void;
		if(dic.clinchedBy_reference !== void){
			clinchedBy_reference = new ObjectReference(dic.clinchedBy_reference);
		}

		if(dic.dOpacity2Auto !== void) dOpacity2Auto = dic.dOpacity2Auto;

		if(nowSpriteId == stWinning) loadSprite(stStanding);

	}

	function restore2()
	{
		super.restore2();

		if(lastClinchEnemy_reference !== void){
			lastClinchEnemy = lastClinchEnemy_reference.getObject();
			invalidate lastClinchEnemy_reference;
			lastClinchEnemy_reference = void;
		}

		if(killedBy_reference !== void){
			killedBy = killedBy_reference.getObject();
			invalidate killedBy_reference;
			killedBy_reference = void;
		}

		if(clinchedBy_reference !== void){
			clinchedBy = clinchedBy_reference.getObject();
			invalidate clinchedBy_reference;
			clinchedBy_reference = void;
		}
	}

	property index{
		getter{
			for(var i=0; i<owner.players.count; i++){
				if(owner.players[i] === this) return i;
			}
		}
	}

}


function getAttackStrength(s)
{
	var strength = int(s * sf.adjAttackRate);
//	if(strength < 1) strength = 1;
	return strength;
}


function enemyHPRate(hp, isBoss = false)
{
	var val;
	switch (f.difficulty){
		case 0:
			val = int(hp * 0.6 * stageRate());
			break;
		case 1:
			val = int(hp * 0.75 * stageRate());
			break;
		case 2:
			val = int(hp * stageRate() * ((sf.adjSinglePlayMode || bao.players.count==1)?0.9:((isBoss)?1:1.1)));
			break;
		case 3:
			val = int(hp * 1.5 * stageRate() * ((isBoss)?0.9:1) * ((sf.adjSinglePlayMode || bao.players.count==1)?0.8:1.05));
			break;
		case 4:
			val = int(hp * 2 * stageRate() * ((isBoss)?0.8:1) * ((sf.adjSinglePlayMode || bao.players.count==1)?0.8:1));
			break;
		case 5:
			val = int(hp * 2.5 * stageRate() * ((isBoss)?0.7:1) * ((sf.adjSinglePlayMode || bao.players.count==1)?0.8:1));
			break;
	}

	return val;
}



function getDamageRate(p)
{
	var cosRate = (p.cosState==3)?1.1:1;

	switch (f.difficulty){
		case 0:
			return sf.adjDamageRate * 2.0 * stageRate() * cosRate * 0.4;
		case 1:
			return sf.adjDamageRate * 2.0 * stageRate() * cosRate * 0.6;
		case 2:
			return sf.adjDamageRate * 2.0 * stageRate() * cosRate * ((sf.adjSinglePlayMode || bao.players.count==1)?0.75:1);
		case 3:
			return sf.adjDamageRate * 2.1 * stageRate() * cosRate * ((sf.adjSinglePlayMode || bao.players.count==1)?0.75:1);
		case 4:
			return sf.adjDamageRate * 2.2 * stageRate() * cosRate * ((sf.adjSinglePlayMode || bao.players.count==1)?0.75:1);
		case 5:
			return sf.adjDamageRate * 2.8 * stageRate() * cosRate * ((sf.adjSinglePlayMode || bao.players.count==1)?0.75:1);
	}
}



function getAttackCheckRate(d)
{
	var r;
	switch (f.difficulty){
		case 0:
			r = int(d * stageRate() * 0.15);
			break;
		case 1:
			r = int(d * stageRate() * 0.3);
			break;
		case 2:
			r = int(d * stageRate() * 0.8 * ((sf.adjSinglePlayMode || bao.players.count==1)?0.9:1.02));
			break;
		case 3:
			r = int(d * stageRate() * 1.2 * ((sf.adjSinglePlayMode || bao.players.count==1)?0.8:1.01));
			break;
		case 4:
			r = int(d * stageRate() * 2.4 * ((sf.adjSinglePlayMode || bao.players.count==1)?0.7:1));
		case 5:
			r = int(d * stageRate() * 5 * ((sf.adjSinglePlayMode || bao.players.count==1)?0.7:1));
			break;
	}
	if(r < 1) r = 1;

	if(sf.adjIncreaseEnemyAttackRate) r = r * 2;
	return r;
}




function stageRate()
{
	if(f.stage>4) return 1;
	return 1 - (4 - int(f.stage))*0.06;
}


function getPlayersCenterX()
{
	var x = 0;
	for(var i=0; i<bao.players.count; i++){
		x += bao.players[i].rootX;
	}
	x /= bao.players.count;
	return x;
}


function getPlayersCenterY()
{
	var y = 0;
	for(var i=0; i<owner.players.count; i++){
		x += owner.players[i].rootY;
	}
	y /= owner.players.count;
	return y;
}



class AttackAlgorithmConductor extends KAGParser
{
	var owner;
	var mp = %[];
	var sprite = %[];
	var layer = %[];

	var kind = cndAAC;

	var frameCountOffset = 0;

	function AttackAlgorithmConductor(owner){
		super.KAGParser(...);
		this.owner = owner;
		ignoreCR = true;
		debugLevel = tkdlNone;

		processSpecialTags = false;
	}

	function finalize()
	{
		owner = void; // owner への参照を切る
		super.finalize(...);
	}

	function attackCheckAlgorithm(p, inverse)
	{
		var obj;

		// フレームカウント用
		var frame = 0;
		var count = 0;
		var movingCount = 0;
		frameCountOffset = 0;

		// 自分（敵キャラ）の攻撃範囲
		var attackR;
		var depth1;
		var depth2;

		// 自分（敵キャラ）の位置パラメータ
		var x = owner.rootX;
		var y = owner.rootY;
		var w = owner.layer.asdWidth;
		var h = owner.layer.asdHeight;
		var c = owner.centerPos;

		// 自分（敵キャラ）の移動テーブル
		var mt = [];
		var moveOffset = new MovingTable();

		// 相手（主人公）の位置パラメータ
		var px = p.rootX;
		var py = p.rootY;

		// 相手（主人公）の当たり判定矩形
		var pHitR;

		if((p.objectClass == clEnemy || p.objectClass == clPlayer) && p.HP <= 0) return -1;
		if(p.hitRect.isEmpty()) return -1;

		attackR = new Rect2();

//if(owner.objectClass==clPlayer) {dm("■ p.hitRect");p.hitRect.dm();}
		pHitR = p.toGlobalRect(p.hitRect);
//if(owner.objectClass==clPlayer) {dm("pHitR");pHitR.dm();}

		if(inverse === void) inverse = owner.inverse;

//		kag.fore.layers[0].type = ltAlpha;
//		kag.fore.layers[0].visible = true;
//		kag.fore.layers[0].width = owner.owner.internalWidth;
//		kag.fore.layers[0].height = owner.owner.height;
//
//		kag.fore.layers[0].fillRect(0, 0, kag.innerWidth, kag.innerHeight, 0x00000000);
//		kag.fore.layers[0].colorRect(pHitR.left, pHitR.top, pHitR.width, pHitR.height, 0xff0000,128);
//		dm("pHitR.left : " + pHitR.left + " / pHitR.top : " + pHitR.top + " / pHitR.width : " + pHitR.width + " / pHitR.height : " + pHitR.height);

		if(owner.objectClass == clEnemy) owner.attackRectBuf.clear();
		moveOffset.reset();

		var retVal = -1;
		debugLevel = tkdlNone;
		while(true){
			if(count == 0){
				// countが０の時にタグを解釈する
				try{
					obj = getNextTag();
				}catch(e){
					continue;
				}

				if(obj === void) break;
				if(obj.tagname == 'dispsize'){
					w = +obj.width;
					h = +obj.height;
					if(obj.centerpos !== void){
						c = (inverse)? (w-obj.centerpos) : +obj.centerpos;
					}else{
						obj.centerpos = w / 2;
						c = obj.centerpos;
					}
				}
				if(obj.tagname == 'disp') attackR.clear();
				if(obj.tagname == 'attack' && obj.rect !== void){
					attackR.setFromStr(obj.rect);
//if(owner.objectClass==clPlayer) {dm("width : " + w + " / attackR");attackR.dm();}
					if(inverse) attackR.inverse(w, h);
//if(owner.objectClass==clPlayer) {dm("attackR.inverse");attackR.dm();}
					x += moveOffset.x;
					y += moveOffset.y;
					moveOffset.reset();
					attackR.addOffset(x - c, y - h - owner.altitude);
//if(owner.objectClass==clPlayer) {dm("attackR.addOffset");attackR.dm();}
					if(obj.depth!==void){
						var array = [].split("(), ", obj.depth, , true);
						depth1 = +array[0];
						depth2 = +array[1];
					}else{
						depth1 = owner.depth / 2;
						depth2 = owner.depth / 2;
					}
				}
				if(obj.tagname == 'move' && obj.path !== void){
					movingCount = 0;
//if(owner.objectClass == clEnemy) dm("obj.path : " + obj.path + " / obj.frame : " + obj.frame);
					owner.setMovingTable(obj, mt);
				}
				if(obj.tagname == 'wait' && obj.frame !== void){
					count = +obj.frame;
				}
			}else{
				// countが０でない時に判定する
				count--;

				// そもそも攻撃判定が存在しないなら飛ばす
				if(attackR.isEmpty()){
					frame++;
					continue;
				}

				var tmpR = new Rect2(attackR);
				// 自分（敵キャラ）の位置
				if(mt.count>0 && mt[movingCount]!==void){
					moveOffset.add(mt[movingCount]);
					tmpR.addOffset(moveOffset.x , - moveOffset.h);
//if(owner.objectClass == clEnemy) dm(" : " + movingCount + " / moveOffset.x : " + moveOffset.x);
					movingCount++;
				}

				// 相手（主人公）の予測位置
//				var f = p.tickCount + frame;
				if(p.movingTable[frame]!==void && isvalid p.movingTable[frame]){
					pHitR.addOffset(p.movingTable[frame].x , - p.movingTable[frame].h);
					px += p.movingTable[frame].x;
					py += p.movingTable[frame].y;

//dm("frame : " + frame + " / p.movingTable[frame].h : " + p.movingTable[frame].h);
				}

//kag.fore.layers[0].colorRect(pHitR.left, pHitR.top, pHitR.width, pHitR.height, 0x00ffff,128);
//kag.fore.layers[0].colorRect(attackR.left, attackR.top, attackR.width, attackR.height, 0x00ff00,128);

				if(owner.objectClass == clEnemy) owner.attackRectBuf[frame] = new Rect2(attackR.left, y - depth1, attackR.right, y + depth2);
//if(owner.objectClass == clEnemy) dm("owner.attackRectBuf[" + frame + "] : " + (owner.attackRectBuf[frame].dm()));
				// 奥行きが合わなかったらそもそも攻撃が当たらない
				var line = new Rect2(0, y - depth1, owner.owner.internalWidth, y + depth2);
				if(!line.includedPos(px, py)){
					frame++;
					continue;
				}

				var r = new Rect2(attackR);
				r.addOffset(0, py-y);

				// 面倒なのでとりあえずp.hitRectは変化しないと仮定して判定
				if(r.intersects(pHitR)){
//if(owner.objectClass==clPlayer) {dm("-------------------");}
//if(owner.objectClass==clPlayer) {dm('line');line.dm();dm('attackR');attackR.dm();dm('r');r.dm();dm('pHitR');pHitR.dm();}
//if(owner.objectClass==clPlayer) dm("■■ x : " + x + " / y : " + y + " / px : " + px + " / py : " + py + " / index : " + bao.getIndex(p) + " / " + p + " / frame : " + frame);
//if(owner.objectClass==clPlayer) {dm("----------------------------------");}
					if(retVal == -1) retVal = frame;
//					return frame;
				}

				invalidate r;
				invalidate line;
				invalidate tmpR;

				frame++;
			}

		}
//		return -1;
		return retVal;
	}


	function attackRectBufSet()
	{
		var obj;

		// フレームカウント用
		var frame = 0;
		var count = 0;
		var movingCount = 0;

		// 自分の攻撃範囲
		var attackR;
		var depth1;
		var depth2;

//		// 自分（敵キャラ）の位置パラメータ
		var x = owner.rootX;
		var y = owner.rootY;
		var w = owner.layer.asdWidth;
		var h = owner.layer.asdHeight;
		var c = owner.centerPos;

		// 自分の移動テーブル
		var mt = [];
		var moveOffset = new MovingTable();

		attackR = new Rect2();

		var inverse = owner.inverse;

		owner.attackRectBuf.clear();
		frameCountOffset = owner.frameCount;

		var retVal = -1;
		debugLevel = tkdlNone;
		while(true){
			if(count == 0){
				// countが０の時にタグを解釈する
				obj = getNextTag();
				if(obj === void) break;
				if(obj.tagname == 'dispsize'){
					w = +obj.width;
					h = +obj.height;
					if(obj.centerpos !== void){
						c = (inverse)? (w-obj.centerpos) : +obj.centerpos;
					}else{
						c = w / 2;
					}
				}
				if(obj.tagname == 'disp'){
					attackR.clear();
				}
				if(obj.tagname == 'attack' && obj.rect !== void){
					attackR.setFromStr(obj.rect);
					if(inverse) attackR.inverse(w, h);
//					attackR.addOffset(x - c, y - h - owner.altitude);
					if(obj.depth!==void){
						var array = [].split("(), ", obj.depth, , true);
						depth1 = +array[0];
						depth2 = +array[1];
					}else{
						depth1 = owner.depth / 2;
						depth2 = owner.depth / 2;
					}
				}
				if(obj.tagname == 'move'){
//					mt = [];
//					movingCount = 0;
//					owner.setMovingTable(obj, mt);
				}
				if(obj.tagname == 'wait' && obj.frame !== void){
					count = +obj.frame;
				}
			}else{
				count--;
				frame++;
				if(frame > 30) break;
			}

		}

		if(!attackR.isEmpty()){
			var tRect = new Rect2(attackR.left, -depth1, attackR.right, depth2);
			if(owner.attackRectBuf[0] == void){
				owner.attackRectBuf[0] = new Rect2(tRect);
			}else{
				owner.attackRectBuf[0].addRect(tRect);
			}
		}

	}






}


class EnemySprite extends CharacterSprite
{

	// 攻撃するか決めるコンダクタ
	var attackConductor;

	// 攻撃可能範囲（画面の外にいるときは攻撃しない）
	var attackableRect;
	// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
	var attackCheckRect;

	var attackList = [];
	var comboAttackList = [];

	// attackRectを記録しておく
	var attackRectBuf = [];

	// ボスキャラであるかどうか
	var isBoss = false;

	var score = 10000;

	// 攻撃判定を行う確率
	var attackCheckRate = [];
	var comboAttackCheckRate = 20;

	// 主人公の方へ向かっていく確率
	var moveRate1 = 40;
	// 適当に動く確率
	var moveRate2 = 30;

	var targetDistance = 50;

	var escapeMP = 0;

	var lastDamageTick = 0;
	var damageCount = 0;
	var damageCountLimit = 500;
	var guardCount = 0;
	var counterAttack = stAttack1;
	var guardDamageRate = 0.1;	// 攻撃をガードしたときのダメージ率（1なら元の攻撃力がそのまま適用）
	var guardRate = 0;			// 攻撃をガードする確率

	// スプライトテーブルが一時書き換えられているかどうか
	var spriteTableChangeFlag = false;

	// 子のスプライト
	var child;

	var nearAvoidPoint;
	var ignoreAvoidPoint = false;

	var holdPlayerPos = void;

	// 敵カウント表示に反映する敵か
	var countFlag = true;

	// 向かっていったり攻撃をしたり受けたりの対象にしているヒロインキャラのオブジェクト
	var targetPlayer = void;
	var clinchPlayer = void;

	// クリンチしたときにどれだけずらすか（０のときは主人公rootX位置がレイヤー左端になる（敵左向き時））
	var clinchedOffset = 0;

	// 多重抱きつき有か無しか
	var multiClinch = false;

	// ダメージを受けたとき主人公の動きに左右されるか
	var damageMoveFlag = true;

	// ユーザー操作キャラによって死んだ
	var killedByUser = false;

	// その場から移動しない敵
	var noMove = false;

	var type = objNormal;

	var damagedByAICount = 0;

	var moveXAccel = 0;

	function EnemySprite(window, owner, elm)
	{
		objectClass = clEnemy;
		initSpriteTable();

		if(owner.stageLayer!==void){
			if(owner.stageLayer.xFreeMode) waiting=true;

//			movableRect = new Rect2(-100, 0, 556, 256);
			// 移動可能範囲設定
			if(movableRect!==void){
				if(movableRect.y1 < owner.stageLayer.topLine) movableRect.y1 = owner.stageLayer.topLine;
				if(movableRect.y2 > owner.stageLayer.bottomLine) movableRect.y2 = owner.stageLayer.bottomLine;
			}

			// 攻撃可能範囲設定
			if(attackableRect!==void){
				if(attackableRect.y1 < owner.stageLayer.topLine) attackableRect.y1 = owner.stageLayer.topLine;
				if(attackableRect.y2 > owner.stageLayer.bottomLine) attackableRect.y2 = owner.stageLayer.bottomLine;
			}
		}

		nowSpriteId = stStanding;
		if(elm.spriteid!="") nowSpriteId = Scripts.eval(elm.spriteid);

		if(typeof sprites[nowSpriteId] == "Object"){
			if(Storages.isExistentStorage(sprites[nowSpriteId][cosState]+".asd")){
				elm.storage = sprites[nowSpriteId][cosState];
			}else{
				elm.storage = sprites[nowSpriteId][0];
			}
			elm.graphic = sprites[nowSpriteId][cosState];
		}else{
			elm.storage = sprites[nowSpriteId];
		}

		super.CharacterSprite(window, owner, elm);
		attackConductor = new AttackAlgorithmConductor(this);
	}

	function initSpriteTable(){
		// オーバーライドする
	}

	function finalize()
	{
		invalidate attackConductor;
		super.finalize();
	}

	function setState(elm)
	{
		super.setState(elm);
	
		if(elm.maxhp !== void) elm.maxhp = enemyHPRate(+elm.maxhp);
		if(elm.hp !== void) elm.hp = enemyHPRate(+elm.hp);

		if(elm.ignoreavoid !== void) ignoreAvoidPoint = +elm.ignoreavoid;
	}

	function loadSprite(id, mode=false, label="")
	{
//		dm(layer.asd + "/" + getConstFromSpriteId(lastSpriteId) + "(" + layer.conductor.curLine + ") → " + getConstFromSpriteId(id));
		lockedChangeColor = false;
		clearHoldPlayer();
		super.loadSprite(...);
	}

	function routineProcess()
	{
		super.routineProcess();
		rootX -= hScrollVal;
		var pExist = (owner.players.count > 0);

		if(lockedCount > 0){
			if(layer.asdOpacity < 50){
				layer.asdOpacity = 255;
				layer.dOpacity2 = 20;
			}
			if(!bao.noWaitMode && bao.fps > 25 && rootX > 0 && rootX < bao.internalWidth){
				if(bao.tickCount % 2 == 0){
					if(layer.graphic !== void){
						layer.adjustGamma(1.2, 32, 255,		1.2, 32, 255,		 1, 0, 255);
					}else{
						layer.asdOpacity = 200;
					}
//					layer.doGrayScale();
					lockedChangeColor = true;
				}else{
					if(layer.graphic !== void){
						layer.loadImagesSub2(layer.graphic);
					}else{
						layer.asdOpacity = 255;
					}
					lockedChangeColor = false;
				}
			}
		}else if(nowSpriteId == stLocked){
			lockedCancel(true);
		}else if(lockedChangeColor){
			lockedCancel(false);
		}else if(nowSpriteId == stDamage2 && altitude < 0 && !layer.conductor.running){
			layer.trigger('landing');
		}

		if(waiting){
			if(owner.stageLayer!==void && movableRect!==void){
				if(movableRect.includedPos(rootX, rootY)){
					waiting = false;
				}else{
					return;
				}
			}
		}

		var y = int(rootY) - layer.asdHeight + footRect.bottom;
		onFloorObject = getObject(rootX, y);
		if(onFloorObject!==void){
			// 床オブジェクトの上に乗っているとき、特定の動作が存在すればそうする。
			if(int(altitude)==onFloorObject.objHeight+onFloorObject.altitude){
				onFloorObject.onObjects.add(this);
				if(onFloorObject.tags!=""){
					addQueue(onFloorObject.tags);
				}
				onFloorObject.layer.trigger("on");
			}
		}

		// 影の処理
		shadowToFloorObject();

		var mt = new MovingTable();

		if(owner.tickCount - attackTick > 15) attackIndex = 0;

		if(nowSpriteId==stStandUp || nowSpriteId==stStanding){
			pursueCount = 1;
			pursueFrom = void;
		}

		if(movingTable[0] !== void && isvalid movingTable[0]) mt.set(movingTable[0]);
		if(floorObjectCollision) checkFloorObjectCollision(mt);

		// 落下していないか
		if(!noGravity){
			mt = checkFall(mt);
		}else{
			fAltitude = getFloorAltitude();
		}
		if(altitude < -450) deleteFlag = true;

		// クリンチが解けていないか確認
		if(pExist) checkClinch();

		// 攻撃を受けていないか
		if(pExist) mt = checkDamage(mt);

		// バトルモード中
		if(f.inBattleMode && sf.bmEnemyHPInfinite){
			if(HP <= 0 && deleteFlag){
				HP = maxHP;
				deleteFlag = false;
				var s = (nowSpriteId == stDown)? lastSpriteId: nowSpriteId;
				switch(s){
					case stThrown2:
					case stThrown4:
						if(kind == "エクセルシフォン"){
							loadSprite(stStandUp3);
						}else{
							loadSprite(stStandUp2);
						}
						break;
					default:
						loadSprite(stStandUp);
						break;
				}
			}
			if(owner.tickCount - lastDamageTick > 30){
				HP = maxHP;
			}
			if(nowSpriteId >= stThrown1 && nowSpriteId <= stThrown11 && (altitude - fAltitude) > 0){
				lastDamageTick = owner.tickCount;
			}
		}

		// 危険箇所の近くにいないか
		nearAvoidPoint = getNearAvoidPoint();
		if(nearAvoidPoint===void || ignoreAvoidPoint){
			// 攻撃可能なら
			if(pExist && enableFreeMove && !noEnemiesAttack && enableAttack) checkAttack((tf.inRescueMode)?5:1);
		}else{
			if(nowSpriteId==stStanding || nowSpriteId==stWalk){
				movingTable = [];
			}
		}
		// 移動可能なら
//		if(enableMove || (movingByScript && movingTable[0] === void)){
//		　↑何でこうしてたかわからない…… → 移動した後にstStandingに戻すため……っぽいので何か別の方法を
		if(enableMove && lockedCount == 0){
			movingByScript = false;
			mt = preMove(mt);
			if(spriteTableChangeFlag) initSpriteTable();
		}
		if(movingByScript && movingTable[0] === void && nowSpriteId === stWalk){
			loadSprite(stStanding);
		}

//		if(pExist && targetPlayer.nowSpriteId==stDown && sprites[stHAttack] !== void){
		if((pExist || f.inBattleMode) && enableFreeMove && enableMove && (nowSpriteId==stWalk || nowSpriteId==stStanding || nowSpriteId == stDash)){
			if((targetPlayer.nowSpriteId==stExtasy || targetPlayer.nowSpriteId==stDown || targetPlayer.nowSpriteId==stDamage3) && sprites[stHAttack] !== void && targetPlayer.clinchedStrength < 1000 && !tf.isExistBoss && kind==tf.killedByKind[0]){
				// 抱きつく（イッてるときやレスキューモード、かつ抱きつかれておらず、ボス戦でないとき）
				if(checkOverlap(rootX, rootY, targetPlayer, true)){
					var oPlayer = bao.getOtherPlayer(targetPlayer);
					if(oPlayer !== void && (oPlayer.nowSpriteId == stSitDown || oPlayer.nowSpriteId == stSitDown2)){
						// 救助中だったら攻撃する
						targetPlayer = oPlayer;
						checkAttack(10);
					}else if(intrandom(0, 100) > (100-getAttackCheckRate(attackCheckRate[0]))){
						loadSprite(stPreHAttack2);
						switch(targetPlayer.nowSpriteId){
							case stExtasy:
								targetPlayer.damageFrom = this;
								targetPlayer.damageFromStr = kind;
								targetPlayer.damage.kind = atkHold;
								targetPlayer.damage.strength = 100;
//								targetPlayer.clinchedBy = this;
//								targetPlayer.clinchedStrength = 100;
//								targetPlayer.loadSprite(stClinched);
								break;
							case stDown:
							case stDamage3:
								// stPreHattack2からclinch()が呼び出されその中で10000になるはず
								//targetPlayer.clinchedStrength = 10000;
								break;
						}
					}
				}
			}else if(sprites[stHolding2] !== void && sprites[stClinching] !== void && !targetPlayer.nowSpriteId==stSpecial1){
				// 抱きつく（通常時）
				if(intrandom(0, 100) > (100-getAttackCheckRate(attackCheckRate[0]))){
					clinch(void, 100);
				}
			}
		}

		// 移動処理
		if(lockedCount == 0){
			move(mt);
			lastMovingTable.set(mt);
		}

		if(typeof(owner.scenarioPaused)!='undefined' && !owner.scenarioPaused){
			MP += recoveryMP;
			if(MP > maxMP) MP = maxMP;
		}

		if(owner.tickCount - lastDamageTick > 30){
			lastDamageTick = 0;
			damageCount = 0;
		}

		if(pExist && holdPlayerPos!==void){
//dm("this : " + bao.getIndex(this) + " / clinchPlayer : " + bao.getIndex(clinchPlayer) + " / clinchPlayer.clinchedBy : " + bao.getIndex(clinchPlayer.clinchedBy));
			if(this !== clinchPlayer.clinchedBy && clinchPlayer.spriteTableChangeFlag){
				loadSprite(stDamage1);
				movingTable = [];
				invincibleCount = 10;
				setMovingTable(%["path" => "(-80,0,0)" , "xaccel" => -1 , "frame" => 15], movingTable);
			}else{
				clinchPlayer.rootY = rootY + holdPlayerPos.y;

				var x = rootX - holdPlayerPos.x * xDirection(inverse);
				var y = int(clinchPlayer.rootY) - clinchPlayer.layer.asdHeight + clinchPlayer.footRect.bottom;

				movingTable = [];
				clinchPlayer.movingTable = [];

				var onFloorObject = getObject(x, y);
				if(getAltitude(x , y) > 0){
					rootX += holdPlayerPos.x * xDirection(inverse);
				}else{
					clinchPlayer.rootX = rootX - holdPlayerPos.x * xDirection(inverse);
				}
				if(holdPlayerPos.altitude > 0) clinchPlayer.noGravity = true;
				clinchPlayer.altitude = altitude + holdPlayerPos.altitude;
			}
		}

		invalidate mt;


	}

	function setMoveByScript(elm){

		if(!+elm.spritestay){
			var id = stWalk;
			if(elm.id !== void) id = Scripts.eval(elm.id);
			loadSprite(id);
		}

		enableMove = false;
		enableAttack = false;

		super.setMoveByScript(elm);

		if(+elm.noinverse !== true){
			if(movingTable[0].x < 0 && inverse || movingTable[0].x>0 && !inverse){
				inverse = !inverse;
				layer.setInverse();
			}
		}
	}

	function holdPlayer(x, y, a)
	{
		holdPlayerPos = new Position(...);
	}

	function clearHoldPlayer(){
		if(holdPlayerPos !== void){
			invalidate holdPlayerPos;
			holdPlayerPos = void;
		}
	}


	function setTargetPlayer(){

		if(owner.players.count == 0){
			targetPlayer = void;
		}
	
		if(owner.players.count == 1){
			targetPlayer = owner.players[0];
			return;
		}
		if(sf.adjSingleMode){
			targetPlayer = owner.nowSelectingPlayer;
			return;
		}

		var d = 100000;
		var t = 0;

		for(var i=0; i<owner.players.count; i++){
			if(owner.players[i].layer.opacity2 == 0) continue;

//			if(owner.players[i].clinchedBy === this || owner.players[i].killedBy === this){
			if(owner.players[i].killedBy === this){
				t = i;
				break;
			}
			if(owner.players[i].clinchedStrength > 999) continue;

			var dt = getDistance(this, owner.players[i]);
			// 距離が近い方になるように
			if(dt < d && owner.players[i].HP > 0){
				d = dt;
				t = i;
			}
		}
		targetPlayer = owner.players[t];

	}


	function setMoveDirection(mt)
	{

		if(!enableFreeMove){
			setMovingTable(%["path" => "(0,0,0)" , "frame" => 10], mt);
			return;
		}

		var x;
		var y;
		var fr;

		var p = targetPlayer;

		if(p === void){
			setMovingTable(%["path" => "(0,0,0)" , "frame" => 15], mt);
			return;
		}

		// 移動方向決め
		var rnd = intrandom(0, 100);
		if(nearAvoidPoint === void || ignoreAvoidPoint){
			if(rnd > (100-moveRate1)){
				var t;
				if(tf.killedByKind[0] === kind && intrandom(0,5)<1){
					t = 0;
				}else{
					t = targetDistance;
				}

				var a = intrandom(40, 80);
				if(p.rootX < rootX){
//					x = (Math.abs(p.rootX - rootX + t)) * a / 100;
					x = (rootX - (p.rootX + t)) * a / 100;
				}else{
//					x = (Math.abs(p.rootX - rootX - t)) * a / 100;
					x = ((p.rootX - t) - rootX) * a / 100;
				}


				y = (p.rootY - rootY) * a / 100;

				var d = Math.sqrt(x*x + y*y);
				fr = int(d / moveSpeed);
				if(fr == 0) fr = 1;

				x = x / fr;
				y = y / fr;
			}else if(rnd > (100-moveRate1-moveRate2)){
				fr = intrandom(15, 60);

				x = intrandom(0, 2) - 1;
				y = intrandom(0, 2) - 1;
				if((rootX<p.rootX && p.inverse) || (p.rootX<rootX && !p.inverse)){
					// 主人公の後ろ側にいる
					if(x > 0) x = moveSpeed;
					else if(x < 0) x = -moveSpeed;
					else x = 0;
				}else{
					// 主人公と相対している
					if(x > 0) x = -moveSpeed;
					else if(x < 0) x = moveSpeed;
					else x = 0;
				}

				// 画面外に出た場合はなるべく早く画面内に
				if(rootX+x < 0 || owner.internalWidth < rootX+x){
					if(x < 0) x = -x;
				}
	//			y = y * moveSpeed / 1.5;
			}else{
				fr = intrandom(10, 20);
				x = 0;
				y = 0;
			}
		}else{
			var dx = (nearAvoidPoint.x-owner.stageLayer.dispLeft) - rootX;
			var dy = nearAvoidPoint.y - rootY;
			if(Math.abs(dx) < 50){
				if(dx < 0 && inverse){
					x = 1;
				}else{
					x = -1;
				}
			}
			if(Math.abs(dy) < 20){
				if(dy < 0){
					y = 1;
				}else{
					y = -1;
				}
			}
			fr = 5;
		}

		if(!inverseMode){
			if((rootX<p.rootX && !inverse) || (p.rootX<rootX && inverse)) x = -x;
		}

		if(moveXAccel == 0){
			setMovingTable(%["path" => "(" + (x*fr) + "," + (y*fr) + ",0)" , "frame" => fr], mt);
		}else{
			var f1 = int(fr / 2);
			var f2 = f1;
			if(fr > f1 + f2) f1++;
			setMovingTable(%["path" => "(" + (x*f1) + "," + (y*f1) + ",0)" , "frame" => f1, "xaccel"=>moveXAccel], mt);
			setMovingTable(%["path" => "(" + (x*f2) + "," + (y*f2) + ",0)" , "frame" => f2, "xaccel"=>-moveXAccel], mt);
		}
//		dm("path = (" + (x*fr) + "," + (y*fr) + ",0) / frame = " + fr);
	}

	function checkOverlap(x, y, p, ignoreAltitude=false)
	{
		// 判定範囲
		var r = new Rect2(x-centerPos+hitRect.left, y-depth/2, x-centerPos+hitRect.left+hitRect.width, y+depth/2);

		// 画面外なら判定しない
		if(x < 0 || x > owner.internalWidth) return false;

		// 無敵時間なら判定しない
		if(p.invincibleCount > 0) return false;
		// 高さが違えば判定しない
		if(!ignoreAltitude && int(altitude) != int(p.altitude)) return false;
		// 相手が死んでたら判定しない
		if(!(tf.inRescueMode || f.inBattleMode) && p.HP <= 0) return false;
		// 当たり判定が存在しなくても判定しない
		if(p.hitRect.isEmpty()) return false;


		var pr = new Rect2(p.rootX-p.centerPos+p.hitRect.left, p.rootY-p.depth/2, p.rootX-p.centerPos+p.hitRect.left+p.hitRect.width, p.rootY+p.depth/2);

		return r.intersects(pr);
	}

	function checkClinch()
	{
		//クリンチ状態のチェック

		if(targetPlayer === void) setTargetPlayer();
		var p = targetPlayer;

		if(nowSpriteId == stClinched){
			// クリンチされていたが解けた場合など
			switch(p.nowSpriteId){
				case stClinching:
					if(p.clinchEnemy !== this) loadSprite(stStanding);
					break;
				case stBackClinch:
					if(p.clinchEnemy !== this) loadSprite(stStanding);
					if(inverse){
						rootX = p.rootX + centerPos;
					}else{
						rootX = p.rootX - layer.asdWidth + centerPos;
					}
					return;
				case stWalk:
				case stStanding:
				case stDamage1:
				case stDamage2:
				case stClinched:
				case stSpecial3:
				case stExtasy:
				case stEtc3:
					invincibleCount = 5;
					loadSprite(stStanding);
			}
		}

		p = clinchPlayer;
		if(p !== void && (nowSpriteId == stClinching || nowSpriteId == stBackClinch || nowSpriteId == stHAttack || nowSpriteId == stHolding2)){
			// クリンチしていたが解かれたなど
			switch(p.nowSpriteId){
				case stStanding:
				case stWalk:
				case stUntangle:
					clearHoldPlayer();
					loadSprite(stDamage1);
					movingTable = [];
					invincibleCount = 10;
					setMovingTable(%["path" => "(-80,0,0)" , "xaccel" => -1 , "frame" => 15], movingTable);
					clinchPlayer = void;
					break;
				case stSpecial2:
					clearHoldPlayer();
					clinchPlayer = void;
					loadSprite(stDamage2);
					break;
				case stDamage1:
				case stDamage2:
					clearHoldPlayer();
					clinchPlayer = void;
					loadSprite(stStanding);
					break;
				case stExtasy:
					if(p.inExtasy > 0 && nowSpriteId != stHAttack) loadSprite(stStanding);
					break;
				default:
//					if(p.rootY+1<movableRect.bottom){
//						rootY = p.rootY + 1;
//					}else{
//						p.rootY--;
//						rootY = p.rootY + 1;
//					}
			}
		}else{
			if(holdPlayerPos !== void){
				clearHoldPlayer();
			}
		}
	}

	function checkDamage(mt)
	{
//		var p = owner.player;

		if(HP <= 0 && (nowSpriteId==stStanding || nowSpriteId==stWalk)) loadSprite(stDamage2);
		if(damage.kind == atkHold && damage.strength == 0) damage.strength = 1;
		if(damage.strength == 0) return mt;
		if(tf.nowRevive && sf.adjDecreaseDamageAtRevive) damage.strength = 1;
		// 追撃技を重ねると攻撃力が落ちる
		for(var i=0; i<owner.players.count; i++){
			var p = owner.players[i];
			if(damageFrom===p && p.nowSpriteId!=((p.chara==chrChiffon)?stSpecial5:stSpecial6)){
				pursueCount = 1;
				pursueFrom = void;
			}
		}
		damage.strength /= pursueCount;

		if(nowSpriteId == stLocked){
			if(atkNormal && (lastSpriteId == stStandUp || lastSpriteId == stDamage2)){
				damage.kind = atkBrowOut|atkEnablePursue;
			}
 			layer.conductor.start();
			lockedCount = 0;
		}

		// 攻撃を受けた
		if(HP > 0) {

//dm(bao.tickCount + " " + this + " : enemies[" + bao.getIndex(this) + "] : " + HP + " / " + damage.strength + " / " + st(nowSpriteId) + " / from : " + damageFrom);
			state = stateDamage;
			var guardRand = intrandom(0,1000);
			if(damage.kind == atkHold) guardRand / 2;
			if(((damage.kind&atkInvalidGuard)!=atkInvalidGuard || isBoss) && lockedCount==0 && (guardRate>0 || escapeMP>0) && (guardRand < guardRate*10+f.difficulty*50 || lastSpriteId==stGuard)
					&& (nowSpriteId==stStanding||nowSpriteId==stWalk||nowSpriteId==stGuard) && ((damage.kind&atkInvalidGuard2)!=atkInvalidGuard2)){
				// ガードする
				var p = targetPlayer;
				if(owner.nowSelectingPlayer === this){
					p.comboCount--;
					if(p.comboCount < 0) p.comboCount = 0;
				}
				if(escapeMP>0 && MP>=escapeMP && sprites[stEscape] !== void && p.nowSpriteId != stSpecial2){
					loadSprite(stEscape);
					MP -= escapeMP;
					damage.strength = 0;
				}else{
					if(sprites[stGuard] !== void && HP > 0 && guardRate > 0){
						var d = damage.strength * guardDamageRate;
						if(d < 1) d = 1;
						HP -= d;
						putHitMark(damage.hitPos, getHitMarkStorage());
						if(HP > 0){
							loadSprite(stGuard);
							guardCount ++;
							damage.strength = 0;
						}
					}
				}
			}


			if(damageFrom !== void && isvalid damageFrom && damageFrom.objectClass != clPlayer && (damageFromStr == 'chiffon' || damageFromStr == 'chocolat')){
				damage.strength = getAttackStrength(damage.strength);
			}


			if(damage.strength > 0){
				lockedCount = 0;
				// ガードできない
				HP -= damage.strength * damageRate;
				var p = targetPlayer;

				putHitMark(damage.hitPos, getHitMarkStorage());

				if((damage.kind&0x0f)==atkNormal && HP>0 && (noGravity || int(altitude-fAltitude)==0)){
					switch(nowSpriteId){
						case stClinched:
							lastDamageTick = owner.tickCount;
							if(p.nowSpriteId==stSpecial1 || p.nowSpriteId==stSpecial2 || p.clinchEnemy !== this){
								loadSprite(stDamage1);
							}else{
								loadSprite(stClinchedDamage);
							}
							break;
						default:
							// 連続で喰らうと反撃される
							if(damageFrom===p && nowSpriteId!=stDamage2) damageCount++;
							var psid = p.nowSpriteId;
							if(damageCount > damageCountLimit && psid!=stSpecial1 && psid!=stSpecial2 && psid!=stSpecial3){
								invincibleCount += 15;
								loadSprite(counterAttack);
							}else{
								loadSprite(stDamage1);
							}
							lastDamageTick = owner.tickCount;
					}
					if(p.movingTable[0]!==void && damageMoveFlag){
						movingTable = [];
						var i = 0;
						while(p.movingTable[i]!==void){
							var mt = new MovingTable();

							// 遠くにいると少し近づく感じ
							var d = Math.abs(rootX - p.rootX);
							var a;
							if(d >= 60) a = 0.3;
							if(30 <= d && d < 60) a = 0.8;
							if(d < 30) a = 1.5;

							mt.set(p.movingTable[i].x*a, p.movingTable[i].y, mt.h);
							movingTable.add(mt);
							i++;
						}
					}
				}else{
					if((damage.kind&0xf000)!=atkNoLoad || nowSpriteId!=stDamage2){
						lastDamageTick = owner.tickCount;
						if(inverseMode && nowSpriteId!=stDamage2){
							if(damageFrom !== void && isvalid damageFrom){
								if(damageFrom.movingTable.count>0 && Math.abs(damageFrom.movingTable[0].x)>0 && (damageFrom.objectClass==clObject || damageFrom.objectClass==clEffect)){
//									if(damageFrom.movingTable[0].x < 0) inverse = true; else inverse = false;
									inverse = !damageFrom.inverse;
								}else{
									if(rootX < damageFrom.rootX) inverse = true; else inverse = false;
								}
							}
						}
						loadSprite(stDamage2);
					}
				}
			}

			targetPlayer = getDamageSourcePlayer(damageFrom);
			if(targetPlayer === owner.notSelectingPlayer) damagedByAICount ++;
			// 誰の攻撃で死んだかを保持
			if(HP <= 0){
				if(owner.nowSelectingPlayer === targetPlayer) killedByUser = true;
			}

			if(damage.strength > 0){
				executeScriptAtDamaged();
			}
		}
		damage.strength = 0;

		if(HP <= 0 && (nowSpriteId==stStanding || nowSpriteId==stWalk)) loadSprite(stDamage2);

		if(movingTable[0] !== void){
			return movingTable[0];
		}else{
			return mt;
		}
	}


	function getDamageSourcePlayer(obj)
	{
		// どのヒロインの攻撃を喰らったか
		if(obj !== void && isvalid obj){
			if(obj.objectClass == clPlayer){
				// 直接喰らった場合
				return obj;
			}else if(obj.kind != ""){
				// エフェクトの攻撃判定に当たった場合、どのヒロインの攻撃なのか
				for(var i=0; i<owner.players.count; i++){
					if(owner.players[i].kind == obj.kind){
						return owner.players[i];
					}
				}
			}else if(obj.objectClass == clObject || obj.objectClass == clEffect){
				var o = obj.getRootSprite();
				if(o !== void && isvalid o && typeof o.objectClass != 'undefined' && o.objectClass == clPayer){
					return o;
				}
			}
		}
		// 不明
		return void;
	}


	function executeScriptAtDamaged()
	{
		if(damage.tags != ""){
			addQueue(damage.tags);
			executeQueue();
			damage.tags = "";
		}
		if(damage.exp != ""){
//dm("exp : " + damage.exp);
//if(damage.expcond!=""){
//	dm("cond : "+ damage.expcond);
//}else{
//	dm("comd : null");
//}
			executeEval(damage);
			damage.exp = "";
		}
	}

	function getHitMarkStorage(){
		var p = targetPlayer;
		var s;
		if(p === void) return;
		if(damageFrom === void || !isvalid damageFrom){
			return hitMarkStorage[0];
		}
		if(damageFrom.parentSprite !== void && isvalid damageFrom.parentSprite){
			s = (damageFrom.parentSprite === p || damageFrom.parentSprite.parentSprite === p)? hitMarkStorage[0] : hitMarkStorage[1];
		}else{
			s = (damageFrom === p || damageFrom.kind === p.kind)?  hitMarkStorage[0] : hitMarkStorage[1];
		}
		return s;
	}


	function checkAttack(r=1)
	{
		if(attackCheckRect === void) return;
		if(attackableRect === void) return;
		var acr = toGlobalRectFromRoot(attackCheckRect);

		if(enableAttack && enableFreeMove){
			for(var j=0; j<owner.players.count ;j++){
				var p = owner.players[j];
				if(sf.adjSinglePlayMode && p === bao.notSelectingPlayer) continue;
//				if(p.nowSpriteId==stStandUp || p.nowSpriteId==stDamage2) continue;
				if(p.hitRect.isEmpty()) continue;
				if(p.HP <= 0) continue;

//dm("attackIndex : " + attackIndex + " / attackableRect.includedPos(rootX, rootY) : " + attackableRect.includedPos(rootX, rootY) + " / acr.includedPos(p.rootX, p.rootY) : " + acr.includedPos(p.rootX, p.rootY));
//acr.dm();
//dm("p.rootX : " + p.rootX + " / p.rootY : " + p.rootY + " / rootX : " + rootX + " / rootY: " + rootY);
				// 攻撃が当たるようなら攻撃する
				if(attackableRect.includedPos(rootX, rootY) && acr.includedPos(p.rootX, p.rootY)){

//					var id = -1;
//					for(var i=0; i<attackList.count; i++){
//						if(checkAttackSub(attackList[i], p)){
//							id = i;
//							break;i
//						}
//					}
//					if(id >= 0){
//						loadSprite(attackList[id]);
//						return;
//					}else if(comboAttackList.count>0 && checkAttackSub(comboAttackList[attackIndex], p)){
//						if(attackIndex > comboAttackList.count-1) attackIndex = 0;
//						loadSprite(comboAttackList[attackIndex]);
//						attackTick = owner.tickCount;
//						return;
//					}


					var a = void;
					if(p.inExtasy == 0 || isBoss || intrandom(0,100)<20 || sf.adjIncreaseEnemyAttackRate){
						var rnd = intrandom(0, 100);
						var flg = true;
						if(f.difficulty > 3){
							attackIndex = intrandom(0, comboAttackList.count-1);
							if(attackList.count > 0) flg = intrandom(0, 1);
						}
						if(flg && (rnd < getAttackCheckRate(comboAttackCheckRate) * r || attackIndex > 0)){
							if(comboAttackList.count>0 && (sf.adjIncreaseEnemyAttackRate || checkAttackSub(comboAttackList[attackIndex], p))){
								state = stateAttack;
								if(attackIndex > comboAttackList.count-1) attackIndex = 0;
								faceToPlayer();
								loadSprite(comboAttackList[attackIndex]);
								attackTick = owner.tickCount;
								return true;
							}
						}

						for(var i=0; i<attackList.count; i++){
							var rnd = intrandom(0, 100);
							if(rnd < getAttackCheckRate(attackCheckRate[i]) * r){
								if(attackList[i] == stHolding && (p.clinchedStrength > 110 || !p.clinchAbled(this))) continue;
								if((sf.adjIncreaseEnemyAttackRate && intrandom(0,100)<30) || checkAttackSub(attackList[i], p)){
									a = attackList[i];
									break;
								}
							}
						}
					}else{
						if(!tf.isExistBoss && (p.nowSpriteId == stExtasy || p.nowSpriteId == stDown) && sprites[stPreHAttack1] !== void){
							if(checkAttackSub(stPreHAttack1, p)){
								a = stPreHAttack1;
							}
						}
					}
					if(a !== void){
						attackTick = owner.tickCount;
						state = stateAttack;
						faceToPlayer();
						loadSprite(a);
						return true;
					}

				}
			}
		}
		return false;

	}


	function faceToPlayer(p = targetPlayer){
		if(rootX < p.rootX){
			inverse = true;
			if(inverse != layer.inverse) setLayerInverse();
		}else if(p.rootX < rootX){
			inverse = false;
			if(inverse != layer.inverse) setLayerInverse();
		}
	}

	function checkAttackSub(id, target)
	{
		// 攻撃が当たるか判定する
		if(typeof id != "Integer") return false;
		try
		{
			var asd = sprites[id];
			if(typeof asd == "Object"){
				if(Storages.isExistentStorage(sprites[id][cosState] + '.asd')){
					asd = sprites[id][cosState];
					if(asd === void) return false;
				}else{
					asd = sprites[id][0];
					if(asd === void) return false;
				}
			}
			attackConductor.loadScenario(asd+".asd");
			var aca = attackConductor.attackCheckAlgorithm(target, inverse);
			if(aca >= 0) return true;
		}
		catch(e)
		{
			throw new Exception("error this : " + this + " / kind : " + kind + " / spriteId : " + st(id) + " / target : " + target + "\n" + e.message);
		}
		return false;
	}

	function attackRectBufSet()
	{
		try
		{
//dm("layer.asd : " + layer.asd + " / layer.conductor : " + layer.conductor);
			attackConductor.assign(layer.conductor);
//dm("attackConductor.curStorage : "+ attackConductor.curStorage + " / attackConductor.curLine : " + attackConductor.curLine);
			attackConductor.attackRectBufSet();
		}
		catch(e)
		{
			throw new Exception("error this : " + this + " / layer.asd : " + layer.asd + "\n" + e.message);
		}
		return false;
	}

	function preMove(m)
	{
		setTargetPlayer();

		var mt = new MovingTable(m);
		var setMtFlag = false;

		// 主人公の方を向く
		// rootXが主人公と同じだと左右反転しまくってアレなので、2pixel余裕を持たせてる
		if(inverseMode && targetPlayer !== void){
			if(rootX < targetPlayer.rootX - 2){
				inverse = true;
				if(inverse != layer.inverse) setLayerInverse();
			}else if(targetPlayer.rootX + 2 < rootX){
				inverse = false;
				if(inverse != layer.inverse) setLayerInverse();
			}
		}

		if(movingTable[0] === void){
			setMoveDirection(movingTable);
			setMtFlag = true;
		}
		mt.set(movingTable[0]);

		if(mt.x==0 & mt.y==0){
			// レバー中立状態
			if(nowSpriteId != stStanding) loadSprite(stStanding, true);
		}else{
			// 通常の歩き
			switch (nowSpriteId){
				case stWalk:
					break;
				case stDash:
					if(setMtFlag) loadSprite(stWalk, true);
					break;
				default:
					loadSprite(stWalk, true);
			}
			if(!inverseMode){
				if(mt.x < 0) inverse = false;
				if(mt.x > 0) inverse = true;
			}
//			mt.set(mt.x, mt.y, mt.h);
			if(inverse != layer.inverse){
				layer.setInverse();
			}
		}

		return mt;
	}


	function getNearAvoidPoint()
	{
		var nearPoint = void;
		var min = 10000;
		var d = 0;
		if(owner.stageLayer===void) return;
		for(var i=0; i<owner.stageLayer.avoidPoints.count; i++){
			var p = owner.stageLayer.avoidPoints[i];
//			var x = p.x-owner.stageLayer.dispLeft;
			var x = p.x;
			if(x < 0 || x > owner.internalWidth) continue;
			var dx = rootX - x;
			var dy = (rootY - p.y);
			d = Math.sqrt(dx*dx + dy*dy);
			if(d < min){
				nearPoint = p;
				min = d;
			}
		}

		if(nearPoint !== void){
			if(Math.abs(rootX - (nearPoint.x-owner.stageLayer.dispLeft))<50 && Math.abs(rootY - nearPoint.y)<20){
				return nearPoint;
			}
		}
		return void;

	}


	function move(mt)
	{
		var r = new Rect2(footRect);
		r.addOffset(rootX - centerPos, rootY - layer.asdHeight);

//		kag.fore.layers[0].fillRect(0, 0, kag.innerWidth, kag.innerHeight, 0x00000000);
//		kag.fore.layers[0].fillRect(r.left, r.top, r.width, r.height, 0x8800ff00);

		if(floorObjectCollision){
			if(int(altitude) < getAltitude(r.right+mt.x, r.bottom+mt.y) || int(altitude) < getAltitude(r.left+mt.x, r.bottom+mt.y)){
				if(mt.x!=0 && mt.y!=0){
					// 引っ掛かり低減処理
					if(mt.x>0 && int(altitude) == getAltitude(r.right, r.bottom+mt.y)){
						for(var i=0; i<mt.x; i++){
							if(int(altitude) < getAltitude(r.right+i, r.bottom+mt.y)){
								mt.x = i - 1;
								break;
							}
							mt.x = 0;
						}
					}else if(mt.x<0 && int(altitude) == getAltitude(r.left, r.bottom+mt.y)){
						for(var i=0; i>mt.x; i--){
							if(int(altitude) < getAltitude(r.right+i, r.bottom+mt.y)){
								mt.x = i + 1;
								break;
							}
							mt.x = 0;
						}
					}else{
						mt.x = 0;
						mt.y = 0;
					}
				}else{
					// 地形で進めないとき
					mt.x = 0;
					mt.y = 0;
				}
			}
		}

		var x = mt.x + rootX;
		var y = mt.y + rootY;
		var h = mt.h + altitude;

		if(movableRect!==void && !movableRect.includedPos(x, y) && !deleteFlag && !ignoreMovableRect){
			if(owner.stageLayer!==void && !owner.stageLayer.xFreeMode){
				if(x < movableRect.left)   x = movableRect.left;
				if(x > movableRect.right)  x = movableRect.right;
			}
			if(y < movableRect.top)    y = movableRect.top;
			if(y > movableRect.bottom) y = movableRect.bottom;
		}
		if(h < -500) h = -500; // -500は暫定的で適当な数字

		rootX = x;
		rootY = y;
		altitude = h;

	}

	function clinched()
	{
		var x = targetPlayer.rootX;
		var y = targetPlayer.rootY;
//		dm("x : " + x + " / y : " + y + " / centerPos : " + centerPos);
		loadSprite(stClinched);

		if(targetPlayer.chara == chrChiffon && targetPlayer.nowSpriteId == stClinching){
			rootY = y + 1;
			if(rootY > movableRect.bottom) targetPlayer.rootY = movableRect.bottom - 1;
		}else{
			rootY = y - 1;
			if(rootY < movableRect.top) targetPlayer.rootY = movableRect.top + 1;
		}

		var c = targetPlayer.chara;
		altitude = targetPlayer.altitude;
		if(x < rootX){
			var dx = x + centerPos + clinchedOffset;
			if(getAltitude(dx, rootY)>altitude){
				return rootX - centerPos;
			}else if(dx > owner.internalWidth){
				rootX = owner.internalWidth;
				return rootX - centerPos;
			}else{
				rootX = dx;
				return x;
			}
		}else{
			var dx = x - layer.asdWidth + centerPos - clinchedOffset;
			if(getAltitude(dx, rootY)>altitude){
				return rootX + layer.asdWidth - centerPos;
			}else if(dx < 0){
				rootX = 0;
				return layer.asdWidth - centerPos;
			}else{
				rootX = dx;
				return x;
			}
		}
	}

	function checkAttackCollision()
	{
		if(attackRect.isEmpty()) return;
		if(attack.strength < 0) return;
		if(owner.players.count == 0) return;
		if(attack.kind == atkNoLoad) return;
		var line = new Rect2(-20, rootY - depth1, owner.internalWidth+20, rootY + depth2);

		for(var i=0; i<owner.players.count; i++){
			var p = owner.players[i];

			if(p===void) continue;
			if(sf.adjSinglePlayMode && p === bao.notSelectingPlayer) continue;
			if(p.hitRect.isEmpty()) continue;
			if(p.invincibleCount > 0) continue;
			if(p.comboDamageCount >= 5) continue;
			if(p.nowSpriteId == stDown || p.nowSpriteId == stDamage3) continue;
			if(attack.kind == atkParalysis && p.state == stateDamage) continue;

			if(!line.includedPos(p.rootX, p.rootY)) continue;
			if(p.damage.tick == attack.tick) continue;

			var r1 = new Rect2(attackRect);
			r1.addOffset(internalLayerLeft, internalLayerTop+p.rootY-rootY);

			var r2 = new Rect2(p.hitRect);
			r2.addOffset(p.internalLayerLeft, p.internalLayerTop);
			r2.addOffset(0, rootY-p.rootY);

			if(r1.intersects(r2)){
				if(nowSpriteId == stHolding){

					if(p.altitude==getAltitude(p.rootX, p.rootY) && p.clinchAbled(this) && p.clinchedStrength < 110){
						p.damageFrom = this;
						p.damageFromStr = kind;
						p.damage.set(attack);
						p.clinchedBy = this;
						targetPlayer = p;
						clinchPlayer = p;
						loadSprite(stHolding2);
					}
				}else if(nowSpriteId == stPreHAttack1 && !tf.isExistBoss){
					if(p.nowSpriteId != stExtasy) continue;
					if(p.altitude==getAltitude(p.rootX, p.rootY)){
						p.damageFrom = this;
						p.damageFromStr = kind;
						p.damage.set(attack);
						p.clinchedBy = this;
						targetPlayer = p;
						clinchPlayer = p;
						loadSprite(stPreHAttack2);
					}
				}else{
					p.damageFrom = this;
					p.damageFromStr = kind;
					p.damage.set(attack);
					targetPlayer = p;
					if(attackTick != attackIndexCountUpTick){
						attackIndexCountUpTick = attackTick;
						attackIndex++;
					}
					if(attack.kind != atkParalysis){
						var tmp1 = getIntersectRect(r1, r2);
						var tmp2 = (rootY > p.rootY)? rootY : p.rootY;
						p.setHitMark(tmp1.centerX, tmp2, tmp2-tmp1.centerY);
					}
				}
			}
		}
	}


	function clinch(id, s=0)
	{
		var p = targetPlayer;
		setTargetPlayer();
		if(p.nowSpriteId==stSpecial1) return;
		if(p.clinchedStrength > 999) return;

		// 多重抱き付きチェック
		if(p.clinchedBy !== void && p.clinchedBy !== this && (!p.clinchedBy.multiClinch || p.clinchedBy.kind != kind)) return;

		if(!enableFreeMove || !(p.enableFreeMove||p.nowSpriteId==stDown)) return;
		if(p.nowSpriteId==stDown){
			p.clinchedStrength = 10000;
			if(id === void) id = stHAttack;
		}

		if(id === void){
			if(sprites[stBackClinch] !== void && p.inverse == inverse){
				id = stBackClinch;
			}else{
				id = stClinching;
			}
		}
		p.clinchedStrength += s;
		p.clinchedBy = this;
		clinchPlayer = p;

		loadSprite(id);

		rootX = p.rootX;
		if(p.rootY == p.movableRect.bottom){
			p.rootY = p.movableRect.bottom - 1;
		}
		rootY = p.rootY+1;
		adjustDisp();
	}


	function locked(cnt = 120)
	{

		if(nowSpriteId != stLocked){
			bEnableMove 		 = enableMove;
			bEnableAttack		 = enableAttack;
			bEnableCommand		 = enableCommand;
			bEnableDoubleJump	 = enableDoubleJump;
			bEnableCounter		 = enableCounter;
			bOtherState			 = otherState;
			bNoGravity 			 = noGravity;

			enableMove 			 = false;
			enableAttack		 = false;
			enableCommand		 = false;
			enableDoubleJump	 = false;
			enableCounter		 = false;
			otherState			 = "";
			noGravity			 = true;

			lastSpriteId = nowSpriteId;
		}

		nowSpriteId = stLocked;

		attackRect.clear();
		if(hitRect.isEmpty || hitRect.height == 1){
			hitRect.set(layer.asdWidth * 0.15, 0, layer.asdWidth * 0.85, layer.asdHeight);
		}

		layer.conductor.stop();
		lockedCount = cnt;

	}


	function lockedCancel(flg = false)
	{

		hitRect.set(0, 0, layer.asdWidth, layer.asdHeight);

		if(flg){
			enableMove 			 = bEnableMove;
			enableAttack		 = bEnableAttack;
			enableCommand		 = bEnableCommand;
			enableDoubleJump	 = bEnableDoubleJump;
			enableCounter		 = bEnableCounter;
			noGravity			 = bNoGravity;

			nowSpriteId = lastSpriteId;
			layer.conductor.start();
		}
		lockedCount = 0;

		layer.loadImagesSub2(layer.graphic);
		lockedChangeColor = false;

	}


	function store()
	{
		var dic = super.store();
		dic.score = score;
		dic.isBoss = isBoss;
		dic.child = child;
		dic.ignoreAvoidPoint = ignoreAvoidPoint;
		dic.escapeMP = escapeMP;

//		dic.spriteTableChangeFlag = spriteTableChangeFlag;
//		if(spriteTableChangeFlag){
//			dic.sprites = [];
//			for(var i=0;i<0x9999; i++){
//				if(sprites[i] !== void){
//					dic.sprites[i] = [];
//					dic.sprites[i].assignStruct(sprites[i]);
//				}
//			}
//		}

		dic.countFlag = countFlag;
		dic.targetPlayerIndex = bao.getPlayerIndex(targetPlayer);
		if(clinchPlayer !== void){
			dic.clinchPlayerIndex = bao.getPlayerIndex(clinchPlayer);
		}
		if(holdPlayerPos !== void){
			dic.holdPlayerPos = holdPlayerPos.store();
		}

		return dic;
	}

	function restore(dic)
	{
		super.restore(dic);
		score = dic.score;
		isBoss = dic.isBoss;
		child = dic.child;
		ignoreAvoidPoint = dic.ignoreAvoidPoint;
		escapeMP = dic.escapeMP;

		if(dic.spriteTableChangeFlag){
			sprites = [];
			for(var i=0;i<0x9999; i++){
				if(dic.sprites[i] !== void){
					sprites[i] = [];
					sprites[i].assignStruct(dic.sprites[i]);
				}
			}
		}else{
			initSpriteTable();
		}
		spriteTableChangeFlag = false;

		countFlag = dic.countFlag;
		if(dic.targetPlayerIndex !== void){
			targetPlayer = owner.players[dic.targetPlayerIndex];
		}
		if(dic.clinchPlayerIndex !== void){
			clinchPlayer = owner.players[dic.clinchPlayerIndex];
		}
		if(dic.holdPlayerPos !== void){
			holdPlayerPos = new Position(...);
			holdPlayerPos.restore(dic.holdPlayerPos);
		}

	}

//	function moveToPoint(mt, x, y){
//
//		var dx = x - rootX;
//		var dy = y - rootY;
//		var d = Math.sqrt(dx*dx + dy*dy);
//		var f = int(d / (moveSpeed*2));
//		setMovingTable(%["path" => "(" + dx + "," + dy + ",0)" , "frame" => f], mt, true);
//
//		addQueue("[move path=(" + int(x) + "," + int(y) + ",0) mode=absolute]");
//	}

}


class SoldierSprite extends EnemySprite
{

	function SoldierSprite(window, owner, elm)
	{
		kind = "Combatant";

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(0, 0, 456, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-150, -15, 150, 15);

		cosState = +elm.cosstate;
		switch(cosState){

			case 0:

				// ノーマル
				name = [(elm.name0!==void)? elm.name0 : "Combatant A", (elm.name1!==void)? elm.name1 : "Soldier", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];
				maxHP = HP = enemyHPRate(100);
				maxMP = MP = 0;
				score = 10000;
				targetDistance = 50;
				recoveryMP = 0.05;

				// ボスキャラであるかどうか
				isBoss = false;

				// 攻撃リスト
				attackList = [stAttack2];
				comboAttackList = [stAttack1, stAttack3];

				// 攻撃が当たる奥行き
				depth = 8;

				// 移動速度
				moveSpeed = 1.5;

				// 攻撃判定を行う確率
				attackCheckRate = [10];
				comboAttackCheckRate = 10;

				// 主人公の方へ向かっていく確率
				moveRate1 = 40;
				// 適当に動く確率
				moveRate2 = 30;

				break;

			case 1:

				// ソード
				name = [(elm.name0!==void)? elm.name0 : "Combatant B", (elm.name1!==void)? elm.name1 : "Soldier", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];
				maxHP = HP = enemyHPRate(140);
				maxMP = MP = 0;
				score = 10000;
				targetDistance = 50;
				recoveryMP = 0.05;

				// ボスキャラであるかどうか
				isBoss = false;

				// 攻撃リスト
				attackList = [stAttack1, stAttack2, stAttack3];

				// 攻撃が当たる奥行き
				depth = 8;

				// 移動速度
				moveSpeed = 1.4;

				// 攻撃判定を行う確率
				attackCheckRate = [50, 35, 10];

				// 主人公の方へ向かっていく確率
				moveRate1 = 45;
				// 適当に動く確率
				moveRate2 = 25;

				break;

			case 2:

				// 盾＆メイス
				name = [(elm.name0!==void)? elm.name0 : "Combatant C", (elm.name1!==void)? elm.name1 : "Soldier", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];
				maxHP = HP = enemyHPRate(120);
				maxMP = MP = 0;
				score = 10000;
				targetDistance = 70;
				recoveryMP = 0.05;

				// ボスキャラであるかどうか
				isBoss = false;

				// 攻撃リスト
				attackList = [stAttack1, stAttack2, stAttack3];

				// 攻撃が当たる奥行き
				depth = 8;

				// 移動速度
				moveSpeed = 1.2;

				// 攻撃判定を行う確率
				attackCheckRate = [15, 35, 10];

				// 主人公の方へ向かっていく確率
				moveRate1 = 40;
				// 適当に動く確率
				moveRate2 = 30;

				// 攻撃をガードする確率
				guardRate = 98.0;

				break;

		}

		super.EnemySprite(...);
		if(f.stage == 2) movableRect.top += 1;

	}

	function initSpriteTable()
	{
		sprites[stStanding]			 = [	"e010_standing",		"e011_standing",		"e012_standing"			];
//		sprites[stStanding2]		 = [	"e010_etc3",			"e010_etc3",			"e010_etc3"				];
		sprites[stWalk]				 = [	"e010_walk",			"e011_walk",			"e012_walk"				];
		sprites[stFalling]			 = [	"e010_falling",			"e010_falling",			"e010_falling"			];
		sprites[stLanding]			 = [	"e010_landing",			"e010_landing",			"e010_landing"			];
		sprites[stStandUp]			 = [	"e010_standup",			"e011_standup",			"e012_standup"			];
		sprites[stStandUp2]			 = [	"e010_standup2",		"e010_standup2",		"e010_standup2"			];
		sprites[stAttack1]			 = [	"e010_attack1",			"e011_attack1",			"e012_attack1"			];
		sprites[stAttack2]			 = [	"e010_attack2",			"e011_attack2",			"e012_attack2"			];
		sprites[stAttack3]			 = [	"e010_attack3",			"e011_attack3",			"e012_attack3"			];
		sprites[stAttack4]			 = [	"e010_attack4"];
		sprites[stDamage1]			 = [	"e010_damage1",			"e011_damage1",			"e012_damage1"			];
		sprites[stDamage2]			 = [	"e010_damage2",			"e011_damage2",			"e012_damage2"			];
		sprites[stClinched]			 = [	"e010_clinched",		"e010_clinched",		"e010_clinched"			];
		sprites[stClinchedDamage]	 = [	"e010_clincheddamage",	"e010_clincheddamage",	"e010_clincheddamage"	];
		sprites[stGuard]			 = [	,						,						"e012_guard"			];
		sprites[stThrown1]			 = [	"e010_thrown1",			"e010_thrown1",			"e010_thrown1"			];
		sprites[stThrown2]			 = [	"e010_thrown2",			"e010_thrown2",			"e010_thrown2"			];
		sprites[stThrown3]			 = [	"e010_thrown3",			"e010_thrown3",			"e010_thrown3"			];
		sprites[stThrown4]			 = [	"e010_thrown4",			"e010_thrown4",			"e010_thrown4"			];
		sprites[stThrown5]			 = [	"e010_thrown5",			"e010_thrown5",			"e010_thrown5"			];
		sprites[stThrown6]			 = [	"e010_thrown6",			"e010_thrown6",			"e010_thrown6"			];

		sprites[stPreHAttack1]		 = [	"e010_holding",			"e010_holding",			"e010_holding"			];
		sprites[stPreHAttack2]		 = [	"e010_holding2",		"e010_holding2",		"e010_holding2"			];
		sprites[stHAttack]			 = [	"e010_clinching",		"e010_clinching",		"e010_clinching"		];

		sprites[stEtc1]				 = [	"e010_etc1",			"e010_etc1",			"e010_etc1"				];
		sprites[stEtc2]				 = [	"e010_etc2",			"e010_etc2",			"e010_etc2"				];
//		sprites[stEtc3]				 = [	"e010_etc3",			"e010_etc3",			"e010_etc3"				];
//		sprites[stEtc4]				 = [	"e010_etc4",			"e010_etc4",			"e010_etc4"				];

//		sprites[stHolding]			 = [	"e010_holding",			
//		sprites[stHolding2]			 = [	"e010_holding2",			
//		sprites[stClinching]		 = [	"e010_clinching",		

//		sprites[stLocked]			 = [	"e010_locked",			"e010_locked",			"e010_locked"			];
	}


}


class WingedSoldierSprite extends EnemySprite
{

	var movingTable2 = [];
	var initAltitude = 0;

	function WingedSoldierSprite(window, owner, elm)
	{
		kind = "Combatant";

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(0, 0, 456, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-170, -15, 170, 15);

		name = [(elm.name0!==void)? elm.name0 : "Winged Combatant", (elm.name1!==void)? elm.name1 : "Winged Soldier", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];
		maxHP = HP = enemyHPRate(100);
		maxMP = MP = 7;
		score = 10000;
		targetDistance = 150;
		recoveryMP = 0.05;

		enableClinched = false;

		// ボスキャラであるかどうか
		isBoss = false;

		// 攻撃リスト
//		attackList = [stAttack2];
//		comboAttackList = [];

		// 攻撃が当たる奥行き
		depth = 10;

		// 移動速度
		moveSpeed = 2.5;

		// 攻撃判定を行う確率
		attackCheckRate = [20, 20];

		// 主人公の方へ向かっていく確率
		moveRate1 = 40;
		// 適当に動く確率
		moveRate2 = 60;

		super.EnemySprite(...);

		if(elm.altitude !== void) initAltitude = +elm.altitude;
	}


	function routineProcess()
	{
		if(altitude < 0) altitude = 0;
		super.routineProcess();
		if(movingTable2[0] !== void){
			rootX += movingTable2[0].x;
			rootY += movingTable2[0].y;
			altitude += movingTable2[0].h;
			movingTable2.erase(0);
		}
	}


	function checkAttack()
	{

		if(attackableRect === void) return;
		if(!attackableRect.includedPos(rootX, rootY)) return;
		if(!enableAttack || !enableFreeMove) return;

		for(var i = 0; i < owner.players.count; i++){
			var p = owner.players[i];
			if(sf.adjSinglePlayMode && p === bao.getOtherPlayer(bao.nowSelectingPlayer)) continue;
			if(p.nowSpriteId==stDamage2 || p.nowSpriteId==stClinched || p.nowSpriteId==stClinchedStruggle) continue;

			if(intrandom(0, 100) < attackCheckRate[0]){
				var d = Math.sqrt(getDistance(this, p));
				if(MP >= maxMP && d<170 && d>130 && Math.abs(p.rootY - rootY) < 20){
					faceToPlayer();
					MP = 0;
					loadSprite(stAttack1);
					return;
				}
			}

			if(intrandom(0, 100) < attackCheckRate[1]){
				var tmpRect = new Rect2(attackCheckRect);
				tmpRect.addOffset(rootX, rootY);
				if(tmpRect.includedPos(p.rootX, p.rootY) && MP >= 5){
					faceToPlayer();
					MP -= 5;
					loadSprite(stAttack2);
					return;
				}
			}
		}

	}


	function initSpriteTable()
	{
		sprites[stStanding]			 = "e013_standing";
		sprites[stWalk]				 = "e013_walk";
		sprites[stDamage1]			 = "e013_damage1";
		sprites[stDamage2]			 = "e013_damage1";
		sprites[stDamage3]			 = "e013_damage2";
		sprites[stAttack1]			 = "e013_attack1";
		sprites[stAttack2]			 = "e013_attack2";
		sprites[stLanding]			 = "e013_landing";
	}

}



class UpstairsSoldierSprite extends EnemySprite
{

	var mode = 1;
	var initX;

	function UpstairsSoldierSprite(window, owner, elm)
	{
		kind = "戦闘員";

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-170, 0, 170, 200);

		name = [(elm.name0!==void)? elm.name0 : "Combatant", (elm.name1!==void)? elm.name1 : "Soldier", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];
		maxHP = HP = enemyHPRate(100);
		maxMP = MP = 7;
		score = 10000;
		targetDistance = 150;
		recoveryMP = 0.05;

		enableClinched = false;

		// ボスキャラであるかどうか
		isBoss = false;

		// 移動速度
		moveSpeed = 1.2;

		// 攻撃リスト
		attackList = [stAttack1, stAttack2];

		// 攻撃判定を行う確率
		attackCheckRate = [10, 5];

		// 主人公の方へ向かっていく確率
		moveRate1 = 40;
		// 適当に動く確率
		moveRate2 = 20;

		super.EnemySprite(...);

		if(elm.altitude !== void) initAltitude = +elm.altitude;
		shadow = false;

	}


	function setState(elm)
	{
		super.setState(...);
		initX = rootX + bao.stageLayer.dispLeft;
		movableRect = void;
		rootY = 42;
	}


	function setMoveDirection(mt)
	{
		var x;
		var fr;

		if(!enableFreeMove || mode == 0){
			setMovingTable(%["path" => "(0,0,0)" , "frame" => 10], mt);
			return;
		}

		// 移動方向決め
		var rnd = intrandom(0, 100);
		if(rnd > (100-moveRate1)){
			x = moveSpeed;
			fr = intrandom(10,30);
		}else if(rnd > (100-moveRate1-moveRate2)){
			fr = intrandom(10, 30);
			if((intrandom(0, 2) - 1) > 0){
				x = moveSpeed;
			}else if(x < 0){
				x = -moveSpeed;
			}else{
				x = 0;
			}
		}else{
			fr = intrandom(20, 60);
			x = 0;
		}

		var absX = rootX + bao.stageLayer.dispLeft;
		if(initX - absX > 100){
			x = Math.abs(x) * xDirection(inverse);
		}
		if(absX - initX> 100){
			x = Math.abs(x) * (-xDirection(inverse));
		}

		setMovingTable(%["path" => "(" + (x*fr) + ",0,0)" , "frame" => fr], mt);

	}


	function checkAttack()
	{
		if(mode == 1 && rootX < 50){
			loadSprite(stAttack2);
		}
		if(!enableAttack || !enableFreeMove) return;
		if(rootX < 20 || rootX > bao.internalWidth - 20) return;

		for(var i = 0; i < owner.players.count; i++){
			var p = owner.players[i];
			if(sf.adjSinglePlayMode && p === bao.getOtherPlayer(bao.nowSelectingPlayer)) continue;
			if(MP == 7 && intrandom(0, 100) < attackCheckRate[0]){
				MP = 0;
				loadSprite(stAttack1);
				return;
			}
			if(mode == 1 && rootX < bao.internalWidth/0.6 && intrandom(0, 1000) < attackCheckRate[1]){
				loadSprite(stAttack2);
				return;
			}
			if(p.HP <= 0 || (mode == 2 && intrandom(0, 200) < attackCheckRate[1])){
				loadSprite(stAttack2);
				return;
			}
		}

	}


	function initSpriteTable()
	{
		sprites[stStanding]			 = "e014_standing";
		sprites[stWalk]				 = "e014_walk";
		sprites[stAttack1]			 = "e014_attack1";
		sprites[stAttack2]			 = "e014_attack2";
		sprites[stDash]				 = "e014_dash";
	}

}


class KnifeSoldierSprite extends SoldierSprite
{

	var attackCheckRect2;

	function KnifeSoldierSprite(window, owner, elm)
	{
		kind = "戦闘員";

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(0, 0, 456, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-150, -15, 150, 15);
		attackCheckRect2 = new Rect2(-500, -15, 500, 15);

		name = [(elm.name0!==void)? elm.name0 : "Combatant D", (elm.name1!==void)? elm.name1 : "Soldier", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];
		maxHP = HP = enemyHPRate(100);
		maxMP = 10;
		MP = 8;
		recoveryMP = 0.08;
		score = 10000;
		targetDistance = 150;

		// ボスキャラであるかどうか
		isBoss = false;

		// 攻撃リスト
		attackList = [stAttack2];

		// 攻撃が当たる奥行き
		depth = 8;

		// 移動速度
		moveSpeed = 2.0;

		// 攻撃判定を行う確率
		attackCheckRate = [20, 20];

		// 主人公の方へ向かっていく確率
		moveRate1 = 50;
		// 適当に動く確率
		moveRate2 = 25;

		super.EnemySprite(...);
	}

	function initSpriteTable()
	{
		sprites[stStanding]			 = "e015_standing";
//		sprites[stStanding2]		 = "e010_etc3";
		sprites[stWalk]				 = "e015_walk";
		sprites[stFalling]			 = "e010_falling";
		sprites[stLanding]			 = "e010_landing";
		sprites[stStandUp]			 = "e010_standup";
		sprites[stStandUp2]			 = "e010_standup2";
		sprites[stAttack1]			 = "e015_attack1";
		sprites[stAttack2]			 = "e015_attack2";
		sprites[stDamage1]			 = "e010_damage1";
		sprites[stDamage2]			 = "e010_damage2";
		sprites[stClinched]			 = "e010_clinched";
		sprites[stClinchedDamage]	 = "e010_clincheddamage";
		sprites[stThrown1]			 = "e010_thrown1";
		sprites[stThrown2]			 = "e010_thrown2";
		sprites[stThrown3]			 = "e010_thrown3";
		sprites[stThrown4]			 = "e010_thrown4";
		sprites[stThrown5]			 = "e010_thrown5";
		sprites[stThrown6]			 = "e010_thrown6";

		sprites[stPreHAttack1]		 = "e010_holding";
		sprites[stPreHAttack2]		 = "e010_holding2";
		sprites[stHAttack]			 = "e010_clinching";

		sprites[stEtc1]				 = "e010_etc1";
//		sprites[stEtc2]				 = "e010_etc2";
//		sprites[stEtc3]				 = "e010_etc3";
//		sprites[stEtc4]				 = "e010_etc4";

	}

	function checkAttack()
	{
		if(attackableRect === void) return;
		if(super.checkAttack()) return;
		if(MP < 10) return;

		if(!enableAttack || !enableFreeMove) return;
		if(nowSpriteId != stStanding && nowSpriteId != stWalk) return;

		if(rootX < 0 || rootX > owner.internalWidth) return;

		var acr2 = toGlobalRectFromRoot(attackCheckRect2);
		for(var j=0; j<owner.players.count; j++){
			var p = owner.players[j];
			// 攻撃が当たるようなら攻撃する
			if(sf.adjSinglePlayMode && p === bao.notSelectingPlayer) continue;
			if(p.hitRect.isEmpty()) continue;
			if(intrandom(0, 100) < getAttackCheckRate(attackCheckRate[1]) && acr2.includedPos(p.rootX, p.rootY)){
				if(rootX < targetPlayer.rootX - 2){
					inverse = true;
				}else if(targetPlayer.rootX + 2 < rootX){
					inverse = false;
				}

				MP -= 10;
				loadSprite(stAttack1);
				return;
			}
		}

	}

}


class NetSprite extends EnemySprite
{

	function NetSprite(window, owner, elm)
	{
		sprites[stFalling]			 = "e820_falling";
		sprites[stDamage1]			 = "e820_damage";
		sprites[stDamage2]			 = "e820_damage";
		sprites[stClinching]		 = "e820_clinching";

		kind = "ネット";
//		name = [(elm.name0!==void)? elm.name0 : "Net", (elm.name1!==void)? elm.name1 : "##_##", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];
		maxHP = HP = 1;
		maxMP = MP = 0;
		score = 0;
		targetDistance = 0;
		countFlag = false;

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		super.EnemySprite(...);
	}

	function checkAttackCollision()
	{
		if(deleteFlag) return;
		if(attackRect.isEmpty()) return;
		if(nowSpriteId != stFalling) return;

		var line = new Rect2(-20, rootY - depth1, owner.internalWidth+20, rootY + depth2);
		for(var i=0; i<bao.players.count; i++){
			var p = owner.players[i];
			if(sf.adjSinglePlayMode && p === bao.notSelectingPlayer) continue;
			if(p.nowSpriteId==stSpecial1) continue;
			if(p.invincibleCount > 0) continue;
			if(!line.includedPos(p.rootX, p.rootY)) continue;
			if(p.damage.tick == attack.tick) continue;

			var r1 = new Rect2(attackRect);
			r1.addOffset(internalLayerLeft, internalLayerTop+p.rootY-rootY);

			var r2 = new Rect2(p.hitRect);
			r2.addOffset(p.internalLayerLeft, p.internalLayerTop);
			r2.addOffset(0, rootY-p.rootY);

			if(r1.intersects(r2)){
				if((p.altitude + p.layer.asdHeight)*0.3 > altitude){
					loadSprite(stDamage2);
				}else{
					p.damageFrom = this;
					p.damage.set(attack);
					p.clinchedBy = this;
					targetPlayer = p;
					loadSprite(stClinching);
				}
			}
		}
	}

	function checkClinch()
	{
		if(nowSpriteId == stClinching){
			var p = targetPlayer;
			switch(p.nowSpriteId){
				case stStanding:
				case stWalk:
					loadSprite(stDamage1);
					movingTable = [];
					break;
//				case stDamage1:
				case stSpecial1:
				case stSpecial2:
				case stDamage2:
					loadSprite(stDamage1);
					break;
			}
		}
	}

}

// あれ？　ダメージ喰らったときどうなるんだ？？？ 特にatkNormalの時


class FemaleSoldierSprite extends EnemySprite
{

	function FemaleSoldierSprite(window, owner, elm)
	{
		kind = "女戦闘員";

		name = [(elm.name0!==void)? elm.name0 : "Female Combatant", (elm.name1!==void)? elm.name1 : "Female Soldier", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];
		score = 10000;
		targetDistance = 120;

		// ボスキャラであるかどうか
		isBoss = false;

		// 攻撃が当たる奥行き
		depth = 8;

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(0, 0, 456, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-170, -15, 170, 15);

		// 主人公の方へ向かっていく確率
		moveRate1 = 20;
		// 適当に動く確率
		moveRate2 =40;

		cosState = +elm.cosstate;
		switch(cosState){

			case 0:
				maxHP = HP = enemyHPRate(70);
				maxMP = MP = 0;
				// 攻撃リスト
				attackList = [stAttack1, stAttack2, stAttack2];
				comboAttackList = [];

				// 移動速度
				moveSpeed = 2.4;

				// 攻撃判定を行う確率
				attackCheckRate = [10, 5, 5];

				break;

			case 1:
				maxHP = HP = enemyHPRate(100);
				maxMP = MP = 0;
				// 攻撃リスト
				attackList = [stAttack2, stAttack1, stAttack3];
				comboAttackList = [];

				// 移動速度
				moveSpeed = 2.8;

				// 攻撃判定を行う確率
				attackCheckRate = [15, 8, 10];

				break;

		}

		super.EnemySprite(...);
	}

	function initSpriteTable()
	{
		sprites[stStanding]			 = [	"e020_standing",		"e021_standing"			];
		sprites[stStanding2]		 = [	"e020_standing2",		"e020_standing2"		];
		sprites[stWalk]				 = [	"e020_walk",			"e021_walk"				];
//		sprites[stFalling]			 = [	"e020_falling",			"e020_falling"			];
//		sprites[stLanding]			 = [	"e020_landing",			"e020_landing"			];
		sprites[stStandUp]			 = [	"e020_standup",			"e021_standup"			];
		sprites[stStandUp2]			 = [	"e020_standup2",		"e021_standup2"			];
		sprites[stAttack1]			 = [	"e020_attack1",			"e021_attack1"			];
		sprites[stAttack2]			 = [	"e020_attack2",			"e021_attack2"			];
		sprites[stAttack3]			 = [	void,					"e021_attack3"			];
		sprites[stDamage1]			 = [	"e020_damage1",			"e021_damage1"			];
		sprites[stDamage2]			 = [	"e020_damage2",			"e021_damage2"			];
		sprites[stDamage3]			 = [	"e020_damage3",			"e021_damage3"			];
		sprites[stClinched]			 = [	"e020_clinched",		"e021_clinched"			];
		sprites[stClinchedDamage]	 = [	"e020_clincheddamage",	"e021_clincheddamage"	];
		sprites[stThrown1]			 = [	"e020_thrown1",			"e020_thrown1"			];
		sprites[stThrown2]			 = [	"e020_thrown2",			"e020_thrown2"			];
		sprites[stThrown3]			 = [	"e020_thrown3",			"e020_thrown3"			];
		sprites[stThrown4]			 = [	"e020_thrown4",			"e020_thrown4"			];
		sprites[stThrown5]			 = [	"e020_thrown5",			"e020_thrown5"			];
		sprites[stThrown6]			 = [	"e020_thrown6",			"e020_thrown6"			];
		sprites[stEtc1]				 = [	"e020_etc1",			"e020_etc1"				];
		sprites[stEtc2]				 = [	"e020_etc2",			"e020_etc2"				];

//		sprites[stPreHAttack1]		 = [	"e020_holding",			"e020_holding"			];
		sprites[stPreHAttack2]		 = [	"e020_holding2",		"e020_holding2"			];
		sprites[stHAttack]			 = [	"e020_clinching",		"e020_clinching"		];
	}

}


class PeopleSprite extends EnemySprite
{

	function PeopleSprite(window, owner, elm)
	{
		kind = "一般人";
		name = [(elm.name0!==void)? elm.name0 : "Ordinary Person", (elm.name1!==void)? elm.name1 : "Civilian", (elm.name2!==void)? elm.name2 : "一般人", (elm.name3!==void)? elm.name3 : "普通人"];
		maxHP = HP = 40;
		maxMP = MP = 0;
		score = 5000;
		targetDistance = 80;

		// ボスキャラであるかどうか
		isBoss = false;

		// 攻撃リスト
		comboAttackList = [];
		attackList = [stAttack1, stHolding];

		// 攻撃が当たる奥行き
		depth = 8;

		// 移動速度
		moveSpeed = 0.8;

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(0, 0, 456, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-170, -15, 170, 15);

		// 攻撃判定を行う確率
		attackCheckRate = [10, 20];

		// 主人公の方へ向かっていく確率
		moveRate1 = 60;
		// 適当に動く確率
		moveRate2 = 5;

		// 多重抱きつき有か無しか
		multiClinch = true;

		initSpriteTable();
		if(elm.cosstate !== void){
			cosState = +elm.cosstate;
		}else{
			if(f.stage != 3){
				cosState = peopleCount % 5;
			}else{
				cosState = peopleCount % 4 + 5;
			}
			peopleCount++;

		}

		// 通常攻撃無し
		if(cosState >= 3) attackCheckRate[0] = 0;

		super.EnemySprite(...);

		if(f.stage == 2) movableRect.top += 1;
	}

	function initSpriteTable()
	{
		sprites[stStanding]			 = ["e030_standing",		"e031_standing",		"e032_standing",		"e033_standing",		"e034_standing",		"e035_standing",		"e036_standing",		"e037_standing",		"e038_standing"];
		sprites[stStanding2]		 = ["e030_standing2",		"e031_standing2",		"e032_standing2",		"e033_standing2",		"e034_standing2",		"e035_standing2",		"e036_standing2",		"e037_standing2",		"e038_standing2"];
		sprites[stWalk]				 = ["e030_walk",			"e031_walk",			"e032_walk",			"e033_walk",			"e034_walk",			"e035_walk",			"e036_walk",			"e037_walk",			"e038_walk"];
		sprites[stStandUp]			 = ["e030_standup",			"e031_standup",			"e032_standup",			"e033_standup",			"e034_standup",			"e035_standup",			"e036_standup",			"e037_standup",			"e038_standup"];
		sprites[stStandUp2]			 = ["e030_standup2",		"e031_standup2",		"e032_standup2",		"e033_standup2",		"e034_standup2",		"e035_standup2",		"e036_standup2",		"e037_standup2",		"e038_standup2"];
		sprites[stAttack1]			 = ["e030_attack1",			"e031_attack1",			"e032_attack1"];
		sprites[stDamage1]			 = ["e030_damage1",			"e031_damage1",			"e032_damage1",			"e033_damage1",			"e034_damage1",			"e035_damage1",			"e036_damage1",			"e037_damage1",			"e038_damage1"];
		sprites[stDamage2]			 = ["e030_damage2",			"e031_damage2",			"e032_damage2",			"e033_damage2",			"e034_damage2",			"e035_damage2",			"e036_damage2",			"e037_damage2",			"e038_damage2"];
		sprites[stClinched]			 = ["e030_clinched",		"e031_clinched",		"e032_clinched",		"e033_clinched",		"e034_clinched",		"e035_clinched",		"e036_clinched",		"e037_clinched",		"e038_clinched"];
		sprites[stClinchedDamage]	 = ["e030_clincheddamage",	"e031_clincheddamage",	"e032_clincheddamage",	"e033_clincheddamage",	"e034_clincheddamage",	"e035_clincheddamage",	"e036_clincheddamage",	"e037_clincheddamage",	"e038_clincheddamage"];
		sprites[stBackClinch]		 = ["e030_backClinch",		"e031_backClinch",		"e032_backClinch",		"e033_backClinch",		"e034_backClinch",		"e035_backClinch",		"e036_backClinch",		"e037_backClinch",		"e038_backClinch"];
		sprites[stThrown1]			 = ["e030_thrown1",			"e031_thrown1",			"e032_thrown1",			"e033_thrown1",			"e034_thrown1",			"e035_thrown1",			"e036_thrown1",			"e037_thrown1",			"e038_thrown1"];
		sprites[stThrown2]			 = ["e030_thrown2",			"e031_thrown2",			"e032_thrown2",			"e033_thrown2",			"e034_thrown2",			"e035_thrown2",			"e036_thrown2",			"e037_thrown2",			"e038_thrown2"];
		sprites[stThrown3]			 = ["e030_thrown3",			"e031_thrown3",			"e032_thrown3",			"e033_thrown3",			"e034_thrown3",			"e035_thrown3",			"e036_thrown3",			"e037_thrown3",			"e038_thrown3"];
		sprites[stThrown4]			 = ["e030_thrown4",			"e031_thrown4",			"e032_thrown4",			"e033_thrown4",			"e034_thrown4",			"e035_thrown4",			"e036_thrown4",			"e037_thrown4",			"e038_thrown4"];
		sprites[stThrown5]			 = ["e030_thrown5",			"e031_thrown5",			"e032_thrown5",			"e033_thrown5",			"e034_thrown5",			"e035_thrown5",			"e036_thrown5",			"e037_thrown5",			"e038_thrown5"];
		sprites[stThrown6]			 = ["e030_thrown6",			"e031_thrown6",			"e032_thrown6",			"e033_thrown6",			"e034_thrown6",			"e035_thrown6",			"e036_thrown6",			"e037_thrown6",			"e038_thrown6"];
		sprites[stEtc1]				 = ["e030_etc1",			"e031_etc1",			"e032_etc1",			"e033_etc1",			"e034_etc1",			"e035_etc1",			"e036_etc1",			"e037_etc1",			"e038_etc1"];
		sprites[stEtc2]				 = ["e030_etc2",			"e031_etc2",			"e032_etc2",			"e033_etc2",			"e034_etc2",			"e035_etc2",			"e036_etc2",			"e037_etc2",			"e038_etc2"];
		sprites[stEtc3]				 = ["e030_etc3",			"e031_etc3",			"e032_etc3",			"e033_etc3",			"e034_etc3",			"e035_etc3",			"e036_etc3",			"e037_etc3",			"e038_etc3"];
		sprites[stEtc4]				 = ["e030_standing2",		"e031_standing2",		"e032_standing2",		"e033_standing2",		"e034_standing2",		"e035_standing2",		"e036_standing2",		"e037_standing2",		"e038_standing2"];
		sprites[stEtc5]				 = ["e030_standing3",		"e031_standing3",		"e032_standing3",		"e033_standing3",		"e034_standing3",		"e035_standing3",		"e036_standing3",		"e037_standing3",		"e038_standing3"];
		sprites[stEtc6]				 = ["e030_walk2",			"e031_walk2",			"e032_walk2",			"e033_walk2",			"e034_walk2",			"e035_walk2",			"e036_walk2",			"e037_walk2",			"e038_walk2"];

		sprites[stHolding]			 = ["e030_holding",			"e031_holding",			"e032_holding",			"e033_holding",			"e034_holding",			"e035_holding",			"e036_holding",			"e037_holding",			"e038_holding"];
		sprites[stHolding2]			 = ["e030_holding2",		"e031_holding2"];
		sprites[stClinching]		 = ["e030_clinching",		"e031_clinching",		"e032_clinching",		"e033_clinching",		"e034_clinching",		"e035_clinching",		"e036_clinching",		"e037_clinching",		"e038_clinching"];

		sprites[stPreHAttack1]		 = ["e030_holding",			"e031_holding",			"e032_holding",			"e033_holding",			"e034_holding",			"e035_holding",			"e036_holding",			"e037_holding",			"e038_holding"];
		sprites[stPreHAttack2]		 = ["e030_prehattack2",		"e031_prehattack2",		"e032_prehattack2",		"e033_prehattack2",		"e034_prehattack2",		"e035_prehattack2",		"e036_prehattack2",		"e037_prehattack2",		"e038_prehattack2"];
		sprites[stHAttack]			 = ["e030_hattack",			"e031_hattack",			"e032_hattack",			"e033_hattack",			"e034_hattack",			"e035_hattack",			"e036_hattack",			"e037_hattack",			"e038_hattack"];
	}

	function clinch(st)
	{
//		var p = owner.player;
		var p = targetPlayer;

		if(((tf.inRescueMode || f.inBattleMode) && p.nowSpriteId == stDown) || p.inExtasy > 0){
			super.clinch(st);
			return;
		}
		if(p.nowSpriteId==stSpecial1 || p.nowSpriteId==stDamage1 || p.nowSpriteId==stDamage2) return;
		if(!enableFreeMove || !p.enableFreeMove) return;

		var id = void;
		for(var i=0; i<owner.enemies.count; i++){
			var e= owner.enemies[i];
			if(e.clinchPlayer === p && e !== this){
				switch (e.nowSpriteId){
					case stClinching:
						if(inverse != p.inverse) inverse=!inverse;
						id = stBackClinch;
						break;
					case stBackClinch:
						if(inverse == p.inverse) inverse=!inverse;
						id = stClinching;
						break;
				}
			}
			if(id !== void) break;
		}
		if(id === void){
			if(inverse == p.inverse){
				id = stBackClinch;
			}else{
				id = stClinching;
			}
		}

		loadSprite(id);

		p.clinchedBy = this;
		p.initSpriteTable();
		clinchPlayer = p;

		rootX = p.rootX;
		if(p.rootY == p.movableRect.bottom){
			p.rootY = rootY - 1;
		}else{
			rootY = p.rootY+1;
		}
		// 表示位置調整
		adjustDisp();
	}


}


class HiSoldierSprite extends EnemySprite
{

	function HiSoldierSprite(window, owner, elm)
	{
		kind = "上級戦闘員";
		name = [(elm.name0!==void)? elm.name0 : "Elite Combatant", (elm.name1!==void)? elm.name1 : "Enhanced Clone Soldier", (elm.name2!==void)? elm.name2 : "強化克隆兵", (elm.name3!==void)? elm.name3 : "強化克隆兵"];
		maxHP = HP = enemyHPRate(200);
		maxMP = MP = 0;
		score = 20000;
		targetDistance = 70;

		// ボスキャラであるかどうか
		isBoss = false;

		// 攻撃リスト
		attackList = [stAttack1, stAttack2, stAttack3];
		comboAttackList = [stAttack1, stAttack1, stAttack2, stAttack3];

		// 攻撃が当たる奥行き
		depth = 10;

		// 移動速度
		moveSpeed = 1.7;

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(0, 0, 456, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-150, -15, 150, 15);

		// 攻撃判定を行う確率
		attackCheckRate = [25, 20, 20];
		comboAttackCheckRate = 30;

		// 主人公の方へ向かっていく確率
		moveRate1 = 50;
		// 適当に動く確率
		moveRate2 = 20;

		// ガードする確率
		guardRate = 90;

		super.EnemySprite(...);
	}

	function initSpriteTable()
	{
		sprites[stStanding]			 = "e040_standing";
		sprites[stStanding2]		 = "e040_standing2";
		sprites[stWalk]				 = "e040_walk";
		sprites[stStandUp]			 = "e040_standup";
		sprites[stStandUp2]			 = "e040_standup2";
		sprites[stAttack1]			 = "e040_attack1";
		sprites[stAttack2]			 = "e040_attack2";
		sprites[stAttack3]			 = "e040_attack3";
		sprites[stDamage1]			 = "e040_damage1";
		sprites[stDamage2]			 = "e040_damage2";
		sprites[stGuard]			 = "e040_guard";
		sprites[stClinched]			 = "e040_clinched";
		sprites[stClinchedDamage]	 = "e040_clincheddamage";
		sprites[stThrown1]			 = "e040_thrown1";
		sprites[stThrown2]			 = "e040_thrown2";
		sprites[stThrown3]			 = "e040_thrown3";
		sprites[stThrown4]			 = "e040_thrown4";
		sprites[stThrown5]			 = "e040_thrown5";
		sprites[stThrown6]			 = "e040_thrown6";

		sprites[stPreHAttack2]		 = "e040_holding2";
		sprites[stHAttack]			 = "e040_clinching";

	}

}


class GoblinSprite extends EnemySprite
{
	var attackableRect2;

	function GoblinSprite(window, owner, elm)
	{
		kind = "ゴブリン兵";
		name = [(elm.name0!==void)? elm.name0 : "Goblin Soldier", (elm.name1!==void)? elm.name1 : "Goblin Soldier", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];
		maxHP = HP = enemyHPRate(70);
		maxMP = MP = 8;
		recoveryMP = 0.05;
		score = 20000;
		targetDistance = 70;

		// ボスキャラであるかどうか
		isBoss = false;

		// 攻撃リスト
		attackList = [stAttack1, stAttack2];

		// 攻撃が当たる奥行き
		depth = 8;

		// 移動速度
		moveSpeed = 2.0;

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(0, 0, 456, 256);
		attackableRect2 = new Rect2(30, 0, 426, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-150, -15, 150, 15);

		// 攻撃判定を行う確率
		attackCheckRate = [15, 10];

		// 主人公の方へ向かっていく確率
		moveRate1 = 20;
		// 適当に動く確率
		moveRate2 = 40;

		// ガードする確率
		guardRate = 75;
		escapeMP = 8;

		super.EnemySprite(...);
	}

	function initSpriteTable()
	{
		sprites[stStanding]			 = "e070_standing";
		sprites[stStanding2]		 = "e070_standing2";
		sprites[stWalk]				 = "e070_walk";
		sprites[stDash]				 = "e070_dash";
		sprites[stStandUp]			 = "e070_standup";
		sprites[stStandUp2]			 = "e070_standup";
		sprites[stAttack1]			 = "e070_attack1";
		sprites[stAttack2]			 = "e070_attack2";
		sprites[stDamage1]			 = "e070_damage1";
		sprites[stDamage2]			 = "e070_damage2";
		sprites[stEscape]			 = "e070_escape";
		sprites[stFalling]			 = "e070_falling";
		sprites[stClinched]			 = "e070_clinched";
		sprites[stClinchedDamage]	 = "e070_clincheddamage";
		sprites[stThrown1]			 = "e070_thrown1";
		sprites[stThrown2]			 = "e070_thrown2";
		sprites[stThrown3]			 = "e070_thrown3";
		sprites[stThrown4]			 = "e070_thrown4";
		sprites[stThrown5]			 = "e070_thrown5";
		sprites[stThrown6]			 = "e070_thrown6";

		sprites[stSpecial1]			 = "e070_special1";
		sprites[stSpecial2]			 = "e070_special2";

		sprites[stPreHAttack2]		 = "e070_prehattack2";
		sprites[stHAttack]			 = "e070_hattack";

	}


	function checkAttack()
	{
		if(attackableRect === void) return;
		if(!enableAttack || !enableFreeMove) return;
		if(super.checkAttack()) return;
		if(!attackableRect2.includedPos(rootX, rootY)) return;

		for(var i=0; i<bao.players.count; i++){
			var p = bao.players[i];
			if(sf.adjSinglePlayMode && i == bao.notSelectingPlayerId) continue;
			if(Math.abs(p.rootY - rootY) > 40) continue;
			if(getDistance(this, p) > 10000){
				for(var j=0; j<bao.enemies.count; j++){
					var e = bao.enemies[j];
					if(e === this) continue;
					if(e.kind != "ゴブリン兵") continue;
					if(!attackableRect.includedPos(e.rootX, e.rootY)) return;
					if(!e.enableAttack) continue;
					if((p.rootX < rootX && rootX < e.rootX - 30) || (rootX < p.rootX && e.rootX < rootX - 30)){

//dm("■ this : " + this + " / rootX : " + rootX + " / e.rootX : " + e.rootX + " / p.rootX : " + p.rootX);
						layer.conductor.mp.other = e;
						e.layer.conductor.mp.other = this;
						e.targetPlayer = p;
						loadSprite(stSpecial1);
						e.loadSprite(stSpecial2);
						return;
					}
				}
			}
		}
	}

}


class GoblinStealthSprite extends GoblinSprite
{

	var dOpacity = 0;
	var nowOpacity;
	var opacityMin = nowOpacity= 12;

	function GoblinStealthSprite(window, owner, elm)
	{
		super.GoblinSprite(...);

		kind = "Goblin Soldier";
		name = "隠れゴブリン兵";
		maxHP = HP = enemyHPRate(100);
		maxMP = MP = 3;
		recoveryMP = 0.03;
		targetDistance = 200;
		attackCheckRate = [3, 2];
		guardRate = 90;

		// 移動可能範囲
		movableRect = new Rect2(-228, 180, 456+228, 256);

		if(!sf.adjNoItem){
			atDeleteExp =  "bao.setObject(%['storage'=>'item01','rootx'=>sprite.rootX-15,'rooty'=>sprite.rootY-5]),";
			atDeleteExp += "bao.setObject(%['storage'=>'item02','rootx'=>sprite.rootX+15,'rooty'=>sprite.rootY+5]),";
		}
		atDeleteExp += "f.goblinCount++";

		enableClinched = false;
	}

	function finalize(){

		if(f.goblinCount >= 2){
			bao.checkMission('ステージ６');
		}
		super.finalize();

	}


	function routineProcess()
	{
		super.routineProcess();

		if(owner.players.count == 0) return;
		if(!deleteFlag){
			if((nowSpriteId==stStanding || nowSpriteId==stWalk) && MP>=3){
				enableClinched = false;
				dOpacity = -8;
				MP -= 3;
			}
			if((nowSpriteId==stDamage1 || nowSpriteId==stDamage2 || nowSpriteId==stClinched) && dOpacity<=0){
				enableClinched = true;
				dOpacity = 20;
			}
			for(var i=0; i<owner.players.count; i++){
				if(owner.players[i].damageFrom===this && dOpacity<=0){
					dOpacity = 20;
					MP = 2;
					owner.players[i].damageFrom = void;
				}
			}

			var o = nowOpacity + dOpacity;
			if(o < opacityMin){
				o = opacityMin;
				dOpacity = 0;
			}
			if(o > 255){
				o = 255;
				dOpacity = 0;
			}
			layer.opacity = nowOpacity = o;
		}

		if(rootX < -220){
			atDeleteExp = "";
			deleteFlag = true;
			layer.opacity = 0;
			dm('ゴブリン削除');
		}

	}


}




class OrthrosSprite extends EnemySprite
{

	function OrthrosSprite(window, owner, elm)
	{
		kind = "オルトロス";
		name = [(elm.name0!==void)? elm.name0 : "Orthrus", (elm.name1!==void)? elm.name1 : "Orthros"];
		name = [(elm.name0!==void)? elm.name0 : "Orthrus", (elm.name1!==void)? elm.name1 : "Orthros", (elm.name2!==void)? elm.name2 : "雙頭犬", (elm.name3!==void)? elm.name3 : "Orthros"];
		maxHP = HP = (!sf.adjOrthrosWeaken)? enemyHPRate(120): enemyHPRate(12);
		maxMP = MP = 10;
		score = 10000;
		targetDistance = 150;
		recoveryMP = 0.2;
		enableClinched = false;

		// 常に主人公の方を向くかどうか
		var inverseMode = false;

		// ボスキャラであるかどうか
		isBoss = false;

		// 攻撃リスト
		comboAttackList = [];
		attackList = [stAttack1];

		// 攻撃が当たる奥行き
		depth = 8;

		// 移動速度
		moveSpeed = 2;

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(0, 0, 456, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-250, -15, 250, 15);

		// 攻撃判定を行う確率
		attackCheckRate = [30, 10];

		// 主人公の方へ向かっていく確率
		moveRate1 = 40;
		// 適当に動く確率
		moveRate2 = 30;

		super.EnemySprite(...);
	}

	function initSpriteTable()
	{
		sprites[stStanding]			 = "e050_standing";
		sprites[stStanding2]		 = "e050_standing";
		sprites[stWalk]				 = "e050_walk";
		sprites[stDash]				 = "e050_dash";
		sprites[stEtc1]				 = "e050_turn";
		sprites[stEtc2]				 = "e050_turn2";
//		sprites[stFalling]			 = "e050_falling";
//		sprites[stLanding]			 = "e050_landing";
		sprites[stStandUp]			 = "e050_standup";
		sprites[stAttack1]			 = "e050_dashattack";
		sprites[stAttack2]			 = "e050_attack2";

//		sprites[stHolding]			 = "e050_holding";
		sprites[stHolding2]			 = "e050_holding2";
		sprites[stClinching]		 = "e050_clinching";

		sprites[stPreHAttack2]		 = "e050_holding2";
		sprites[stHAttack]			 = "e050_clinching";

		sprites[stDamage1]			 = "e050_damage1";
		sprites[stDamage2]			 = "e050_damage2";
	}

	function preMove(m)
	{
		setTargetPlayer();

		// 主人公の方を向く
		var p = targetPlayer;
		if(rootX < p.rootX + 40 && !inverse){
			if(Math.abs(rootX-p.rootX) < 80){
				loadSprite(stEtc2);
			}else{
				loadSprite(stEtc1);
			}
			inverse = true;
			return m;
		}else if(p.rootX - 40 < rootX && inverse){
			if(Math.abs(rootX-p.rootX) < 80){
				loadSprite(stEtc2);
			}else{
				loadSprite(stEtc1);
			}
			inverse = false;
			return m;
		}

		var mt = new MovingTable(m);

		if(movingTable[0] === void){
			setMoveDirection(movingTable);
		}
		mt = movingTable[0];

		if(mt.x==0 & mt.y==0){
			// レバー中立状態
			if(nowSpriteId != stStanding) loadSprite(stStanding, true);
		}else{
			// 通常の歩き
			if(nowSpriteId != stWalk) loadSprite(stWalk, true);
			mt.set(mt.x, mt.y, mt.h);
			setLayerInverse();
		}

		return mt;
	}

	function checkAttack()
	{
		if(super.checkAttack()) return;
		if(targetPlayer === void) setTargetPlayer();

		if(intrandom(0, 100) < attackCheckRate[1]){
			if(enableAttack && enableFreeMove && (Math.abs(targetPlayer.rootX-rootX)>180) && MP >= 10){
				MP -= 10;
				loadSprite(stDash);
				return;
			}
		}

	}

}


class EvilInsectSprite extends WingedSoldierSprite
{
	function EvilInsectSprite(window, owner, elm)
	{
		kind = "邪妖蟲";

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(0, 0, 456, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-140, -15, 140, 15);

		name = [(elm.name0!==void)? elm.name0 : kind, (elm.name1!==void)? elm.name1 : "##_##", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];
		maxHP = HP = enemyHPRate(70);
		maxMP = MP = 7;
		score = 10000;
		targetDistance = 150;
		recoveryMP = 0.05;

		enableClinched = false;

		// ボスキャラであるかどうか
		isBoss = false;

		// 攻撃リスト
//		attackList = [stAttack2];
//		comboAttackList = [];

		// 攻撃が当たる奥行き
		depth = 10;

		// 移動速度
		moveSpeed = 2.8;

		// 攻撃判定を行う確率
		attackCheckRate = [15, 20];

		// 主人公の方へ向かっていく確率
		moveRate1 = 30;
		// 適当に動く確率
		moveRate2 = 60;

		super.EnemySprite(...);

		if(elm.altitude !== void){
			initAltitude = +elm.altitude;
		}else{
			initAltitude = 40;
		}

		moveXAccel = 0.8;
	}

	function initSpriteTable()
	{
		sprites[stStanding]			 = "e060_standing";
		sprites[stWalk]				 = "e060_walk";
		sprites[stDamage1]			 = "e060_damage1";
		sprites[stDamage2]			 = "e060_damage1";
		sprites[stDamage3]			 = "e060_damage2";
		sprites[stAttack1]			 = "e060_attack1";
		sprites[stAttack2]			 = "e060_attack2";
		sprites[stStandUp]			 = "e060_standup";

		sprites[stPreHAttack2]		 = "e060_prehattack2";
		sprites[stHAttack]			 = "e060_hattack";

	}

}



class OgreSprite extends EnemySprite
{

	function OgreSprite(window, owner, elm)
	{
		sprites[stStanding]			 = "e090_standing";
		sprites[stStanding2]		 = "e090_standing2";
		sprites[stWalk]				 = "e090_walk";
		sprites[stStandUp]			 = "e090_standup";
		sprites[stStandUp2]			 = "e090_standup2";
		sprites[stClinched]			 = "e090_clinched";
		sprites[stClinchedDamage]	 = "e090_clincheddamage";
		sprites[stClinching]		 = "e090_clinching";
		sprites[stAttack1]			 = "e090_attack1";
		sprites[stAttack2]			 = "e090_attack2";
		sprites[stHolding]			 = "e090_holding";
		sprites[stHolding2]			 = "e090_holding2";
		sprites[stDamage1]			 = "e090_damage1";
		sprites[stDamage2]			 = "e090_damage2";
		sprites[stThrow1]			 = "e090_throw";
		sprites[stThrown1]			 = "e090_thrown1";
		sprites[stThrown2]			 = "e090_thrown2";
		sprites[stThrown3]			 = "e090_thrown3";
		sprites[stThrown4]			 = "e090_thrown4";
		sprites[stThrown5]			 = "e090_thrown5";
		sprites[stThrown6]			 = "e090_thrown6";
		sprites[stGuard]			 = "e090_guard";

		sprites[stPreHAttack2]		 = "e090_prehattack2";
		sprites[stHAttack]			 = "e090_hattack";

		kind = "Ogre Soldier";
		name = (elm.name!==void)? elm.name : kind;
		maxHP = HP = enemyHPRate(350);
		maxMP = MP = 0;
		score = 20000;
		targetDistance = 120;

		// ボスキャラであるかどうか
		isBoss = false;

		// 攻撃リスト
		comboAttackList = [];
		attackList = [stAttack2, stAttack1, stHolding];

		// 攻撃が当たる奥行き
		depth = 12;

		// 移動速度
		moveSpeed = 0.8;

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(0, 0, 456, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-180, -15, 180, 15);

		// 攻撃判定を行う確率
		attackCheckRate = [0, 0, 15];

		// クリンチしたときにどれだけ表示をずらすか
		clinchedOffset = -20;

		// 主人公の方へ向かっていく確率
		moveRate1 = 50;
		// 適当に動く確率
		moveRate2 = 10;

		// これ以上喰らうと無条件反撃
		damageCountLimit = 2;
		counterAttack = stAttack1;

		// ガードする確率
		guardRate = 80;

		super.EnemySprite(...);
	}

	function routineProcess()
	{
		super.routineProcess();
		var p = targetPlayer;
		if(p === void) return;
		if(enableMove && (nowSpriteId==stWalk || nowSpriteId==stStanding) && (p.nowSpriteId<stClinched)){
			if(attackCheckRate[0] > intrandom(0,100)){
				if(checkOverlap(rootX, rootY, p)){
					throwPlayer();
				}
			}
		}
	}

	function throwPlayer()
	{
		var p = targetPlayer;
		p.clinchedBy = this;
		p.clinchedStrength += 500;
		p.loadSprite(stThrown1);
		p.state = stateDamage;
		loadSprite(stThrow1);

		if(rootY < movableRect.top+1) rootY = movableRect.top+1;
		if(rootY > movableRect.bottom-1) rootY = movableRect.bottom-1;
	}

}


class SlimeSprite extends EnemySprite
{
	var scrollLock = true;
	var onGround = true;

	function SlimeSprite(window, owner, elm)
	{
		kind = "スライム";
		name = [(elm.name0!==void)? elm.name0 : "Slime", (elm.name1!==void)? elm.name1 : "Slime"];
		maxHP = HP = enemyHPRate(80);
		maxMP = MP = 0;
		score = 5000;
		targetDistance = 80;
		enableClinched = false;

		// ボスキャラであるかどうか
		isBoss = false;

		// 攻撃リスト
		attackList = [stHolding];
		comboAttackList = [];

		// 攻撃が当たる奥行き
		depth = 8;

		// 移動速度
		moveSpeed = 0.8;

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(0, 0, 456, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-170, -15, 170, 15);

		// 攻撃判定を行う確率
		attackCheckRate = [5];

		// 主人公の方へ向かっていく確率
		moveRate1 = 90;
		// 適当に動く確率
		moveRate2 = 5;

		super.EnemySprite(...);

//		if(elm.scrolllock !== void) scrollLock = +elm.scrolllock;
	}

	function initSpriteTable()
	{
		sprites[stStanding]			 = "e080_standing";
		sprites[stStanding2]		 = "e080_standing";
		sprites[stWalk]				 = "e080_walk";
		sprites[stFalling]			 = "e080_falling";
		sprites[stLanding]			 = "e080_landing";
		sprites[stDamage1]			 = "e080_damage1";
		sprites[stDamage2]			 = "e080_damage2";
		sprites[stClinching]		 = "e080_clinching";
		sprites[stBackClinch]		 = "e080_backClinch";
		sprites[stEtc1]				 = "e080_damage3";

		sprites[stHolding]			 = "e080_jumpAttack1";
		sprites[stHolding2]			 = "e080_jumpAttack2";
		sprites[stPreHAttack2]		 = "e080_jumpAttack2";
		sprites[stHAttack]			 = "e080_hattack";
	}

//	function routineProcess()
//	{
//		super.routineProcess();
//		if(owner.players.count == 0) return;
//
//		var p = targetPlayer;
//		if(p.nowSpriteId==stSpecial1) return;
//		if(enableMove && (nowSpriteId==stWalk || nowSpriteId==stStanding)){
//			if(checkOverlap(rootX, rootY, p)){
//				p.clinchedBy = this;
//				loadSprite(stHolding);
//			}
//		}
//	}

	function checkAttack()
	{

		if(!enableFreeMove) return;
		if(attackableRect === void) return;

		var tmpRect = new Rect2(attackCheckRect);
		tmpRect.addOffset(rootX, rootY);

		for(var i=0; i<owner.players.count; i++){
			var p = owner.players[i];
			if(sf.adjSinglePlayMode && p === bao.notSelectingPlayer) continue;
			if(p.nowSpriteId==stDashAttack) continue;
			if(p.nowSpriteId >= stCommand1 && p.nowSpriteId <= stCommand6) continue;
			if(p.clinchedBy !== void) continue;

			if(enableAttack && enableFreeMove && tmpRect.includedPos(p.rootX, p.rootY)){
				loadSprite(stHolding);
				return;
			}
		}
	}

	function move(mt)
	{
		if(nearAvoidPoint !== void && (nowSpriteId == stWalk || nowSpriteId == stStanding)){
			var dx = (nearAvoidPoint.x-owner.stageLayer.dispLeft) - rootX;
			var dy = nearAvoidPoint.y - rootY;
			if(dx < 0){
				inverse = true;
				setLayerInverse();
			}else{
				inverse = false;
				setLayerInverse();
			}
			loadSprite(stHolding);
			return;
		}

		super.move(...);
	}

	function checkAttackCollision()
	{

		if(attackRect.isEmpty()) return;
		var line = new Rect2(-20, rootY - depth1, owner.internalWidth+20, rootY + depth2);

		for(var i=0; i<owner.players.count; i++){
			var p = owner.players[i];

			if(sf.adjSinglePlayMode && p === bao.notSelectingPlayer) continue;
			if(p.invincibleCount > 0) continue;
			if(p.hitRect.isEmpty()) continue;
			if(!p.clinchAbled(this)) continue;
			if(p.nowSpriteId == stSpecial1) continue;
			if(p.nowSpriteId >= stCommand1 && p.nowSpriteId <= stCommand6) continue;
			if(p.nowSpriteId == stDamage2) continue;
			if(!line.includedPos(p.rootX, p.rootY)) continue;
			if(p.damage.tick == attack.tick) continue;

			var r1 = new Rect2(attackRect);
			r1.addOffset(internalLayerLeft, internalLayerTop+p.rootY-rootY);

			var r2 = new Rect2(p.hitRect);
			r2.addOffset(p.internalLayerLeft, p.internalLayerTop);
			r2.addOffset(0, rootY-p.rootY);

			if(r1.intersects(r2)){
				targetPlayer = p;
				clinchPlayer = p;
				p.damageFrom = this;
				p.damageFromStr = kind;
				p.damage.set(attack);
				loadSprite(stHolding2);
			}
		}
	}
}



class OrcSprite extends EnemySprite
{
	function OrcSprite(window, owner, elm)
	{
		sprites[stStanding]			 = "e110_standing";
		sprites[stWalk]				 = "e110_walk";
//		sprites[stFalling]			 = "falling";
		sprites[stStandUp]			 = "e110_standup";
		sprites[stStandUp2]			 = "e110_standup2";
		sprites[stAttack1]			 = "e110_attack1";
		sprites[stAttack2]			 = "e110_attack2";
		sprites[stDamage1]			 = "e110_damage1";
		sprites[stDamage2]			 = "e110_damage2";
		sprites[stDown]				 = "e110_down";
		sprites[stGuard]			 = "e110_guard";
		sprites[stClinched]			 = "e110_clinched";
		sprites[stClinchedDamage]	 = "e110_clincheddamage";
		sprites[stClinching]		 = "e110_clinching";
		sprites[stSpecial1]			 = "e110_special1";
		sprites[stSpecial2]			 = "e110_special2";
		sprites[stThrown1]			 = "e110_thrown1";
		sprites[stThrown2]			 = "e110_thrown2";
		sprites[stThrown3]			 = "e110_thrown3";
		sprites[stThrown4]			 = "e110_thrown4";
		sprites[stThrown5]			 = "e110_thrown5";
		sprites[stThrown6]			 = "e110_thrown6";

		kind = "デビルオーク";
		name = [(elm.name0!==void)? elm.name0 : "Devil Orc", (elm.name1!==void)? elm.name1 : "##_##", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];

		// ボスキャラであるかどうか
		isBoss = true;

		HP = maxHP = enemyHPRate(700, isBoss);
		maxMP = 15;
		MP = 10;
		recoveryMP = 0.05 * ((sf.adjEnemyPattern2)?1.2:1);
		score = 50000;
		targetDistance = 50;

		// 攻撃リスト
		attackList = [stAttack1, stAttack2];
		comboAttackList = [];

		// 攻撃が当たる奥行き
		depth = 10;

		// 移動速度
		moveSpeed = 1.2;

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(-50, 0, 506, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-100, -15, 100, 15);

		// 攻撃判定を行う確率
		attackCheckRate = [30, 30];

		// 主人公の方へ向かっていく確率
		moveRate1 = 50;
		// 適当に動く確率
		moveRate2 = 20;

		// ガードする確率
		guardRate = ((f.difficulty > 3)? 82 : 0);

		// これ以上喰らうと無条件反撃
		damageCountLimit = 3;
		counterAttack = stSpecial2;

		super.EnemySprite(...);
	}

	function checkAttack()
	{
		if(attackableRect === void) return;
		if(super.checkAttack()) return;

		if(!enableAttack || !enableFreeMove) return;

		if(MP >= 15 && attackableRect.includedPos(rootX, rootY)){
			MP -= 15;
			loadSprite(stSpecial1);
			return;
		}
	}

}



class Orc2Sprite extends EnemySprite
{
	function Orc2Sprite(window, owner, elm)
	{
		sprites[stStanding]			 = "e310_standing";
		sprites[stWalk]				 = "e310_walk";
		sprites[stStandUp]			 = "e310_standup";
		sprites[stStandUp2]			 = "e310_standup2";
		sprites[stAttack1]			 = "e310_attack1";
		sprites[stAttack3]			 = "e310_attack3";
		sprites[stDamage1]			 = "e310_damage1";
		sprites[stDamage2]			 = "e310_damage2";
		sprites[stDown]				 = "e310_down";
		sprites[stGuard]			 = "e310_guard";
		sprites[stClinched]			 = "e310_clinched";
		sprites[stClinchedDamage]	 = "e310_clincheddamage";
		sprites[stClinching]		 = "e310_clinching";
		sprites[stHolding]			 = "e310_attack2";
		sprites[stHolding2]			 = "e310_clinching";
		sprites[stSpecial1]			 = "e310_special1";
		sprites[stThrow1]			 = "e310_throw1";
		sprites[stThrow2]			 = "e310_throw2";
		sprites[stThrow3]			 = "e310_throw3";
		sprites[stThrow4]			 = "e310_throw4";
		sprites[stThrown1]			 = "e310_thrown1";
		sprites[stThrown2]			 = "e310_thrown2";
		sprites[stThrown3]			 = "e310_thrown3";
		sprites[stThrown4]			 = "e310_thrown4";
		sprites[stThrown5]			 = "e310_thrown5";
		sprites[stThrown6]			 = "e310_thrown6";

		kind = "デスオーク";
		name = [(elm.name0!==void)? elm.name0 : "Death Orc", (elm.name1!==void)? elm.name1 : "##_##", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];

		// ボスキャラであるかどうか
		isBoss = true;

		HP = maxHP = enemyHPRate(550, isBoss);
		maxMP = 15;
		MP = 10;
		recoveryMP = 0.08 * ((sf.adjEnemyPattern2)?1.2:1);
		score = 50000;
		targetDistance = 50;

		// 攻撃リスト
		attackList = [stHolding];
		comboAttackList = [stAttack3, stAttack3, stAttack1];

		// 攻撃が当たる奥行き
		depth = 10;

		// 移動速度
		moveSpeed = 1.2;

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(-50, 0, 506, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-100, -15, 100, 15);

		// 攻撃判定を行う確率
		attackCheckRate = [20];
		comboAttackCheckRate = 20;

		// 主人公の方へ向かっていく確率
		moveRate1 = 50;
		// 適当に動く確率
		moveRate2 = 20;

		// ガードする確率
		guardRate = 30;

		// これ以上喰らうと無条件反撃
		damageCountLimit = 4;
		counterAttack = stHolding;

		super.EnemySprite(...);
	}

	function checkAttack()
	{
		if(attackableRect === void) return;
		if(super.checkAttack()) return;

		if(!enableAttack || !enableFreeMove) return;

		if(MP >= 15 && attackableRect.includedPos(rootX, rootY) && targetPlayer.state == stateNormal && getDistance(this, targetPlayer) > 16900 && Math.abs(rootY - targetPlayer.rootY)<20){
			faceToPlayer();
			MP -= 15;
			loadSprite(stSpecial1);
			return;
		}
	}

}



class Orc3Sprite extends EnemySprite
{
	function Orc3Sprite(window, owner, elm)
	{
		sprites[stStanding]			 = "e320_standing";
		sprites[stWalk]				 = "e320_walk";
		sprites[stStandUp]			 = "e320_standup";
		sprites[stStandUp2]			 = "e320_standup2";
		sprites[stAttack1]			 = "e320_attack1";
		sprites[stAttack2]			 = "e320_attack2";
		sprites[stDamage1]			 = "e320_damage1";
		sprites[stDamage2]			 = "e320_damage2";
		sprites[stDown]				 = "e320_down";
		sprites[stGuard]			 = "e320_guard";
		sprites[stClinched]			 = "e320_clinched";
		sprites[stClinchedDamage]	 = "e320_clincheddamage";
		sprites[stClinching]		 = "e320_clinching";
		sprites[stHolding]			 = "e320_holding";
		sprites[stHolding2]			 = "e320_clinching";
		sprites[stSpecial1]			 = "e320_special1";
		sprites[stThrow1]			 = "e320_throw1";
		sprites[stThrow2]			 = "e320_throw2";
		sprites[stThrow3]			 = "e320_throw3";
		sprites[stThrow4]			 = "e320_throw4";
		sprites[stThrown1]			 = "e320_thrown1";
		sprites[stThrown2]			 = "e320_thrown2";
		sprites[stThrown3]			 = "e320_thrown3";
		sprites[stThrown4]			 = "e320_thrown4";
		sprites[stThrown5]			 = "e320_thrown5";
		sprites[stThrown6]			 = "e320_thrown6";

		kind = "ヘルオーク";
		name = [(elm.name0!==void)? elm.name0 : "Hell Orc", (elm.name1!==void)? elm.name1 : "##_##", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];

		// ボスキャラであるかどうか
		isBoss = true;

		HP = maxHP = enemyHPRate(550, isBoss);
		maxMP = 15;
		MP = 10;
		recoveryMP = 0.05 * ((sf.adjEnemyPattern2)?1.2:1);
		score = 50000;
		targetDistance = 50;

		// 攻撃リスト
		attackList = [stHolding];
		comboAttackList = [stAttack1, stAttack2];

		// 攻撃が当たる奥行き
		depth = 10;

		// 移動速度
		moveSpeed = 1.2;

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(-50, 0, 506, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-100, -15, 100, 15);

		// 攻撃判定を行う確率
		attackCheckRate = [20];
		comboAttackCheckRate = 20;

		// 主人公の方へ向かっていく確率
		moveRate1 = 50;
		// 適当に動く確率
		moveRate2 = 20;

		// ガードする確率
		guardRate = 30;

		// これ以上喰らうと無条件反撃
		damageCountLimit = 4;
		counterAttack = stHolding;

		super.EnemySprite(...);
	}

	function checkAttack()
	{
		if(attackableRect === void) return;
		if(super.checkAttack()) return;

		if(!enableAttack || !enableFreeMove) return;

		if(MP >= 15 && attackableRect.includedPos(rootX, rootY) && targetPlayer.state == stateNormal && getDistance(this, targetPlayer) > 19600 && Math.abs(rootY - targetPlayer.rootY)<20){
			faceToPlayer();
			MP -= 15;
			loadSprite(stSpecial1);
			return;
		}
	}

}



class WizardSprite extends EnemySprite
{
	var attackCheckRect2;

	function WizardSprite(window, owner, elm)
	{
		sprites[stStanding]			 = "e120_standing";
		sprites[stWalk]				 = "e120_walk";
		sprites[stStandUp]			 = "e120_standup";
		sprites[stStandUp2]			 = "e120_standup2";
		sprites[stAttack1]			 = "e120_attack1";
		sprites[stAttack2]			 = "e120_attack2";
		sprites[stDamage1]			 = "e120_damage1";
		sprites[stDamage2]			 = "e120_damage2";
		sprites[stDown]				 = "e120_down";
		sprites[stEscape]			 = "e120_escape";
		sprites[stClinched]			 = "e120_clinched";
		sprites[stClinchedDamage]	 = "e120_clincheddamage";
		sprites[stSpecial1]			 = "e120_special1";
		sprites[stSpecial2]			 = "e120_special2";
		sprites[stThrown1]			 = "e120_thrown1";
		sprites[stThrown2]			 = "e120_thrown2";
		sprites[stThrown3]			 = "e120_thrown3";
		sprites[stThrown4]			 = "e120_thrown4";
		sprites[stThrown5]			 = "e120_thrown5";
		sprites[stThrown6]			 = "e120_thrown6";

		kind = "サイコウィザード";
		name = [(elm.name0!==void)? elm.name0 : "Psycho Wizard", (elm.name1!==void)? elm.name1 : "##_##", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];

		// ボスキャラであるかどうか
		isBoss = true;

		HP = maxHP = enemyHPRate(550, isBoss);
		maxMP = 12;
		MP = 8;
		recoveryMP = 0.05 * ((sf.adjEnemyPattern2)?1.1:1);
		score = 50000;
		targetDistance = 150;

		// 攻撃リスト
		attackList = [stAttack1, stAttack2];
		comboAttackList = [];

		// 攻撃が当たる奥行き
		depth = 10;

		// 移動速度
		moveSpeed = 1.2;

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(-50, 0, 506, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-100, -15, 100, 15);

		// 攻撃判定を行う確率
		attackCheckRate = [30, 30];

		// 主人公の方へ向かっていく確率
		moveRate1 = 30;
		// 適当に動く確率
		moveRate2 = 20;

		// ガードする確率
		guardRate = 92;
		escapeMP = 8;

		// これ以上喰らうと無条件反撃
		damageCountLimit = 3;
		counterAttack = stSpecial1;

		super.EnemySprite(...);
	}


	function checkAttack()
	{
		if(attackableRect === void) return;
		if(super.checkAttack()) return;

		if(!enableAttack || !enableFreeMove) return;

		if(MP >= 8 && attackableRect.includedPos(rootX, rootY) && getDistance(this, targetPlayer) > 16900){
			MP -= 8;
			loadSprite(stSpecial2);
			return;
		}
	}

}



class SquidSprite extends EnemySprite
{
	var tentacles = [];
	var elementStorages;

	var attackCheckRect2;
	var attackCheckRect3;

	var disableAttack = false;

	function SquidSprite(window, owner, elm)
	{
		sprites[stStanding]			 = "e130_standing";
		sprites[stStanding2]		 = "e130_standing2";
//		sprites[stAttack1]			 = "e130_attack1";
//		sprites[stAttack2]			 = "e130_attack2";
		sprites[stDamage1]			 = "e130_damage1";
		sprites[stDamage2]			 = "e130_damage2";
		sprites[stSpecial1]			 = "e130_special1";
//		sprites[stSpecial2]			 = "e130_special2";

		kind = "ジャイアントスクイッド";
		name = [(elm.name0!==void)? elm.name0 : "Giant Squid", (elm.name1!==void)? elm.name1 : "GiantSquid"];

		// ボスキャラであるかどうか
		isBoss = true;

		maxHP = enemyHPRate(700, isBoss);
		HP = maxHP;
		maxMP = 15;
		MP = 2;
		recoveryMP = 0.05 * ((sf.adjEnemyPattern2)?1.2:1);
		score = 80000;
		targetDistance = 50;
		enableClinched = false;

		// 攻撃リスト
		attackList[0] = ["e130_tentacle1_attack1", "e130_tentacle1_attack2","e130_tentacle1_attack3","e130_tentacle1_attack4"];
		attackList[1] = ["e130_tentacle2_attack1", "e130_tentacle2_holding1a", "e130_tentacle2_holding1b"];

		// 攻撃が当たる奥行き
		depth = 10;

		// 移動速度
		moveSpeed = 0;

		// 移動可能範囲
//		movableRect = new Rect2(-100, 0, 556, 256);
		movableRect = void;

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(-100, 0, 756, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-280, -80, 30, 80);
		attackCheckRect2 = new Rect2(-150, 0, 30, 80);
		attackCheckRect3 = new Rect2(-150, -80, 30, 80);

		// 攻撃判定を行う確率
		attackCheckRate = [[20, 20, 10], [20, 20, 10]];

		// これ以上喰らうと無条件反撃
		damageCountLimit = 4;
		counterAttack = stSpecial1;

		super.EnemySprite(...);

		elementStorages = ["e130_element01", "e130_element01b", "e130_element01c", "e130_element01", "e130_element02b", "e130_element02c", "e130_element02", "e130_element04", "e130_element03c", "e130_element03", "e130_element03d", "e130_element03c"];

		var tmp = new Vector(16, 10, 55);
		tentacles[0] = new Tentacle(owner, this, 12, tmp, "e130_tentacle1_waiting.asd", elementStorages);
		tentacles[0].maxHP = 100;
		tentacles[0].HP = 100;
		tentacles[0].num = 0;

		tmp.set(56, -10, 65);
		tentacles[1] = new Tentacle(owner, this, 12, tmp, "e130_tentacle2_waiting.asd", elementStorages);
		tentacles[1].maxHP = 100;
		tentacles[1].HP = 100;
		tentacles[1].num = 1;

		shadow = false;
		noMove = true;
	}

	function finalize()
	{
		for(var i=0; i<tentacles.count; i++){
			invalidate tentacles[i];
		}
		super.finalize();
	}

	function routineProcess()
	{

		if(f.inBattleMode && sf.bmEnemyHPInfinite){
			if(HP <= maxHP * 0.5){
				HP = maxHP;
			}
		}


		super.routineProcess();
		for(var i=0; i<tentacles.count; i++){
			tentacles[i].routineProcess();
		}
	}

	function preMove(m)
	{
//		setTargetPlayer();
//		rootX = int(bao.stageLayer.wallLayer.imageWidth / (bao.cZoomRate/bao.sZoomRate)) - owner.stageLayer.dispLeft - centerPos;

		// 特に何もしない
		return m;
	}

	function move(mt)
	{
		// 特に何もしない
	}

	function checkDamage(mt)
	{
		var p = targetPlayer;

		// 攻撃を受けた
		if(HP > 0 && nowSpriteId != stDamage2){
			var fAltitude = getAltitude(int rootX, int rootY);
			if(damage.strength != 0) {

				if(nowSpriteId == stLocked){
						layer.loadImagesSub2(layer.graphic);
						layer.conductor.start();
						lockedCount = 0;
				}

				HP -= damage.strength * damageRate;
				putHitMark(damage.hitPos, hitMarkStorage[(damageFrom===p)?0:1]);

				if(HP > 0){
					switch(nowSpriteId){
						// 連続で喰らうと反撃される
						damageCount++;
						var psid = p.nowSpriteId;
						if(damageCount > damageCountLimit && psid!=stSpecial1 && psid!=stSpecial2 && psid!=stSpecial3){
							invincibleCount += 15;
							loadSprite(counterAttack);
						}else{
							loadSprite(stDamage1);
						}
						lastDamageTick = owner.tickCount;
					}
				}else{
					loadSprite(stDamage2);
				}

				if(damage.tags != ""){
					addQueue(damage.tags);
					executeQueue();
					damage.tags = "";
				}
				if(damage.exp != ""){
					executeEval(damage);
					damage.exp = "";
				}
				damage.strength = 0;
			}
		}
		if(movingTable[0] !== void){
			return movingTable[0];
		}else{
			return mt;
		}
	}

	function checkAttack()
	{
		var acr = toGlobalRectFromRoot(attackCheckRect);
		var acr2 = toGlobalRectFromRoot(attackCheckRect2);
		var acr3 = toGlobalRectFromRoot(attackCheckRect3);

		if(attackableRect === void) return;
		if(nowSpriteId == stDamage1 || nowSpriteId == stSpecial1) return;

		if(MP == maxMP && tentacles[0].waiting && tentacles[1].waiting){
//			MP = 0; // e130_special1.asd中でMPを減らす
			loadSprite(stSpecial1);
		}

		if(!enableAttack || !attackableRect.includedPos(rootX, rootY) || !enableFreeMove) return;

		for(var j=0; j<owner.players.count; j++){
			var p = owner.players[j];
			// 攻撃が当たるようなら攻撃する
			if(sf.adjSinglePlayMode && p === bao.notSelectingPlayer) continue;
			if(p.nowSpriteId >= stClinched) continue;
			if(p.hitRect.isEmpty()) continue;
			if(p.nowSpriteId == stDamage2 || p.nowSpriteId == stStanding3) continue;

			for(var i=0; i<tentacles.count; i++){
				var t = tentacles[i];
				if(t.isDead || t.disableAttackCount > 0 || !t.waiting || disableAttack) continue;
				if(acr.includedPos(p.rootX, p.rootY)){
					for(var k=0; k<attackList[i].count; k++){
						var rnd = intrandom(0, 100);
						if(rnd < getAttackCheckRate(attackCheckRate[i][k])){
							t.loadAsd(attackList[i][k]);
						}
					}
				}
				if(attackList[i][3] !== void && acr3.includedPos(p.rootX, p.rootY)){
					t.loadAsd(attackList[i][3]);
				}
				if(acr2.includedPos(p.rootX, p.rootY)){
					t.loadAsd(attackList[i][2]);
				}
			}
		}
	}


//	function setObjAttack(){
//		for(var i=0; i<tentacles.count; i++){
//			tentacles[i].setObjAttack();
//		}
//	}
//
//	function setObjNormal(){
//		for(var i=0; i<tentacles.count; i++){
//			tentacles[i].setObjNormal();
//		}
//	}

}


class Tentacle
{
	var owner;		// baoのオブジェクト
	var parent;		// ジャイアントスクイッドのオブジェクト

	var num = 0;

	var element_num;
	var elements = [];

	var conductor;

	var pos;
	var relativePos; // ベースのスプライトのrootからの相対位置

	var posDelta;
	var lastPosDelta;
	var deltaTable = [];
	var movingTable = [];

	var amp1 = 0;
	var amp2 = 0.5;

	var xAxis;
	var yAxis;
	var zAxis;

	var angleSpeed1 = 0; //与える角速度
	var angleSpeed2 = 0;

//	var hardnessFlag;

	var stop = true;
//	var stopFlag = true;
//	var stopVec;
	var stopCount = 0;
//	var noMove = true;
	var disableAttackCount = 0;
	var attackHitTick = 0;
	var disableSoundCount = 0;

	var attackStrength = 0;

	var maxHP = enemyHPRate(100);
	var HP = maxHP;
	var damageTick = 0;

	// 触手が死んでるか
	var isDead = false;
	var deleteFlag = false;
	// 再生までのカウント
	var regenerateCount = 0;
	var regenerate = 450;

//	var positionMatrix = [];

	var touchDamage = 0;

	var rootX;
	var rootY;

	var storage;
	var length = 1;

	var initAsd;

	var moveStartTick;
	var moveEndTick;
	var moving = false;

	var moveStartLength;
	var moveEndLength;
	var accel = 0;

	var attackKind = atkNoLoad;
	var attackStrength = 0;

	var waiting = true;
	var holding = false;
	var holdTick;

	var hitCount = 0;

	var inverse = false;
	var ignoreDamage = false;

	function Tentacle(owner, parent, num, p, asd, elm){
		this.owner = owner;
		this.parent = parent;
		element_num = num;
		initAsd = asd;
		if(elm !== void && elm.length !== void) length = +elm.length;

		conductor = new SpriteConductor(this);

		xAxis = new Vector(1, 0, 0);
		yAxis = new Vector(0, 1, 0);
		zAxis = new Vector(0, 0, 1);

		pos				 = new Vector(1, 0, 0);
		relativePos		 = new Vector(p.x, p.y, p.z);
//		stopVec			 = new Vector();
		posDelta		 = new Vector();
		lastPosDelta	 = new Vector();

		for(var i=0; i<element_num; i++){
			var elm = %[];
			elm.root = this;
			elm.num = i;
			elm.storage = parent.elementStorages[i];
			elm.length = length;

			if(i==0){
				elm.parent = this;
			}else{
				elm.parent = elements[i-1];
			}

			elements[i] = new TentacleElement(owner.window, owner, elm);
			if(i>0) elements[i-1].child = elements[i];
			owner.objects.add(elements[i]);
		}

		loadAsd(initAsd);
	}

	function finalize()
	{
		invalidate pos;
		invalidate relativePos;
//		invalidate stopVec;
		invalidate posDelta;
		invalidate lastPosDelta;

		// tentacleElementはここで削除せずにbao側で処理するためにdeleteFlagを立てる
		for(var i=0; i<element_num; i++){
			if(isvalid elements[i]) elements[i].deleteFlag = true;
		}
		elements = void;
	}

	function loadAsd(asdFile, label='')
	{
		if(asdFile.indexOf(".") < 0) asdFile += ".asd";

//dm("loadAsd " + conductor.curStorage + " : " + conductor.curLine + " -> " + asdFile);

		conductor.loadScenario(asdFile);
		if(label != '') conductor.goToLabel(label);
		conductor.start();
	}

	function routineProcess()
	{
		if(parent.lockedCount == 0){
			conductor.frameProcess();
		}

		if(movingTable[0] !== void){
			relativePos.x += movingTable[0].x * xDirection(parent.inverse);
			relativePos.y += movingTable[0].y * xDirection(parent.inverse);
			relativePos.z += movingTable[0].h;
			movingTable.erase(0);
		}

		pos.x = parent.rootX + relativePos.x * xDirection(parent.inverse);
		pos.y = parent.rootY - relativePos.y * xDirection(parent.inverse);
		pos.z = parent.altitude + relativePos.z;

		rootX = pos.x;
		rootY = pos.y;

		if(isDead){
			if(parent.targetPlayer.nowSpriteId == stThrown4) holding = true;
			if(holding) release();
			regenerateCount ++;
			if(regenerateCount>regenerate && parent.nowSpriteId==stStanding){
				init();
			}
			return;
		}
		regenerateCount = 0;

		lastPosDelta.copy(posDelta);
		if(deltaTable[0] !== void){
			if(parent.inverse){
				posDelta.x += deltaTable[0].x;
			}else{
				posDelta.x -= deltaTable[0].x;
			}
			posDelta.y += deltaTable[0].y;
			posDelta.z += deltaTable[0].h;
			deltaTable.erase(0);
		}else{
			posDelta.set(0, 0, 0);
		}

		// 根本部分の動き
		if(stop){
			stopCount --;
			if(stopCount == 0){
				loadAsd(initAsd);
				stop = false;
			}
		}

		if(moving) tentacleMove();
		if(waiting) hitCount = 0;


		if(disableAttackCount > 0) disableAttackCount--;
		if(disableSoundCount  > 0) disableSoundCount--;

	}

	function init()
	{
		length = 1;
		movingTable = [];
		deltaTable = [];

		HP = maxHP;
		for(var i=0; i<element_num; i++){
			elements[i].loadImages(%["storage"=>parent.elementStorages[i]]);
			elements[i].length = 1;
		}
		isDead = false;
		deleteFlag = false;
		loadAsd(initAsd);
	}

	function setDeltaTable(elm)
	{
		parent.setMovingTable(elm, deltaTable, false);
	}

	function setMovingTable(elm)
	{
		parent.setMovingTable(elm, movingTable, false);
	}


	function startTentacleMove(elm)
	{
		moving = true;

		moveStartTick = owner.tickCount;
		moveEndTick = moveStartTick + (+elm.frame);
//dm("num : " + num + " / bao.tickCount : " + bao.tickCount + " / owner.tickCount : " + owner.tickCount + " / moveStartTick : " + moveStartTick + " / elm.frame : " + elm.frame + " / moveEndTick : " + moveEndTick);

		moveStartLength = length;
		moveEndLength = +elm.length;
		accel = +elm.accel;

		for(var i=0; i<element_num; i++){
			elements[i].setMove();
		}
	}


	function setTentacleAttack(elm)
	{
		attackKind = Scripts.eval(elm.kind);
		attackStrength = +elm.strength;
	}


	function tentacleMove()
	{
		if(owner.tickCount >= moveEndTick){
			moving = false;
			return;
		}else{
			for(var i=0; i<elements.count; i++){
				elements[i].move();
			}
		}

		length = getLength();
	}


	function getLength()
	{
		var dl = moveEndLength - moveStartLength;
		var df = moveEndTick - moveStartTick;
		if(accel == 0){
			return moveStartLength + (dl / df * (owner.tickCount - moveStartTick));
		}else{
			var d = dl / Math.pow(df, Math.abs(accel)+1);
			if(accel > 0){
				return moveStartLength + (d * Math.pow((owner.tickCount - moveStartTick), Math.abs(accel)+1));
			}else{
				return moveEndLength - (d * Math.pow((moveEndTick-owner.tickCount), Math.abs(accel)+1));
			}
		}
	}


	function hit(damage, num, damageFrom)
	{
		attackStrength = 0;
		if(ignoreDamage || isDead){
			return;
		}

		// 本体が死んでたら処理しない
		if(parent.nowSpriteId == stDamage2){
			if(damageFrom.objectClass == clPlayer) damageFrom.comboCount--;
			return;
		}

		// 他のエレメントにダメージが通っていれば処理しない
//		if(damageTick == damage.tick){
		if(damage.tick - damageTick < 5){
			if(isvalid damageFrom && damageFrom.objectClass == clPlayer) damageFrom.comboCount--;
			return;
		}

		// 本体にダメージが行っていれば処理しない
		if(parent.damage.tick == damage.tick){
			if(damageFrom.objectClass == clPlayer) damageFrom.comboCount--;
			return;
		}

		damageTick = damage.tick;

		damage.hitPos.y += 20;
		damage.hitPos.altitude += 20;
		parent.putHitMark(damage.hitPos, hitMarkStorage[0]);
//		var d = 80 * xDirection(parent.inverse);

		if(!holding){
			var d = 20;
			if(attackKind & 0x0f <= atkHold){
				if(isvalid damageFrom){
					d = 200 * xDirection(elements[num].rootX<damageFrom.rootX);
				}
				stopCount = 20;
			}else{
				if(isvalid damageFrom){
					d = 20 * xDirection(elements[num].rootX<damageFrom.rootX);
				}
				stopCount = 8;
			}
			for(var i=0; i<element_num; i++){
				elements[i].setMovingTable(%['path'=>'('+d+',0,0)','frame'=>30,'xaccel'=>-1], elements[i].movingTable);
				elements[i].invincibleCount = 30;
			}
		}

//		parent.damageFrom = this;
		if(parent.nowSpriteId != stSpecial1 && parent.clinchPlayer === void){
//dm("damage");
			stop = true;
			conductor.stop();
			disableAttackCount = 10;
			parent.loadSprite(stDamage1);
		}
		HP -= damage.strength;
		damage.strength = 0;

		// ヒロインを掴んでいる場合
		hitCount ++;
//dm('hitcount ; '+ hitCount);
		if(hitCount > 4) release();

		if(HP <= 0){
			parent.loadSprite(stDamage1);
			dead();
		}
	}

	function dead()
	{
		isDead = true;
		waiting = true;
		release();
		for(var i=0; i<element_num; i++){
			elements[i].movingTable = [];
			elements[i].layer.trigger("dead");
		}
	}


	function clearHoldPlayer()
	{
//dm('clearHoldPlayer ' + conductor.curStorage + " : " + conductor.curLine);
		for(var j=0; j<elements.count; j++){
			elements[j].clearHoldPlayer();
		}
	}

	function release()
	{
//dm('release / hitCount : ' + hitCount);
		if(holding){
			hitCount = 0;
			clearHoldPlayer();
			parent.clinchPlayer = void;
			holding = false;
			conductor.mp.holding = false;
			parent.targetPlayer.movableRect.right = 260;
			parent.targetPlayer.layer.trigger('end');
			for(var i=0; i< parent.tentacles.count; i++){
				var t = parent.tentacles[i];
				if(!t.isDead) t.loadAsd(t.initAsd);
			}
		}
	}


}


class TentacleElement extends CharacterSprite
{
	var owner;	// baoのオブジェクト
	var root;	// Tentacleクラスのオブジェクト
	var parent;	// 根本方向のオブジェクト
	var child;	// 先端方向のオブジェクト
	var num;

	var vec; // 親からのベクトル位置
	var pos;
	var posDelta;
	var lastPosDelta;

	var positionV;
//	var rotateAxis;
//	var angularVelocity = 0;
//	var inertia = 0;

//	var maxLength = 13;
	var length = 1;

	var depth = 10;

	// objectのタイプ
	var type = objNormal;
	// attackRectを記録しておく
	var attackRectBuf = [];

	var moveFrame;
	var moveAngle;
	var moveVec;
	var startVec;

	var holdPlayerPos = void;

	var colorFlag = false;

	function TentacleElement(window, owner, elm)
	{
		objectClass = clObject;

		parent = elm.parent;
		super.CharacterSprite(window, owner, elm);

		this.owner = owner;
		root = elm.root;
		num = elm.num;
//		maxLength = elm.length;
		positionV	 = new Vector();
		vec			 = new Vector(1, 0, 0);
		pos			 = new Vector();
		posDelta	 = new Vector();
		lastPosDelta = new Vector();
//		rotateAxis	 = new Vector(0, 1, 0);
		noGravity = true;

		movableRect = new Rect2(-200, bao.stageLayer.topLine, 656, 556);

		onRefreshFrame();

		// HPを設定しないと当たり判定が発生しないので
		HP = 10;

		noStore = true;
		layer.opacity = 0;
	}

	function finalize()
	{
		parent = void;
		child  = void;
		super.finalize();
	}

	function onRefreshFrame(){
		if(isvalid root && isvalid root.parent && root.parent.lockedCount == 0){
			if(colorFlag) layer.loadImagesSub2(layer.graphic);
			super.onRefreshFrame();
		}else{
			if(bao.tickCount % 2 == 0){
				layer.adjustGamma(1.2, 32, 255,		1.2, 32, 255,		 1, 0, 255);
				colorFlag = true;
			}else{
				layer.loadImagesSub2(layer.graphic);
				colorFlag = false;
			}
		}

//		これは要らん
//		routineProcess();

		if(!isvalid root) return;

		if(root.isDead){
			clearHoldPlayer();

			var mt = new MovingTable();
			if(movingTable[0] !== void){
				mt.set(movingTable[0]);
				movingTable.erase(0);
			}
			if(!noGravity) mt = checkFall(mt);

			rootX += mt.x;
			rootY += mt.y;
			altitude += mt.h;

			rootX -= root.parent.hScrollVal;
			vOffset -= root.parent.vScrollVal;
			adjustDisp();

			lastMovingTable.set(mt);
			return;
		}


		if(damage.strength != 0) {
			root.hit(damage, num, damageFrom);
			damage.strength = 0;
		}

		if(invincibleCount > 0) invincibleCount--;
//		if(Math.abs(angularVelocity)>0.1) checkAttackCollision();
//		if(movingTable.count>0) movingTable.erase(0);

//		if(root.moving) move();

		// 長さ調整
		vec.normalize();
		vec.scale(length * root.length);
//dm(length + " / " + root.length);

		// 表示位置
		if(movingTable[0]!==void){
			vec.x += movingTable[0].x;
			vec.y += movingTable[0].y;
			vec.z += movingTable[0].h;
			movingTable.erase(0);
		}

		lastPosDelta.copy(posDelta);
		posDelta.copy(parent.lastPosDelta);
//		posDelta.scale(1.1);

		pos.copy(parent.pos);
		pos.x += vec.x + posDelta.x * (num * root.amp1 +1 ) * root.amp2;
		pos.y += vec.y + posDelta.y * (num * root.amp1 +1 ) * root.amp2;
		pos.z -= vec.z + posDelta.z * (num * root.amp1 +1 ) * root.amp2;

		rootX = pos.x;
		rootY = pos.y;
		altitude = pos.z - layer.asdHeight/2;
		var fAltitude = getAltitude(int rootX, int rootY);

		if(!ignoreMovableRect){
//			if(rootX < movableRect.left)   rootX = movableRect.left;
//			if(rootX > movableRect.right)  rootX = movableRect.right;
			if(rootY < movableRect.top)    rootY = movableRect.top;
			if(rootY > movableRect.bottom) rootY = movableRect.bottom;
		}

		if(altitude < fAltitude) altitude = fAltitude;

		var targetPlayer = root.parent.clinchPlayer;
		if(targetPlayer!==void && isvalid targetPlayer && holdPlayerPos!==void){
//dm("this : " + bao.getIndex(this) + " / targetPlayer : " + bao.getIndex(targetPlayer) + " / targetPlayer.clinchedBy : " + bao.getIndex(targetPlayer.clinchedBy));
			targetPlayer.rootX = rootX - holdPlayerPos.x;
			targetPlayer.rootY = rootY + holdPlayerPos.y;
			if(holdPlayerPos.altitude > 0) targetPlayer.noGravity = true;
			targetPlayer.altitude = altitude + holdPlayerPos.altitude;
		}

		vOffset -= root.parent.vScrollVal;
		adjustDisp();
		setAbsolute(int(rootY));

		// 影の処理
		shadowToFloorObject();
	}


	function holdPlayer(x, y, a)
	{
		holdPlayerPos = new Position(...);
	}

	function clearHoldPlayer(){
		if(holdPlayerPos !== void){
			invalidate holdPlayerPos;
			holdPlayerPos = void;
		}
	}


	function checkClinch()
	{
		if(holdPlayerPos === void) return;

		var flag = false;
		for(var i=0; bao.players.count; i++){
			if(sf.adjSinglePlayMode && p === bao.notSelectingPlayer) continue;
			if(bao.players[i].nowSpriteId >= stThrown1 || bao.players[i].nowSpriteId <= stThrown6){
				if(bao.players[i] === clinchPlayer){
					flag = true;
				}
			}
		}
		if(!flag){
			clearHoldPlayer();
			clinchPlayer = void;
			root.loadAsd(initAsd);
		}

	}

	function setMove()
	{
		moveFrame = root.moveEndTick - root.moveStartTick;
		startVec = new Vector(vec);
		moveVec = getNormalVector(vec, positionV);
		moveAngle = getAngle(startVec, positionV);
	}


	function move()
	{
		var tick = owner.tickCount - root.moveStartTick + 1;
		var accel = root.accel;
		var angle;

//dm(root.num + " / " + num + " / Start : " + root.moveStartTick + " / End : " + root.moveEndTick + " / tickCount : " + bao.tickCount + " / tick : " + tick + " / " + vec.x + " , " + vec.y + " , " + vec.z);
		if(moveFrame == tick){
			vec.copy(positionV);
		}else{
			
			if(accel == 0){
				angle = (moveAngle / moveFrame) * (tick);
			}else{
				var d = moveAngle / Math.pow(moveFrame, Math.abs(accel)+1);
				if(accel > 0){
					var a = d * Math.pow(tick, Math.abs(accel)+1);
					angle = a;
				}else{
					var a = d * Math.pow((moveFrame - tick), Math.abs(accel)+1);
					angle = moveAngle - a;
				}
			}

			var v = new Vector(startVec);
			v.transform(moveVec, angle);
			vec.copy(v);
		}

//		length = root.length;
	}


	function setPositionV(x, y, z){
		positionV.set(x * ((root.inverse)? -1 : 1), y, z);
	}


	function checkAttackCollision()
	{
		if(!isvalid root) return;
		if(!isvalid root.parent) return;
		if(root.parent.HP <= 0) return;
		if(attackRect.isEmpty()) return;
		if(root.attackKind == atkNoLoad || root.attackKind == atkOther) return;

		var line = new Rect2(-20, rootY - depth1, owner.internalWidth+20, rootY + depth2);

		for(var i=0; i<owner.players.count; i++){
			var p = owner.players[i];
			if(sf.adjSinglePlayMode && p === bao.notSelectingPlayer) continue;
			if(p.invincibleCount > 0) continue;
			if(p.HP <= 0) continue;
			if(p.comboDamageCount >= 5) continue;
			if(owner.tickCount - p.damage.tick < 5) continue;
			if(p.hitRect.isEmpty()) continue;

			if(p.damageFrom==root && owner.tickCount-p.damage.tick<10) continue;

			if(!line.includedPos(p.rootX, p.rootY)) continue;

			var r1 = new Rect2(attackRect);
			r1.addOffset(internalLayerLeft, internalLayerTop+p.rootY-rootY);
			var r2 = new Rect2(p.hitRect);
			r2.addOffset(p.internalLayerLeft, p.internalLayerTop);
			r2.addOffset(0, rootY-p.rootY);

			if(r1.intersects(r2)){
				p.damageFrom = root.parent;
				p.damageFromStr = root.parent.kind;
				p.damage.kind = root.attackKind;
				if(root.attackKind != atkHold){
					p.damage.strength = root.attackStrength;
					p.damage.tick = owner.tickCount;
					var tmp1 = getIntersectRect(r1, r2);
					var tmp2 = (rootY > p.rootY)? rootY : p.rootY;
					p.setHitMark(tmp1.centerX, tmp2, tmp2-tmp1.centerY);
				}else{
					if(!root.holding){
						root.holdTick = bao.tickCount;
						root.holding = true;
						var checkOtherFlag = false;

						// このエレメントが属してない方の触手がisDead状態になっているかどうかチェック
						for(var j=0; j<root.parent.tentacles.count; j++){
							var t = root.parent.tentacles[j];
							if(t === root) continue;
							if(t.isDead) checkOtherFlag = true;
						}
						root.parent.clinchPlayer = p;
						p.state = stateDamage;
						if(checkOtherFlag){
							p.state = stateDamage;
							p.loadSprite(stThrown5);
						}else{
							p.state = stateDamage;
							p.loadSprite(stThrown4);
						}

					}
					root.parent.targetPlayer = p;
					root.attackKind = atkOther;
					root.loadAsd("e130_tentacle2_holding2");
				}
			}
		}
	}

	function attackRectBufSet()
	{
		attackRectBuf[0] = new Rect2(0, -4, 24, 4);
	}


}


class ButterflySprite extends EnemySprite
{

	var mode = 1;				// 0:通常　1:無敵状態
	var modeChangeTime = 8 * 30;
	var modeChangeCount = 2 * 30;

	var basisX = void;
	var basisY = void;

	function ButterflySprite(window, owner, elm)
	{
		sprites[stStanding]			 = "e810_standing";
		sprites[stWalk]				 = "e810_flying";
		sprites[stEscape]			 = "e810_escape";
		sprites[stDamage1]			 = "e810_damage1";
		sprites[stDamage2]			 = "e810_damage2";

		kind = "魔影蝶";
		name = [(elm.name0!==void)? elm.name0 : "Phantom Butterfly", (elm.name1!==void)? elm.name1 : "Shadow Butterfly"];
		maxHP = HP = 56;
		maxMP = MP = 1;
		recoveryMP = 1;
		score = 5000;
//
		enableClinched = false;

		// ボスキャラであるかどうか
		isBoss = false;

		// 攻撃リスト
		attackList = [];
		comboAttackList = [];

		// 攻撃が当たる奥行き
		depth = 30;

		// 移動速度
		moveSpeed = 5.5;

		// ガードに要するMP
		escapeMP = 1;

		// 移動可能範囲
		movableRect = new Rect2(-50, 0, 456*3, 256);
		if(sf.difficulty == 3) movableRect.right -= 114;
		if(sf.difficulty >= 4) movableRect.right -= 228;

		noGravity = true;
		altitude = 100;

		super.EnemySprite(...);
	}

	function onRefreshFrame(){
		super.onRefreshFrame(...);
		if(enableFreeMove){
			if(modeChangeCount > 0) modeChangeCount --;
			basisX = void;
			basisY = void;
		}else{
			if(basisX === void) basisX = rootX;
			if(basisY === void) basisY = rootY;
		}
	}

	function preMove(m)
	{
		var mt = new MovingTable(m);

		if(movingTable[0] === void){
			setMoveDirection(movingTable);
		}
		mt = movingTable[0];

//		if(nowSpriteId != stWalk) loadSprite(stWalk, true);
		mt.set(mt.x, mt.y, mt.h);

		if(mt.x < 0) inverse = false;
		if(mt.x > 0) inverse = true;
		if(inverse != layer.inverse) layer.setInverse();

		return mt;
	}

	function setMoveDirection(mt)
	{
		var x;
		var y;
		var h;
		var fr;

		// 移動方向決め
		var a = intrandom(20, 70);
		if(enableFreeMove){
			x = intrandom(30,50) * a / 100;
			y = intrandom(-20,20) * a / 100;
			inverse = true;
			fr = int(Math.sqrt(x*x+y*y) / moveSpeed);
		}else{
			x = intrandom(4, 20);
			y = intrandom(4, 8) * ((intrandom(0,1)<1)?-1:1);
			if((inverse && rootX + x > basisX) || (!inverse && rootX - x < basisX)) inverse = !inverse;
			if(rootY + y > basisY ) y = -y;
			fr = int(Math.sqrt(x*x+y*y) / moveSpeed) * 2;
		}
		if(inverse != layer.inverse) setLayerInverse();

		if(fr == 0) fr = 4;

		x = x / fr;
		y = y / fr;

		h = intrandom(-20, 20);
		if(altitude>140 && h>0) h = -h;
		if(altitude<100 && h<0) h = -h;

		var path = "(" + (x*fr) + "," + (y*fr) + "," + h +")";
		setMovingTable(%["path" => path , "frame" => fr*4], mt);
//		dm("path : " + path + " / fr : " + fr);
	}

	function checkDamage(mt)
	{
		if(damage.strength == 0) return mt;

		if(nowSpriteId == stLocked){
				layer.conductor.start();
				lockedCount = 0;
		}

		if(HP > 0) {
			targetPlayer = getDamageSourcePlayer(damageFrom);
//dm((targetPlayer.chara == chrChiffon)?"シフォン" : "ショコラ");

			if(mode==1){
				loadSprite(stEscape);
//				MP -= escapeMP;
				damage.strength = 0;
				return;
			}
			state = stateDamage;
			HP -= (sf.adjSinglePlayMode)? 12: 8;
			putHitMark(damage.hitPos, getHitMarkStorage());
			if(HP > 0){
				mode = 1;
				modeChangeCount = modeChangeTime;
				loadSprite(stDamage1);
			}else{
				loadSprite(stDamage2);
				if(owner.nowSelectingPlayer === targetPlayer) killedByUser = true;
			}
		}
		if(damage.strength > 0){
			executeScriptAtDamaged();
		}
		damage.strength = 0;
		return mt;
	}

	function checkAttackCollision()
	{

		if(attackRect.isEmpty()) return;
		for(var i=0; i<owner.players.count; i++){
			var p = owner.players[i];

			if(p.invincibleCount > 0) return;
			if(p.nowSpriteId==stDamage1 || p.nowSpriteId==stDamage2 || p.nowSpriteId==stCommand3) return;
			if(p.hitRect.isEmpty()) return;

			var line = new Rect2(-20, rootY - depth1, owner.width+20, rootY + depth2);
			if(!line.includedPos(p.rootX, p.rootY)) return;
			if(p.damage.tick == attack.tick) return;

			var r1 = new Rect2(attackRect);
			r1.addOffset(layer.left, layer.top+p.rootY-rootY);

			var r2 = new Rect2(p.hitRect);
			r2.addOffset(p.layer.left, p.layer.top);
			r2.addOffset(0, rootY-p.rootY);

			if(r1.intersects(r2)){
				p.loadSprite(stDamage1);
				// 表示位置調整
				adjustDisp();

			}
		}
	}

	function reset()
	{
		if(HP > 0){
			if(rootX > owner.internalWidth){
				rootX = owner.internalWidth + intrandom(100, owner.internalWidth-100);
			}
			mode = 0;
			modeChangeCount = 0;
		}
	}


}



class BeizelSprite extends EnemySprite
{
	var ctrl = void;

	function BeizelSprite(window, owner, elm)
	{
		kind = "ベイゼル";
		name = [(elm.name0!==void)? elm.name0 : "Bezel", (elm.name1!==void)? elm.name1 : "##_##", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];

		// ボスキャラであるかどうか
		isBoss = true;

		HP = maxHP = enemyHPRate(700, isBoss);
		maxMP = 15;
		MP = 7;
		recoveryMP = 0.06 * ((sf.adjEnemyPattern2)?1.2:1);
		score = 50000;
		targetDistance = 150;

		// 攻撃リスト
		attackList = [stAttack1, stAttack2];
		comboAttackList = [];

		// 攻撃が当たる奥行き
		depth = 10;

		// 移動速度
		moveSpeed = 1.2;

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(-50, 0, 506, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-100, -15, 100, 15);

		// 攻撃判定を行う確率
		attackCheckRate = [30, 30];

		// 主人公の方へ向かっていく確率
		moveRate1 = 20;
		// 適当に動く確率
		moveRate2 = 20;

		// ガードする確率
		guardRate = 92;
		escapeMP = 8;

		// これ以上喰らうと無条件反撃
		damageCountLimit = 3;
		counterAttack = stSpecial1;

		super.EnemySprite(...);
	}

	function initSpriteTable()
	{
		sprites[stStanding]			 = "e140_standing";
		sprites[stWalk]				 = "e140_walk";
		sprites[stStandUp]			 = "e140_standup";
		sprites[stStandUp2]			 = "e140_standup2";
		sprites[stAttack1]			 = "e140_attack1";
		sprites[stAttack2]			 = "e140_attack2";
		sprites[stDamage1]			 = "e140_damage1";
		sprites[stDamage2]			 = "e140_damage2";
		sprites[stEscape]			 = "e140_escape";
		sprites[stClinched]			 = "e140_clinched";
		sprites[stClinchedDamage]	 = "e140_clincheddamage";
		sprites[stSpecial1]			 = "e140_special1";
		sprites[stSpecial2]			 = "e140_special2";
		sprites[stThrown1]			 = "e140_thrown1";
		sprites[stThrown2]			 = "e140_thrown2";
		sprites[stThrown3]			 = "e140_thrown3";
		sprites[stThrown4]			 = "e140_thrown4";
		sprites[stThrown5]			 = "e140_thrown5";
		sprites[stThrown6]			 = "e140_thrown6";
		sprites[stDown]				 = "e140_down";
	}

	function checkAttack()
	{
		if(attackableRect === void) return;
		if(super.checkAttack()) return;

		if(!enableAttack || !enableFreeMove) return;

		if(MP >= 12 && attackableRect.includedPos(rootX, rootY) && getDistance(this, targetPlayer) > 16900){
			MP -= 12;
			loadSprite(stSpecial2);
			return;
		}
	}


}


class BeizelTentacleBaseSprite extends EnemySprite
{
	var elementStorages = [];
	var tentacle;
	var tentacle_num = 12;
//	var targetPlayer = void;
//	var clinchPlayer = void;

	var beizel;
	var bNum = void;

	var onRevive = true;

	var followParent = true;
	var locateResetFlag = false;

//	var attackList;
	function BeizelTentacleBaseSprite(window, owner, elm)
	{

		kind = "Tentacle Base";
		maxHP = HP = 1;
		maxMP = MP = 0;
		score = 0;
		targetDistance = 0;
		countFlag = false;
		enableClinched = false;

		sprites[stStanding]			 = "e830_base";
		sprites[stAttack1]			 = "e830_attack1";
		sprites[stAttack2]			 = "e830_attack2";
		sprites[stDamage1]			 = "e830_damage";
		sprites[stDamage2]			 = "e830_damage";
		sprites[stEscape]			 = "e830_disappear";	// これを呼び出すと消える
		sprites[stStandUp]			 = "e830_reset";

		super.EnemySprite(...);

		for(var i=0; i<tentacle_num; i++){
			elementStorages[i] = "e830_element";
		}

		var tmp = new Vector(0, 0, 0);
		tentacle = new Tentacle(owner, this, tentacle_num, tmp, "e830_tentacle_standing.asd", %['length'=>0.1]);
		tentacle.maxHP = 70;
		tentacle.HP = 70;
		tentacle.num = 0;

//		var beizel = elm.parent.layer.conductor.mp.beizel;

		if(elm.bnum !== void){
			bNum = +elm.bnum;
			beizel = bao.enemies[bNum];
		}

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 456+100, 306);

		// 攻撃リスト
		attackList = [stAttack1, stAttack2];

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(-100, 0, 456, 286);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-120, -80, 120, 80);

		// 攻撃判定を行う確率
		attackCheckRate = [30, 20];
	}

	function routineProcess(){


		if(beizel === void || !isvalid beizel) getBeizel();
		if(beizel !== void && followParent){
			if(rootX < beizel.rootX){
				inverse = false;
			}else{
				inverse = true;
			}
		}

		tentacle.routineProcess();
		super.routineProcess(...);

		if(beizel.lockedCount > 0) return;
		checkAttack();

		if(tentacle.isDead && tentacle.regenerateCount==1){
//			layer.trigger('disappear');
			loadSprite(stEscape);
			onRevive = true;
		}

	}


	function getBeizel()
	{
		for(var i=0; i<bao.enemies.count; i++){
			var e = bao.enemies[i];
			if(e.kind == 'ベイゼル' && isvalid e) beizel = e;
		}
	}


	function checkAttack()
	{
		var acr = toGlobalRectFromRoot(attackCheckRect);

		if(attackableRect === void) return;
//		if(!beizel.enableAttack || !beizel.enableFreeMove) return;
		if(!beizel.enableFreeMove) return;
		if(beizel.HP <= 0) return;
		if(tentacle.isDead || tentacle.disableAttackCount > 0  || !tentacle.waiting) return;
		if(!attackableRect.includedPos(rootX, rootY)) return;
		for(var j=0; j<owner.players.count; j++){
			var p = owner.players[j];
			// 攻撃が当たるようなら攻撃する
			if(sf.adjSinglePlayMode && p === bao.notSelectingPlayer) continue;
			if(p.nowSpriteId >= stClinched) continue;
			if(p.nowSpriteId == stDamage2 || p.nowSpriteId == stStanding3) continue;
			if(p.hitRect.isEmpty()) continue;

			if(acr.includedPos(p.rootX, p.rootY) && intrandom(0, 100) < getAttackCheckRate(attackCheckRate[0])){
				targetPlayer = p;
				inverse = (p.rootX < rootX)? false: true;
				loadSprite(attackList[0]);
			}

			if((inverse && rootX < p.rootX) || (!inverse && p.rootX < rootX)){

				var d = getDistance(this, p);
				if(d > 10000 && d < 32400 && Math.abs(rootY - p.rootY) < 30 && intrandom(0, 100) < getAttackCheckRate(attackCheckRate[1])){
					targetPlayer = p;
					inverse = (p.rootX < rootX)? false: true;
					loadSprite(attackList[1]);
				}

			}

		}
	}



	function finalize(){
		invalidate tentacle;
		super.finalize();
	}

}


class FakeReviellaSprite extends EnemySprite
{
	var attackCheckRect2;

	function FakeReviellaSprite(window, owner, elm)
	{
		kind = "レヴィエラ";
		if(f.inBattleMode) kind = 'フェイクレヴィエラ';
		name = [(elm.name0!==void)? elm.name0 : "Reviella", (elm.name1!==void)? elm.name1 : "##_##", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];

		// ボスキャラであるかどうか
		isBoss = true;

		HP = maxHP = enemyHPRate(400, isBoss);
		maxMP = 15;
		MP = 12;
		recoveryMP = 0.05 * ((sf.adjEnemyPattern2)?1.1:1);
		score = 50000;
		targetDistance = 150;

		// 攻撃リスト
		attackList = [stAttack1, stDashAttack, stCommand2];
		comboAttackList = [stAttack1, stAttack2, stAttack3, stAttack4];
		comboAttackCheckRate = 20;


		// 攻撃が当たる奥行き
		depth = 10;

		// 移動速度
		moveSpeed = 3.0;

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(-50, 0, 506, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-200, -20, 200, 20);
		attackCheckRect2 = new Rect2(-250, -15, 250, 15);

		// 攻撃判定を行う確率
		attackCheckRate = [40, 10, 30];

		// 主人公の方へ向かっていく確率
		moveRate1 = 60;
		// 適当に動く確率
		moveRate2 = 10;

		// ガードする確率
		guardRate = 95;
		escapeMP = 8;

		// これ以上喰らうと無条件反撃
		damageCountLimit = 3;
		counterAttack = stSpecial1;

		super.EnemySprite(...);
	}

	function initSpriteTable()
	{
		sprites[stStanding]			 = "e151_standing";
		sprites[stStanding2]		 = "e151_standing2";
		sprites[stStanding3]		 = "e151_standing3";
		sprites[stWalk]				 = "e151_walk";
		sprites[stStandUp]			 = "e151_standup";
		sprites[stStandUp2]			 = "e151_standup2";
		sprites[stFalling]			 = "e151_falling";
		sprites[stLanding]			 = "e151_landing";
		sprites[stLanding2]			 = "e151_landing2";
		sprites[stDashAttack]		 = "e151_dashattack";
		sprites[stDashAttack2]		 = "e151_dashattack2";
		sprites[stDashAttack3]		 = "e151_dashattack3";
		sprites[stAttack1]			 = "e151_attack1";
		sprites[stAttack2]			 = "e151_attack2";
		sprites[stAttack3]			 = "e151_attack3";
		sprites[stAttack4]			 = "e151_attack4";
		sprites[stDamage1]			 = "e151_damage1";
		sprites[stDamage2]			 = "e151_damage2";
		sprites[stEscape]			 = "e151_roll1";
		sprites[stRoll2]			 = "e151_roll2";
		sprites[stClinched]			 = "e151_clinched";
		sprites[stClinchedDamage]	 = "e151_clincheddamage";
		sprites[stSpecial1]			 = "e151_special1";
		sprites[stRecovery]			 = "e151_recovery";
		sprites[stCommand2]			 = "e151_command2";
		sprites[stThrown1]			 = "e151_thrown1";
		sprites[stThrown2]			 = "e151_thrown2";
		sprites[stThrown3]			 = "e151_thrown3";
		sprites[stThrown4]			 = "e151_thrown4";
		sprites[stThrown5]			 = "e151_thrown5";
		sprites[stThrown6]			 = "e151_thrown6";
		sprites[stEtc1]				 = "e151_etc1";
		sprites[stEtc2]				 = "e151_etc2";
		sprites[stEtc3]				 = "e151_etc3";
	}

	function checkAttack()
	{
		if(attackableRect === void) return;
		if(super.checkAttack()) return;

		if(!enableAttack || !enableFreeMove) return;
		if(nowSpriteId != stStanding && nowSpriteId != stWalk) return;

		var acr2 = toGlobalRectFromRoot(attackCheckRect2);
		for(var j=0; j<owner.players.count; j++){
			var p = owner.players[j];
			// 攻撃が当たるようなら攻撃する
			if(sf.adjSinglePlayMode && p === bao.notSelectingPlayer) continue;
			if(p.hitRect.isEmpty()) continue;
			if(intrandom(0, 100) < getAttackCheckRate(attackCheckRate[1]) && acr2.includedPos(p.rootX, p.rootY)){
				if(rootX < targetPlayer.rootX - 2){
					inverse = true;
				}else if(targetPlayer.rootX + 2 < rootX){
					inverse = false;
				}

				attackIndex++;
				if(attackIndex > comboAttackList.count) attackIndex = 0;
				loadSprite(attackList[attackIndex]);
			}
		}

	}

}


class ReviellaSprite extends EnemySprite
{
	var attackCheckRect2;

	function ReviellaSprite(window, owner, elm)
	{
		kind = "レヴィエラ";
		name = [(elm.name0!==void)? elm.name0 : "Reviella", (elm.name1!==void)? elm.name1 : "##_##", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];

		// ボスキャラであるかどうか
		isBoss = true;

		if(f.inRouteA || f.inRouteB || f.inRouteC || f.inRouteD){
			HP = maxHP = enemyHPRate(640, isBoss);
		}else{
			HP = maxHP = enemyHPRate(800, isBoss);
		}
		maxMP = 12;
		MP = 2;
		recoveryMP = 0.05 * ((sf.adjEnemyPattern2)?1.1:1);
		score = 50000;
		targetDistance = 170;

		// 攻撃リスト
		attackList = [stAttack3, stAttack2, stAttack1];

		// 攻撃が当たる奥行き
		depth = 12;

		// 移動速度
		moveSpeed = 2.6;

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(-50, 0, 506, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-200, -20, 200, 20);
		attackCheckRect2 = new Rect2(-220, -18, 220, 18);

		// 攻撃判定を行う確率
		attackCheckRate = [30, 30, 30];

		// 主人公の方へ向かっていく確率
		moveRate1 = 40;
		// 適当に動く確率
		moveRate2 = 10;

		// ガードする確率
		guardRate = 92;
		escapeMP = 8;

		// これ以上喰らうと無条件反撃
		damageCountLimit = 4;
		counterAttack = stSpecial2;

		super.EnemySprite(...);
	}

	function initSpriteTable()
	{
		sprites[stStanding]			 = "e150_standing";
		sprites[stStanding2]		 = "e150_standing2";
		sprites[stWalk]				 = "e150_walk";
		sprites[stStandUp]			 = "e150_standup";
		sprites[stStandUp2]			 = "e150_standup2";
		sprites[stRecovery]			 = "e150_recovery";
		sprites[stEscape]			 = "e150_escape";
		sprites[stAttack1]			 = "e150_attack1";
		sprites[stAttack2]			 = "e150_attack2";
		sprites[stAttack3]			 = "e150_attack3";
		sprites[stDamage1]			 = "e150_damage1";
		sprites[stDamage2]			 = "e150_damage2";
		sprites[stDown]				 = "e150_down";
		sprites[stClinched]			 = "e150_clinched";
		sprites[stClinchedDamage]	 = "e151_clincheddamage";
		sprites[stSpecial1]			 = "e150_special1";
		sprites[stSpecial2]			 = "e150_special2";
		sprites[stSpecial3]			 = "e150_special3";
		sprites[stThrown1]			 = "e151_thrown1";
		sprites[stThrown2]			 = "e151_thrown2";
		sprites[stThrown3]			 = "e151_thrown3";
		sprites[stThrown4]			 = "e151_thrown4";
		sprites[stThrown5]			 = "e151_thrown5";
		sprites[stThrown6]			 = "e151_thrown6";
	}

	function checkAttack()
	{
		if(attackableRect === void) return;
		if(super.checkAttack())	return;

		if(!enableAttack || !enableFreeMove) return;
		if(nowSpriteId != stStanding && nowSpriteId != stWalk) return;

		var flag = true;
		var acr2 = toGlobalRectFromRoot(attackCheckRect2);
		for(var i=0; i<owner.players.count; i++){
			var p = owner.players[i];
			if(sf.adjSinglePlayMode && p === bao.notSelectingPlayer) continue;

			if(intrandom(0, 100) < getAttackCheckRate(attackCheckRate[3]) && acr2.includedPos(p.rootX, p.rootY)){
				if(rootX < p.rootX - 2){
					inverse = true;
				}else if(p.rootX + 2 < rootX){
					inverse = false;
				}
				loadSprite(stAttack1);
				return;
			}

			if(getDistance(this, p) < 22500) flag = false;
		}

		if(!tf.inRescueMode && flag && MP > 4 && intrandom(0, 100) < getAttackCheckRate(attackCheckRate[2]) && targetPlayer.state < stateDamage && targetPlayer.lockedCount==0 && getDistance(this, targetPlayer) > 32400){
			MP -= 4;
			loadSprite(stSpecial3);
		}

		if(flag && MP >= 10){
			MP -= 10;
			loadSprite(stSpecial1);
		}

	}

}


class ElgonaireSprite extends EnemySprite
{
	var attackCheckRect2;
	var opacity3 = 100;
	var dOpacity3 = 4;

	function ElgonaireSprite(window, owner, elm)
	{
		kind = "エルゴネア";
		name = [(elm.name0!==void)? elm.name0 : "Ergonia", (elm.name1!==void)? elm.name1 : "##_##", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];

		// ボスキャラであるかどうか
		isBoss = true;

		HP = maxHP = enemyHPRate(1200, isBoss);
		maxMP = 12;
		MP = 3;
		recoveryMP = 0.06 * ((sf.adjEnemyPattern2)?1.2:1);
		score = 100000;
		targetDistance = 150;

		// 攻撃リスト
		attackList = [stAttack1, stAttack3, stHolding];

		// 攻撃が当たる奥行き
		depth = 12;

		// 移動速度
		moveSpeed = 2.0;

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(-50, 0, 506, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-200, -20, 200, 20);
		attackCheckRect2 = new Rect2(-200, -60, 200, 60);

		// 攻撃判定を行う確率
		attackCheckRate = [30, 40, 30, 20, 10];

		// 主人公の方へ向かっていく確率
		moveRate1 = 50;
		// 適当に動く確率
		moveRate2 = 20;

		enableClinched = false;

		// ガードする確率
		guardRate = 95;
		escapeMP = 5;

		// これ以上喰らうと無条件反撃
		damageCountLimit = 3;
		counterAttack = stSpecial1;

		super.EnemySprite(...);
	}

	function initSpriteTable()
	{
		sprites[stStanding]			 = "e160_standing";
		sprites[stWalk]				 = "e160_walk";
		sprites[stDash]				 = "e160_walk2";
		sprites[stStandUp]			 = "e160_standup";
		sprites[stStandUp2]			 = "e160_standup2";
		sprites[stRecovery]			 = "e160_recovery";
		sprites[stAttack1]			 = "e160_attack1";
		sprites[stAttack2]			 = "e160_attack2";
		sprites[stAttack3]			 = "e160_attack3";
		sprites[stDamage1]			 = "e160_damage1";
		sprites[stDamage2]			 = "e160_damage2";
		sprites[stGuard]			 = "e160_guard";
		sprites[stDown]				 = "e160_down";
		sprites[stClinched]			 = "e160_clinched";
		sprites[stClinchedDamage]	 = "e160_clincheddamage";
		sprites[stSpecial1]			 = "e160_special1";
		sprites[stSpecial2]			 = "e160_special2";
		sprites[stHolding]			 = "e160_holding";
		sprites[stHolding2]			 = "e160_holding2";
		sprites[stClinching]		 = "e160_clinching";
		sprites[stThrow1]			 = "e160_throw";
		sprites[stEtc1]				 = "e160_etc1";
	}


	function checkAttack()
	{
		if(attackableRect === void) return;
		if(super.checkAttack()) return;

		if(!enableAttack || !enableFreeMove) return;
		if(nowSpriteId != stStanding && nowSpriteId != stWalk) return;

		var flag = true;
		var acr2 = toGlobalRectFromRoot(attackCheckRect2);
		for(var i=0; i<owner.players.count; i++){
			var p = owner.players[i];
			if(sf.adjSinglePlayMode && p === bao.notSelectingPlayer) continue;

			if(acr2.includedPos(p.rootX, p.rootY) || getDistance(this, p) < 25600){
				flag = false;
			}
		}

		if(flag && intrandom(0, 100) < getAttackCheckRate(attackCheckRate[3]) && MP >= 3){
			if(sf.adjSinglePlayMode || bao.players.count == 1){
				targetPlayer = bao.nowSelectingPlayer;
			}else{
				targetPlayer = (Math.abs(rootY-bao.players[0].rootY) < Math.abs(rootY-bao.players[1].rootY))? bao.players[0]: bao.players[1];
			}

			if(targetPlayer.nowSpriteId != stDamage2 && targetPlayer.nowSpriteId != stDown && rootX > -20 && rootX < bao.internalWidth+20){
				MP -= 5;
				if(rootX < targetPlayer.rootX - 2){
					inverse = true;
				}else if(targetPlayer.rootX + 2 < rootX){
					inverse = false;
				}
				loadSprite(stAttack2);
			}
		}

		var r;
		if(HP < maxHP / 4){
			r = 100;
		}else if(HP < maxHP / 2){
			r = 300;
		}else{
			r = 400;
		}

		if((rootX > 0 && rootX < bao.internalWidth) && intrandom(0, r) < getAttackCheckRate(attackCheckRate[4])){
			loadSprite(stSpecial2);
		}

	}


	function routineProcess(){
		super.routineProcess();

		opacity3 += dOpacity3;
		if(opacity3 > 100){
			opacity3 = 100;
			dOpacity3 = -2;
		}
		if(opacity3 < 80){
			dOpacity3 = 2;
		}

		layer.opacity = int(layer.asdOpacity * (layer.opacity2/100) * (opacity3/100));
	}


	function throwPlayer()
	{
		var p = targetPlayer;
		p.clinchedBy = this;
		p.state = stateDamage;
		p.loadSprite(stThrown1);
		loadSprite(stClinching);

		if(rootY < movableRect.top+1) rootY = movableRect.top+1;
		if(rootY > movableRect.bottom-1) rootY = movableRect.bottom-1;
	}

}


class EnemyChiffonSprite extends EnemySprite
{
	var attackCheckRect2;
	var chara = chrChiffon;

	function EnemyChiffonSprite(window, owner, elm)
	{
		kind = "エクセルシフォン";
		name = [(elm.name0!==void)? elm.name0 : "Excel Chiffon", (elm.name1!==void)? elm.name1 : "##_##", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];

		// ボスキャラであるかどうか
		isBoss = true;

		HP = maxHP = enemyHPRate(500, isBoss);
		maxMP = 15;
		MP = 12;
		recoveryMP = 0.04 * ((sf.adjEnemyPattern2)?1.1:1);
		score = 50000;
		targetDistance = 150;

		clinchedOffset = -5;

		// 攻撃リスト
		attackList = [stAttack1, stDashAttack, stCommand2];
		comboAttackList = [stAttack1, stAttack2, stAttack3, stAttack4];
		comboAttackCheckRate = 20;


		// 攻撃が当たる奥行き
		depth = 10;

		// 移動速度
		moveSpeed = 3.0;

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(-50, 0, 506, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-200, -20, 200, 20);
		attackCheckRect2 = new Rect2(-250, -15, 250, 15);

		// 攻撃判定を行う確率
		attackCheckRate = [40, 10, 30];

		// 主人公の方へ向かっていく確率
		moveRate1 = 60;
		// 適当に動く確率
		moveRate2 = 10;

		// ガードする確率
		guardRate = 95;
		escapeMP = 8;

		// これ以上喰らうと無条件反撃
		damageCountLimit = 3;
		counterAttack = stSpecial1;

		cosState = 4;

		super.EnemySprite(...);
	}

	function initSpriteTable()
	{
		sprites[stStanding]			 = "e210_standing";
		sprites[stWalk]				 = "e210_walk";
		sprites[stStandUp]			 = "e210_standup";
		sprites[stStandUp2]			 = "e210_standup2";
		sprites[stStandUp3]			 = "e210_standup3";
		sprites[stFalling]			 = "e210_falling";
		sprites[stLanding]			 = "e210_landing";
		sprites[stLanding2]			 = "e210_landing2";
		sprites[stDashAttack]		 = "e210_dashattack";
		sprites[stDashAttack2]		 = "e210_dashattack2";
		sprites[stDashAttack3]		 = "e210_dashattack3";
		sprites[stAttack1]			 = "e210_punch1";
		sprites[stAttack2]			 = "e210_punch2";
		sprites[stAttack3]			 = "e210_kick1";
		sprites[stAttack4]			 = "e210_kick2";
		sprites[stDamage1]			 = "e210_damage1";
		sprites[stDamage2]			 = "e210_damage2";
		sprites[stEscape]			 = "e210_roll1";
		sprites[stRoll2]			 = "e210_roll2";
		sprites[stClinched]			 = "e210_clinched";
		sprites[stClinchedDamage]	 = "e210_clincheddamage";
		sprites[stSpecial1]			 = "e210_special1";
		sprites[stRecovery]			 = "e210_recovery";
		sprites[stCommand2]			 = "e210_command2";
		sprites[stThrown1]			 = "e210_thrown1";
		sprites[stThrown2]			 = "e210_thrown2";
		sprites[stThrown3]			 = "e210_thrown3";
		sprites[stThrown4]			 = "e210_thrown4";
		sprites[stThrown5]			 = "e210_thrown5";
		sprites[stThrown6]			 = "e210_thrown6";
//		sprites[stEtc1]				 = "p00_etc1";
//		sprites[stEtc2]				 = "p04_etc2";
//		sprites[stEtc3]				 = "p04_etc3";
	}

	function checkAttack()
	{
		if(attackableRect === void) return;
		if(super.checkAttack()) return;

		if(!enableAttack || !enableFreeMove) return;
		if(nowSpriteId != stStanding && nowSpriteId != stWalk) return;

		var acr2 = toGlobalRectFromRoot(attackCheckRect2);
		for(var j=0; j<owner.players.count; j++){
			var p = owner.players[j];
			// 攻撃が当たるようなら攻撃する
			if(sf.adjSinglePlayMode && p === bao.notSelectingPlayer) continue;
			if(p.hitRect.isEmpty()) continue;
			if(intrandom(0, 100) < getAttackCheckRate(attackCheckRate[1]) && acr2.includedPos(p.rootX, p.rootY)){
				if(rootX < targetPlayer.rootX - 2){
					inverse = true;
				}else if(targetPlayer.rootX + 2 < rootX){
					inverse = false;
				}

				attackIndex++;
				if(attackIndex > comboAttackList.count) attackIndex = 0;
				loadSprite(attackList[attackIndex]);
			}
		}

	}

}



class EnemyChocolatSprite extends EnemySprite
{
	var attackCheckRect2;
	var chara = chrChocolat;

	function EnemyChocolatSprite(window, owner, elm)
	{
		kind = "エクセルショコラ";
		name = [(elm.name0!==void)? elm.name0 : "Excel Chocolat", (elm.name1!==void)? elm.name1 : "##_##", (elm.name2!==void)? elm.name2 : "##_##", (elm.name3!==void)? elm.name3 : "##_##"];

		// ボスキャラであるかどうか
		isBoss = true;

		HP = maxHP = enemyHPRate(500, isBoss);
		maxMP = 15;
		MP = 12;
		recoveryMP = 0.04 * ((sf.adjEnemyPattern2)?1.1:1);
		score = 50000;
		targetDistance = 150;

		clinchedOffset = -5;

		// 攻撃リスト
		attackList = [stAttack1, stDashAttack, stCommand1, stCommand2, stCommand3, stHolding];
		comboAttackList = [stAttack1, stAttack1, stAttack2, stAttack3];
		comboAttackCheckRate = 20;


		// 攻撃が当たる奥行き
		depth = 10;

		// 移動速度
		moveSpeed = 3.0;

		// 移動可能範囲
		movableRect = new Rect2(-100, 0, 556, 256);

		// 攻撃可能範囲（画面の外にいるときは攻撃しない）
		attackableRect = new Rect2(-50, 0, 506, 256);

		// 攻撃判定を行うrootX,rootYを中心とした範囲（この中に主人公がいたら攻撃判定をする）
		attackCheckRect = new Rect2(-200, -20, 200, 20);
		attackCheckRect2 = new Rect2(-250, -15, 250, 15);

		// 攻撃判定を行う確率
		attackCheckRate = [0, 0, 0, 0, 0, 40];

		// 主人公の方へ向かっていく確率
		moveRate1 = 60;
		// 適当に動く確率
		moveRate2 = 10;

		// ガードする確率
		guardRate = 95;
		escapeMP = 8;

		// これ以上喰らうと無条件反撃
		damageCountLimit = 3;
		counterAttack = stSpecial1;

		cosState = 4;

		super.EnemySprite(...);
	}

	function initSpriteTable()
	{
		sprites[stStanding]			 = "e220_standing";
		sprites[stWalk]				 = "e220_walk";
		sprites[stStandUp]			 = "e220_standup";
		sprites[stStandUp2]			 = "e220_standup2";
		sprites[stFalling]			 = "e220_falling";
		sprites[stLanding]			 = "e220_landing";
		sprites[stLanding2]			 = "e220_landing2";
		sprites[stDashAttack]		 = "e220_dashattack";
		sprites[stAttack1]			 = "e220_punch1";
		sprites[stAttack2]			 = "e220_punch2";
		sprites[stAttack3]			 = "e220_kick1";
		sprites[stAttack3]			 = "e220_kick2";
		sprites[stHolding]			 = "e220_holding";
		sprites[stHolding2]			 = "e220_holding2";
		sprites[stDamage1]			 = "e220_damage1";
		sprites[stDamage2]			 = "e220_damage2";
		sprites[stEscape]			 = "e220_roll1";
		sprites[stRoll2]			 = "e220_roll2";
		sprites[stClinched]			 = "e220_clinched";
		sprites[stClinchedDamage]	 = "e220_clincheddamage";
		sprites[stSpecial1]			 = "e220_special1";
		sprites[stRecovery]			 = "e220_recovery";
		sprites[stCommand1]			 = "e220_command1";
		sprites[stCommand2]			 = "e220_command2";
		sprites[stCommand3]			 = "e220_command3";
		sprites[stThrow1]			 = "e220_throw1";
		sprites[stThrow2]			 = "e220_throw2";
		sprites[stThrown1]			 = "e220_thrown1";
		sprites[stThrown2]			 = "e220_thrown2";
		sprites[stThrown3]			 = "e220_thrown3";
		sprites[stThrown4]			 = "e220_thrown4";
		sprites[stThrown5]			 = "e220_thrown5";
		sprites[stThrown6]			 = "e220_thrown6";
		sprites[stEtc1]				 = "e220_etc1";
//		sprites[stEtc2]				 = "p04_etc2";
//		sprites[stEtc3]				 = "p04_etc3";
	}

	function checkAttack()
	{
		if(attackableRect === void) return;
		if(super.checkAttack()) return;

		if(!enableAttack || !enableFreeMove) return;
		if(nowSpriteId != stStanding && nowSpriteId != stWalk) return;

		var acr2 = toGlobalRectFromRoot(attackCheckRect2);
		for(var j=0; j<owner.players.count; j++){
			var p = owner.players[j];
			// 攻撃が当たるようなら攻撃する
			if(sf.adjSinglePlayMode && p === bao.notSelectingPlayer) continue;
			if(p.hitRect.isEmpty()) continue;
			if(intrandom(0, 100) < getAttackCheckRate(attackCheckRate[1]) && acr2.includedPos(p.rootX, p.rootY)){
				if(rootX < targetPlayer.rootX - 2){
					inverse = true;
				}else if(targetPlayer.rootX + 2 < rootX){
					inverse = false;
				}

				attackIndex++;
				if(attackIndex > comboAttackList.count) attackIndex = 0;
				loadSprite(attackList[attackIndex]);
			}
		}

	}

	function throwPlayer()
	{
		var p = targetPlayer;
		p.clinchedBy = this;
		p.clinchedStrength += 500;

		if(rootY < movableRect.top+1) rootY = movableRect.top+1;
		if(rootY > movableRect.bottom-1) rootY = movableRect.bottom-1;

		if(p.inverse != inverse){
			p.rootY = rootY + 1;
			p.state = stateDamage;
			p.loadSprite(stThrown8);
			loadSprite(stThrow1);
		}else{
			p.rootY = rootY - 1;
			p.state = stateDamage;
			p.loadSprite(stThrown9);
			loadSprite(stThrow2);
		}

	}

}



class MobSprite extends EnemySprite
{

	function MobSprite(window, owner, elm)
	{
		sprites[stStanding] = elm.storage;

		kind = "Mob";
		name = (elm.name!==void)? elm.name : kind;
		maxHP = HP = 1;
		maxMP = MP = 0;
		score = 0;
		targetDistance = 0;
		enableClinched = false;

		movableRect = new Rect2(-100, 0, 556, 256);
		if(owner.stageLayer !== void){
			if(movableRect.y1 < owner.stageLayer.topLine) movableRect.y1 = owner.stageLayer.topLine;
			if(movableRect.y2 > owner.stageLayer.bottomLine) movableRect.y2 = owner.stageLayer.bottomLine;
		}

		super.EnemySprite(...);
	}

}

class StageLayer extends Layer
{
	var scrollLineL; // 左側のスクロール開始ライン
	var scrollLineR; // 右側のスクロール開始ライン

	var reverseDirection = false;

	var owner;
	var window;

	var floorLayers = [];
	var floorObjects = [];

	var wallLayer;
	var maskLayer;

	var srcWidth;
	var srcHeight;

	var storage = "";

	var triggerLine = void;
	var triggerLine2 = void;
	var dLeft = 0;
	var scrollLimit;
	var scrollLimitLeft = 0;
	var scrollLimitLeft_b = 0;

	// ステージレイヤー外へはみ出るのを制限するか
	var limitRight = true;
	var limitLeft = false;

	var scrollSpeedLimit;
	var scrollSpeed;

	var topLine;
	var bottomLine;

	var setTop = 0;
	var dispTop = 0;

	// 床底面の高さ（この値を低くすると底に落ちるとか出来る）
	var floorBottom = 0;

	var xFreeMode = false;

	var scrollLockCount = 0;

	// 敵キャラが移動時に避けようとする地点
	var avoidPoints = [];

	// 敵キャラを発生させない矩形範囲
	var enemySetAvoidRect = void;

	function StageLayer(window, owner){
		this.window = window;
		this.owner = owner;

		super.Layer(window, owner.srcLayer);
		name = "stageLayer";

		face = dfOpaque;
		type = ltOpaque;

		setSize(owner.width, owner.height);
		setImageSize(owner.width, owner.height);
		setPos(0, 0);

		srcWidth = owner.width \ owner.sZoomRate;
		srcHeight = owner.height \ owner.sZoomRate;

		// メインの背景レイヤー
		wallLayer = new .Layer(window, this);
		wallLayer.face = dfOpaque;
		wallLayer.type = ltOpaque;
		wallLayer.visible = (owner.sZoomRate==1)? true: false;
		wallLayer.name = 'StageWallLayer';

		maskLayer = new .Layer(window, this);
		maskLayer.visible = false;
		maskLayer.name = 'maskLayer';

		enemySetAvoidRect = new Rect2();
	}

	function finalize(){
		invalidate wallLayer;

		clearStage();
		floorLayers = void;
		floorObjects = void;
		avoidPoints = [];
		super.finalize();
	}

	function clearStage(){

		storage = "";
		visible = false;
		setSize(32, 32);
		setImageSize(32, 32);

		for(var i=0; i<floorLayers.count; i++){
			invalidate floorLayers[i];
		}
		floorLayers = [];

		clearFloorObjects();
		clearAvoidPoint();

		dLeft = 0;
		scrollLimitLeft = 0;
		scrollLimitLeft_b = 0;
		scrollLockCount = 0;

		setTop = 0;
		dispTop = 0;
		floorBottom = 0;

		xFreeMode = false;

		limitRight = true;
		limitLeft = false;

		reverseDirection = false;
	}

	function loadImages(elm)
	{
		scrollLineL = 80;
		scrollLineR = 240;

		scrollSpeedLimit = 6.5;
		scrollSpeed = 2.5;
		topLine = 160;
		bottomLine = 250;

		storage = elm.storage;
		visible = false;

		setSize(owner.width, owner.height);
		setImageSize(owner.width, owner.height);

		srcWidth = owner.width \ owner.sZoomRate;
		srcHeight = owner.height \ owner.sZoomRate;

		loadImagesSub(elm.storage);
		wallLayer.setPos(0, 0);

		dLeft = 0;
		scrollLimit = int(wallLayer.imageWidth / (bao.cZoomRate/bao.sZoomRate));

		if(elm.bottom !== void){
			floorBottom = +elm.bottom;
		}else{
			floorBottom = 0;
		}

		if(elm.displine !== void) dLeft = +elm.displine;
		if(elm.disp !== void){
			switch(elm.disp){
				case "left":
					dLeft = 0;
					break;
				case "right":
					dLeft = imageWidth - owner.internalWidth;
					break;
				case "rightadd":
					dLeft = - owner.internalWidth;
					break;
				case "leftadd":
					dLeft = - imageWidth;
			}
		}
//		setPos(dLeft, 0);

		wallLayer.opacity = 255;
		wallLayer.absolute = 0;
		wallLayer.visible = false;

		visible = true;
		owner.shadowLayer.visible = true;
	}

	function loadImagesSub(storage){
		wallLayer.loadImages(owner.fHeader2 + storage);
		wallLayer.setSizeToImageSize();
	}

	function addFloorLayer(elm){
		var l = new FloorLayer(window, wallLayer, this, elm);
		l.loadImages(elm.storage);
		l.setSizeToImageSize();
		l.visible = false;
		if(elm.absolute!==void){
			l.absolute = elm.absolute;
		}else{
			l.absolute = absolute + 20 - (floorLayers.count+1) * 2;
		}
//		l.setPos(left, top);

		wallLayer.operateRect(l.left, l.top, l, 0, 0, l.imageWidth, l.imageHeight, omAuto, 255);

		floorLayers.add(l);
	}

	function addFloorObject(elm){

		var l = new FloorObject(window, owner, elm);

		if(elm.absolute === void){
			if(l.objHeight > 0){
				l.layer.absolute = 20000 - floorObjects.count * 400;
			}else{
				l.layer.absolute = 100 + (floorObjects.count+1) * 2;
			}
		}else{
			l.layer.absolute = +elm.absolute;
		}

		floorObjects.add(l);

//		owner.shadowLayer.visible = false;

		if(elm.return!==void){
			Scripts.eval(elm.return + " = bao.stageLayer.floorObjects[bao.stageLayer.floorObjects.count-1]");
		}
	}

	function clearFloorObjects(){
		for(var i=0; i<floorObjects.count; i++){
			invalidate floorObjects[i];
		}
		floorObjects = [];
	}

	function addAvoidPoint(elm)
	{
		var p = new Position(+elm.x, +elm.y);
		if(elm.id === void){
			p.etc = avoidPoints.count;
		}else{
			p.etc = +elm.id;
		}
		avoidPoints.add(p);
	}

	function deleteAvoidPoint(id)
	{
		for(var i=0; i<avoidPoints.count; i++){
			if(avoidPoints[i].etc == id){
				invalidate avoidPoints[i];
				avoidPoints.erase(i);
				return;
			}
		}
	}

	function clearAvoidPoint(){
		for(var i=0; i<avoidPoints.count; i++){
			invalidate avoidPoints[i];
		}
		avoidPoints = [];
	}

	function setScrollLimit(line)
	{
		if(line >= dLeft + owner.internalWidth){
			scrollLimit = line;
		}
	}

	function setScrollLimitLeft(line)
	{
//		scrollLimitLeft_b = line;
		scrollLimitLeft = line;
	}

//	function bgScroll(x, length)
	function bgScroll()
	{
		if(owner.players.count == 0) return;

		var leftX = 9999;
		var leftP;
		var rightX = -1000;
		var rightP;
		for(var i=0;i<owner.players.count; i++){
			if(owner.players[i].layer.opacity2 == 0) continue;
			var p = owner.players[i];
			if(p.rootX > rightX){
				rightP = p;
				rightX = p.rootX;
			}
			if(p.rootX < leftX){
				leftP = p;
				leftX = p.rootX;
			}
		}

		var scroll = 0;
		var scrollMax = scrollLimit - bao.internalWidth; // スクロールできる最大位置

		if(scrollLockCount <= 0){
			if(scrollLineR < rightX && scrollLineL < leftX){
				// キャラが右へ進行するスクロール
				scroll = rightX - scrollLineR;
				if(scrollLineL > leftX - scroll){
					// スクロールさせると左側のスクロールラインを越えてしまう
					scroll = leftX - scrollLineL;
				}
				if(leftP.movableRect.left > leftX - scroll){
					// スクロールさせると左側にいるキャラが移動範囲外に出ようとしてしまう（実際は出れないので地面を滑ってしまう）
					scroll = leftX - leftP.movableRect.left;
				}
				if(scrollMax < dLeft + scroll){
					scroll = scrollMax - dLeft;
				}
			}else if(leftX < scrollLineL && rightX < scrollLineR){
				// キャラが左へ進行するスクロール
				scroll = leftX - scrollLineL;
				if(rightX - scroll > scrollLineR){
					// スクロールさせると右側のスクロールラインを越えてしまう
					scroll = rightX - scrollLineR;
				}
				if(rightX - scroll > rightP.movableRect.right){
					// スクロールさせると右側にいるキャラが移動範囲外に出ようとしてしまう（実際は出れないので地面を滑ってしまう）
					scroll = rightX - rightP.movableRect.right;
				}
				if(scrollLimitLeft > dLeft + scroll){
					scroll = scrollLimitLeft - dLeft;
				}
			}
		}

		// スクロールスピードの調整
		if(scroll > 0){
			if(rightP.lastMovingTable.x > scrollSpeed){
				scroll = (scroll < scrollSpeedLimit)? scroll : scrollSpeedLimit;
			}else{
				scroll = (scroll < scrollSpeed)? scroll: scrollSpeed;
			}
		}

		if(scroll < 0){
			if(leftP.lastMovingTable.x < -scrollSpeed){
				scroll = (scroll > -scrollSpeedLimit)? scroll : -scrollSpeedLimit;
			}else{
				scroll = (scroll > -scrollSpeed)? scroll: -scrollSpeed;
			}
		}

//dm("scroll : " + scroll + " / rightX : " + rightX + " / lastMovingTable.x : " + rightP.lastMovingTable.x);

		// ヒロインキャラにスクロール反映
		for(var i=0; i<owner.players.count; i++){
			if(owner.players[i].layer.opacity2 > 0){
				// 非表示状態ではスクロールを反映しない。
				owner.players[i].rootX -= scroll;
				owner.players[i].adjustDisp();
			}
		}

		dispLeft += scroll;
		// トリガーラインを越えたら発砲
		if(owner.conductor === owner.mainConductor){
			// extraConductorの時は処理しない
			if(triggerLine !== void){
				if((!reverseDirection && triggerLine <= dispLeft) || (reverseDirection && dispLeft <= triggerLine)){

//dm("■ triggerLine : " + triggerLine + " / dispLeft : " + dispLeft);
					owner.trigger('line');
					triggerLine = void;
				}
			}

			var p = owner.players[0];
			if(owner.players.count > 1){
				if(!reverseDirection){
					p = (owner.players[0].rootX > owner.players[1].rootX)? owner.players[0]: owner.players[1];
				}else{
					p = (owner.players[0].rootX < owner.players[1].rootX)? owner.players[0]: owner.players[1];
				}
			}
			if(triggerLine2 !== void){
				if((!reverseDirection && triggerLine2 <= dispLeft + p.rootX) || (reverseDirection && dispLeft + p.rootX <= triggerLine2)){
//dm("■ dispLeft : " + dispLeft + " / id : " + bao.getIndex(p) + " / p.rootX : " + p.rootX + " / dispLeft+p.rootX : " + (dispLeft+p.rootX));
					owner.trigger('pline');
					triggerLine2 = void;
				}
			}

		}


//		// 縦方向スクロール
		var dTop = 0;
		if(setTop > dispTop){
			dTop = 4;
			if(dispTop+dTop > setTop) dTop = setTop - dispTop;
		}

		if(setTop < dispTop){
			dTop = -4;
			if(dispTop+dTop < setTop) dTop = setTop - dispTop;
		}
		dispTop += dTop;
		owner.shadowLayer.top -= dTop * owner.cZoomRate;
		for(var i=0; i<floorObjects.count; i++)
			if(!floorObjects[i].ignoreScroll) floorObjects[i].baseTop -= dTop;

		owner.hScrollVal = scroll;
		owner.vScrollVal = dTop;

		return;
	}

	function disp()
	{
//		if(wallLayer.height < srcHeight) return;

		if(floorLayers.count>0){
			// shadowLayer（もしくはshadowLayer.internalLayer）をfloorLayerでマスクする
			var target;
			switch(owner.mode){
				case 1:
				case 2:
					target = owner.shadowLayer;
					break;
				case 3:
					target = owner.shadowLayer.internalLayer;
					break;
			}
			if(maskLayer.width != target.width || maskLayer.height != floorLayers[0].height) maskLayer.setSize(target.width, floorLayers[0].height);
			maskLayer.fillRect(0, 0, maskLayer.width, maskLayer.height, 0x00000000);
			for(var i=0; i<floorLayers.count; i++){
				var f = floorLayers[i];
				if(dispLeft+f.width/owner.sZoomRate2+f.xOffset > 0 && -dispLeft+f.xOffset < owner.internalWidth){
					// floorLayerが画面内に収まっている場合
					maskLayer.operateRect(0, 0, f, dispLeft*owner.sZoomRate2-f.dispXOffset, 0, target.width, f.height, omAuto, 255);
				}
			}
//			showLayer(maskLayer);
			target.clipAlphaRect(0, target.height-maskLayer.height, maskLayer, 0, 0, maskLayer.width, maskLayer.height, 0);
		}

		switch(owner.mode){
			case 1:
			case 2:
				// stageLayerを拡大しない場合(mode=1or2のとき）
				// wallLayerを表示のためにコピーする
				copyRect(0, 0, wallLayer, dispLeft * bao.sZoomRate2, dispTop * bao.sZoomRate2, srcWidth, srcHeight);
				break;
			case 3:
				var s = owner.shadowLayer;
				var i = owner.shadowLayer.internalLayer;
				// mode=3のとき
				// wallLayerを表示のために拡大コピーする
				stretchCopy(0, 0, width, height, wallLayer, dispLeft * bao.sZoomRate2, dispTop * bao.sZoomRate2, srcWidth, srcHeight, stNearest);
				// shadowLayerを拡大コピーする
				s.stretchCopy(0, 0, s.width, s.height, i, 0, 0, i.width, i.height, stNearest);
				break;
		}
	}

	function setTriggerLine(line)
	{
//dm("reverseDirection : " + reverseDirection + " / dispLeft : " + dispLeft + " / line : " + line);
		if(!reverseDirection){
			// 右へ向かう場合(通常)
			if(dispLeft < line){
				triggerLine = line -  bao.internalWidth;
				return true;
			}else{
				return false;
			}
		}else{
			// 左へ向かう場合
			if(line < dispLeft){
				triggerLine = line;
				return true;
			}else{
				return false;
			}
		}
	}

	function setTriggerLine2(line)
	{
		if(!reverseDirection){
			// 右へ向かう場合(通常)
			var p = (owner.players.count==1 || owner.players[0].rootX > owner.players[1].rootX)? owner.players[0]: owner.players[1];
			if(dispLeft + p.rootX < line){
				triggerLine2 = line;
				return true;
			}else{
				return false;
			}
		}else{
			// 左へ向かう場合
			var p = (owner.players.count==1 || owner.players[0].rootX < owner.players[1].rootX)? owner.players[0]: owner.players[1];
			if(line < dispLeft + p.rootX){
				triggerLine2 = line;
				return true;
			}else{
				return false;
			}
		}
	}

	function getAltitude(x, y, c)
	{
		// 画面上の座標 x, y に対して高さを返す

		var h = floorBottom;

		if(int(dispLeft + x) < 0){
			if(limitLeft){
				return 500;
			}else{
				return 0;
			}
		}
		if(limitRight && int(dispLeft + x) >= (wallLayer.width / (bao.cZoomRate/bao.sZoomRate))) return 500;

		for(var i=0; i<floorLayers.count; i++){
			var l = floorLayers[i];
			var lx = (int(dispLeft + x - l.xOffset)) * (owner.cZoomRate / owner.sZoomRate); // 画面上の座標をレイヤー上の座標に変換
			var ly = (int(y) - l.yOffset) * (owner.cZoomRate / owner.sZoomRate);
//dm("c : " + c + " / i : " + i + " / x : " + x + " / y : " + y + " / lx : " + lx + " / ly : " + ly + " / l.imageWidth : " + l.imageWidth);
			if(0<lx && lx<l.imageWidth && 0<ly && ly<l.imageHeight){
				if(l.getMaskPixel(lx, ly) > 128){
					h = 0;
					break;
				}
			}
		}

		// オブジェクトについても考慮
		var oh = 0;
		var o = getObject(x, y, c);
		if(o !== void){
			oh = o.getAltitude(x, y);
//			if(oh > 0) return oh;
			return oh;
		}

		return h;

	}

	function showAltitude()
	{
		// デバッグ用関数
		var l = kag.fore.layers[0];
		l.visible = true;
		l.loadImages(%["storage"=>"_tr"]);
		l.setSizeToImageSize();
		l.opacity = 128;

		for(var j=0;j<owner.internalHeight; j++){
			for(var i=0;i<owner.internalWidth; i++){
				if(getAltitude(i, j, 0)==0){
					l.fillRect(i*owner.cZoomRate, j*owner.cZoomRate, owner.cZoomRate, owner.cZoomRate, 0xffff0000);
				}else{
					l.fillRect(i*owner.cZoomRate, j*owner.cZoomRate, owner.cZoomRate, owner.cZoomRate, 0xff0000ff);
				}
			}
		}
	}



	function getFloorLayer(x, y)
	{
		// 画面上の座標 x, y に存在するfloorLayerを返す

		x = int(dispLeft + x);	// 画面上の座標をレイヤー上の座標に変換
		y = int(y);

		for(var i=0; i<floorLayers.count; i++){
			if(floorLayers[i].getMaskPixel(x, y) > 128) return floorLayers[i];
		}

		return void;
	}

	function getObject(x, y, c)
	{
		// 画面上の座標 x, y に存在するobjectを返す
		for(var i=0; i<floorObjects.count; i++){
			var o = floorObjects[i];
			switch (c){
				case clPlayer:
					if(!o.collisionPlayer) continue;
					break;
				case clEnemy:
					if(!o.collisionEnemy) continue;
					break;
				case clObject:
					if(!o.collisionObject) continue;
					break;
			}
			if(checkObject(o, x, y)) return o;
		}
		return void;
	}

	function checkObject(o, x, y)
	{
		// 画面上の座標 x, y に該当objectが存在するかどうか
		if(o.baseLayer===void) return false;
		if(x-o.objLeft>0 && x-o.objLeft<o.layer.asdWidth && y-o.objTop-o.altitude>0 && y-o.objTop-o.altitude<o.layer.asdHeight){
			if(o.baseLayer.getMaskPixel(int(x-o.objLeft), int(y-o.objTop-o.altitude)) > 128){
				return true;
			}
		}
		return false;
	}

	function getObject2(x, y)
	{
		// 座標x, y に存在するobjectをざっくりと返す
		for(var i=0; i<floorObjects.count; i++){
			var o = floorObjects[i];
			var l = floorObjects[i].layer;
			if(l.left<x && (l.top+o.objHeight)<y && x<(l.left+l.width) && y<(l.top+l.height)){
				return o;
			}
		}
		return void;
	}

	function floorObjectsSort()
	{
		// フロアオブジェクトの表示プライオリティソート
		for(var i=0; i<floorObjects.count; i++){
			var o1 = floorObjects[i];
			if(o1.absoluteSort){
				for(var j=0; j<floorObjects.count; j++){
					var o2 = floorObjects[j];
					if(o1 === o2) continue;
					if(!o2.absoluteSort) continue;
					if(o1.baseTop+o1.objDepth < o2.baseTop+o2.objDepth && o1.layer.absolute > o2.layer.absolute){
						floorObjects[i] <-> floorObjects[j];
						floorObjects[i].layer.absolute <-> floorObjects[j].layer.absolute;
					}
				}
			}
		}
	}


	function store()
	{
//		var dic = super.store();
		var dic = %[];

		dic.storage = storage;
		dic.scrollLineL = scrollLineL;
		dic.scrollLineR = scrollLineR;

		dic.floorLayers = [];
		for(var i=0; i<floorLayers.count; i++){
			dic.floorLayers[i] = floorLayers[i].store();
		}

		dic.floorObjects = [];
		for(var i=0; i<floorObjects.count; i++){
			dic.floorObjects[i] = floorObjects[i].store();
		}

		dic.avoidPoints = [];
		for(var i=0; i<avoidPoints.count; i++){
			dic.avoidPoints[i] = avoidPoints[i].store();
		}

		dic.triggerLine = triggerLine;
		dic.triggerLine2 = triggerLine2;
		dic.dLeft = dLeft;
		dic.scrollLimit = scrollLimit;
		dic.scrollLimitLeft = scrollLimitLeft;
		dic.topLine = topLine;
		dic.bottomLine = bottomLine;
		dic.floorBottom = floorBottom;
		dic.xFreeMode = xFreeMode;
		dic.scrollLockCount = scrollLockCount;
		dic.scrollSpeedLimit = scrollSpeedLimit;
		dic.scrollSpeed = scrollSpeed;

		dic.limitright = limitRight;
		dic.limitLeft = limitLeft;

		dic.setTop = setTop;
		dic.dispTop = dispTop;

		dic.reverseDirection = reverseDirection;

		return dic;
	}

	function restore(dic)
	{
		if(dic.storage != ""){
			storage = dic.storage;
//			super.restore(dic);
			loadImages(dic);
		}

		scrollLineL =dic. scrollLineL;
		scrollLineR =dic. scrollLineR;

		avoidPoints = [];
		for(var i=0; i<dic.avoidPoints.count; i++){
			var p = new Position();
			p.restore(dic.avoidPoints[i]);
			avoidPoints.add(p);
		}

		triggerLine = dic.triggerLine;
		triggerLine2 = dic.triggerLine2;
		dLeft = dic.dLeft;
		scrollLimit = dic.scrollLimit;
		scrollLimitLeft = dic.scrollLimitLeft;
		topLine = dic.topLine;
		bottomLine = dic.bottomLine;
		floorBottom = dic.floorBottom;
		xFreeMode = dic.xFreeMode;
		scrollLockCount = dic.scrollLockCount;
		scrollSpeedLimit = dic.scrollSpeedLimit;
		scrollSpeed = dic.scrollSpeed;

		limitRight = dic.limitright;
		limitLeft = dic.limitLeft;

		setTop = dic.setTop;
		dispTop = dic.dispTop;

		srcWidth = owner.width \ owner.sZoomRate;
		srcHeight = owner.height \ owner.sZoomRate;

		if(dic.reverseDirection !== void) reverseDirection = dic.reverseDirection;

		floorLayers = [];
		for(var i=0; i<dic.floorLayers.count; i++){
			var l = new FloorLayer(window, wallLayer, this);
			l.restore(dic.floorLayers[i]);
			wallLayer.operateRect(l.dispXOffset, l.dispYOffset, l, 0, 0, l.imageWidth, l.imageHeight, omAuto, 255);
			floorLayers.add(l);
		}

		floorObjects = [];
		for(var i=0; i<dic.floorObjects.count; i++){
			var l = new FloorObject(window, owner, dic);
			l.restore(dic.floorObjects[i]);
			floorObjects.add(l);
//			addFloorObject(dic);
			if(typeof(l.layer.colorParams.return)!="undefined"){
				Scripts.eval(l.layer.colorParams.return + " = bao.stageLayer.floorObjects[bao.stageLayer.floorObjects.count-1]");
			}
		}
	}

	property dispLeft
	{
		setter(l)
		{
			if(l < 0) l = 0;
			if(l > scrollLimit - bao.internalWidth) l = scrollLimit - bao.internalWidth;

			var d = dLeft - l;
			dLeft = l;
			if(dLeft < 0) dLeft = 0;

			wallLayer.left = -dLeft * (bao.cZoomRate/bao.sZoomRate);

//			for(var i=0; i<floorLayers.count; i++)
//				floorLayers[i].setPos(wallLayer.left, wallLayer.top);

//			dm("dLeft : " + dLeft + " / l : " + l + " / d : " + d);
			for(var i=0; i<floorObjects.count; i++)
				if(!floorObjects[i].ignoreScroll) floorObjects[i].baseLeft += d;

			for(var i=0; i<avoidPoints.count; i++)
				avoidPoints[i].x += d;

		}
		getter()
		{
			return dLeft;
		}
	}

	property internalWidth
	{
		getter()
		{
			return wallLayer.width / (bao.cZoomRate/bao.sZoomRate);
		}
	}

//	property dispTop
//	{
//		setter(t)
//		{
//			wallLayer.top = -t * (bao.cZoomRate/bao.sZoomRate);
//
////			for(var i=0; i<floorLayers.count; i++)
////				floorLayers[i].setPos(wallLayer.left, wallLayer.top);
//		}
//
//		getter()
//		{
//			return -top;
//		}
//
//	}

}


class FloorLayer extends Layer
{
	var storage;
	var xOffset = 0;
	var yOffset = 0;

	var owner;
	var root;

	function FloorLayer(window, parent, owner, elm)
	{
		this.owner = owner;
		root = owner.owner;
		super.Layer(window, parent);

		if(elm===void) return;
		if(elm.left!==void) xOffset = +elm.left;
		if(elm.top!==void) yOffset = +elm.top;
		setPos(dispXOffset, dispYOffset);
	}

	function finalize()
	{
		visible = false;
		super.finalize();
	}

	function loadImages(st){
		storage = st;
		super.loadImages(root.fHeader2 + storage);
		name = root.fHeader2 + storage;
	}

	function store()
	{
		var dic = %[];

		dic.storage = storage;
		dic.xOffset = xOffset;
		dic.yOffset = yOffset;

		dic.left = left;
		dic.top = top;
		dic.width = width;
		dic.height = height;
		dic.imageWidth = imageWidth;
		dic.imageHeight = imageHeight;
		dic.opacity = opacity;
		dic.visible = visible;
		dic.imageLeft = imageLeft;
		dic.imageTop = imageTop;
		dic.absolute = absolute;
		dic.type = type;

		return dic;
	}

	function restore(dic)
	{
		storage = dic.storage;
		xOffset = dic.xOffset;
		yOffset = dic.yOffset;

		loadImages(storage);
		setSizeToImageSize();

		left = dic.left;
		top = dic.top;
//		width = dic.width;
//		height = dic.height;
//		imageWidth = dic.imageWidth;
//		imageHeight = dic.imageHeight;
		opacity = dic.opacity;
		visible = dic.visible;
		imageLeft = dic.imageLeft;
		imageTop = dic.imageTop;
		absolute = dic.absolute;
		type = dic.type;

		super.setPos(dispXOffset, dispYOffset);

	}

	property dispLeft{
		getter(){
			return internalLayerLeft * (root.cZoomRate / root.sZoomRate);
		}
	}

	property dispTop{
		getter(){
			return internalLayerTop * (root.cZoomRate / root.sZoomRate);
		}
	}

	property dispXOffset{
		getter(){
			return xOffset * (root.cZoomRate / root.sZoomRate);
		}
	}

	property dispYOffset{
		getter(){
			return yOffset * (root.cZoomRate / root.sZoomRate);
		}
	}

}


class FloorObject extends Sprite
{
	var storage;
	var baseLayer;
	var shadowLayer;

	var objHeight;
	var objDepth;
	var objLeft;
	var objTop;

	var bTop;
	var bLeft;

	var hOffset = 0;

	var whichFace;
	var shadow = false;

	// 当たり判定があるかどうか
	var hitCollision = false;
	var hitPlayer = void;

	// キャラクタとの当たり判定があるかどうか
	var collisionPlayer = true;
	var collisionEnemy = true;
	var collisionObject = true;

	// 高さを返すかどうか（falseにするとgetAltitudeで0が返る）
	var altitudeFlag = true;

	// 表示プライオリティのソートをするかどうか
	var absoluteSort = false;

	// ベースレイヤーの読み込み無視
	var ignoreBaseLayer = false;

	// スクロールを無視するかどうか
	var ignoreScroll = false;

	var tags = "";
	var onObjects = [];

	// 画面外にあるとき、処理を強制するか（通常は画面外のオブジェクトは処理しない）
	var enforceRefresh = false;

	// 影描画の強制をするか（通常はbao.shadowLayerのコピーで済ませる）
	var enforceDrawShadow = false;

	// このオブジェクトのある高さ位置
	var altitude = 0;
	var altitudeDelta = 0;
	// フロアより下にある(altitudeが負)
	var underFloorFlag = false;

	function FloorObject(window, parent, elm)
	{
		storage = elm.storage;

		super.Sprite(window, parent, elm);

		if(elm.baseleft !== void) baseLeft = +elm.baseleft - owner.stageLayer.dispLeft;
//		dm("elm.baseleft : " + elm.baseleft + " / owner.stageLayer.dispLeft : " + owner.stageLayer.dispLeft);
		if(elm.basetop !== void) baseTop = +elm.basetop;
		if(elm.hitcollision !== void) hitCollision = +elm.hitcollision;

		layer.visible = true;

		if(elm.shadow !== void) shadow = +elm.shadow;
		if(elm.ignorebaselayer !== void) ignoreBaseLayer = +elm.ignorebaselayer;

//		setBaseLayer();

		whichFace = fcRight;

		if(elm.collisionplayer !== void) collisionPlayer = +elm.collisionplayer;
		if(elm.collisionenemy !== void) collisionEnemy = +elm.collisionenemy;
		if(elm.collisionobject !== void) collisionObject = +elm.collisionobject;

		if(elm.altitude !== void) altitude = +elm.altitude;
	}

	function finalize()
	{
		if(baseLayer !== void){
			baseLayer.visible = false;
			invalidate baseLayer;
		}
		if(shadowLayer !== void){
			shadowLayer.visible = false;
			invalidate shadowLayer;
		}

		super.finalize();
	}

	function loadImages(elm)
	{
		storage = elm.storage;
		super.loadImages(%["storage"=>storage]);

		if(elm.shadow !== void) shadow = +elm.shadow;
	}

	function setBaseLayer()
	{
		if(baseLayer === void){
			baseLayer = new Layer(window, layer);
			baseLayer.visible = false;
			baseLayer.name = 'baseLayer';
		}

		if(!ignoreBaseLayer && Storages.isExistentStorage(storage + "_b.png")){
			ignoreBaseLayer = false;
			baseLayer.loadImages(storage + "_b");
			baseLayer.setSizeToImageSize();

			if(shadowLayer === void && objHeight<150){
				shadowLayer = new Layer(window, layer);
				shadowLayer.visible = true;
				shadowLayer.opacity = 128;
				shadowLayer.name = 'shadowLayer';
				shadowLayer.setSize(layer.dispWidth, layer.dispHeight);

				if(owner.shadowLayer.maskLayers[storage] === void){
					var tmpLayer = new Layer(window, owner.shadowLayer);
					tmpLayer.setSize(baseLayer.width * owner.cZoomRate, baseLayer.height * owner.cZoomRate);
					tmpLayer.stretchCopy(0, 0, tmpLayer.width, tmpLayer.height, baseLayer, 0, 0, baseLayer.width, baseLayer.height, stNearest);
					tmpLayer.name = storage;
					owner.shadowLayer.pushShadowMask(storage, tmpLayer);
				}
			}

		}else{
			baseLayer.setSize(layer.asdWidth, layer.asdHeight);
			baseLayer.fillRect(0, 0, layer.asdWidth, layer.asdHeight, 0x00000000);
		}
	}

	function onRefreshFrame(){
		if(!enforceRefresh && (layer.left+layer.width<0 || layer.left>owner.width)) return;

		for(var j=0; j<owner.players.count; j++){
			if(owner.players[j] !== void){
				var ary = [];
				ary.assign(layer.triggerRect);
				for(var i=0; i<ary.count; i+=2){
					var r = layer.toGlobalRect(ary[i+1]);
					if(r.includedPos(owner.players[j].rootX, owner.players[j].rootY)){
						layer.trigger(ary[i], owner.players[j]);
					}
				}
			}
		}
		super.onRefreshFrame();

		if(int(altitudeDelta) != 0){
			altitude += altitudeDelta;
			baseTop =bTop;
			for(var i=0; i<onObjects.count; i++){
				onObjects[i].altitude = altitude;
			}
			altitudeDelta = 0;
		}
		onObjects = [];

		underFloor();
	}

	function underFloor()
	{
		var s = owner.stageLayer;
		
		if(int(altitude) < 0 && s.floorLayers.count > 0){
			// 床面よりも下にいる→被さる部分のフロアレイヤーをコピーする
			for(var i=0; i<s.floorLayers.count; i++){
				var l = s.floorLayers[i];
				if(owner.stageLayer.dispLeft+baseLeft+layer.asdWidth < l.xOffset+l.width\2 ){
					if(i==0) break;
					var l2 = s.floorLayers[i-1];
					var sLeft = (owner.stageLayer.dispLeft + baseLeft - l2.xOffset) * (owner.cZoomRate/owner.sZoomRate);
					var sTop  = (objTop - l2.yOffset) * (owner.cZoomRate/owner.sZoomRate);

					if(!layer.zoomMode){
						layer.loadImagesSub(layer.graphic, %[]);
					}

					var m = owner.shadowLayer.maskLayers[storage];
					if(!layer.zoomMode){
						layer.face = dfMask;
						layer.fillRect(0, altitude*bao.cZoomRate+m.height, layer.dispWidth, -altitude*bao.cZoomRate, 0);
						layer.face = dfAuto;
						layer.clipAlphaRect(0, altitude*bao.cZoomRate, m, 0, 0, m.width, m.height);
						layer.type = ltAlpha; // 無いとは思うけど下手に覆い焼きとかになると不都合なので
						shadowLayer.face = dfMask;
						shadowLayer.fillRect(0, altitude*bao.cZoomRate+m.height, layer.dispWidth, -altitude*bao.cZoomRate, 0);
						shadowLayer.face = dfAuto;
						shadowLayer.clipAlphaRect(0, altitude*bao.cZoomRate, m, 0, 0, m.width, m.height);
					}else{
						layer.stretchCopy(0, 0, layer.dispWidth, layer.dispHeight, layer.bufLayer, layer.dl*layer.internalWidth, layer.dt*layer.internalHeight, layer.internalWidth, layer.internalHeight, stNearest);
						layer.face = dfMask;
						layer.fillRect(0, altitude*bao.cZoomRate+m.height, layer.dispWidth, -altitude*bao.cZoomRate, 0);
						layer.face = dfAuto;
						layer.clipAlphaRect(0, altitude*bao.cZoomRate, m, 0, 0, m.width, m.height);
						layer.type = ltAlpha; // 無いとは思うけど下手に覆い焼きとかになると不都合なので
						shadowLayer.face = dfMask;
						shadowLayer.fillRect(0, altitude*bao.cZoomRate+m.height, layer.dispWidth, -altitude*bao.cZoomRate, 0);
						shadowLayer.face = dfAuto;
						shadowLayer.clipAlphaRect(0, altitude*bao.cZoomRate, m, 0, 0, m.width, m.height);
					}

					underFloorFlag = true;
					break;
				}
			}
		}else{
			if(underFloorFlag){
				underFloorFlag = false;
				if(!layer.zoomMode){
					layer.loadImagesSub(layer.graphic, %[]);
				}else{
					layer.stretchCopy(0, 0, layer.dispWidth, layer.dispHeight, layer.bufLayer, layer.dl*layer.internalWidth, layer.dt*layer.internalHeight, layer.internalWidth, layer.internalHeight, stNearest);
				}
			}
		}
	}


	function drawShadow(){
		if(objDepth == 0) return;
		if(shadowLayer === void) return;

		if(objHeight == 0 && !enforceDrawShadow){
			// shadowLayerのコピー
			shadowLayer.copyRect(0, 0, owner.shadowLayer, baseLeft*owner.cZoomRate, baseTop*owner.cZoomRate, layer.width, layer.height);
			var m = owner.shadowLayer.maskLayers[storage];
			// shadowLayerをマスク
			if(m !== void){
				shadowLayer.clipAlphaRect(0, 0, m, 0, 0, m.width, m.height);
			}
		}else{
			// shadowLayerをマスク（shadowLayerの描画自体はCharacterSprite内のshadowToFloorObject()で行っている）
			var m = owner.shadowLayer.maskLayers[storage];
			if(m !== void){
				shadowLayer.clipAlphaRect(0, 0, m, 0, objHeight*owner.cZoomRate, m.width, m.height, 0);
			}
		}
	}

	function getAltitude(x, y)
	{
		// 画面上の座標 x, y に対して高さを返す

		x = int(x - objLeft);	// 画面上の座標をレイヤー上の座標に変換
		y = int(y - objTop - altitude);

		if(baseLayer.getMaskPixel(x, y) > 128 && altitudeFlag){
			return objHeight + altitude;
		}

		return 0;
	}

	function setTags(elm)
	{
		tags = "";
		if(elm.speed !== void) tags = "[eval exp=\"sprite.rootX+=" + elm.speed + "\"]";
		if(elm.vspeed !== void) tags = "[eval exp=\"sprite.rootY+=" + elm.vspeed + "\"]";
		if(elm.tags !== void) tags += elm.tags;
	}

	function beltScroll(src, x, y)
	{
		layer.operateRect(0, 0, src, x, y, layer.width, layer.height, omAuto);
	}

	function fillBaseLayer(col)
	{
		baseLayer.fillRect(0, 0, baseLayer.width, baseLayer.height, col);
	}

	function store()
	{
		var dic = super.store();

		dic.storage = storage;
		dic.objHeight = objHeight;
		dic.objDepth = objDepth;
		dic.objLeft = objLeft;
		dic.objTop = objTop;
		dic.bLeft = bLeft;
		dic.bTop = bTop;
		dic.hOffset = hOffset;
		dic.whichFace = whichFace;
		dic.tags = tags;
		dic.ignoreBaseLayer = ignoreBaseLayer;
		dic.ignoreScroll = ignoreScroll;

		dic.collisionPlayer = collisionPlayer;
		dic.collisionEnemy = collisionEnemy;
		dic.collisionObject = collisionObject;

		dic.enforceRefresh = enforceRefresh;
		dic.enforceDrawShadow = enforceDrawShadow;
		dic.absoluteSort = absoluteSort;

		dic.altitude = altitude;

		return dic;
	}

	function restore(dic)
	{
		super.restore(dic);

		storage = dic.storage;
		objHeight = dic.objHeight;
		objDepth = dic.objDepth;
		objLeft = dic.objLeft;
		objTop = dic.objTop;
		bLeft = dic.bLeft;
		bTop = dic.bTop;
		hOffset = dic.hOffset;
		whichFace = dic.whichFace;
		tags = dic.tags;
		ignoreBaseLayer = dic.ignoreBaseLayer;
		ignoreScroll = dic.ignoreScroll;

		collisionPlayer = dic.collisionPlayer;
		collisionEnemy = dic.collisionEnemy;
		collisionObject = dic.collisionObject;

		altitude = dic.altitude;

//		loadImages(%['storage'=>storage]);

		if(objDepth > 0){
			setBaseLayer(ignoreBaseLayer);
		}

		if(dic.enforceRefresh !== void) enforceRefresh = dic.enforceRefresh;
		if(dic.enforceDrawShadow !== void) enforceDrawShadow = dic.enforceDrawShadow;
		if(dic.absoluteSort !== void) absoluteSort = dic.absoluteSort;

	}

	function setPos(x, y)
	{
		if(x !== void) baseLeft = x - owner.stageLayer.dispLeft;
		if(y !== void) baseTop = y;
	}

	property baseLeft
	{
		setter(x)
		{
			bLeft = objLeft = x;
			layer.left = bLeft * bao.cZoomRate;
		}
		getter()
		{
			return bLeft;
		}
	}

	property baseTop
	{
		setter(y)
		{
			bTop = y;
			objTop = bTop - objHeight + hOffset - altitude;
			layer.top = objTop * bao.cZoomRate;
		}
		getter()
		{
			return bTop;
		}
	}


}


class ObjectSprite extends CharacterSprite
{
	var overlapQueue = "";
	var hitQueue = "";

	var attackToPlayer = true;
	var attackToEnemy = true;
	var attackToObject = false;

	var absoluteOffset = 0;

	var generatedFrom = void;
//	var originObjectClass;
//	var originIndex;
	var generatedFrom_reference;

	var type = objNormal;

	// attackRectを記録しておく
	var attackRectBuf = [];

	// 攻撃するか決めるコンダクタ
	var attackConductor;

	function ObjectSprite(window, owner, elm)
	{
		objectClass = clObject;
		shadow = false;
		inverseMode = false;
		floorObjectCollision = false;
		if(elm.overlaptag !== void) overlapQueue = elm.overlaptag;
		if(elm.kind !== void) kind = elm.kind;

		super.CharacterSprite(window, owner, elm);
		layer.name = elm.storage;
	}

	function finalize()
	{
		if(attackConductor !== void) invalidate attackConductor;
		if(parentSprite !== void && isvalid parentSprite){
			parentSprite.childSprites.remove(this);
		}
		super.finalize();
	}

	function setState(elm){

		super.setState(elm);

		if(elm.generatedFrom !== void) generatedFrom = elm.generatedFrom;
//		if(elm.originObjectClass !== void) originObjectClass = elm.originObjectClass;
//		if(elm.originIndex !== void) originIndex = elm.originIndex;
	}

	function onRefreshFrame(h, v){

		if(!ignoreScroll) hScrollVal = h;
		if(!ignoreScroll) vScrollVal = v;

		if(movingTableCopyFrom !== void && movingTableCopyFrom.movingTableBuffer[movingTableCopyIndex] !== void){
			movingTable[0] = movingTableCopyFrom.movingTableBuffer[movingTableCopyIndex];
			movingTableCopyIndex ++;
//		}else{
//			movingTableCopyIndex = 0;
		}

		layer.onRefreshFrame();
		routineProcess();

		// ヒット判定
		if(damage.strength > 0 && !deleteFlag && kind!="e99"){
			putHitMark(damage.hitPos, hitMarkStorage[0]);
			if(hitQueue != "") addQueue(hitQueue);
			layer.trigger('hit', damageFrom);
			damage.strength = 0;
		}

		// 攻撃判定
		if(!attackRect.isEmpty()){
			if(attackToPlayer){
				for(var i=0; i<owner.players.count; i++){
					if(owner.players[i] !== void && owner.players[i].HP > 0){
						if(checkAttackCollision(owner.players[i])) layer.trigger('pattack', owner.players[i]);
					}
				}
			}
			if(attackToEnemy){
				for(var i=0; i<owner.enemies.count; i++){
					if(parentSprite === owner.enemies[i]) continue; // 自分の電撃で自分がやられる等を防ぐ
					if(checkAttackCollision(owner.enemies[i])) layer.trigger('eattack', owner.enemies[i]);
				}
			}
			if(attackToObject){
				for(var i=0; i<owner.objects.count; i++) if(owner.objects[i]!==this) checkAttackCollision(owner.objects[i]);
			}
		}

		// 重なり判定
		for(var i=0; i<owner.players.count; i++){
			if(owner.players[i]!==void && checkOverlap(owner.players[i])){
				if(overlapQueue != "") addQueue(overlapQueue);
				layer.trigger('poverlap', owner.players[i]);
			}
		}
		for(var i=0; i<owner.enemies.count; i++){
			if(checkOverlap(owner.enemies[i])){
				if(overlapQueue != "") addQueue(overlapQueue);
				layer.trigger('eoverlap', owner.enemies[i]);
			}
		}

		if(movingTable.count>0) movingTable.erase(0);

		vOffset -= vScrollVal;
//		layer.left = internalLayerLeft * bao.cZoomRate;
//		layer.top = internalLayerTop * bao.cZoomRate;
		adjustDisp();

		setAbsolute(int(rootY)+absoluteOffset);

	}

	function routineProcess()
	{
		super.routineProcess();

		var mt = new MovingTable();
		if(movingTable[0] !== void) mt = movingTable[0];

		// 床オブジェクトの上に乗っているとき、特定の動作が存在すればそうする
		onFloorObject = getObject(rootX, rootY);
		if(onFloorObject!==void && int(altitude)==onFloorObject.objHeight+onFloorObject.altitude){
			onFloorObject.onObjects.add(this);
			if(onFloorObject.tags!=""){
				addQueue(onFloorObject.tags);
			}
		}

		// 影の処理
		shadowToFloorObject();

		// 移動処理
		if(floorObjectCollision) checkFloorObjectCollision(mt);
		if(!noGravity) mt = checkFall(mt);
		move(mt);
		lastMovingTable.set(mt);

	}

	function move(mt)
	{
		if(inverseMode){
			var x = getPlayersCenterX();
			if(rootX < x - 10){
				inverse = true;
				if(inverse != layer.inverse) setLayerInverse();
			}else if(x + 10 < rootX){
				inverse = false;
				if(inverse != layer.inverse) setLayerInverse();
			}
		}

		var x = mt.x + rootX - hScrollVal;
		var y = mt.y + rootY;
		var h = mt.h + altitude;

		if(floorObjectCollision && int(altitude) < getAltitude(x, y)){
			layer.trigger('floorobjectcollision');
			if(int(altitude) == getAltitude(x+((mt.x>0)?1:0) - ((mt.x<0)?1:0), y)){
				// 地形引っかかり軽減
				x += ((mt.x>0)?1:0) - ((mt.x<0)?1:0);
			}else if(int(altitude) == getAltitude(x, y+((mt.y>0)?1:0) - ((mt.y<0)?1:0))){
				// 地形引っかかり軽減
				y += ((mt.y>0)?1:0) - ((mt.y<0)?1:0);
			}else{
				// 地形により進めない
				x = rootX - hScrollVal;
				y = rootY;
			}
		}

//		if(y < bao.stageLayer.topLine || y > bao.stageLayer.bottomLine){
//			layer.trigger('yrangeout');
//		}

		if(movableRect !== void && !ignoreMovableRect){
			if(!movableRect.includedPos(x, y)){
				if(x < movableRect.left)   x = movableRect.left;
				if(x > movableRect.right)  x = movableRect.right;
				if(y < movableRect.top)    y = movableRect.top;
				if(y > movableRect.bottom) y = movableRect.bottom;
			}
		}

		if(!ignoreMovableRect && y < bao.stageLayer.topLine && bao.stageLayer.topLine !== void) y = bao.stageLayer.topLine;
		if(!ignoreMovableRect && y > bao.stageLayer.bottomLine && bao.stageLayer.bottomLine !== void) y = bao.stageLayer.bottomLine;

		rootX = x;
		rootY = y;
		altitude = h;

	}

	function checkOverlap(obj)
	{
		if(layer.onTriggerTarget['poverlap']===void && layer.onTriggerTarget['eoverlap']===void) return false;

		// 判定範囲
		var r = new Rect2(internalLayerLeft, internalLayerTop, internalLayerLeft+layer.asdWidth, internalLayerTop+layer.asdHeight);
		if(obj === void) return false;

		// 高さが違えば判定しない
		if(int(altitude) != int(obj.altitude)) return false;
		// 画面外なら判定しない
		if(obj.rootX < 0 || obj.rootX > owner.internalWidth) return false;
		// 相手が死んでたら判定しない
		if(obj.HP <= 0) return false;;

		var pr = new Rect2(obj.rootX-obj.centerPos+obj.hitRect.left, obj.rootY-obj.altitude-8, obj.rootX-obj.centerPos+obj.hitRect.left+obj.hitRect.width, obj.rootY-obj.altitude);

		if(r.intersects(pr)){
			return true;
		}

		return false;
	}

	function checkAttackCollision(obj)
	{
		if(obj.HP!==void && obj.HP<=0) return false;
		if(obj.invincibleCount > 0) return false;
		if(obj.hitRect.isEmpty()) return false;

		if(attackRect.isEmpty()) return false;
		var r1 = new Rect2(attackRect);
		r1.addOffset(internalLayerLeft, internalLayerTop);

		var line = new Rect2(-100, rootY - depth1, owner.internalWidth+100, rootY + depth2);
		if(!line.includedPos(obj.rootX, obj.rootY)) return false;
		if(obj.damage.tick >= attack.tick) return false;

		if(obj.nowSpriteId==stDamage2 && (attack.kind&atkEnablePursue)!=atkEnablePursue) return false;
		if(obj.nowSpriteId == stDown) return false;


		var r2 = new Rect2(obj.hitRect);
		r2.addOffset(obj.internalLayerLeft, obj.internalLayerTop);
		r2.addOffset(0, rootY-obj.rootY);

		if(r1.intersects(r2)){
			if(parentSprite !== void && isvalid parentSprite && parentSprite.objectClass != clEnemy){
				// parentSpriteがプレイヤー（ヒロインキャラ）だった場合
				for(var i=0; i<owner.players.count; i++){
					var p = owner.players[i];
					if((p === parentSprite || p === parentSprite.parentSprite) && p.comboCountFlag){
						if(obj.objectClass == clEnemy){
							obj.targetPlayer = p;
							p.comboCount++;
						}
						p.attackTick = owner.tickCount;
						if(p === bao.nowSelectingPlayer) f.score += 100 * 2;
					}
				}
			}
			if(kind != ''){
				for(var i=0; i<owner.players.count; i++){
					var p = owner.players[i];
					if(p === owner.nowSelectingPlayer && p.chara == chrChiffon && kind == 'chiffon') f.score += 100 * 2;
					if(p === owner.nowSelectingPlayer && p.chara == chrChocolat && kind == 'chocolat') f.score += 100 * 2;
				}
			}

			layer.trigger('attack');
			obj.damageFrom = this;
			obj.damageFromStr = kind;
			obj.damage.set(attack);
			if(attackTick != attackIndexCountUpTick){
				attackIndexCountUpTick = attackTick;
				attackIndex++;
			}
			var tmp1 = getIntersectRect(r1, r2);
			var tmp2 = (rootY > obj.rootY)? rootY : obj.rootY;
			var abs = (layer.absolute > obj.layer.absolute)? layer.absolute : obj.layer.absolute;
			obj.damage.hitPos.x = -200;
			obj.damage.hitPos.y = -200;
			obj.setHitMark(tmp1.centerX, tmp2, tmp2-tmp1.centerY);
			if(obj.objectClass == clEnemy){
				if((attack.kind&atkEnablePursue)==atkEnablePursue && obj.pursueFrom!==this && parentSprite !== void && isvalid parentSprite && parentSprite.objectClass == clPlayer){
					if(obj.pursueFrom!==void){
						obj.pursueCount++;
					}
					obj.pursueFrom = this;
				}
			}
			return true;
		}
		return false;
	}

	function getRootSprite()
	{
		var o = parentSprite;
		while(o !== void && isvalid o){
			o = o.parentSprite;
		}
		return o;
	}

	function attackRectBufSet()
	{
		try
		{
			if(attackConductor == void) attackConductor = new AttackAlgorithmConductor(this);

			attackConductor.assign(layer.conductor);
			attackConductor.attackRectBufSet();
		}
		catch(e)
		{
			throw new Exception("error this : " + this + " / layer.asd : " + layer.asd + ":" + attackConductor.curLine + "\n" + e.message);
		}
		return false;
	}

	function store()
	{
		var dic = super.store();
		dic.overlapQueue = overlapQueue;
		dic.objectType = type;

		dic.attackToPlayer = attackToPlayer;
		dic.attackToEnemy  = attackToEnemy;
		dic.attackToObject = attackToObject;
		dic.absoluteOffset = absoluteOffset;

		dic.overlapQueue = overlapQueue;
		dic.hitQueue = hitQueue;

//		if(originObjectClass !== void) dic.originObjectClass = originObjectClass;
//		if(originIndex !== void) dic.originIndex = originIndex;

		if(generatedFrom !== void && isvalid generatedFrom){
			generatedFrom_reference = new ObjectReference(generatedFrom);
			dic.generatedFrom_reference = generatedFrom_reference.store();
		}

		return dic;
	}

	function restore(dic)
	{

		var storage = dic.layer.noHeaderGraphicName;
		if(storage[0] == 'p' && (storage[1] == '0' || storage[1] == '1')){
			var asd = dic.layer.asd;
			if(dic.layer.loadParams.directspecify && Storages.isExistentStorage(asd + ".png")){
				dic.layer.noHeaderGraphicName = asd;
			}else{
				var s1 = storage.substring(0, 2);
				var s2 = storage.substring(3);
				if(sf.adjEvilCosMode){
					storage = s1 + string(sf.adjCosVariation) + s2;
				}else{
					storage = s1 + "0" + s2;
				}
				if(Storages.isExistentStorage(storage + ".png")){
					dic.layer.noHeaderGraphicName = storage;
				}
			}
		}

		super.restore(dic);
		overlapQueue = dic.overlapQueue;
		type = dic.objectType;

		attackToPlayer = dic.attackToPlayer;
		attackToEnemy  = dic.attackToEnemy;
		attackToObject = dic.attackToObject;
		absoluteOffset = dic.absoluteOffset;

		overlapQueue = dic.overlapQueue;
		hitQueue = dic.hitQueue;

		generatedFrom_reference = void;
		if(dic.generatedFrom_reference !== void){
			generatedFrom_reference = new ObjectReference(dic.generatedFrom_reference);
		}

//		if(dic.originObjectClass !== void) originObjectClass = dic.originObjectClass;
//		if(dic.originIndex !== void) originIndex = dic.originIndex;
//		if(originObjectClass !== void && originIndex !== void){
//			var o = owner.getObjectFromObjectClassAndIndex(originObjectClass, originIndex);
//			generatedFrom = o.layer.conductor;
//		}

//		dm("----");
//		dm("layer.graphic : " + layer.graphic);
//		dm("centerPos : " + centerPos);
//		dm("altitude : " + altitude);
//		dm("layer.conductor.currentLabel : " + layer.conductor.currentLabel);
	}

	function restore2()
	{
		super.restore2();

		if(generatedFrom_reference !== void){
			generatedFrom = generatedFrom_reference.getObject();
			invalidate generatedFrom_reference;
			generatedFrom_reference = void;
		}
	}

}


class EffectSprite extends ObjectSprite
{
	var xOffset = 0;
	var yOffset = 0;
	var hOffset = 0;
	var aOffset = void;

	var followParent = true;
	var ignoreFollowX = false;
	var ignoreFollowY = false;
	var ignoreFollowH = false;

	// 親スプライトが削除されたりしても無視するか
	var ignoreParentDelete = false;

//	var parentObjectClass = 0;
//	var parentObjectIndex = 0;

	var movingTable2 = [];
	var parentSpriteId;

	// 削除条件式
	var deleteExp = "";

	// opacity2がゼロになったら消去するか
	var deleteAtOpacity2Zero = true;
	var ignoreParentSpriteIdChange = true;

	function EffectSprite(window, owner, elm)
	{
//		var parent = elm.parent;
//
//		if(elm.parent !== void){
//			parent = elm.parent;
//			parentObjectClass = parent.objectClass;
//		}else{
//			parent = elm.parent = bao.getObjectFromObjectClassAndIndex(elm.parentObjectClass, elm.parentObjectIndex);
//		}
//		parentSpriteId = parent.nowSpriteId;

		if(elm.parent !== void){
			parentSpriteId = elm.parent.nowSpriteId;

			var parent = elm.parent;
			elm.rootx = (elm.xoffset !== void)? (parent.rootX + (+elm.xoffset) * xDirection(parent.inverse)) : ((elm.rootx !== void)? (+elm.rootx) : parent.rootX);
			elm.rooty = (elm.yoffset !== void)? (parent.rootY + (+elm.yoffset)) : ((elm.rooty !== void)? (+elm.rooty) : (parent.rootY + 1));
			elm.altitude = (elm.hoffset !== void)? (parent.altitude + (+elm.hoffset)) : ((elm.altitude!==void)? +elm.altitude : parent.altitude);
			elm.absolute = (elm.aoffset !== void)? (parent.layer.absolute + (+elm.aoffset) + 1) : ((elm.absolute!==void)? +elm.absolute : void);
			elm.inverse = (elm.inverse !== void)? int(+elm.inverse) : parent.inverse;
			parentSprite = parent;

			if(elm.kind === void) elm.kind = parent.kind;
		}

		if(elm.type === void) elm.type = ltPsHardLight; else elm.type = Scripts.eval(elm.type);
		elm.shadow = (elm.shadow !== void)? int(+elm.shadow) : false;

		if(elm.altitude < fAltitude) elm.altitude = fAltitude;

//dm("this : " + this + " / elm.yoffset : " + elm.yoffset + " / elm.rooty : " + elm.rooty + " / elm.altitude : " + elm.altitude + " / altitide : " + altitude);

		if(elm.follow !== void) followParent = +elm.follow;
		xOffset = +elm.xoffset * xDirection(elm.inverse);
		yOffset = +elm.yoffset;
		hOffset = +elm.hoffset;
		if(elm.aoffset !== void) aOffset = +elm.aoffset;

		super.ObjectSprite(...);
		objectClass = clEffect;
	}

	function onRefreshFrame(h, v){
		hScrollVal = h;
		vScrollVal = v;

		if(parentSprite === void || !isvalid parentSprite || (!ignoreParentSpriteIdChange && parentSprite.nowSpriteId != parentSpriteId)) followParent = false;

		var mt = new MovingTable();

		if(followParent){
			if(movingTable.count > 0){
				mt.set(movingTable[0]);
				movingTable.erase(0);
			}

			xOffset += mt.x;
			yOffset += mt.y;
			hOffset += mt.h;

			if(!ignoreFollowX){
				rootX = parentSprite.rootX + xOffset;
			}else{
				rootX += mt.x;
			}
			if(!ignoreFollowY){
				rootY = parentSprite.rootY + yOffset;
			}else{
				rootY += mt.y;
			}
			if(!ignoreFollowH){
				altitude = parentSprite.altitude + hOffset;
			}else{
				altitude += mt.h;
			}
			movingTable2 = [];
			movingTable2.assign(parentSprite.movingTable);

			if(aOffset !== void) layer.absolute = fixedAbsolute = parentSprite.layer.absolute + aOffset + 1;

		}else{
			if(movingTable2.count > 0 && isvalid movingTable2[0]){
				if(!ignoreFollowX) rootX += movingTable2[0].x;
				if(!ignoreFollowY) rootY += movingTable2[0].y;
				if(!ignoreFollowH) altitude += movingTable2[0].h;
//				if(altitude < fAltitude) altitude = fAltitude;
				movingTable2.erase(0);
			}
			if((!ignoreParentSpriteIdChange && (!isvalid parentSprite || parentSprite.nowSpriteId != parentSpriteId))){
				deleteFlag = true;
				layer.dOpacity2 = -30;
			}
		}

		if(ignoreScroll){
			hScrollVal = vScrollVal = 0;
		}
		super.onRefreshFrame(hScrollVal, vScrollVal);

		// 親スプライトがダメージを喰らったらフェードアウトさせる
		if(!ignoreParentDelete && (parentSprite === void || !isvalid parentSprite || (parentSprite.nowSpriteId >= stDamage1 && parentSprite.nowSpriteId <= stThrown3)) && !deleteFlag){
			layer.dOpacity2 = -30;
		}

		if(deleteExp != ""){
			if(layer.conductor.executeEval(%['exp'=>deleteExp])){
				deleteExp = "";
				layer.dOpacity2 = -40;
			}
		}

		if(layer.opacity2 <= 0 && deleteAtOpacity2Zero){
			deleteFlag = true;
			layer.opacity2 = 0;
			layer.dOpacity2 = 0;
		}

	}

	function store(){
		var dic = super.store();

		dic.parentSpriteId = parentSpriteId;

//		dic.parentObjectClass = parentSprite.objectClass;
//		dic.parentObjectIndex = bao.getIndex(parentSprite);

		return dic;
	}

	function restore(dic){
		super.restore(dic);

		parentSpriteId = dic.parentSpriteId;

//		parentObjectClass = dic.parentObjectClass;
//		parentObjectIndex = dic.parentObjectIndex;
	}

//	function restore2(){
//		super.restore2();
//
//		parentSprite = bao.getObjectFromObjectClassAndIndex(parentObjectClass, parentObjectIndex);
//	}

}


//class AfterImageSprite extends EffectSprite
//{
//	function AfterImageSprite(window, owner, elm)
//	{
//		super.EffectSprite(...);
//		movableRect = new Rect2(elm.parent.movableRect);
//		floorObjectCollision = true;
//	}
//
//	function move(mt)
//	{
//		var r = new Rect2(footRect);
//		r.addOffset(rootX - centerPos, rootY - layer.asdHeight);
//
////		if(floorObjectCollision){
////
////			if((mt.x > 0 && int(altitude) < getAltitude(r.right+mt.x, r.top))||(mt.x > 0 && int(altitude) < getAltitude(r.right+mt.x, r.bottom))) mt.x = 0;
////			if((mt.x < 0 && int(altitude) < getAltitude(r.left +mt.x, r.top))||(mt.x > 0 && int(altitude) < getAltitude(r.left +mt.x, r.bottom))) mt.x = 0;
////
////			if((mt.y > 0 && int(altitude) < getAltitude(r.left, r.bottom+mt.y))
////						|| (mt.y > 0 && int(altitude) < getAltitude(r.right, r.bottom+mt.y))
////						|| (mt.y < 0 && int(altitude) < getAltitude(r.left, r.top+mt.y))
////						|| (mt.y < 0 && int(altitude) < getAltitude(r.right, r.top+mt.y))) mt.y = 0;
////
////			if(int(altitude) < getAltitude(rootX+mt.x, r.bottom+mt.y) || int(altitude) < getAltitude(rootX+mt.x, r.top+mt.y)){
////				mt.x = 0;
////				mt.y = 0;
////			}
////		}
//
//		var x = mt.x + rootX;
//		var y = mt.y + rootY;
//		var h = mt.h + altitude;
//
//		// 移動可能領域からはみ出ないように
//		if(!movableRect.includedPos(x, y) && !ignoreMovableRect){
//			if(x < movableRect.left)   x = movableRect.left;
//			if(x > movableRect.right)  x = movableRect.right;
//			if(y < movableRect.top)    y = movableRect.top;
//			if(y > movableRect.bottom) y = movableRect.bottom;
//		}
//
//		rootX = x;
//		rootY = y;
//		altitude = h;
//
//	}
//
//
//}



class ShadowLayer extends Layer
{
	var owner;
	var layers = [];
	var others = %[];
	var size = [62, 82, 102, 122, 136, 148, 170, 200];

	var pShow = true;
	var internalLayer;

	var maskLayers = %[];

	function ShadowLayer(window, parent, owner)
	{
		super.Layer(...);
		this.owner = owner;
		init();
	}

	function finalize()
	{
		clear();
		super.finalize();
	}

	function clear()
	{
		if(internalLayer !== void) invalidate internalLayer;

		for(var i=0; i<layers.count; i++){
			invalidate layers[i];
		}
		layers = void;

		var l = [];
		l.assign(others);
		for(var i=0; i<l.count; i+=2){
			invalidate l[i];
		}
		others = void;

		var l = [];
		l.assign(maskLayers);
		for(var i=0; i<l.count; i+=2){
			invalidate l[i];
		}
		maskLayers = void;

	}

	function init()
	{
		clear();
		layers = [];
		others = %[];
		maskLayers = %[];
		for(var i=0; i<size.count; i++){
			var l = new .Layer(window, this);
			l.visible = false;
			l.loadImages(l.name = owner.fHeader2 + "shadow" + size[i]);
			l.setSizeToImageSize();
			layers.add(l);
		}
		if(owner.sZoomRate != 1){
			internalLayer = new .Layer(window, this);
			internalLayer.name = "internalLayer";
			internalLayer.setSize(owner.width / owner.sZoomRate, owner.height / owner.sZoomRate);
		}

		fillRect(0, 0, width, height, 0x00000000);
	}

	function onRefreshFrame()
	{
		if(owner.sZoomRate==1){
			fillRect(0, 0, width, height, 0x00000000);
		}else{
			internalLayer.fillRect(0, 0, internalLayer.width, internalLayer.height, 0x00000000);
		}

		var b = owner;
		for(var i=0; i<b.players.count; i++) if(b.players[i].shadow) setShadow(b.players[i], b.players[i].shadowStorage);
		for(var i=0; i<b.enemies.count; i++) if(b.enemies[i].shadow) setShadow(b.enemies[i], b.enemies[i].shadowStorage);
		for(var i=0; i<b.objects.count; i++) if(b.objects[i].shadow) setShadow(b.objects[i], b.objects[i].shadowStorage);
		for(var i=0; i<b.others.count ; i++) if(b.others[i].shadow ) setShadow(b.others[i],  b.others[i].shadowStorage);

	}

	function setShadow(o, storage="")
	{
		if(o.altitude < 0) return;

		var l = getShadow(...);
		var b = owner;

		var x = (o.rootX - o.centerPos + o.layer.asdWidth/2) * b.sZoomRate2 - l.width/2 - (o.shadowOffset*xDirection(o.layer.inverse)* b.sZoomRate2);
		var y = (o.rootY - 4) * b.sZoomRate2 - l.height/2;

		var op = o.layer.opacity;
		if(o.altitude > 220){
			var tmp = (320 - o.altitude);
			if(tmp < 0) tmp = 0;
			op = (o.shadowOpacity / 255) * (op / 255) * (tmp / 100) * 255;
		}

		if(owner === bao && o.rootY < owner.stageLayer.topLine){
			op = op - (owner.stageLayer.topLine - o.rootY) * 15;
			if(op < 0) op = 0;
		}

		if(owner.sZoomRate==1){
			face = dfAlpha;
			operateRect(x, y, l, 0, 0, l.width, l.height, omAuto, op);
		}else{
			internalLayer.face = dfAlpha;
			internalLayer.operateRect(x, y , l, 0, 0, l.width, l.height, omAuto, op);
		}
	}

	function getShadow(o, storage="")
	{
		var l;

		if(storage == ""){
			for(var i=0; i<size.count; i++){
				if(o.shadowSize+10 <= size[i]){
					l = layers[i];
					break;
				}
			}
			if(l === void) l = layers[layers.count-1];
		}else{
			var filename = storage;
			if(o.inverse) filename += "_i";
 			if(others[filename] === void){
				l = new .Layer(window, this);
				l.visible = false;
				l.loadImages(owner.fHeader2 + storage);
				l.name = storage;
				l.setSizeToImageSize();
				if(o.inverse) l.flipLR();
				others[filename] = l;
			}else{
				l = others[filename];
			}
		}

		return l;
	}

	function pushShadowMask(name, l)
	{
		maskLayers[name] = l;
	}

}