5306 lines
242 KiB
Text
5306 lines
242 KiB
Text
|
||
var debugMode = false;
|
||
var noEnemiesAttack = false;
|
||
var noTimerLimit = false;
|
||
|
||
var hitMarkStorage = ["hitmark01", "hitmark02", "hitmark03"];
|
||
var fHeaderMatrix = ['', '', 'm2_', 'm3_'];
|
||
var artsList = [['commandList0','commandList0_2'], ['commandList1', 'commandList1_2']];
|
||
|
||
var p0;
|
||
var p1;
|
||
|
||
|
||
function dd(){
|
||
|
||
p0.HP = 0;
|
||
p1.HP = 0;
|
||
|
||
}
|
||
|
||
|
||
|
||
class BeltAction_Plugin extends KAGPlugin
|
||
{
|
||
var window;
|
||
var windowActive = true;
|
||
|
||
var timer;
|
||
var inputTimer;
|
||
var conductor;
|
||
var mainConductor;
|
||
|
||
var extraConductor;
|
||
var usingExtraConductor;
|
||
|
||
var fps = 0;
|
||
var fpsCount;
|
||
var fpsTimer;
|
||
var spf;
|
||
var lastSpf = 0;
|
||
|
||
var refreshFlag = false;
|
||
var nowTime;
|
||
var lastTime;
|
||
|
||
|
||
var tickCount = 10000;
|
||
|
||
var srcLayer;
|
||
var dispLayer1;
|
||
var dispLayer2;
|
||
var drawLayer;
|
||
|
||
// スコア等表示レイヤー
|
||
var informLayer;
|
||
// // マウス移動円レイヤー
|
||
// var dcLayer;
|
||
// カットインレイヤー
|
||
var cutinLayer = [];
|
||
// 影レイヤー
|
||
var shadowLayer;
|
||
// 背景のレイヤー
|
||
var stageLayer;
|
||
// 吹き出しの制御オブジェクト
|
||
var fukidashi;
|
||
// アイコン表示用レイヤー
|
||
var iconLayers = [];
|
||
|
||
// 表示モード （１：通常 ２：高画質 ３：最高画質）
|
||
var mode;
|
||
|
||
var fHeader = '';
|
||
var fHeader2 = '';
|
||
|
||
// 画面サイズ
|
||
var width = 1366;
|
||
var height = 768;
|
||
|
||
// 座標計算上の内部的なサイズ
|
||
var internalWidth = 456;
|
||
var internalHeight = 256;
|
||
|
||
// 表示時のsrcLayer拡大率
|
||
var zoomRate = 1;
|
||
// stageLayerの拡大率
|
||
var sZoomRate = 3;
|
||
// 内部的な座標から実際のスプライト表示位置への拡大率
|
||
var cZoomRate = 3;
|
||
|
||
// ポーズボタンが押されたかどうか
|
||
var pauseInKey = false;
|
||
// ポーズキーを一定時間無効にする仕掛け
|
||
var disablePauseKey = 0;
|
||
// カットイン表示中に全体を止めるための仕掛け
|
||
var pausedByCutin = false;
|
||
var totEnabled;
|
||
var mainConductorTotEnabled;
|
||
|
||
var tagHandlers;
|
||
|
||
// スクロール量
|
||
var hScrollVal;
|
||
var vScrollVal;
|
||
|
||
// 各キャラのスプライト
|
||
var players = [];
|
||
var enemies = [];
|
||
var objects = [];
|
||
var hitMarks = [];
|
||
var others = [];
|
||
var selectIndicator;
|
||
var selectIndicator2;
|
||
|
||
// 選択中ヒロインキャラID
|
||
var nowSelectingPlayerId = 0;
|
||
|
||
// 選択キャラ切り替えフラグ
|
||
var exchangePlayerFlag = false;
|
||
|
||
var gaugeDispList = [];
|
||
|
||
var timeOrigin; // resetWait で設定された時間原点
|
||
var lastWaitTime; // wait mode=until で実際に待った時間
|
||
|
||
// var keySpecial = [VK_C, VK_PAD1, VK_MBUTTON];
|
||
// var keyAttack = [VK_X, VK_PAD2, VK_RBUTTON];
|
||
// var keyJump = [VK_Z, VK_PAD3];
|
||
|
||
var enableInput = false;
|
||
|
||
// var command = %["dash" => "6+0{1,6}6+$/4+0{1,6}4+$", "roll" => "8+0{1,6}8+$/2+0{1,6}2+$", "shouryuken" => "2[0-9]*6[0-9]*8/2[0-9]*4[0-9]*8"];
|
||
// var command = %["dash" => "6+0{1,8}6+$/4+0{1,8}4+$", "roll" => "8+0{1,8}8+$/2+0{1,8}2+$", "hadouken" => "2[0-9]*6/2[0-9]*4", "sonicboom" => "4[0-9]*6/6[0-9]*4"];
|
||
// var command = %["dash" => "6+0{1,8}6+$/4+0{1,8}4+$", "roll" => "8+0{1,8}8+$/2+0{1,8}2+$", "hadouken" => "2[0-9]*6/2[0-9]*4"];
|
||
|
||
var commandList =[];
|
||
commandList[cmdDash] = ["6+0{1,8}6+", "4+0{1,8}4+"];
|
||
commandList[cmdRoll] = ["8+0{1,8}8+$", "2+0{1,8}2+$"];
|
||
commandList[cmdSonicBoom] = ["[14][013-9]{0,12}[36]+","[36][013-9]{0,12}[14]+"];
|
||
commandList[cmdHadouken] = ["2(?=[^4]{0,12}4{1,8}[^4]{0,8}$)", "2(?=[^6]{0,12}6{1,8}[^6]{0,8}$)"];
|
||
commandList[cmdRHadouken] = ["8(?=[^4]{0,12}4{1,8}[^4]{0,8}$)", "8(?=[^6]{0,12}6{1,8}[^6]{0,8}$)"];
|
||
commandList[cmdSomersault] = ["[1-3][0-9]*[789]"];
|
||
commandList[cmdExcution] = ["[123][0-9]*[789][0-9]*[123]"];
|
||
commandList[cmdGenocidePhantom] = ["2[0-9]*6[0-9]*[89]", "2[0-9]*4[0-9]*[78]"];
|
||
commandList[cmdYogaFlame] = ["[14][0-9]*2[0-9]*[369]", "[36][0-9]*2[0-9]*[147]"];
|
||
// commandList[cmdRYoga] = ["[47][0-9]*8[0-9]*[369]", "[69][0-9]*8[0-9]*[147]"];
|
||
// commandList[cmdRHadou] = ["4[41]{1,8}2", "6[36]{1,8}2"];
|
||
// commandList[cmdRHadou2] = ["4[71]{1,8}8", "6[69]{1,8}8"];
|
||
commandList[cmdDash2] = ["6+[^6]{1,8}[369]", "4+[^4]{1,8}[147]"];
|
||
// commandList[cmdGeyser] = ["2[0-9]*4[0-9]*[369]", "2[0-9]*6[0-9]*[147]"];
|
||
|
||
var mouseWheel = false;
|
||
|
||
var nowDownTimerChange;
|
||
var nowDownTimerChange2;
|
||
var nowDownTimerChange3;
|
||
|
||
var noWaitMode = false;
|
||
|
||
var mx;
|
||
var my;
|
||
var mButtonDownTick = 0;
|
||
var dyBuf = [];
|
||
|
||
var quakeEndTick;
|
||
var quakeHorzMax;
|
||
var quakeVertMax;
|
||
var quaking = false;
|
||
var quakePhase;
|
||
|
||
// KAG3に戻るときの状態（通常:""、やられ:"miss"、クリア:"clear"）
|
||
var returnState = "";
|
||
var killedPlayerId;
|
||
var jumpStorage = "";
|
||
var jumpTarget = "";
|
||
|
||
// ステージをクリアした
|
||
var clearFlag = false;
|
||
|
||
var enemySetFlag = false;
|
||
|
||
// killallトリガを発砲するオフセット（１に設定すると敵が一体残っていても発砲される）
|
||
var enemyCountOffset = 0;
|
||
|
||
// [pause]タグによる停止中かどうか
|
||
var scenarioPaused = false;
|
||
// シナリオの実行が停止中であるかどうか
|
||
var interrupted = true;
|
||
// このプラグイン自体が停止中であるかどうか
|
||
var enabled = false;
|
||
// ポーズキーによるポーズ中かどうか
|
||
var pausedByKey = false;
|
||
// ポーズキーを無効にするかどうか
|
||
var pauseKeyDisabled = false;
|
||
|
||
var seBuf = 0;
|
||
var seStorage = [];
|
||
|
||
var goIndicatorStorage = "";
|
||
var fpsShow = false;
|
||
var fpsShowKey = false;
|
||
|
||
var dispEnemyCount = 0;
|
||
var noRestoreFlag = false;
|
||
var encounterBoss = false;
|
||
|
||
// 入力処理オブジェクト
|
||
var inputs = [];;
|
||
|
||
var setEnemyCount = 0;
|
||
|
||
function BeltAction_Plugin(window)
|
||
{
|
||
super.KAGPlugin();
|
||
this.window = window;
|
||
|
||
mode = sf.screenMode;
|
||
setMode(mode);
|
||
|
||
timer = new Timer(refreshFrame, "");
|
||
timer.interval = sf.adjTimerInterval;
|
||
if(noTimerLimit) timer.interval = 3;
|
||
timer.capacity = 1;
|
||
timer.enabled = false;
|
||
|
||
inputTimer = new Timer(execInput, "");
|
||
inputTimer.interval = 16.667;
|
||
inputTimer.capacity = 1;
|
||
inputTimer.mode = atmExclusive;
|
||
inputTimer.enabled = false;
|
||
|
||
// 拡大前のレイヤー
|
||
srcLayer = new Layer(window, window.fore.base.dispLayer);
|
||
srcLayer.setSize(width, height);
|
||
srcLayer.opacity = 255;
|
||
srcLayer.absolute = 300;
|
||
srcLayer.visible = debugMode;
|
||
srcLayer.face = dfOpaque;
|
||
srcLayer.type = ltOpaque;
|
||
srcLayer.name = "bao.srcLayer";
|
||
|
||
// 影用レイヤー
|
||
shadowLayer = new ShadowLayer(window, srcLayer, this);
|
||
shadowLayer.opacity = 128;
|
||
shadowLayer.absolute = 1;
|
||
shadowLayer.visible = true;
|
||
shadowLayer.name = "bao.shadowLayer";
|
||
shadowLayer.setSize(internalWidth * cZoomRate, internalHeight * cZoomRate);
|
||
|
||
drawLayer = new DrawLayer(window, srcLayer, this);
|
||
drawLayer.setSize(width, height);
|
||
drawLayer.opacity = 255;
|
||
drawLayer.absolute = 100000;
|
||
drawLayer.visible = false;
|
||
drawLayer.name = "bao.drawLayer";
|
||
|
||
for(var i=0; i<2; i++){
|
||
cutinLayer[i] = new CutinLayer(window, srcLayer, this, this);
|
||
cutinLayer[i].absolute = 100001 + i;
|
||
cutinLayer[i].name = "bao.cutinLayer";
|
||
}
|
||
|
||
informLayer = new InformLayer(window, srcLayer, this, mode);
|
||
informLayer.absolute = 100003;
|
||
informLayer.name = "bao.informLayer";
|
||
|
||
// 実際に表示するレイヤー
|
||
dispLayer1 = new .Layer(window, window.fore.base.dispLayer);
|
||
dispLayer1.setSize(width * zoomRate, height * zoomRate);
|
||
dispLayer1.opacity = 255;
|
||
dispLayer1.hitThreshold = 256;
|
||
dispLayer1.absolute = 100;
|
||
dispLayer1.visible = false;
|
||
dispLayer1.face = dfOpaque;
|
||
dispLayer1.type = ltOpaque;
|
||
dispLayer1.name = "bao.dispLayer1";
|
||
|
||
dispLayer2 = new .Layer(window, window.back.base.dispLayer);
|
||
dispLayer2.setSize(width * zoomRate, height * zoomRate);
|
||
dispLayer2.opacity = 255;
|
||
dispLayer2.hitThreshold = 256;
|
||
dispLayer2.absolute = 100;
|
||
dispLayer2.visible = false;
|
||
dispLayer2.face = dfOpaque;
|
||
dispLayer2.type = ltOpaque;
|
||
dispLayer2.name = "bao.dispLayer2";
|
||
dispLayer2.font.height = 18;
|
||
|
||
stageLayer = new StageLayer(window, this);
|
||
stageLayer.absolute = 0;
|
||
|
||
// dcLayer = new DirectionCircleLayer(window, srcLayer);
|
||
// dcLayer.absolute = 100003;
|
||
|
||
tagHandlers = getHandlers();
|
||
conductor = mainConductor = new SConductor(this, tagHandlers);
|
||
// conductor.loadScenario("macrodefine.ssd");
|
||
// if(conductor.status != conductor.mRun) conductor.run();
|
||
extraConductor = new SConductor(this, tagHandlers);
|
||
|
||
// fpsを計測するタイマー。ゲームの進行には特に関係しない。
|
||
fpsCount = 0;
|
||
fpsTimer = new Timer(showFps, "");
|
||
fpsTimer.interval = 1000;
|
||
fpsTimer.enabled = false;
|
||
lastTime = System.getTickCount();
|
||
|
||
// 選択中のキャラ表示
|
||
selectIndicator = new CharacterSprite(window, this, %["storage"=>"dummy"]);
|
||
selectIndicator.layer.visible = false;
|
||
selectIndicator.layer.opacity2 = 0;
|
||
selectIndicator2 = new CharacterSprite(window, this, %["storage"=>"dummy"]);
|
||
|
||
// 吹き出しの制御オブジェクト
|
||
fukidashi = new FukidashiControl(window, this, dispLayer1);
|
||
|
||
for(var i=0; i<2; i++){
|
||
iconLayers[i] = new FrameAnimeLayer(window, window.fore.base, this, this);
|
||
iconLayers[i].absolute = 101+i;
|
||
iconLayers[i].setPos(((i==0)?12:(1366-96-12)),572);
|
||
iconLayers[i].opacity = 255;
|
||
iconLayers[i].hitThreshold = 256;
|
||
iconLayers[i].visible = false;
|
||
iconLayers[i].face = dfOpaque;
|
||
iconLayers[i].type = ltOpaque;
|
||
iconLayers[i].name = "bao.iconLayers";
|
||
}
|
||
|
||
// キー入力
|
||
inputs[0] = new KeyInput(this, 0);
|
||
inputs[1] = new KeyInput(this, 1);
|
||
|
||
// ウィンドウがアクティブになったとき
|
||
window.onActivate = function()
|
||
{
|
||
bao.windowActive = true;
|
||
} incontextof (window);
|
||
|
||
// ウィンドウが非アクティブになったとき
|
||
window.onDeactivate = function()
|
||
{
|
||
bao.windowActive = false;
|
||
} incontextof (window);
|
||
|
||
// System.addContinuousHandler(dispFrame);
|
||
|
||
}
|
||
|
||
function finalize()
|
||
{
|
||
|
||
// System.removeContinuousHandler(dispFrame);
|
||
|
||
window.onActivate = function()
|
||
{
|
||
} incontextof (window);
|
||
|
||
window.onDeactivate = function()
|
||
{
|
||
} incontextof (window);
|
||
|
||
resetStage();
|
||
|
||
timer.enabled = false;
|
||
invalidate timer;
|
||
inputTimer.enabled = false;
|
||
invalidate inputTimer;
|
||
|
||
invalidate srcLayer;
|
||
invalidate shadowLayer;
|
||
invalidate cutinLayer[0];
|
||
invalidate cutinLayer[1];
|
||
invalidate dispLayer1;
|
||
invalidate informLayer;
|
||
invalidate dispLayer1;
|
||
invalidate dispLayer2;
|
||
invalidate stageLayer;
|
||
// invalidate dcLayer;
|
||
|
||
invalidate conductor;
|
||
invalidate mainConductor;
|
||
invalidate extraConductor;
|
||
invalidate fpsTimer;
|
||
invalidate selectIndicator;
|
||
invalidate selectIndicator2;
|
||
invalidate fukidashi;
|
||
|
||
for(var i=0; iconLayers.count<2; i++){
|
||
invalidate iconLayers[i];
|
||
}
|
||
}
|
||
|
||
function changeMode(m){
|
||
var tmp = %[];
|
||
var isFlag;
|
||
if((!informLayer.visible && informLayer.opacityDelta>0) || (informLayer.visible && informLayer.opacityDelta==0)){
|
||
isFlag = true;
|
||
}else{
|
||
isFlag = false;
|
||
}
|
||
onStore(tmp);
|
||
setMode(m);
|
||
shadowLayer.init();
|
||
if(enabled) onRestore(tmp);
|
||
informLayer.init();
|
||
if(isFlag){
|
||
informLayer.opacity = 255;
|
||
informLayer.visible = 1;
|
||
}
|
||
}
|
||
|
||
function setMode(m){
|
||
|
||
mode = m;
|
||
switch(mode){
|
||
case 1:
|
||
width = 456;
|
||
height = 256;
|
||
zoomRate = 3;
|
||
sZoomRate = 1;
|
||
cZoomRate = 1;
|
||
fHeader = fHeaderMatrix[1];
|
||
fHeader2 = fHeaderMatrix[1];
|
||
break;
|
||
|
||
case 2:
|
||
width = 683;
|
||
height = 384;
|
||
zoomRate = 2;
|
||
sZoomRate = 1;
|
||
cZoomRate = 1.5;
|
||
fHeader = fHeaderMatrix[2];
|
||
fHeader2 = fHeaderMatrix[2];
|
||
break;
|
||
|
||
case 3:
|
||
width = 1366;
|
||
height = 768;
|
||
zoomRate = 1;
|
||
sZoomRate = 2;
|
||
cZoomRate = 3;
|
||
fHeader = fHeaderMatrix[3];
|
||
fHeader2 = fHeaderMatrix[2];
|
||
break;
|
||
}
|
||
|
||
if(srcLayer !== void) srcLayer.setSize(width, height);
|
||
if(shadowLayer !== void) shadowLayer.setSize(internalWidth * cZoomRate, internalHeight * cZoomRate);
|
||
if(drawLayer !== void) drawLayer.setSize(width, height);
|
||
if(dispLayer1 !== void) dispLayer1.setSize(width * zoomRate, height * zoomRate);
|
||
if(dispLayer2 !== void) dispLayer2.setSize(width * zoomRate, height * zoomRate);
|
||
|
||
}
|
||
|
||
property sZoomRate2{
|
||
getter()
|
||
{
|
||
return cZoomRate / sZoomRate;
|
||
}
|
||
}
|
||
|
||
|
||
function clearInput()
|
||
{
|
||
for(var i=0; i<inputs.count; i++){
|
||
inputs[i].clear();
|
||
}
|
||
}
|
||
|
||
function execInput()
|
||
{
|
||
// if(!windowActive) return;
|
||
if(players.count == 0) return;
|
||
|
||
if(enableInput){
|
||
|
||
// clearInput();
|
||
|
||
for(var i=0; i<players.count; i++){
|
||
|
||
var inp;
|
||
|
||
if(nowSelectingPlayerId == 0){
|
||
inp = (i == 0)? 0: 1;
|
||
if(players.count==1 && players[0].chara == chrChocolat && sf.inputAtChocolatOnly) inp = 1;
|
||
}else{
|
||
inp = (i == 0)? 1: 0;
|
||
}
|
||
|
||
inputs[inp].clear();
|
||
// レバー入力
|
||
inputs[inp].getInputDirection();
|
||
// ボタン入力
|
||
inputs[inp].getInputKey();
|
||
|
||
var pc = players[i].pc;
|
||
if(pc.enforceControl) inputs[inp].clear(); // コンピュータ操作強制の場合は入力を捨てる
|
||
if(inputs[inp].isExist()) pc.lastManualControlTick = tickCount;
|
||
if(pc.lastManualControlTick + 30 > tickCount || (nowSelectingPlayerId == i && !sf.adjAIAssist) || (notSelectingPlayerId == i && !sf.AIForChara2Enabled)){
|
||
pc.nowManualControl = true;
|
||
// コマンド処理用に入力方向を溜めておく
|
||
inputs[inp].addHistory();
|
||
}else{
|
||
pc.decisionAction();
|
||
pc.nowManualControl = false;
|
||
}
|
||
}
|
||
|
||
}else{
|
||
// dcLayer.hide();
|
||
}
|
||
|
||
getInputOthers();
|
||
|
||
}
|
||
|
||
|
||
function getInputOthers(){
|
||
|
||
if(tf.debugMode && inputs[0].get(keySwitch)) dm("inputs[0].get(keySwitch) : " + inputs[0].get(keySwitch) + " / pausedByKey : " + pausedByKey);
|
||
|
||
// 操作キャラの入れ替え
|
||
if((inputs[0].get(keySwitch)||inputs[1].get(keySwitch)) && timer.enabled && players.count == 2 && notSelectingPlayer.HP > 0){
|
||
if(tf.debugMode) dm("exchange");
|
||
inputs[0].done(keySwitch);
|
||
inputs[1].done(keySwitch);
|
||
if(sf.adjSinglePlayMode){
|
||
// // シングルプレイモードでは交代フラグを立てるだけ → シングルプレイモードでは何もしないに変更
|
||
// → 調整モードの設定で可能に
|
||
if(sf.adjSinglePlayExchangeMode && nowSelectingPlayer.nowSpriteId != stDummy && nowSelectingPlayer.nowSpriteId != stClinched && nowSelectingPlayer.nowSpriteId != stClinchedStruggle){
|
||
//dm(st(nowSelectingPlayer.nowSpriteId));
|
||
exchangePlayerFlag = true;
|
||
}
|
||
}else{
|
||
// 即時交代
|
||
kag.se[9].play(%["storage"=>"sys_decide"]);
|
||
exchangePlayer();
|
||
}
|
||
}
|
||
|
||
if(exchangePlayerFlag && (nowSelectingPlayer.enableMove || nowSelectingPlayer.nowSpriteId==stClinching || nowSelectingPlayer.nowSpriteId==stBackClinch)){
|
||
// 交代できるタイミングなら交代
|
||
exchangePlayerFlag = false;
|
||
kag.se[9].play(%["storage"=>"sys_decide"]);
|
||
notSelectingPlayer.damage.strength = 0;
|
||
notSelectingPlayer.rootX = nowSelectingPlayer.rootX;
|
||
notSelectingPlayer.rootY = nowSelectingPlayer.rootY;
|
||
notSelectingPlayer.altitude = nowSelectingPlayer.altitude;
|
||
notSelectingPlayer.HP = nowSelectingPlayer.HP;
|
||
notSelectingPlayer.MP = nowSelectingPlayer.MP;
|
||
exchangePlayer();
|
||
}
|
||
|
||
|
||
// 任せてモード（待機指示）
|
||
if(sf.adjEnableLeaveItMode && inputs[0].get(keyLeaveIt) && !sf.adjSinglePlayMode && players.count == 2 &&
|
||
(nowSelectingPlayer.state < stateDamage || (nowSelectingPlayer.nowSpriteId == stClinched && notSelectingPlayer.pc.leaveItMode)) && nowSelectingPlayer.HP > 0 && notSelectingPlayer.HP > 0){
|
||
inputs[0].done(keyLeaveIt);
|
||
|
||
// 吹き出し表示
|
||
if(!notSelectingPlayer.pc.leaveItMode){
|
||
nowSelectingPlayer.defaultFaceNum = (f.stage!=2)?3:5;
|
||
bao.fukidashi.clear();
|
||
if(tickCount - notSelectingPlayer.pc.leaveItModeEnterTick > 300){
|
||
notSelectingPlayer.pc.leaveItModeEnterTick = tickCount;
|
||
if(players[nowSelectingPlayerId].chara == chrChiffon){
|
||
bao.fukidashi.add(%['chara'=>chrChiffon, 'storage'=>'a9027', 'text'=>"Leave this to me!",'expOnStart'=>'bao.informLayer.setFace(bao.players[bao.nowSelectingPlayerId],(f.stage!=2)?3:5)']);
|
||
if((notSelectingPlayer.nowSpriteId <= stDamage1 && notSelectingPlayer.nowSpriteId != stExtasy) || (notSelectingPlayer.nowSpriteId >= stClinching && notSelectingPlayer.nowSpriteId <= stClinchAttack3) || notSelectingPlayer.nowSpriteId>= stThrow1){
|
||
bao.fukidashi.add(%['chara'=>chrChocolat, 'storage'=>'b9026', 'text'=>"Be careful, Chiffon!"]);
|
||
}
|
||
}else{
|
||
bao.fukidashi.add(%['chara'=>chrChocolat, 'storage'=>'b9028', 'text'=>"Chiffon, let me handle this!",'expOnStart'=>'bao.informLayer.setFace(bao.players[bao.nowSelectingPlayerId],(f.stage!=2)?3:5)']);
|
||
if((notSelectingPlayer.nowSpriteId <= stDamage1 && notSelectingPlayer.nowSpriteId != stExtasy) || (notSelectingPlayer.nowSpriteId >= stClinching && notSelectingPlayer.nowSpriteId <= stClinchAttack3) || notSelectingPlayer.nowSpriteId>= stThrow1){
|
||
bao.fukidashi.add(%['chara'=>chrChiffon, 'storage'=>'a9030', 'text'=>"Yes, don't let your guard down...!"]);
|
||
}
|
||
}
|
||
}else{
|
||
if(players[nowSelectingPlayerId].chara == chrChiffon){
|
||
bao.fukidashi.add(%['chara'=>chrChiffon, 'storage'=>'a9028', 'text'=>"Let's go!",'expOnStart'=>'bao.informLayer.setFace(bao.players[bao.nowSelectingPlayerId],(f.stage!=2)?3:5)']);
|
||
}else{
|
||
bao.fukidashi.add(%['chara'=>chrChocolat, 'storage'=>'b9029', 'text'=>"Prepare yourself!",'expOnStart'=>'bao.informLayer.setFace(bao.players[bao.nowSelectingPlayerId],(f.stage!=2)?3:5)']);
|
||
}
|
||
}
|
||
notSelectingPlayer.pc.enterLeaveItMode();
|
||
}else{
|
||
nowSelectingPlayer.defaultFaceNum = informLayer.getDefaultFaceNum(nowSelectingPlayerId);
|
||
notSelectingPlayer.pc.leaveItMode = false;
|
||
informLayer.resetFace2();
|
||
if((notSelectingPlayer.nowSpriteId <= stDamage1 && notSelectingPlayer.nowSpriteId != stExtasy) || (notSelectingPlayer.nowSpriteId >= stClinching && notSelectingPlayer.nowSpriteId <= stClinchAttack3) || notSelectingPlayer.nowSpriteId>= stThrow1){
|
||
bao.fukidashi.clear();
|
||
if(players[nowSelectingPlayerId].chara == chrChiffon){
|
||
bao.fukidashi.add(%['chara'=>chrChiffon, 'storage'=>'a9029', 'text'=>"Chocolat, please!",'expOnStart'=>'bao.informLayer.setFace(bao.players[bao.nowSelectingPlayerId],(f.stage!=2)?bao.players[bao.nowSelectingPlayerId].defaultFaceNum:5)']);
|
||
bao.fukidashi.add(%['chara'=>chrChocolat, 'storage'=>'b9027', 'text'=>"Sure!"]);
|
||
}else{
|
||
bao.fukidashi.clear();
|
||
bao.fukidashi.add(%['chara'=>chrChocolat, 'storage'=>'b9030', 'text'=>"Chiffon, please!",'expOnStart'=>'bao.informLayer.setFace(bao.players[bao.nowSelectingPlayerId],(f.stage!=2)?bao.players[bao.nowSelectingPlayerId].defaultFaceNum:5)']);
|
||
bao.fukidashi.add(%['chara'=>chrChiffon, 'storage'=>'a9031', 'text'=>"Yes!"]);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if(kag.getKeyState(VK_F1)){
|
||
if(!fpsShowKey){
|
||
fpsShow = !fpsShow;
|
||
fpsShowKey = true;
|
||
}
|
||
}else{
|
||
fpsShowKey = false;
|
||
}
|
||
|
||
if(tf.debugMode && windowActive){
|
||
if(kag.getKeyState(VK_1)){
|
||
sf.screenMode = 1;
|
||
changeMode(1);
|
||
}
|
||
if(kag.getKeyState(VK_2)){
|
||
sf.screenMode = 2;
|
||
changeMode(2);
|
||
}
|
||
if(kag.getKeyState(VK_3)){
|
||
sf.screenMode = 3;
|
||
changeMode(3);
|
||
}
|
||
|
||
if(kag.getKeyState(VK_PRIOR)){
|
||
if(!nowDownTimerChange){
|
||
timer.interval /= 2;
|
||
nowDownTimerChange = true;
|
||
}
|
||
}else if(kag.getKeyState(VK_NEXT)){
|
||
if(!nowDownTimerChange){
|
||
timer.interval *= 2;
|
||
nowDownTimerChange = true;
|
||
}
|
||
}else if(kag.getKeyState(VK_HOME)){
|
||
if(!nowDownTimerChange){
|
||
timer.interval = sf.adjTimerInterval;
|
||
nowDownTimerChange = true;
|
||
}
|
||
}else{
|
||
nowDownTimerChange = false;
|
||
}
|
||
|
||
if(kag.getKeyState(VK_INSERT)){
|
||
if(players[nowSelectingPlayerId].HP > 0){
|
||
players[nowSelectingPlayerId].HP = players[nowSelectingPlayerId].maxHP;
|
||
players[nowSelectingPlayerId].MP = players[nowSelectingPlayerId].maxMP;
|
||
}
|
||
}
|
||
}
|
||
|
||
if(windowActive && (tf.debugMode || sf.adjEnableNoWaitMode)){
|
||
if(kag.getKeyState(VK_F12)){
|
||
if(!nowDownTimerChange3){
|
||
nowDownTimerChange3 = true;
|
||
if(timer.interval == 1){
|
||
timer.interval = sf.adjTimerInterval;
|
||
noWaitMode = false;
|
||
}else{
|
||
timer.interval = 1;
|
||
noWaitMode = true;
|
||
}
|
||
}
|
||
}else{
|
||
nowDownTimerChange3 = false;
|
||
}
|
||
}
|
||
|
||
if(windowActive && (tf.debugMode || sf.adjButtonStateZankiFreeAdjust.selected)){
|
||
if(kag.getKeyState(VK_ADD) || kag.getKeyState(187)){
|
||
if(!nowDownTimerChange2){
|
||
if(f.playerNum[0] < 10) f.playerNum[0] ++;
|
||
if(f.playerNum[1] < 10) f.playerNum[1] ++;
|
||
nowDownTimerChange2 = true;
|
||
}
|
||
}else if(kag.getKeyState(VK_SUBTRACT) || kag.getKeyState(189)){
|
||
if(!nowDownTimerChange2 && f.playerNum[players[nowSelectingPlayerId].chara] > 1){
|
||
if(f.playerNum[0] > 0) f.playerNum[0] --;
|
||
if(f.playerNum[1] > 0) f.playerNum[1] --;
|
||
nowDownTimerChange2 = true;
|
||
}
|
||
}else{
|
||
nowDownTimerChange2 = false;
|
||
}
|
||
}
|
||
|
||
|
||
if((tf.debugMode || sf.adjEnableDyingKey) && windowActive && !(f.inBattleMode && sf.bmPlayerHPInfinite)){
|
||
if(kag.getKeyState(VK_DELETE)){
|
||
if(players[nowSelectingPlayerId].HP >0){
|
||
players[nowSelectingPlayerId].HP = 1;
|
||
players[nowSelectingPlayerId].MP = 1;
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
|
||
function resetTimerInterval(){
|
||
if(noWaitMode){
|
||
timer.interval = 1;
|
||
}else{
|
||
timer.interval = sf.adjTimerInterval;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
function exchangePlayer()
|
||
{
|
||
|
||
nowSelectingPlayerId = !nowSelectingPlayerId;
|
||
players[0].input <-> players[1].input;
|
||
players[0].pc.pIn <-> players[1].pc.pIn;
|
||
|
||
informLayer.playerInformLayers[0].loadBg();
|
||
informLayer.playerInformLayers[1].loadBg();
|
||
|
||
informLayer.playerInformLayers[0].setSelectCircleLayer();
|
||
informLayer.playerInformLayers[1].setSelectCircleLayer();
|
||
|
||
// if(players.count > 0 && sf.showSelectIndicator > 0) showSelectIndicator(nowSelectingPlayerId);
|
||
if(sf.showSelectIndicator > 0) showSelectIndicator(nowSelectingPlayerId);
|
||
if(players.count > 0 && sf.showSelectIndicator > 0){
|
||
if(!sf.adjSinglePlayMode || tf.inRescueMode || tf.toRescueMode){
|
||
selectIndicator2.loadImages(%["storage"=>"selectIndicator00"]);
|
||
}
|
||
}
|
||
|
||
|
||
players[0].pc.leaveItMode = false;
|
||
players[1].pc.leaveItMode = false;
|
||
|
||
// // これなんで入れたかわからない……いや要る。任せてモード解除に伴いアイコンをリセットする
|
||
bao.informLayer.resetFace2();
|
||
|
||
tf.killCount[0] <-> tf.killCount[1];
|
||
|
||
}
|
||
|
||
|
||
function showSelectIndicator(id = 0)
|
||
{
|
||
if(players === void) return;
|
||
|
||
selectIndicator.loadImages(%["storage"=>players[id].selectIndicatorStorage, "type"=>ltPsHardLight]);
|
||
selectIndicator.layer.visible = true;
|
||
}
|
||
|
||
|
||
function refreshFrame(){
|
||
hScrollVal = 0;
|
||
vScrollVal = 0;
|
||
|
||
// 入力コマンドのチェック
|
||
for(var i=0; i<inputs.count; i++){
|
||
inputs[i].checkCommand();
|
||
}
|
||
|
||
// window.caption = inputHistory.join('');
|
||
// window.caption = inputKeyJump + " / " + inputKeyAttack + " / " + inputKeySpecial;
|
||
|
||
if(!pausedByCutin){
|
||
|
||
for(var i=0; i<stageLayer.floorObjects.count; i++){
|
||
if(stageLayer.floorObjects[i].objDepth > 0){
|
||
var l = stageLayer.floorObjects[i].shadowLayer;
|
||
if(l !== void) l.fillRect(0, 0, l.width, l.height, 0x00000000);
|
||
}
|
||
}
|
||
|
||
// プレイヤー処理
|
||
for(var i=0; i<players.count; i++){
|
||
if(players[i] !== void && isvalid players[i]){
|
||
players[i].onRefreshFrame(hScrollVal, vScrollVal);
|
||
}
|
||
}
|
||
stageLayer.bgScroll();
|
||
|
||
// 敵処理
|
||
dispEnemyCount = 0;
|
||
gaugeDispList.clear();
|
||
for(var i=0; i<enemies.count; i++){
|
||
var e = enemies[i];
|
||
e.onRefreshFrame(hScrollVal, vScrollVal);
|
||
if(e.countFlag) dispEnemyCount++;
|
||
if(e.targetPlayer !== void){
|
||
// if(e.isBoss){
|
||
// informLayer.enemyGaugeLayers[i].target = nowSelectingPlayerId;
|
||
// informLayer.enemyGaugeLayers[i].alignChangeTick = 0;
|
||
// }else{
|
||
if(!sf.adjSinglePlayMode && bao.players.count > 1){
|
||
informLayer.enemyGaugeLayers[i].target = e.targetPlayer.id;
|
||
}
|
||
// }
|
||
}
|
||
|
||
// ＨＰゲージを表示する敵キャラを選別
|
||
for(var j=0; j<players.count; j++){
|
||
if(gaugeDispList[i]) continue;
|
||
if(e.isBoss || (e.damage.tick>0 && e.damage.tick+90>tickCount) || getDistance(e, players[j]) < 2500
|
||
|| (players[j].damageFrom===e && players[j].damage.tick+90>tickCount)){
|
||
if(e.maxHP>5){
|
||
gaugeDispList[i] = true;
|
||
}else{
|
||
gaugeDispList[i] = false;
|
||
}
|
||
}else{
|
||
gaugeDispList[i] = false;
|
||
}
|
||
}
|
||
|
||
if(e.isBoss){
|
||
encounterBoss = true;
|
||
if(e.deleteFlag){
|
||
// if(e.targetPlayer !== void) tf.killCount[e.targetPlayer.id] ++;
|
||
if(e.killedByUser){
|
||
f.score += e.score * 1.5;
|
||
}else{
|
||
f.score += e.score * 0.5;
|
||
}
|
||
e.score = 0;
|
||
clearFlag = true;
|
||
if(conductor === extraConductor){
|
||
// ※ここ、救助モードの画面表示が終わるまでは実行しない方がいい気がする……どうやろ？
|
||
conductor.goToLabel("*end");
|
||
conductor.startProcess();
|
||
}
|
||
}else{
|
||
clearFlag = false;
|
||
}
|
||
}
|
||
|
||
// 削除フラグの立っているものを削除する
|
||
if(e.deleteFlag && !e.isBoss){
|
||
if(e.scriptQueue.count > 0) e.executeQueue();
|
||
// 不透明度が０だったり画面外に出たら削除
|
||
if(e.layer.opacity==0 || e.layer.left+e.layer.width<0 || e.layer.left>width || e.layer.top>height){
|
||
if(e.damageFromStr=='爆発'){
|
||
sf.killingByExplode++;
|
||
// if(sf.killingByExplode >= 100){
|
||
// checkMission("爆殺");
|
||
// }
|
||
}
|
||
if(e.targetPlayer !== void) tf.killCount[e.targetPlayer.id] ++;
|
||
if(e.killedByUser){
|
||
f.score += e.score * 1.5;
|
||
}else{
|
||
f.score += e.score * 0.5;
|
||
}
|
||
deleteEnemy(i);
|
||
}
|
||
}
|
||
}
|
||
if(clearFlag && conductor === mainConductor) trigger("killall");
|
||
|
||
// オブジェクト処理
|
||
for(var i=0; i<objects.count; i++){
|
||
var o = objects[i];
|
||
o.onRefreshFrame(hScrollVal, vScrollVal);
|
||
}
|
||
for(var i=0; i<objects.count; i++){
|
||
var o = objects[i];
|
||
// 削除フラグの立っているものを削除する
|
||
if(o.deleteFlag){
|
||
invalidate o;
|
||
objects.erase(i);
|
||
}
|
||
}
|
||
|
||
// フロアオブジェクト処理
|
||
for(var i=0; i<stageLayer.floorObjects.count; i++){
|
||
var o = stageLayer.floorObjects[i];
|
||
o.onRefreshFrame();
|
||
// 削除フラグの立っているものを削除する
|
||
if(o.deleteFlag){
|
||
invalidate o;
|
||
stageLayer.floorObjects.erase(i);
|
||
}
|
||
}
|
||
stageLayer.floorObjectsSort();
|
||
|
||
// その他処理
|
||
for(var i=0; i<others.count; i++){
|
||
var o = others[i];
|
||
o.onRefreshFrame(hScrollVal, vScrollVal);
|
||
// 削除フラグの立っているものを削除する
|
||
if(o.deleteFlag){
|
||
invalidate o;
|
||
others.erase(i);
|
||
}
|
||
}
|
||
|
||
// 影レイヤー
|
||
shadowLayer.onRefreshFrame();
|
||
|
||
// ステージレイヤー
|
||
stageLayer.disp();
|
||
|
||
// 影更新
|
||
for(var i=0; i<stageLayer.floorObjects.count; i++){
|
||
stageLayer.floorObjects[i].drawShadow();
|
||
}
|
||
|
||
// ヒットマーク
|
||
for(var i=0; i<hitMarks.count; i++){
|
||
var e = hitMarks[i];
|
||
e.onRefreshFrame();
|
||
|
||
// 削除フラグの立っているものを削除する
|
||
if(e.deleteFlag){
|
||
// e.layer.fillRect(0, 0, e.layer.imageWidth, e.layer.imageHeight, 0x000000);
|
||
e.layer.visible = false;
|
||
invalidate e;
|
||
delete e;
|
||
hitMarks.erase(i);
|
||
}
|
||
}
|
||
|
||
if((enemies.count - enemyCountOffset)==0 && conductor === mainConductor){
|
||
if(enemySetFlag){
|
||
stageLayer.scrollLockCount = 0;
|
||
trigger("killall");
|
||
enemySetFlag = false;
|
||
}
|
||
}else{
|
||
informLayer.lastIndicateTick = tickCount - 165;
|
||
}
|
||
|
||
if(nowSelectingPlayer !== void && isvalid nowSelectingPlayer){
|
||
var p = nowSelectingPlayer;
|
||
selectIndicator.rootX = p.rootX - p.selectIndicatorOffset*xDirection(p.layer.inverse);
|
||
|
||
// selectIndicator.rootX = p.rootX - p.centerPos + p.layer.asdWidth/2;
|
||
// selectIndicator.rootX = p.rootX - p.centerPos + p.layer.asdWidth/2 - p.shadowOffset*xDirection(p.layer.inverse);
|
||
//dm(p.layer.asd + ":" + p.layer.conductor.curLine + " / x= " + selectIndicator.rootX);
|
||
|
||
selectIndicator.rootY = p.rootY;
|
||
// selectIndicator.altitude = p.altitude + p.layer.asdHeight;
|
||
// selectIndicator.altitude = p.altitude + 110;
|
||
selectIndicator.onRefreshFrame();
|
||
if(stageLayer !== void && stageLayer.floorObjects.count > 0){
|
||
// selectIndicator.layer.absolute = 18000;
|
||
var a = p.layer.absolute - 200;
|
||
if(a < 10) a = 10;
|
||
selectIndicator.layer.absolute = a;
|
||
}
|
||
|
||
selectIndicator2.rootX = p.rootX - p.centerPos + p.layer.asdWidth/2;
|
||
selectIndicator2.rootY = p.rootY;
|
||
selectIndicator2.altitude = p.altitude + 110;
|
||
selectIndicator2.onRefreshFrame();
|
||
}
|
||
|
||
// 画面揺れ
|
||
if(quaking) onQuake();
|
||
|
||
// ＨＰゲージ等の更新
|
||
informLayer.draw(gaugeDispList);
|
||
|
||
// 残機エクステンド
|
||
if(f.extendScores !== void && f.extendScores.count>0 && f.score>=f.extendScores[0] && !f.inRouteB && !f.inBattleMode){
|
||
f.extendScores.erase(0);
|
||
f.playerNum[0]++;
|
||
f.playerNum[1]++;
|
||
toastMultiLanguage("残機がエクステンドしました。","Remaining Lives EXTENDED.");
|
||
window.se[9].play(%["storage" => "sys_extend"]);
|
||
}
|
||
|
||
if(sf.cloneKillCount >= 1000){
|
||
checkMission("戦闘員");
|
||
}
|
||
}
|
||
|
||
for(var i=0; i<2; i++){
|
||
if(cutinLayer[i].conductor.running){
|
||
// カットイン
|
||
cutinLayer[i].onRefreshFrame();
|
||
}
|
||
}
|
||
|
||
for(var i=0; i<iconLayers.count; i++){
|
||
if(iconLayers[i].conductor.running){
|
||
// アイコンレイヤー
|
||
iconLayers[i].onRefreshFrame();
|
||
}
|
||
}
|
||
|
||
fukidashi.refreshFrame();
|
||
|
||
// 描画（負荷が高いときは間引く）
|
||
if((spf<37 || lastSpf<37 || !refreshFlag) || tf.debugMode){
|
||
refreshFlag = true;
|
||
// copyToSrcLayer();
|
||
dispFrame();
|
||
|
||
// fpsのカウントアップ
|
||
fpsCount++;
|
||
tickCount++;
|
||
}else{
|
||
refreshFlag = false;
|
||
}
|
||
|
||
lastSpf = spf;
|
||
nowTime = System.getTickCount();
|
||
spf = nowTime - lastTime;
|
||
lastTime = nowTime;
|
||
|
||
}
|
||
|
||
function checkClearStage(){
|
||
|
||
var clearFlag = false;
|
||
var bossFlag = false;
|
||
|
||
if(encounterBoss){
|
||
clearFlag = true;
|
||
if(enemies.count == 0){
|
||
dm("敵キャラがゼロ");
|
||
clearFlag = true;
|
||
}else{
|
||
for(var i=0; i<enemies.count; i++){
|
||
var e = enemies[i];
|
||
if(e.isBoss){
|
||
bossFlag = true;
|
||
if(e.HP > 0){
|
||
dm("ボスキャラのＨＰがゼロ以上");
|
||
clearFlag = false;
|
||
break;
|
||
}else{
|
||
dm("ボスキャラが死んだ");
|
||
clearFlag = true;
|
||
}
|
||
}
|
||
}
|
||
if(bossFlag == false) clearFlag = false;
|
||
}
|
||
}
|
||
|
||
dm("■ clearFlag : " + clearFlag);
|
||
return clearFlag;
|
||
}
|
||
|
||
function deleteEnemy(num)
|
||
{
|
||
if(num>=enemies.count) return;
|
||
var e = enemies[num];
|
||
invalidate e;
|
||
enemies.erase(num);
|
||
invalidate informLayer.enemyGaugeLayers[num];
|
||
informLayer.enemyGaugeLayers.erase(num);
|
||
gaugeDispList.erase(num);
|
||
}
|
||
|
||
function copyToSrcLayer()
|
||
{
|
||
srcLayer.absolute = 300;
|
||
srcLayer.piledCopy(0, 0, srcLayer, 0, 0, width, height);
|
||
if(drawLayer.drawFlag){
|
||
srcLayer.operateRect(0, 0, drawLayer, 0, 0, drawLayer.width, drawLayer.height, omPsNormal);
|
||
}
|
||
}
|
||
|
||
function putHitMark(x, y, h, storage=hitMarkStorage[1])
|
||
{
|
||
// var e = new CharacterSprite(window, this, %["type"=>ltPsColorDodge], storage);
|
||
|
||
var inv = intrandom(0,1);
|
||
var rg = Math.random()*1.5+0.5;
|
||
var gg = Math.random()*1.5+0.5;
|
||
var bg = Math.random()*1.5+0.5;
|
||
for(var i=0; i<2; i++){
|
||
var e = new CharacterSprite(window, this, %["type"=>(i==0)?ltPsHardLight:ltPsColorDodge5,"rgamma"=>rg,"ggamma"=>gg,"bgamma"=>bg, "storage"=>storage]);
|
||
e.rootX = x;
|
||
e.rootY = y + 2;
|
||
e.altitude = h - e.layer.asdHeight/2;
|
||
if(e.rootY < stageLayer.topLine-10) return;
|
||
if(inv){
|
||
e.inverse = true;
|
||
e.layer.setInverse();
|
||
}
|
||
if(i == 1) e.opacity2 = 50;
|
||
hitMarks.add(e);
|
||
}
|
||
}
|
||
|
||
function dmKillCount()
|
||
{
|
||
dm("killCount " + tf.killCount[0] + " / " + tf.killCount[1]);
|
||
}
|
||
|
||
function dispFrame()
|
||
{
|
||
if(!enabled) return;
|
||
|
||
if(!refreshFlag){
|
||
refreshFlag = true;
|
||
return;
|
||
}
|
||
copyToSrcLayer();
|
||
|
||
//dispLayerに拡大して表示
|
||
if(zoomRate==1){
|
||
dispLayer2.assignImages(srcLayer);
|
||
}else{
|
||
dispLayer2.stretchCopy(0, 0, width * zoomRate, height * zoomRate, srcLayer, 0, 0, width, height, stNearest);
|
||
}
|
||
|
||
// drawLayerの消去
|
||
if(drawLayer.drawFlag){
|
||
drawLayer.fillRect(0, 0, drawLayer.width, drawLayer.height, 0x00000000);
|
||
drawLayer.drawFlag = false;
|
||
}
|
||
|
||
if(fpsShow){
|
||
var str = "FPS:";
|
||
if(fps < 10) str += " ";
|
||
str += fps;
|
||
dispLayer2.drawText(756-1,746,str,0x000000,255,true,255,0x000000,2);
|
||
dispLayer2.drawText(756+1,746,str,0x000000,255,true,255,0x000000,2);
|
||
dispLayer2.drawText(756,746-1,str,0x000000,255,true,255,0x000000,2);
|
||
dispLayer2.drawText(756,746+1,str,0x000000,255,true,255,0x000000,2);
|
||
dispLayer2.drawText(756,746,str,0xffffff,255,true);
|
||
|
||
if(tf.debugMode){
|
||
if(players.count > 1){
|
||
str = "%03d%s/ %03d%s".sprintf(tf.killCount[0], (players[0].pc.considerAggressiveness(false))? " ": "!", tf.killCount[1], (players[1].pc.considerAggressiveness(false))? " ": "!");
|
||
dispLayer2.drawText(544,746,str,0xffffff,255,true,255,0x000000,2);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
// if(debugMode){
|
||
// kag.fore.layers[0].type = ltAlpha;
|
||
// kag.fore.layers[0].visible = true;
|
||
// kag.fore.layers[0].setSize(width, height);
|
||
//// kag.fore.layers[0].fillRect(0, 0, kag.innerWidth, kag.innerHeight, 0x00000000);
|
||
// }
|
||
dispLayer1.assignImages(dispLayer2);
|
||
}
|
||
|
||
|
||
function loadStage(file, label="")
|
||
{
|
||
resetStage();
|
||
setMode(mode);
|
||
|
||
conductor.loadScenario(file);
|
||
if(label !== "") conductor.goToLabel(label);
|
||
// if(conductor.status != conductor.mRun) conductor.run();
|
||
// ここで走らせず、scenarioRun()で明示的にした方がわかりやすい？
|
||
|
||
// timer.enabled = true;
|
||
// inputTimer.enabled = true;
|
||
// fpsTimer.enabled = true;
|
||
// scenarioPaused = false;
|
||
|
||
informLayer.lastIndicateTick = tickCount - 60;
|
||
}
|
||
|
||
function onPauseKey(){
|
||
if(pauseKeyDisabled) return;
|
||
if(!scenarioPaused){
|
||
if(timer.enabled){
|
||
conductor.stop();
|
||
totEnabled = conductor.timeOutTimer.enabled;
|
||
conductor.timeOutTimer.enabled = false;
|
||
pausedByKey = true;
|
||
informLayer.pauseLayer.visible = true;
|
||
if(sf.pauseScreenMode){
|
||
kag.fore.layers[3].loadImages(%['storage'=>artsList[nowSelectingPlayer.chara][sf.adjEnableNewArts]]);
|
||
kag.fore.layers[3].opacity = 255;
|
||
kag.fore.layers[3].visible = true;
|
||
kag.helpCommandMenu0Item.enabled = false;
|
||
kag.helpCommandMenu1Item.enabled = false;
|
||
}
|
||
if(f.inBattleMode){
|
||
kag.fore.messages[3].visible = true;
|
||
kag.fore.messages[3].locate(1100, 710);
|
||
kag.fore.messages[3].addButton2(%['clickse'=>'sys_decide', 'color'=>0xffffff, 'graphic'=>'general_button6a', 'text'=>"Return", 'fontsize'=>24, 'target'=>'*return']);
|
||
}
|
||
copyToSrcLayer();
|
||
refreshFlag = true;
|
||
dispFrame();
|
||
for(var i=0; i<17; i++){
|
||
kag.se[i].paused = true;
|
||
}
|
||
window.bgm.pause();
|
||
window.se[9].play(%["storage" => "sys_pause"]);
|
||
timer.enabled = false;
|
||
iconLayers[0].opacity = 0;
|
||
iconLayers[1].opacity = 0;
|
||
}else{
|
||
informLayer.pauseLayer.visible = false;
|
||
if(sf.pauseScreenMode){
|
||
kag.fore.layers[3].visible = false;
|
||
kag.helpCommandMenu0Item.enabled = true;
|
||
kag.helpCommandMenu1Item.enabled = true;
|
||
}
|
||
if(f.inBattleMode){
|
||
kag.fore.messages[3].clear();
|
||
kag.fore.messages[3].visible = false;
|
||
}
|
||
for(var i=0; i<17; i++){
|
||
kag.se[i].paused = false;
|
||
}
|
||
window.bgm.resume();
|
||
window.se[9].play(%["storage" => "sys_resume"]);
|
||
timer.enabled = true;
|
||
pausedByKey = false;
|
||
conductor.start();
|
||
conductor.timeOutTimer.enabled = totEnabled;
|
||
lastTime = System.getTickCount();
|
||
iconLayers[0].opacity = 255;
|
||
iconLayers[1].opacity = 255;
|
||
}
|
||
}
|
||
}
|
||
|
||
function scenarioPause(a=true)
|
||
{
|
||
// dispLayer1.hitThreshold = 256;
|
||
// dispLayer2.hitThreshold = 256;
|
||
// dcLayer.hide();
|
||
|
||
interrupted = true;
|
||
timer.enabled = a;
|
||
clearInput();
|
||
inputTimer.enabled =false;
|
||
// fpsTimer.enabled = false;
|
||
scenarioPaused = true;
|
||
conductor.stop();
|
||
}
|
||
|
||
function scenarioRun()
|
||
{
|
||
// dispLayer1.hitThreshold = 0;
|
||
// dispLayer2.hitThreshold = 0;
|
||
|
||
if(conductor.status != conductor.mRun) conductor.run();
|
||
informLayer.pauseLayer.visible = false;
|
||
// srcLayer.visible = debugMode;
|
||
dispLayer1.visible = true;
|
||
dispLayer2.visible = true;
|
||
|
||
interrupted = false;
|
||
timer.enabled = true;
|
||
inputTimer.enabled = true;
|
||
fpsTimer.enabled = true;
|
||
scenarioPaused = false;
|
||
enabled = true;
|
||
|
||
returnState = "";
|
||
lastTime = System.getTickCount();
|
||
}
|
||
|
||
function quit()
|
||
{
|
||
interrupted = true;
|
||
// dcLayer.hide();
|
||
timer.enabled = false;
|
||
clearInput();
|
||
inputTimer.enabled = false;
|
||
fpsTimer.enabled = false;
|
||
enabled = false;
|
||
|
||
if(conductor.status == conductor.mRun)
|
||
conductor.interrupt();
|
||
}
|
||
|
||
function resetStage()
|
||
{
|
||
stopQuake();
|
||
quit();
|
||
|
||
conductor.sleep();
|
||
conductor = mainConductor;
|
||
usingExtraConductor = false;
|
||
pausedByCutin = false;
|
||
|
||
stageLayer.clearStage();
|
||
|
||
//プレイヤー
|
||
resetPlayers();
|
||
nowSelectingPlayerId = 0;
|
||
|
||
resetEnemies();
|
||
resetObjects();
|
||
resetOthers();
|
||
resetHitMarks();
|
||
|
||
for(var i=0; i<2; i++){
|
||
cutinLayer[i].conductor.stop();
|
||
cutinLayer[i].delLayers();
|
||
cutinLayer[i].visible = false;
|
||
}
|
||
|
||
|
||
gaugeDispList = [];
|
||
enemySetFlag = false;
|
||
|
||
srcLayer.fillRect(0, 0, srcLayer.width, srcLayer.height, 0x00000000);
|
||
|
||
shadowLayer.init();
|
||
shadowLayer.visible = true;
|
||
|
||
noRestoreFlag = false;
|
||
|
||
informLayer.init(true);
|
||
selectIndicator.layer.freeImage();
|
||
selectIndicator.layer.visible = false;
|
||
selectIndicator.layer.opacity2 = 0;
|
||
selectIndicator2.layer.freeImage();
|
||
goIndicatorStorage = "";
|
||
|
||
clearFlag = false;
|
||
tf.doubleKO = false;
|
||
|
||
f.noHAttack = false;
|
||
|
||
// timer.interval = sf.adjTimerInterval;
|
||
resetTimerInterval();
|
||
|
||
encounterBoss = false;
|
||
enemyCountOffset = 0;
|
||
|
||
iconHide();
|
||
|
||
// System.doCompact(clAll);
|
||
}
|
||
|
||
function iconHide(){
|
||
for(var i=0; i<iconLayers.count; i++){
|
||
iconLayers[i].freeImage();
|
||
}
|
||
}
|
||
|
||
function resetPlayers()
|
||
{
|
||
// プレイヤーリセット
|
||
for(var i=0; i<players.count; i++){
|
||
if(players[i] !== void) invalidate players[i];
|
||
players[i] = void;
|
||
}
|
||
players =[];
|
||
}
|
||
|
||
function resetEnemies()
|
||
{
|
||
// 敵リセット
|
||
for(var i=0; i<enemies.count; i++){
|
||
if(enemies[i].killedByUser && (enemies[i].HP==0 || enemies[i].deleteFlag)) f.score += enemies[i].score * 2;
|
||
invalidate enemies[i];
|
||
invalidate informLayer.enemyGaugeLayers[i];
|
||
}
|
||
enemies = [];
|
||
informLayer.enemyGaugeLayers = [];
|
||
}
|
||
|
||
function resetObjects()
|
||
{
|
||
// オブジェクトリセット
|
||
for(var i=0; i<objects.count; i++){
|
||
invalidate objects[i];
|
||
}
|
||
objects = [];
|
||
}
|
||
|
||
function resetHitMarks()
|
||
{
|
||
// オブジェクトリセット
|
||
for(var i=0; i<hitMarks.count; i++){
|
||
invalidate hitMarks[i];
|
||
}
|
||
hitMarks = [];
|
||
}
|
||
|
||
function resetOthers()
|
||
{
|
||
//その他オブジェクト
|
||
for(var i=0; i<others.count; i++){
|
||
invalidate others[i];
|
||
}
|
||
others = [];
|
||
}
|
||
|
||
function getFloorLayer(x, y){
|
||
return stageLayer.getFloorLayer(int x, int y);
|
||
}
|
||
|
||
function hide()
|
||
{
|
||
// scenarioPause(false);
|
||
srcLayer.visible = false;
|
||
dispLayer1.fillRect(0, 0, dispLayer1.width, dispLayer1.height, 0x00000000);
|
||
dispLayer2.fillRect(0, 0, dispLayer2.width, dispLayer2.height, 0x00000000);
|
||
dispLayer1.visible = false;
|
||
dispLayer2.visible = false;
|
||
}
|
||
|
||
function show(){
|
||
dispLayer1.visible = true;
|
||
dispLayer2.visible = true;
|
||
}
|
||
|
||
function showFps()
|
||
{
|
||
fps = fpsCount;
|
||
// if(fps > 30 && !noTimerLimit) fps = 30;
|
||
fpsCount = 0;
|
||
|
||
if(nowSelectingPlayer !== void){
|
||
if(timer.enabled && inputTimer.enabled && nowSelectingPlayer.enableFreeMove){
|
||
f.gameTime++;
|
||
//dm(f.gameTime);
|
||
}
|
||
}
|
||
}
|
||
|
||
function returnKag3()
|
||
{
|
||
window.conductor.trigger("bao_trig");
|
||
}
|
||
|
||
function showCutin(storage, l = 0)
|
||
{
|
||
cutinLayer[l].loadImages(%["storage"=>fHeader + storage]);
|
||
}
|
||
|
||
function showIcon(storage, p)
|
||
{
|
||
if(players.count == 1) p = 0;
|
||
var align = informLayer.playerInformLayers[p].align;
|
||
|
||
iconLayers[align].visible = true;
|
||
iconLayers[align].loadImages(%["storage"=>storage, "noZoom"=>true]);
|
||
iconLayers[align].conductor.mp.player = p;
|
||
}
|
||
|
||
|
||
function checkMission(str)
|
||
{
|
||
if(str=="" || str===void) return;
|
||
if(sf.mission[str]===void || sf.mission[str]==false){
|
||
sf.mission[str] = true;
|
||
toast(getMissionClearText(str));
|
||
checkMissionAllClear();
|
||
}
|
||
}
|
||
|
||
|
||
function callExtraConductor(storage, label)
|
||
{
|
||
// conductor.stop();
|
||
mainConductorTotEnabled = conductor.timeOutTimer.enabled;
|
||
conductor.timeOutTimer.enabled = false;
|
||
|
||
// extraConductor を使ってサブルーチンを呼び出す
|
||
conductor = extraConductor; // コンダクタを切り替える
|
||
(Dictionary.assign incontextof extraConductor.macros)(mainConductor.macros);
|
||
if(storage == ''){
|
||
// ストレージ指定がないので現在のストレージを読み込ませる
|
||
storage = mainConductor.curStorage;
|
||
}
|
||
usingExtraConductor = true;
|
||
|
||
// 呼び出す
|
||
conductor.clearCallStack();
|
||
processCall(storage, label);
|
||
}
|
||
|
||
|
||
function processCall(file, label)
|
||
{
|
||
// 指定ファイル、指定ラベルを呼ぶ
|
||
|
||
if(file != ''){
|
||
// ファイルを読み込み
|
||
conductor.loadScenario(file);
|
||
}
|
||
|
||
conductor.callLabel(label); // 実行開始
|
||
dm("処理を開始します : " + file + " / " + label);
|
||
if(conductor.status != conductor.mRun) conductor.run();
|
||
}
|
||
|
||
|
||
function returnExtraConductor()
|
||
{
|
||
// extraConductor のサブルーチンから戻る
|
||
|
||
conductor.sleep(); // 停止
|
||
conductor.interrupt();
|
||
// interrupt は コンダクタのイベント内でコンダクタの実行を
|
||
// 停止させるためのメソッド
|
||
|
||
conductor = mainConductor; // コンダクタを切り替え
|
||
usingExtraConductor = false;
|
||
|
||
conductor.timeOutTimer.enabled = mainConductorTotEnabled;
|
||
}
|
||
|
||
|
||
function onConductorReturn(elm)
|
||
{
|
||
// // コンダクタが return タグを処理するとき
|
||
//
|
||
// if(conductor === extraConductor)
|
||
// {
|
||
//dm("■ conductor.callStackDepth : " + conductor.callStackDepth);
|
||
// // extraConductor サブルーチン用のコンダクタから呼ばれている
|
||
// if(conductor.callStackDepth == 1)
|
||
// {
|
||
// // つまり、最終の return が実行されたと言うこと
|
||
// dm("extraConductor サブルーチンから戻ります ...");
|
||
// returnExtraConductor();
|
||
// if(elm.storage !== void) conductor.loadScenario(elm.storage);
|
||
// if(elm.target !== void) conductor.goToLabel(elm.target);
|
||
//
|
||
// return false; // return は実行しない
|
||
// }
|
||
// }
|
||
return true;
|
||
}
|
||
|
||
|
||
function addHighScore(s)
|
||
{
|
||
var addFlag = false;
|
||
for(var i=0; i<sf.highScore.count; i++){
|
||
if(sf.highScore[i].score < s){
|
||
sf.highScore.insert(i, makeHighScoreData(s));
|
||
addFlag = true;
|
||
break;
|
||
}
|
||
}
|
||
if(!addFlag){
|
||
sf.highScore.add(makeHighScoreData(s));
|
||
}
|
||
if(sf.highScore.count > 20){
|
||
sf.highScore.erase(20);
|
||
}
|
||
}
|
||
|
||
function makeHighScoreData(s)
|
||
{
|
||
var h = %[];
|
||
var d = new Date();
|
||
h.date = "%4d/%02d/%02d %02d:%02d:%02d".sprintf(d.getYear(),(d.getMonth()+1),d.getDate(),d.getHours(),d.getMinutes(),d.getSeconds());
|
||
h.score = s;
|
||
h.difficulty = f.difficulty;
|
||
return h;
|
||
}
|
||
|
||
function onConductorLabel(label, page)
|
||
{
|
||
}
|
||
|
||
function onConductorJump(elm){
|
||
return true;
|
||
}
|
||
|
||
function onConductorCall(elm){
|
||
return true;
|
||
}
|
||
|
||
function onConductorReturn(elm){
|
||
return true;
|
||
}
|
||
|
||
function onConductorAfterReturn(elm){
|
||
return true;
|
||
}
|
||
|
||
// 以下、KAGPlugin のメソッドのオーバーライド
|
||
|
||
function onStore(f, elm)
|
||
{
|
||
var dic = f.bao = %[];
|
||
|
||
dic.conductor = mainConductor.store();
|
||
|
||
dic. mode = mode;
|
||
|
||
dic.scenarioPaused = scenarioPaused;
|
||
dic.hScrollVal = hScrollVal;
|
||
dic.vScrollVal = vScrollVal;
|
||
|
||
if(stageLayer !== void) dic.stageLayer = stageLayer.store();
|
||
|
||
dic.players = [];
|
||
for(var i=0; i<players.count; i++){
|
||
if(players[i] !== void){
|
||
dic.players[i] = players[i].store();
|
||
// dic.players[i].align = informLayer.playerInformLayers[i].align;
|
||
}
|
||
}
|
||
|
||
dic.enemies = [];
|
||
for(var i=0; i<enemies.count; i++){
|
||
dic.enemies[i] = enemies[i].store();
|
||
}
|
||
|
||
dic.objects = [];
|
||
for(var i=0; i<objects.count; i++){
|
||
dic.objects[i] = objects[i].store();
|
||
}
|
||
|
||
dic.others = [];
|
||
for(var i=0; i<others.count; i++){
|
||
dic.others[i] = others[i].store();
|
||
}
|
||
|
||
dic.hitMarks = [];
|
||
for(var i=0; i<hitMarks.count; i++){
|
||
dic.hitMarks[i] = hitMarks[i].store();
|
||
}
|
||
|
||
dic.gaugeDispList = [];
|
||
dic.gaugeDispList.assignStruct(gaugeDispList);
|
||
dic.timeOrigin = timeOrigin;
|
||
dic.lastWaitTime = lastWaitTime;
|
||
|
||
dic.quakeEndTick = quakeEndTick;
|
||
dic.quakeHorzMax = quakeHorzMax;
|
||
dic.quakeVertMax = quakeVertMax;
|
||
dic.quaking = quaking;
|
||
dic.quakePhase = quakePhase;
|
||
|
||
dic.nowSelectingPlayerId = nowSelectingPlayerId;
|
||
|
||
dic.returnState = returnState;
|
||
|
||
dic.goIndicatorStorage = goIndicatorStorage;
|
||
|
||
dic.drawLayer = drawLayer.store();
|
||
|
||
dic.interrupted = interrupted;
|
||
dic.enabled = enabled;
|
||
dic.noRestoreFlag = noRestoreFlag;
|
||
|
||
dic.visible = dispLayer1.visible;
|
||
|
||
dic.jumpStorage = jumpStorage;
|
||
dic.jumpTartget = jumpTarget;
|
||
|
||
dic.encounterBoss = encounterBoss;
|
||
dic.enemyCountOffset = enemyCountOffset;
|
||
|
||
}
|
||
|
||
function onRestore(f, clear, elm)
|
||
{
|
||
if(noRestoreFlag) return;
|
||
|
||
resetStage();
|
||
|
||
var dic = f.bao;
|
||
|
||
// if(dic.mode !== void){
|
||
// mode = dic.mode;
|
||
// }else{
|
||
// mode = 1;
|
||
// }
|
||
//
|
||
// setMode(mode);
|
||
informLayer.init(true);
|
||
|
||
if(dic.conductor.storageName != "") mainConductor.restore(dic.conductor);
|
||
conductor = mainConductor;
|
||
extraConductor.clear();
|
||
usingExtraConductor = false;
|
||
iconLayers[0].freeImage();
|
||
iconLayers[1].freeImage();
|
||
|
||
scenarioPaused = dic.scenarioPaused;
|
||
hScrollVal = dic.hScrollVal;
|
||
vScrollVal = dic.vScrollVal;
|
||
|
||
nowSelectingPlayerId = dic.nowSelectingPlayerId;
|
||
|
||
if(dic.stageLayer !== void) stageLayer.restore(dic.stageLayer);
|
||
|
||
|
||
// 各スプライトrestoreその１
|
||
|
||
for(var i=0; i<dic.players.count; i++){
|
||
if(dic.players[i] !== void){
|
||
setPlayer(dic.players[i]);
|
||
players[i].restore(dic.players[i]);
|
||
}
|
||
}
|
||
|
||
for(var i=0; i<dic.objects.count; i++){
|
||
if(!dic.objects[i].noStore){
|
||
dic.objects[i].storage = dic.objects[i].layer.storage;
|
||
if(dic.objects[i].objectClass == clEffect){
|
||
setEffect(dic.objects[i]);
|
||
}else{
|
||
setObject(dic.objects[i]);
|
||
}
|
||
objects[objects.count-1].restore(dic.objects[i]);
|
||
|
||
if(typeof(objects[objects.count-1].params.return)!="undefined"){
|
||
Scripts.eval(objects[objects.count-1].params.return + " = bao.objects[bao.objects.count-1]");
|
||
}
|
||
}
|
||
}
|
||
|
||
for(var i=0; i<dic.enemies.count; i++){
|
||
setEnemy(dic.enemies[i].params);
|
||
if(enemies[i] !== void){
|
||
enemies[i].restore(dic.enemies[i]);
|
||
if(typeof(enemies[i].params.return)!="undefined"){
|
||
Scripts.eval(enemies[i].params.return + " = bao.enemies[bao.enemies.count-1]");
|
||
}
|
||
}
|
||
}
|
||
|
||
for(var i=0; i<dic.others.count; i++){
|
||
dic.others[i].storage = dic.others[i].layer.storage;
|
||
setOthers(dic.others[i]);
|
||
others[i].restore(dic.others[i]);
|
||
}
|
||
|
||
for(var i=0; i<dic.hitMarks.count; i++){
|
||
var e = new CharacterSprite(window, this, %["type"=>ltPsHardLight, "storage"=>hitMarkStorage[1]]);
|
||
e.restore(dic.hitMarks[i]);
|
||
hitMarks.add(e);
|
||
}
|
||
|
||
// 各スプライトrestoreその２
|
||
for(var i=0; i<players.count; i++) players[i].restore2();
|
||
for(var i=0; i<objects.count; i++) objects[i].restore2();
|
||
for(var i=0; i<enemies.count; i++) enemies[i].restore2();
|
||
for(var i=0; i<others.count; i++) others[i].restore2();
|
||
for(var i=0; i<hitMarks.count; i++) hitMarks[i].restore2();
|
||
|
||
|
||
gaugeDispList = [];
|
||
gaugeDispList.assignStruct(dic.gaugeDispList);
|
||
timeOrigin = dic.timeOrigin;
|
||
lastWaitTime = dic.lastWaitTime;
|
||
|
||
quakeEndTick = dic.quakeEndTick;
|
||
quakeHorzMax = dic.quakeHorzMax;
|
||
quakeVertMax = dic.quakeVertMax;
|
||
quaking = dic.quaking;
|
||
quakePhase = dic.quakePhase;
|
||
|
||
returnState = dic.returnState;
|
||
|
||
goIndicatorStorage = dic.goIndicatorStorage;
|
||
|
||
if(dic.drawLayer !== void) drawLayer.restore(dic.drawLayer);
|
||
|
||
interrupted = dic.interrupted;
|
||
enabled = dic.enabled;
|
||
noRestoreFlag = dic.noRestoreFlag;
|
||
|
||
if(enabled){
|
||
//その他画面更新
|
||
shadowLayer.onRefreshFrame();
|
||
stageLayer.disp();
|
||
informLayer.draw(gaugeDispList);
|
||
scenarioRun();
|
||
}
|
||
|
||
dispLayer1.visible = dic.visible;
|
||
dispLayer2.visible = dic.visible;
|
||
|
||
if(dic.jumpStorage!==void) jumpStorage = dic.jumpStorage;
|
||
if(dic.jumpTarget!==void) jumpTarget = dic.jumpTarget;
|
||
|
||
if(dic.encounterBoss!==void) encounterBoss = dic.encounterBoss;
|
||
if(dic.enemyCountOffset!==void) enemyCountOffset = dic.enemyCountOffset;
|
||
|
||
pauseKeyDisabled = false;
|
||
}
|
||
|
||
function onStableStateChanged(stable)
|
||
{
|
||
}
|
||
|
||
function onMessageHiddenStateChanged(hidden)
|
||
{
|
||
}
|
||
|
||
function onCopyLayer(toback)
|
||
{
|
||
}
|
||
|
||
function onExchangeForeBack()
|
||
{
|
||
srcLayer.parent = window.fore.base;
|
||
for(var i=0; i<2; i++){
|
||
iconLayers[i].parent = window.fore.base;
|
||
iconLayers[i].absolute = 101;
|
||
}
|
||
dispLayer1.parent <-> dispLayer2.parent;
|
||
dispLayer1.absolute = 100;
|
||
dispLayer2.absolute = 100;
|
||
}
|
||
|
||
function onSaveSystemVariables()
|
||
{
|
||
}
|
||
|
||
function onConductorScript(script, scriptname, lineofs)
|
||
{
|
||
// iscript タグ
|
||
try
|
||
{
|
||
Scripts.exec(script, scriptname, lineofs);
|
||
}
|
||
catch(e)
|
||
{
|
||
throw new Exception(scriptname + " の 行 " + lineofs + " から始まる"
|
||
" iscript ブロックでエラーが発生しました。"
|
||
"\n( 詳細はコンソールを参照してください )\n" + e.message);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
//------------------------------------------------- コンダクタのイベント --
|
||
|
||
function onConductorScenarioLoad(name)
|
||
{
|
||
// コンダクタが新しいシナリオファイルを読み込む前によばれる。
|
||
// name は読み込もうとしたシナリオファイル。
|
||
// 戻り値に文字列を返すと、それをシナリオとして
|
||
// ファイルの代わりに使うようになるので、ここにフィルタを書くこ
|
||
// とができる。
|
||
// true を返すと通常のシナリオファイル読み込みとなる。
|
||
return true;
|
||
}
|
||
|
||
|
||
function onConductorScenarioLoaded(name)
|
||
{
|
||
// コンダクタが新しいシナリオファイルを読み込んだ
|
||
// if(!usingExtraConductor) incRecordLabel(true);
|
||
return true;
|
||
}
|
||
|
||
//------------------------------------------------------------- 背景関連 --
|
||
|
||
function setBackGround(elm)
|
||
{
|
||
|
||
stageLayer.loadImages(elm.storage);
|
||
if(elm.left !== void) stageLayer.dispLeft = -elm.left;
|
||
|
||
}
|
||
|
||
// function bgScroll(x, length)
|
||
// {
|
||
// return stageLayer.bgScroll(x, length);
|
||
// }
|
||
|
||
function bgScrollSoon(left)
|
||
{
|
||
if(left + internalWidth > stageLayer.wallLayer.width){
|
||
left = stageLayer.wallLayer.width - internalWidth;
|
||
}
|
||
if(left < 0) left = 0;
|
||
|
||
var d = left - stageLayer.dispLeft;
|
||
stageLayer.dispLeft = left;
|
||
|
||
players[nowSelectingPlayerId].rootX -= d;
|
||
for(var i=0; i<enemies.count; i++){
|
||
enemies[i].rootX -= d ;
|
||
}
|
||
for(var i=0; i<objects.count; i++){
|
||
objects[i].rootX -= d ;
|
||
}
|
||
}
|
||
|
||
function setTriggerLine(line)
|
||
{
|
||
return stageLayer.setTriggerLine(line);
|
||
}
|
||
|
||
function setTriggerLine2(line)
|
||
{
|
||
return stageLayer.setTriggerLine2(line);
|
||
}
|
||
|
||
//------------------------------------------------------------ quake関連 --
|
||
|
||
function doQuake(elm)
|
||
{
|
||
// elm に従って quake を開始
|
||
if(elm.frame !== void){
|
||
quakeEndTick = tickCount + +elm.frame;
|
||
}else{
|
||
quakeEndTick = -1;
|
||
}
|
||
|
||
if(elm.hmax !== void) quakeHorzMax = +elm.hmax; else quakeHorzMax = 1;
|
||
if(elm.vmax !== void) quakeVertMax = +elm.vmax; else quakeVertMax = 1;
|
||
|
||
quaking = true;
|
||
}
|
||
|
||
function stopQuake()
|
||
{
|
||
// 揺れを停止
|
||
dispLayer1.setPos(0, 0);
|
||
dispLayer2.setPos(0, 0);
|
||
quaking = false;
|
||
}
|
||
|
||
function onQuake()
|
||
{
|
||
if(quakeEndTick != -1 && tickCount > quakeEndTick){
|
||
stopQuake();
|
||
return;
|
||
}
|
||
|
||
var x, y;
|
||
if(quakeHorzMax == quakeVertMax)
|
||
{
|
||
// だいたい同じ
|
||
x = int(Math.random() * quakeHorzMax - quakeHorzMax);
|
||
y = int(Math.random() * quakeVertMax - quakeVertMax);
|
||
}
|
||
else if(quakeHorzMax < quakeVertMax)
|
||
{
|
||
// 縦揺れ
|
||
x = int(Math.random() * quakeHorzMax - quakeHorzMax);
|
||
y = int((quakePhase ? Math.random() : -Math.random()) * quakeVertMax);
|
||
}
|
||
else
|
||
{
|
||
// 横揺れ
|
||
x = int((quakePhase ? Math.random() : -Math.random()) * quakeHorzMax);
|
||
y = int(Math.random() * quakeVertMax - quakeVertMax);
|
||
}
|
||
quakePhase = !quakePhase;
|
||
dispLayer1.setPos(x, y);
|
||
dispLayer2.setPos(x, y);
|
||
}
|
||
|
||
//--------------------------------------------------------- スプライト関連 --
|
||
|
||
function resumeQueueAll(elm)
|
||
{
|
||
for(var i=0; i<players.count; i++){
|
||
if(players[i] !== void) players[i].resumeQueue();
|
||
}
|
||
for(var i=0; i<enemies.count; i++) enemies[i].resumeQueue();
|
||
for(var i=0; i<objects.count; i++) objects[i].resumeQueue();
|
||
}
|
||
|
||
function getObject(elm)
|
||
{
|
||
if(elm.id == "player") return players[0];
|
||
if(elm.id == "player0") return players[0];
|
||
if(elm.id == "player1") return players[1];
|
||
|
||
var index = elm.id.indexOf("enemy");
|
||
if(index != -1){
|
||
var id = +elm.id.substring(5);
|
||
if(enemies[id] !== void) return enemies[id];
|
||
}
|
||
var index = elm.id.indexOf("object");
|
||
if(index != -1){
|
||
var id = +elm.id.substring(6);
|
||
if(objects[id] !== void) return objects[id];
|
||
}
|
||
return void;
|
||
}
|
||
|
||
function getOtherPlayer(p){
|
||
for(var i=0; i<players.count; i++){
|
||
if(players[i] !== p && isvalid players[i]) return players[i];
|
||
}
|
||
return void;
|
||
}
|
||
|
||
function getNearestEnemy(p, kind = void){
|
||
var nd = 500 * 500;
|
||
var ne = void;
|
||
for(var i=0; i<enemies.count; i++){
|
||
var e = enemies[i];
|
||
if(kind !== void && kind != e.kind){
|
||
continue;
|
||
}
|
||
var d = getDistance(e, p);
|
||
if(d < nd && isvalid e){
|
||
nd = d;
|
||
ne = e;
|
||
}
|
||
}
|
||
return ne;
|
||
}
|
||
|
||
|
||
// function getIndex(obj)
|
||
// {
|
||
// if(typeof(obj.objectClass) == 'undefined') return -1;
|
||
// switch(obj.objectClass){
|
||
// case clPlayer:
|
||
// for(var i=0; i<players.count; i++){
|
||
// if(players[i] === obj) return i;
|
||
// }
|
||
// break;
|
||
// case clEnemy:
|
||
// for(var i=0; i<enemies.count; i++){
|
||
// if(enemies[i] === obj) return i;
|
||
// }
|
||
// break;
|
||
// case clObject:
|
||
// for(var i=0; i<objects.count; i++){
|
||
// if(objects[i] === obj) return i;
|
||
// }
|
||
// break;
|
||
// }
|
||
// return -1;
|
||
// }
|
||
|
||
function getObjectFromClassAndIndex(cls, index)
|
||
{
|
||
if(index < 0) return void;
|
||
|
||
switch(cls){
|
||
case clPlayer:
|
||
return players[index];
|
||
case clEnemy:
|
||
return enemies[index];
|
||
case clObject:
|
||
case clEffect:
|
||
return objects[index];
|
||
}
|
||
}
|
||
|
||
function checkSpritesStabled()
|
||
{
|
||
// var tick = tickCount;
|
||
for(var i=0; i<players.count; i++){
|
||
// if(tick > tickCount+10) return false;
|
||
var p = players[i];
|
||
//dm('player : ' + i +' / nowSpriteId : ' + (st(p.nowSpriteId)));
|
||
// これHPがゼロになってたらどうなるんだろ……大丈夫っぽい？
|
||
switch (p.nowSpriteId){
|
||
case stClinched:
|
||
case stClinchedStruggle:
|
||
p.loadSprite(stUntangle);
|
||
p.initSpriteTable();
|
||
break;
|
||
case stClinching:
|
||
case stBackClinch:
|
||
case stStanding:
|
||
case stStanding2:
|
||
case stStanding3:
|
||
case stClinching:
|
||
case stSitDown:
|
||
break;
|
||
default:
|
||
return false;
|
||
}
|
||
}
|
||
|
||
for(var i=0; i<enemies.count; i++){
|
||
// if(tick > tickCount+10) return false;
|
||
var e = enemies[i];
|
||
if(e === void || !isvalid e) break;
|
||
//dm('enemy : ' + i +' / nowSpriteId : ' + (st(e.nowSpriteId)));
|
||
switch (e.nowSpriteId){
|
||
case stClinched:
|
||
case stDamage1:
|
||
case stDamage2:
|
||
case stStanding:
|
||
case stStanding2:
|
||
case stStandUp:
|
||
case stEtc1:
|
||
case stEtc2:
|
||
case stEtc3:
|
||
break;
|
||
case stThrown1:
|
||
case stThrown2:
|
||
case stThrown3:
|
||
case stThrown4:
|
||
case stThrown5:
|
||
case stThrown6:
|
||
if(int(e.fAltitude-e.altitude)==0) break;
|
||
return false;
|
||
case stWalk:
|
||
case stDash:
|
||
e.loadSprite(stStanding);
|
||
break;
|
||
default:
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// for(var i=0; i<objects.count; i++){
|
||
//// if(tick > tickCount+10) return false;
|
||
// var o = objects[i];
|
||
//dm('object : ' + i +' / layer.asd : ' + o.layer.asd);
|
||
// if(o === void || !isvalid o) break;
|
||
// if(o.objectClass == clEffect){
|
||
// o.layer.dOpacity2 = -30;
|
||
// return false;
|
||
// }
|
||
// }
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
//------------------------------------------------- プレイヤーキャラ関連 --
|
||
|
||
function setPlayer(elm)
|
||
{
|
||
var pNum = players.count;
|
||
elm.id = pNum;
|
||
|
||
var p;
|
||
var e = %[];
|
||
if(typeof elm.kind == "String"){
|
||
elm.kind = elm.kind.toLowerCase();
|
||
}else{
|
||
if(elm.params !== void) elm.kind= elm.params.kind;
|
||
}
|
||
|
||
switch(elm.kind){
|
||
case "chiffon":
|
||
p = new ChiffonSprite(window, this, elm);
|
||
break;
|
||
case "chocolat":
|
||
p = new ChocolatSprite(window, this, elm);
|
||
break;
|
||
case "dummy":
|
||
p = new DummyPlayerSprite(window, this, elm);
|
||
break;
|
||
default:
|
||
p = new ChiffonSprite(window, this, elm);
|
||
}
|
||
|
||
players.add(p);
|
||
setPlayerState(elm, players[pNum]);
|
||
|
||
e.face = p.faceStorage;
|
||
e.id = pNum;
|
||
e.maxHP = players[pNum].maxHP;
|
||
e.HP = players[pNum].HP;
|
||
e.maxMP = players[pNum].maxMP;
|
||
e.MP = players[pNum].MP;
|
||
if(elm.align === void){
|
||
if(sf.adjSinglePlayMode && f.stage != 5){
|
||
e.align = 0;
|
||
}else{
|
||
e.align = pNum;
|
||
}
|
||
}else{
|
||
e.align = +elm.align;
|
||
}
|
||
// e.align = p.chara;
|
||
|
||
p.defaultFaceNum = informLayer.getDefaultFaceNum(pNum);
|
||
informLayer.addPlayerInformLayer(e);
|
||
|
||
if(pNum == nowSelectingPlayerId && sf.showSelectIndicator >= 1) showSelectIndicator(nowSelectingPlayerId);
|
||
if(players.count >= 2){
|
||
if(nowSelectingPlayerId){
|
||
// exchangePlayer()の中にnowSelectingPlayerIdを反転させる処理が入っているので、あらかじめ反転させてしまう（なので元に戻る）
|
||
nowSelectingPlayerId = !nowSelectingPlayerId;
|
||
exchangePlayer();
|
||
}
|
||
p0 = players[0];
|
||
p1 = players[1];
|
||
}else{
|
||
p0 = players[0];
|
||
}
|
||
|
||
}
|
||
|
||
function setPlayerState(elm, t)
|
||
{
|
||
var p;
|
||
var type = typeof(t);
|
||
|
||
switch (type){
|
||
case 'Object':
|
||
p = t;
|
||
break;
|
||
case 'Integer':
|
||
p = players[t];
|
||
break;
|
||
default:
|
||
p = nowSelectingPlayer;
|
||
break;
|
||
}
|
||
|
||
if(elm.storage !== void) p.loadImages(elm);
|
||
if(elm.spriteid !== void) p.loadSprite(Scripts.eval(elm.spriteid));
|
||
if(elm.enablemove !==void){
|
||
enableInput = +elm.enablemove;
|
||
if(enableInput) kag.cancelSkip();
|
||
}
|
||
p.setState(elm);
|
||
}
|
||
|
||
function setAllPlayersState(elm)
|
||
{
|
||
for(var i=0; i<players.count; i++){
|
||
setPlayerState(elm, players[i]);
|
||
}
|
||
}
|
||
|
||
function tag_setPlayerState(elm)
|
||
{
|
||
if(elm.id !== void){
|
||
setPlayerState(elm, elm.id);
|
||
return;
|
||
}
|
||
if(elm.object !== void){
|
||
setPlayerState(elm, elm.object);
|
||
return;
|
||
}
|
||
setAllPlayersState(elm);
|
||
}
|
||
|
||
//--------------------------------------------------------- 敵キャラ関連 --
|
||
|
||
function setEnemy3(elm)
|
||
{
|
||
if(sf.adjItemIncrease){
|
||
elm.atdelexp="bao.setObject(%['storage'=>'item01','rootx'=>sprite.rootX,'rooty'=>sprite.rootY])";
|
||
elm.rgamma=1.5;
|
||
}
|
||
setEnemy2(elm);
|
||
}
|
||
|
||
function setEnemy4(elm)
|
||
{
|
||
if(sf.adjItemIncrease){
|
||
elm.atdelexp="bao.setObject(%['storage'=>'item02','rootx'=>sprite.rootX,'rooty'=>sprite.rootY])";
|
||
elm.bgamma=1.5;
|
||
}
|
||
setEnemy2(elm);
|
||
}
|
||
|
||
function setEnemy2(elm)
|
||
{
|
||
if(!+elm.force && (sf.adjEnemyChangeKind != 'e01' || f.difficulty <= 2)){
|
||
elm.kind = sf.adjEnemyChangeKind;
|
||
}
|
||
setEnemy(elm);
|
||
}
|
||
|
||
function setEnemy(elm)
|
||
{
|
||
var e;
|
||
|
||
switch(elm.kind){
|
||
case "e01":
|
||
case "e01a":
|
||
case "戦闘員":
|
||
// 通常
|
||
if(elm.cosstate === void) elm.cosstate = 0;
|
||
e = new SoldierSprite(window, this, elm);
|
||
break;
|
||
case "e01sw":
|
||
case "e01b":
|
||
case "戦闘員剣":
|
||
// ソード
|
||
if(elm.cosstate === void) elm.cosstate = 1;
|
||
e = new SoldierSprite(window, this, elm);
|
||
break;
|
||
case "e01mc":
|
||
case "e01sh":
|
||
case "e01c":
|
||
case "戦闘員盾":
|
||
case "戦闘員メイス":
|
||
// 盾＆メイス
|
||
if(elm.cosstate === void) elm.cosstate = 2;
|
||
e = new SoldierSprite(window, this, elm);
|
||
break;
|
||
case "e01w":
|
||
case "e01d":
|
||
case "有翼戦闘員":
|
||
// 羽有り
|
||
e = new WingedSoldierSprite(window, this, elm);
|
||
break;
|
||
case "e01u":
|
||
case "戦闘員上":
|
||
e = new UpstairsSoldierSprite(window, this, elm);
|
||
break;
|
||
case "e01k":
|
||
case "e01d":
|
||
case "戦闘員ナイフ":
|
||
e = new KnifeSoldierSprite(window, this, elm);
|
||
break;
|
||
|
||
case "e82":
|
||
case "ネット":
|
||
e = new NetSprite(window, this, elm);
|
||
break;
|
||
|
||
case "e02":
|
||
case "e02a":
|
||
case "女戦闘員":
|
||
e = new FemaleSoldierSprite(window, this, elm);
|
||
break;
|
||
|
||
case "e02b":
|
||
case "女戦闘員爪":
|
||
// クロー装備
|
||
if(elm.cosstate === void) elm.cosstate = 1;
|
||
e = new FemaleSoldierSprite(window, this, elm);
|
||
break;
|
||
|
||
case "e03":
|
||
case "一般人":
|
||
e = new PeopleSprite(window, this, elm);
|
||
break;
|
||
|
||
case "e04":
|
||
case "上級戦闘員":
|
||
e = new HiSoldierSprite(window, this, elm);
|
||
break;
|
||
|
||
case "e05":
|
||
case "オルトロス":
|
||
// e = new StudentSprite(window, this, elm);
|
||
e = new OrthrosSprite(window, this, elm);
|
||
break;
|
||
|
||
case "e06":
|
||
case "邪妖蟲":
|
||
e = new EvilInsectSprite(window, this, elm);
|
||
break;
|
||
|
||
case "e07":
|
||
case "ゴブリン兵":
|
||
e = new GoblinSprite(window, this, elm);
|
||
break;
|
||
|
||
case "e07s":
|
||
case "隠れゴブリン兵":
|
||
e = new GoblinStealthSprite(window, this, elm);
|
||
break;
|
||
|
||
case "e08":
|
||
case "スライム":
|
||
e = new SlimeSprite(window, this, elm);
|
||
break;
|
||
|
||
case "e09":
|
||
case "オーガ兵":
|
||
e = new OgreSprite(window, this, elm);
|
||
break;
|
||
|
||
|
||
case "e11":
|
||
case "デビルオーク":
|
||
e = new OrcSprite(window, this, elm);
|
||
break;
|
||
|
||
case "e31":
|
||
case "デスオーク":
|
||
e = new Orc2Sprite(window, this, elm);
|
||
break;
|
||
case "e32":
|
||
case "ヘルオーク":
|
||
e = new Orc3Sprite(window, this, elm);
|
||
break;
|
||
|
||
case "e12":
|
||
case "サイコウィザード":
|
||
e = new WizardSprite(window, this, elm);
|
||
break;
|
||
case "e13":
|
||
case "ジャイアントスクイッド":
|
||
e = new SquidSprite(window, this, elm);
|
||
break;
|
||
case "e14":
|
||
case "ベイゼル":
|
||
e = new BeizelSprite(window, this, elm);
|
||
break;
|
||
case "e83":
|
||
case "触手基部":
|
||
e = new BeizelTentacleBaseSprite(window, this, elm);
|
||
break;
|
||
|
||
|
||
case "e15f":
|
||
case "フェイクレヴィエラ":
|
||
e = new FakeReviellaSprite(window, this, elm);
|
||
break;
|
||
|
||
case "e15":
|
||
case "レヴィエラ":
|
||
e = new ReviellaSprite(window, this, elm);
|
||
break;
|
||
|
||
case "e16":
|
||
case "エルゴネア":
|
||
e = new ElgonaireSprite(window, this, elm);
|
||
break;
|
||
|
||
|
||
case "e21":
|
||
case "シフォン":
|
||
e = new EnemyChiffonSprite(window, this, elm);
|
||
break;
|
||
|
||
case "e22":
|
||
case "ショコラ":
|
||
e = new EnemyChocolatSprite(window, this, elm);
|
||
break;
|
||
|
||
|
||
case "e81":
|
||
case "魔影蝶":
|
||
e = new ButterflySprite(window, this, elm);
|
||
break;
|
||
|
||
|
||
case "e99":
|
||
e = new MobSprite(window, this, elm);
|
||
break;
|
||
default:
|
||
e = new SoldierSprite(window, this, elm);
|
||
}
|
||
if(elm.enablemove === void) elm.enablemove = true;
|
||
|
||
if(elm.y !== void) elm.rooty = elm.y;
|
||
if(elm.x !== void) elm.rootx = elm.x;
|
||
|
||
var flg1 = false;
|
||
var flg2 = false;
|
||
if(elm.rooty===void){
|
||
flg1 = true;
|
||
elm.rooty = intrandom(e.movableRect.top, e.movableRect.bottom);
|
||
}
|
||
if(elm.rootx===void){
|
||
flg2 = true;
|
||
if(tf.inRescueMode){
|
||
var x = [e.movableRect.left + 1, e.movableRect.right - 1];
|
||
var r = intrandom(0, 1);
|
||
if(stageLayer.getAltitude(x[r], +elm.rooty, 1) > 0){
|
||
r = !r;
|
||
}
|
||
elm.rootx = x[r];
|
||
}else if(stageLayer.xFreeMode || +elm.random){
|
||
var px = players[0].rootX + stageLayer.dispLeft;
|
||
var x = intrandom(80, int(stageLayer.wallLayer.width / (bao.cZoomRate/bao.sZoomRate)) - 80);
|
||
// 主人公のそばやオブジェクトの上には発生しないようにする
|
||
if(players[0]!==void){
|
||
while((px-100<x && x<px+100) || stageLayer.getAltitude(x-stageLayer.dispLeft,+elm.rooty,1)!=0
|
||
|| (stageLayer.enemySetAvoidRect.isEmpty && stageLayer.enemySetAvoidRect.includedPos(x,elm.rooty))){
|
||
x = intrandom(80, stageLayer.wallLayer.width / (bao.cZoomRate/bao.sZoomRate) - 80);
|
||
}
|
||
}
|
||
elm.rootx = x - stageLayer.dispLeft;
|
||
}else{
|
||
if(intrandom(0,1)==0){
|
||
elm.rootx = e.movableRect.left + 1;
|
||
}else{
|
||
elm.rootx = e.movableRect.right - 1;
|
||
}
|
||
}
|
||
}
|
||
if(elm.rootx=="random"){
|
||
flg2 = true;
|
||
elm.rootx = intrandom(40, internalWidth-40);
|
||
}
|
||
if(elm.rootx=="rightrandom"){
|
||
elm.rootx = intrandom(-40, 280);
|
||
}
|
||
if(elm.inverse ===void && (elm.rootx=="left" || elm.rootx=="l" || elm.rootx<0)) elm.inverse=true;
|
||
|
||
if(elm.rootx !== void){
|
||
if(elm.rootx == "left" || elm.rootx == "l"){
|
||
flg2 = true;
|
||
elm.rootx = e.movableRect.left + 1;
|
||
}else if(elm.rootx == "right" || elm.rootx == "r"){
|
||
flg2 = true;
|
||
elm.rootx = e.movableRect.right - 1;
|
||
}else{
|
||
elm.rootx = +elm.rootx;
|
||
}
|
||
}
|
||
|
||
if(stageLayer.getAltitude(elm.rootx, elm.rootx) > 0){
|
||
invalidate e;
|
||
return;
|
||
}
|
||
|
||
e.setState(elm);
|
||
enemies.add(e);
|
||
informLayer.addEnemyGauge(e.maxHP, e.name);
|
||
|
||
enemySetFlag = true;
|
||
setEnemyCount++;
|
||
|
||
if(f.difficulty >4 && !e.isBoss && elm.return === void && elm.atdelexp === void && setEnemyCount % 3 == 0 && flg1 && flg2){
|
||
setEnemy(elm);
|
||
}
|
||
|
||
if(elm.return!==void){
|
||
if(elm.from!==void){
|
||
Scripts.eval(elm.return + " = bao.objects[bao.objects.count-1]",,,elm.from.conductor);
|
||
}else{
|
||
Scripts.eval(elm.return + " = bao.enemies[bao.enemies.count-1]");
|
||
}
|
||
}
|
||
return e;
|
||
}
|
||
|
||
// function setEnemy2(elm){
|
||
// if(elm.y !== void) elm.rooty = elm.y;
|
||
// if(elm.x !== void) elm.rootx = elm.x;
|
||
//
|
||
// if(elm.rooty < stageLayer.topLine) elm.rooty = stageLayer.topLine;
|
||
// if(elm.rooty > stageLayer.bottomLine) elm.rooty = stageLayer.bottomLine;
|
||
// setEnemy(...);
|
||
// }
|
||
|
||
function setEnemyState(e, elm)
|
||
{
|
||
if(elm.storage !== void) e.loadSprite(Scripts.eval(elm.storage));
|
||
e.setState(elm);
|
||
}
|
||
|
||
function setAllEnemiesState(elm)
|
||
{
|
||
for(var i=0; i<enemies.count; i++)
|
||
setEnemyState(enemies[i], elm);
|
||
}
|
||
|
||
function gatherToPlayer()
|
||
{
|
||
for(var i=0; i<enemies.count; i++){
|
||
var e = enemies[i];
|
||
if(!e.enableFreeMove) continue;
|
||
if(e.noMove) continue;
|
||
if(e.HP <= 0) continue;
|
||
if(e.layer.graphic=="e010_ride") continue;
|
||
if(e.layer.asd[0]!="e") continue;
|
||
if(e.maxHP < 20) continue;
|
||
|
||
var target = getNearestPlayer(e);
|
||
|
||
var tx = target.rootX;
|
||
var ty = target.rootY;
|
||
for(var i=0; target.movingTable[i]!==void; i++){
|
||
tx += target.movingTable[i].x;
|
||
ty += target.movingTable[i].y;
|
||
}
|
||
|
||
var r = i + 30;
|
||
e.addQueue("[waitaction][move path=(" + int(tx + r*Math.cos(r)) + "," + int(ty + r*Math.sin(r)) + ",0) mode=absolute]");
|
||
}
|
||
}
|
||
|
||
function getNearestPlayer(obj){
|
||
if(sf.adjSinglePlayMode){
|
||
return nowSelectingPlayer;
|
||
}
|
||
var d = getDistance(obj, players[0]);
|
||
var o = players[0];
|
||
for(var i=1; i<players.count; i++){
|
||
var dd = getDistance(obj, players[i]);
|
||
if(dd < d){
|
||
d = dd;
|
||
o = players[i];
|
||
}
|
||
}
|
||
return o;
|
||
}
|
||
|
||
function getIndex(obj){
|
||
if(obj === void || !isvalid obj) return void;
|
||
switch(obj.objectClass){
|
||
case clPlayer:
|
||
return getPlayerIndex(obj);
|
||
case clEnemy:
|
||
return getEnemyIndex(obj);
|
||
case clObject:
|
||
case clEffect:
|
||
return getObjectIndex(obj);
|
||
}
|
||
}
|
||
|
||
function getPlayerIndex(p){
|
||
for(var i=0; i<players.count; i++){
|
||
if(players[i] === p) return i;
|
||
}
|
||
}
|
||
|
||
function getEnemyIndex(obj){
|
||
if(obj !== void){
|
||
for(var i=0; i<enemies.count; i++){
|
||
if(enemies[i] === obj){
|
||
return i;
|
||
}
|
||
}
|
||
}
|
||
return void;
|
||
}
|
||
|
||
function getObjectIndex(obj){
|
||
if(obj !== void){
|
||
for(var i=0; i<objects.count; i++){
|
||
if(objects[i] === obj){
|
||
return i;
|
||
}
|
||
}
|
||
}
|
||
return void;
|
||
}
|
||
|
||
|
||
function getNearEnemy(x, y, range=20)
|
||
{
|
||
var minDistance = 1000000;
|
||
var nearestEnemy = void;
|
||
for(var i=0; i<enemies.count; i++){
|
||
var e = enemies[i];
|
||
var d = (x-e.rootX)*(x-e.rootX) + (y-e.rootY)*(y-e.rootY);
|
||
if(e.deleteFlag) continue;
|
||
if(d < range*range && d < minDistance){
|
||
minDistance = d;
|
||
nearestEnemy = e;
|
||
}
|
||
}
|
||
return nearestEnemy;
|
||
}
|
||
|
||
|
||
function getNearPlayer(x, y, range=20)
|
||
{
|
||
var minDistance = 1000000;
|
||
var nearestPlayer = void;
|
||
for(var i=0; i<players.count; i++){
|
||
var p = players[i];
|
||
if(sf.adjSinglePlayMode && p === bao.getOtherPlayer(bao.nowSelectingPlayer)) continue;
|
||
|
||
var d = (x-p.rootX)*(x-p.rootX) + (y-p.rootY)*(y-p.rootY);
|
||
if(d < range*range && d < minDistance){
|
||
minDistance = d;
|
||
nearestPlayer = p;
|
||
}
|
||
}
|
||
return nearestPlayer;
|
||
}
|
||
|
||
|
||
function getHighHpEnemy()
|
||
{
|
||
var mh = 0;
|
||
var me = void;
|
||
for(var i=0; i<enemies.count; i++){
|
||
var e = enemies[i];
|
||
if(e.rootX > -50 && e.rootX < internalWidth+50 && e.HP > mh){
|
||
mh = e.HP;
|
||
me = e;
|
||
}
|
||
}
|
||
return me;
|
||
}
|
||
|
||
|
||
//--------------------------------------------------- その他オブジェクト --
|
||
|
||
function setObject(elm)
|
||
{
|
||
if(elm.y !== void) elm.rooty = elm.y;
|
||
if(elm.x !== void) elm.rootx = elm.x;
|
||
var o;
|
||
o = new ObjectSprite(window, this, elm);
|
||
o.setState(elm);
|
||
objects.add(o);
|
||
|
||
if(elm.soon){
|
||
o.onRefreshFrame(0, 0);
|
||
}
|
||
|
||
if(elm.return!==void){
|
||
Scripts.eval(elm.return + " = bao.objects[bao.objects.count-1]");
|
||
}
|
||
return o;
|
||
}
|
||
|
||
function setEffect(elm)
|
||
{
|
||
if(elm.y !== void) elm.rooty = elm.y;
|
||
if(elm.x !== void) elm.rootx = elm.x;
|
||
var o;
|
||
o = new EffectSprite(window, this, elm);
|
||
o.setState(elm);
|
||
objects.add(o);
|
||
o.adjustDisp();
|
||
|
||
if(elm.return!==void){
|
||
Scripts.eval(elm.return + " = bao.objects[bao.objects.count-1]",,,o.parentSprite.layer.conductor);
|
||
}
|
||
return o;
|
||
}
|
||
|
||
function setOther(elm)
|
||
{
|
||
var o;
|
||
o = new ObjectSprite(window, this, elm);
|
||
o.setState(elm);
|
||
others.add(o);
|
||
}
|
||
|
||
//--------------------------------------------------------- 効果音の再生 --
|
||
|
||
function playse(elm)
|
||
{
|
||
// 効果音の再生
|
||
// window.se[+elm.buf].volume = 100;
|
||
// window.se[+elm.buf].play(elm);
|
||
|
||
var buf = +elm.buf;
|
||
|
||
// バッファを順繰りでずらして使用する。
|
||
if(buf==0||buf==1||buf==10||buf==11){
|
||
buf = -1;
|
||
// 同じSEが重複して鳴るとエコーっぽくなってウザいのでそうしないための仕掛け
|
||
if(seStorage[0] == elm.storage) buf = 0;
|
||
if(seStorage[1] == elm.storage) buf = 1;
|
||
if(seStorage[10] == elm.storage) buf = 10;
|
||
if(seStorage[11] == elm.storage) buf = 11;
|
||
|
||
if(buf < 0){
|
||
switch (seBuf){
|
||
case 0:
|
||
seBuf = 1;
|
||
break;
|
||
case 1:
|
||
seBuf = 10;
|
||
break;
|
||
case 10:
|
||
seBuf = 11;
|
||
break;
|
||
case 11:
|
||
seBuf = 0;
|
||
break;
|
||
}
|
||
buf = seBuf;
|
||
}
|
||
seStorage[buf] = elm.storage;
|
||
}
|
||
|
||
window.se[buf].volume = 100;
|
||
window.se[buf].play(elm);
|
||
}
|
||
|
||
function fadeoutse(elm)
|
||
{
|
||
// 効果音のフェードアウト
|
||
window.se[+elm.buf].fadeOut(elm);
|
||
return 0;
|
||
}
|
||
|
||
function fadeinse(elm)
|
||
{
|
||
// 効果音のフェードイン再生
|
||
window.se[+elm.buf].fadeIn(elm);
|
||
return 0;
|
||
}
|
||
|
||
//--------------------------------------------------------- ウェイト関連 --
|
||
|
||
function resetWait()
|
||
{
|
||
// 時間原点のリセット
|
||
timeOrigin = System.getTickCount();
|
||
}
|
||
|
||
function waitTime(waittime, canskip)
|
||
{
|
||
// waittime 分待つ
|
||
if(waittime == 0) return 0;
|
||
if(canskip)
|
||
{
|
||
conductor.waitWithTimeOut(%[
|
||
click : function
|
||
{
|
||
// やることなし
|
||
} incontextof this,
|
||
|
||
timeout : function
|
||
{
|
||
// やることなし
|
||
} incontextof this
|
||
], waittime);
|
||
}
|
||
else
|
||
{
|
||
// スキップできない場合
|
||
conductor.waitWithTimeOut(%[
|
||
timeout : function
|
||
{
|
||
// やることなし
|
||
} incontextof this
|
||
], waittime);
|
||
}
|
||
return -2; // break
|
||
|
||
}
|
||
|
||
function doWait(elm)
|
||
{
|
||
// wait タグの処理
|
||
var waittime;
|
||
if(elm.mode == 'until')
|
||
{
|
||
// until モード
|
||
waittime = timeOrigin + +elm.time - System.getTickCount();
|
||
if(waittime < 0) { lastWaitTime = 0; return 0; } // すでに時間が経過している
|
||
lastWaitTime = waittime;
|
||
if(waittime < 6) return 0; // あまりに待ち時間が短いので待たない
|
||
}
|
||
else
|
||
{
|
||
waittime = +elm.time;
|
||
}
|
||
return waitTime(waittime, (elm.canskip === void || +elm.canskip));
|
||
}
|
||
|
||
|
||
//---------------------------------------------------- トリガ管理(TJS用) --
|
||
|
||
function waitTrigger(elm)
|
||
{
|
||
// elm.name で示されたトリガを待つ
|
||
if((elm.canskip !== void && +elm.canskip))
|
||
{
|
||
// スキップできる場合
|
||
if(skipMode)
|
||
{
|
||
// スキップ動作中
|
||
if(elm.onskip !== void) Scripts.eval(elm.onskip);
|
||
return 0; // すぐに返る
|
||
}
|
||
conductor.wait(%[
|
||
click : function(arg)
|
||
{
|
||
if(arg !== void) Scripts.eval(arg);
|
||
} incontextof this,
|
||
click_arg : elm.onskip,
|
||
elm.name => function
|
||
{
|
||
} incontextof this
|
||
]);
|
||
}
|
||
else
|
||
{
|
||
conductor.wait(%[
|
||
elm.name => function
|
||
{
|
||
} incontextof this
|
||
]);
|
||
}
|
||
return -2;
|
||
}
|
||
|
||
function trigger(name)
|
||
{
|
||
// name で示したトリガをBeltActionのコンダクタに対して発動する
|
||
conductor.trigger(name);
|
||
//dm("name : " + name);
|
||
}
|
||
|
||
//------------------------------------------------------- タグハンドラ群 --
|
||
|
||
function getHandlers()
|
||
{
|
||
return %[
|
||
|
||
// setbg : function(elm)
|
||
// {
|
||
// // 背景の読み込み
|
||
// setBackGround(elm);
|
||
// return 0;
|
||
// } incontextof this,
|
||
|
||
loadbg : function(elm)
|
||
{
|
||
// 背景BGの読み込み
|
||
stageLayer.loadImages(elm);
|
||
stageLayer.xFreeMode = false;
|
||
if(elm.topline !== void) stageLayer.topLine = +elm.topline;
|
||
if(elm.bottomline !== void) stageLayer.bottomLine = +elm.bottomline;
|
||
if(elm.mode!==void && elm.mode=="xfree") stageLayer.xFreeMode = true;
|
||
if(elm.limitright !== void) stageLayer.limitRight = +elm.limitright;
|
||
if(elm.limitleft !== void) stageLayer.limitLeft = +elm.limitleft;
|
||
shadowLayer.visible = true;
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
bgstate : function(elm)
|
||
{
|
||
// 背景とかの設定
|
||
if(elm.lline !== void) stageLayer.scrollLineL = +elm.lline;
|
||
if(elm.rline !== void) stageLayer.scrollLineR = +elm.rline;
|
||
if(elm.goindicator !== void) goIndicatorStorage = elm.goindicator;
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
bgfloor : function(elm)
|
||
{
|
||
// 床面の読み込み
|
||
stageLayer.addFloorLayer(elm);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
floorobj : function(elm)
|
||
{
|
||
// オブジェクトの読み込み
|
||
stageLayer.addFloorObject(elm);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
avoid : function(elm)
|
||
{
|
||
// オブジェクトの読み込み
|
||
stageLayer.addAvoidPoint(elm);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
scrolllimit : function(elm)
|
||
{
|
||
// スクロール制限
|
||
if(elm.line !== void) stageLayer.setScrollLimit(+elm.line);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
scrolllimitleft : function(elm)
|
||
{
|
||
// スクロール制限
|
||
if(elm.line !== void) stageLayer.setScrollLimitLeft(+elm.line);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
player : function(elm)
|
||
{
|
||
// 主人公の表示
|
||
setPlayer(elm);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
playerstate : function(elm)
|
||
{
|
||
// 主人公の状態設定
|
||
tag_setPlayerState(elm);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
enemy : function(elm)
|
||
{
|
||
// 敵の表示
|
||
setEnemy(elm);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
enemy2 : function(elm)
|
||
{
|
||
// 敵の表示
|
||
setEnemy2(elm);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
enemy3 : function(elm)
|
||
{
|
||
// 敵の表示
|
||
setEnemy3(elm);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
enemy4 : function(elm)
|
||
{
|
||
// 敵の表示
|
||
setEnemy4(elm);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
enemystate : function(elm)
|
||
{
|
||
// 敵の状態設定
|
||
setEnemyState(getObject(elm), elm);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
object : function(elm)
|
||
{
|
||
// オブジェクトの表示
|
||
setObject(elm);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
other : function(elm)
|
||
{
|
||
// オブジェクトの表示
|
||
setOthers(elm);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
wait : function(elm)
|
||
{
|
||
// ウェイト
|
||
return doWait(elm);
|
||
} incontextof this,
|
||
|
||
eval : function(elm)
|
||
{
|
||
// 式の評価
|
||
Scripts.eval(elm.exp,,,this);
|
||
// var f = Scripts.eval("function(){" + elm.exp + ";}");
|
||
// (f incontextof this)();
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
waittrig : function(elm)
|
||
{
|
||
// トリガを待つ
|
||
switch(elm.name){
|
||
case 'killall':
|
||
if(enemies.count == 0){
|
||
return 0;
|
||
}else{
|
||
return waitTrigger(elm);
|
||
}
|
||
break;
|
||
case 'line':
|
||
if(setTriggerLine(+elm.l)){
|
||
return waitTrigger(elm);
|
||
}else{
|
||
return 0;
|
||
}
|
||
break;
|
||
case 'pline':
|
||
if(setTriggerLine2(+elm.l)){
|
||
return waitTrigger(elm);
|
||
}else{
|
||
return 0;
|
||
}
|
||
default:
|
||
return waitTrigger(elm);
|
||
}
|
||
} incontextof this,
|
||
|
||
s : function(elm)
|
||
{
|
||
// // 実行停止
|
||
// stablePosibility = true;
|
||
// cancelSkip();
|
||
// if(!usingExtraConductor) incRecordLabel(true);
|
||
// inSleep = true;
|
||
// if(recordHistoryOfStore == 2) // 2 : 選択肢 ( @s タグ ) ごと
|
||
// setToRecordHistory();
|
||
// notifyStable();
|
||
return -1;
|
||
} incontextof this,
|
||
|
||
pause : function(elm)
|
||
{
|
||
if(elm.animation !== void){
|
||
scenarioPause(+elm.animation);
|
||
}else{
|
||
scenarioPause(true);
|
||
}
|
||
return -1;
|
||
} incontextof this,
|
||
|
||
stageend : function(elm)
|
||
{
|
||
dm("■■■■ tag : stageend (returnState = clear) ■■■■");
|
||
returnState = "clear";
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
retkag3 : function(elm)
|
||
{
|
||
// KAG3に戻る
|
||
// quit();
|
||
returnKag3();
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
trigger : function(elm)
|
||
{
|
||
// KAG3に対してトリガ発砲
|
||
window.conductor.trigger(elm.name);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
interrupt : function(elm)
|
||
{
|
||
return -2;
|
||
} incontextof this,
|
||
|
||
addqueue : function(elm)
|
||
{
|
||
// 制御用キューに追加
|
||
if(elm.id!==void) getObject(elm).addQueue(elm.tag);
|
||
if(elm.object!==void){
|
||
if(typeof elm.object == 'Object') elm.object.addQueue(elm.tag);
|
||
if(typeof elm.object == 'String') Scripts.eval(elm.object).addQueue(elm.tag);
|
||
}
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
resumequeue : function(elm)
|
||
{
|
||
// 制御用キューの停止を解除
|
||
if(elm.id === void) return 0;
|
||
resuneQueue(elm);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
windowon : function(elm)
|
||
{
|
||
kag.callExtraConductor('etc.ks','*window_on');
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
windowoff : function(elm)
|
||
{
|
||
kag.callExtraConductor('etc.ks','*window_off');
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
ch : function(elm)
|
||
{
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
quake : function(elm)
|
||
{
|
||
// 揺れ
|
||
doQuake(elm);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
stopquake : function(elm)
|
||
{
|
||
// 揺れの停止
|
||
stopQuake();
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
playse : function(elm)
|
||
{
|
||
// 効果音の再生
|
||
playse(elm);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
fadeoutse : function(elm)
|
||
{
|
||
// 効果音のフェードアウト
|
||
fadeoutse(elm);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
fadeinse : function(elm)
|
||
{
|
||
// 効果音のフェードイン再生
|
||
fadeinse(elm);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
goindicator : function(elm)
|
||
{
|
||
informLayer.showGoIndicator(elm.storage);
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
returnextra : function(elm)
|
||
{
|
||
returnExtraConductor();
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
];
|
||
}
|
||
|
||
property nowSelectingPlayer
|
||
{
|
||
getter(){
|
||
if(players.count == 0 || nowSelectingPlayerId > players.count) return void;
|
||
if(players[nowSelectingPlayerId] === void || !isvalid players[nowSelectingPlayerId]) return void;
|
||
return players[nowSelectingPlayerId];
|
||
}
|
||
}
|
||
|
||
property notSelectingPlayerId
|
||
{
|
||
getter(){
|
||
if(players.count < 2) return void;
|
||
return (nowSelectingPlayerId == 0)? 1: 0;
|
||
}
|
||
}
|
||
|
||
property notSelectingPlayer
|
||
{
|
||
getter(){
|
||
if(players.count < 2) return void;
|
||
if(players[notSelectingPlayerId] !== void && isvalid players[notSelectingPlayerId]){
|
||
return players[notSelectingPlayerId];
|
||
}
|
||
}
|
||
}
|
||
|
||
property isExistBoss
|
||
{
|
||
getter(){
|
||
for(var i=0; i<enemies.count; i++){
|
||
if(enemies[i].isBoss){
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
}
|
||
|
||
function getObjectFromObjectClassAndIndex(oc, i){
|
||
switch (oc){
|
||
case clPlayer:
|
||
return players[i];
|
||
case clEnemy:
|
||
return enemies[i];
|
||
case clObject:
|
||
case clEffect:
|
||
return objects[i];
|
||
}
|
||
return void;
|
||
}
|
||
|
||
function enemyList(){
|
||
for(var i=0; i<enemies.count; i++){
|
||
var e = enemies[i];
|
||
dm("%2d pos(%3d,%3d,%3d) ab:%06d / now:0x%04X / ".sprintf(i ,e.rootX, e.rootY, e.altitude, e.layer.absolute, e.nowSpriteId) + e.layer.asd + "(" + e.layer.conductor.curLine+")" + " " + e);
|
||
}
|
||
}
|
||
|
||
function objectList(){
|
||
for(var i=0; i<objects.count; i++){
|
||
var e = objects[i];
|
||
dm("%2d (%3d,%3d,%3d) %6d : ".sprintf(i ,e.rootX, e.rootY, e.altitude, e.layer.absolute) + e.layer.asd + " " + e);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
function e(){
|
||
bao.enemyList();
|
||
}
|
||
|
||
function o(){
|
||
bao.objectList();
|
||
}
|
||
|
||
|
||
class Attack
|
||
{
|
||
var strength;
|
||
var tick;
|
||
var kind;
|
||
var exp;
|
||
var expcond;
|
||
var tags;
|
||
var score;
|
||
|
||
var hitPos;
|
||
|
||
function Attack(s=0, t=-1, k=0, e="", ec= "", tag="", sc=0)
|
||
{
|
||
if(typeof s == "Object"){
|
||
strength = s.strength;
|
||
tick = s.tick;
|
||
kind = s.kind;
|
||
exp = s.exp;
|
||
expcond = s.expcond;
|
||
tags = s.tags;
|
||
score = s.score;
|
||
}else{
|
||
strength = s;
|
||
tick = t;
|
||
kind = k;
|
||
exp = e;
|
||
expcond = ec;
|
||
tags = tag;
|
||
score = sc;
|
||
}
|
||
|
||
hitPos = new Position();
|
||
}
|
||
|
||
function set(s=0, t=-1, k=0, e="", ec="", tag="", sc=0)
|
||
{
|
||
if(typeof s == "Object"){
|
||
strength = s.strength;
|
||
tick = s.tick;
|
||
kind = s.kind;
|
||
exp = s.exp;
|
||
expcond = s.expcond;
|
||
tags = s.tags;
|
||
score = s.score;
|
||
}else{
|
||
strength = s;
|
||
tick = t;
|
||
kind = k;
|
||
exp = e;
|
||
tags = tag;
|
||
expcond = ec;
|
||
score = sc;
|
||
}
|
||
}
|
||
|
||
function clear()
|
||
{
|
||
strength = 0;
|
||
tick = -1;
|
||
kind = 0;
|
||
exp = "";
|
||
expcond = "";
|
||
tags = "";
|
||
score = 0;
|
||
}
|
||
|
||
function isClear()
|
||
{
|
||
return (kind == 0);
|
||
}
|
||
|
||
function store()
|
||
{
|
||
var dic = %[];
|
||
|
||
dic.strength = strength;
|
||
dic.tick = tick;
|
||
dic.kind = kind;
|
||
dic.exp = exp;
|
||
dic.expcond = expcond;
|
||
dic.tags = tags;
|
||
dic.score = score;
|
||
|
||
dic.hitPos = hitPos.store();
|
||
|
||
return dic;
|
||
}
|
||
|
||
function restore(dic)
|
||
{
|
||
strength = dic.strength;
|
||
// tickを保存したところで意味は無いはず……
|
||
// tick = dic.tick;
|
||
kind = dic.kind;
|
||
exp = dic.exp;
|
||
if(dic.expcond !== void) expcond = dic.expcond;
|
||
tags = dic.tags;
|
||
score = dic.score;
|
||
|
||
hitPos.restore(dic.hitPos);
|
||
}
|
||
|
||
}
|
||
|
||
|
||
class Position
|
||
{
|
||
var x;
|
||
var y;
|
||
var altitude;
|
||
var absolute;
|
||
var inverse;
|
||
var etc;
|
||
|
||
function Position(x=0, y=0, h=0, abs=0, inv=false)
|
||
{
|
||
this.x = x;
|
||
this.y = y;
|
||
altitude = h;
|
||
absolute = abs;
|
||
inverse = inv;
|
||
}
|
||
|
||
function finalize()
|
||
{
|
||
invalidate x;
|
||
invalidate y;
|
||
invalidate altitude;
|
||
invalidate absolute;
|
||
invalidate inverse;
|
||
}
|
||
|
||
function store()
|
||
{
|
||
var dic = %[];
|
||
|
||
dic.x = x;
|
||
dic.y = y;
|
||
dic.altitude = altitude;
|
||
dic.absolute = absolute;
|
||
dic.inverse = inverse;
|
||
dic.etc = etc;
|
||
|
||
return dic;
|
||
}
|
||
|
||
function restore(dic)
|
||
{
|
||
x = dic.x;
|
||
y = dic.y;
|
||
altitude = dic.altitude;
|
||
absolute = dic.absolute;
|
||
inverse = dic.inverse;
|
||
etc = dic.etc;
|
||
}
|
||
|
||
}
|
||
|
||
function xDirection(i)
|
||
{
|
||
if(i) return 1; else return -1;
|
||
}
|
||
|
||
|
||
class DrawLayer extends Layer
|
||
{
|
||
var drawFlag = false;
|
||
var owner;
|
||
|
||
var lineWidth = [];
|
||
var lineColor = [];
|
||
|
||
function DrawLayer(win, par, owner){
|
||
super.Layer(...);
|
||
this.owner = owner;
|
||
}
|
||
|
||
function setPen(c, w)
|
||
{
|
||
lineWidth = [];
|
||
lineColor = [];
|
||
app.clear();
|
||
app.addPen(c, w * owner.cZoomRate, 0, 0);
|
||
lineWidth.add(w);
|
||
lineColor.add(c);
|
||
}
|
||
|
||
function addPen(c, w)
|
||
{
|
||
app.addPen(c, w * owner.cZoomRate, 0, 0);
|
||
lineWidth.add(w);
|
||
lineColor.add(c);
|
||
}
|
||
|
||
function drawLine(x1, y1, x2, y2){
|
||
drawFlag = true;
|
||
super.drawLine(app, x1*owner.cZoomRate, y1*owner.cZoomRate, x2*owner.cZoomRate, y2*owner.cZoomRate);
|
||
}
|
||
|
||
function store()
|
||
{
|
||
var dic = %[];
|
||
|
||
dic.lineWidth = [];
|
||
for(var i=0; i<lineWidth.count; i++){
|
||
dic.lineWidth[i] = lineWidth[i];
|
||
}
|
||
|
||
dic.lineColor = [];
|
||
for(var i=0; i<lineColor.count; i++){
|
||
dic.lineColor[i] = lineColor[i];
|
||
}
|
||
|
||
return dic;
|
||
}
|
||
|
||
function restore(dic)
|
||
{
|
||
if(dic.lineWidth === void || dic.lineColor === void) return;
|
||
|
||
if(dic.lineWidth[0] !== void && dic.lineColor[0] !== void) setPen(dic.lineColor[0], dic.lineWidth[0]);
|
||
for(var i=1; i<dic.lineWidth.count; i++){
|
||
if(dic.lineColor[i] !== void) addPen(dic.lineColor[i], dic.lineWidth[i]);
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
|
||
|
||
class InformLayer extends Layer
|
||
{
|
||
var playerInformLayers = [];
|
||
|
||
var enemyGaugeLayers = [];
|
||
var scoreLayer;
|
||
var enemyNumLayer;
|
||
var enemyLayer;
|
||
var pauseLayer;
|
||
var goLayer;
|
||
var rescueGaugeLayer;
|
||
var trainGaugeLayer;
|
||
|
||
var parent;
|
||
var owner;
|
||
var mode;
|
||
|
||
var opacityDelta = 0;
|
||
|
||
var lastIndicateTick = 0;
|
||
|
||
function InformLayer(win, parent, owner, mode)
|
||
{
|
||
this.parent = parent;
|
||
this.owner = owner;
|
||
|
||
super.Layer(...);
|
||
|
||
scoreLayer = new NumberLayer(window, this);
|
||
scoreLayer.name ="scoreLayer";
|
||
|
||
enemyNumLayer = new NumberLayer(win, this);
|
||
enemyNumLayer.name = "enemyNumLayer";
|
||
|
||
enemyLayer = new .Layer(win, this);
|
||
enemyLayer.name = "enemyLayer";
|
||
|
||
pauseLayer = new .Layer(win, this);
|
||
pauseLayer.name = "pauseLayer";
|
||
|
||
goLayer = new FrameAnimeLayer(win, this, owner, owner);
|
||
goLayer.name = "goLayer";
|
||
|
||
rescueGaugeLayer = new NormalGaugeLayer(win, this);
|
||
rescueGaugeLayer.name = "rescueGaugeLayer";
|
||
|
||
trainGaugeLayer = new NormalGaugeLayer(win, this, 1);
|
||
trainGaugeLayer.name = "trainGaugeLayer";
|
||
|
||
init();
|
||
}
|
||
|
||
function init(delflg = false){
|
||
switch(owner.mode){
|
||
case 1:
|
||
init1();
|
||
break;
|
||
case 2:
|
||
init2();
|
||
break;
|
||
case 3:
|
||
init3();
|
||
break;
|
||
}
|
||
|
||
visible = false;
|
||
opacity = 0;
|
||
|
||
if(delflg){
|
||
for(var i=0; i<playerInformLayers.count; i++){
|
||
invalidate playerInformLayers[i];
|
||
}
|
||
playerInformLayers = [];
|
||
}else{
|
||
for(var i=0; i<playerInformLayers.count; i++){
|
||
playerInformLayers[i].init();
|
||
}
|
||
}
|
||
goLayer.freeImage();
|
||
trainGaugeLayer.enabled = false;
|
||
}
|
||
|
||
function init1(win)
|
||
{
|
||
loadImages("infobg");
|
||
setSizeToImageSize();
|
||
|
||
scoreLayer.setPos(213, 4);
|
||
scoreLayer.zeroHead = true;
|
||
scoreLayer.init(10, "numeral01");
|
||
scoreLayer.visible = true;
|
||
|
||
enemyNumLayer.setPos(235, 244);
|
||
enemyNumLayer.zeroHead = false;
|
||
enemyNumLayer.init(2, "numeral01");
|
||
enemyNumLayer.visible = true;
|
||
|
||
enemyLayer.setPos(201, 242);
|
||
enemyLayer.loadImages("info_enemy");
|
||
enemyLayer.setSizeToImageSize();
|
||
enemyLayer.visible = true;
|
||
enemyLayer.absolute=1000;
|
||
|
||
pauseLayer.visible = false;
|
||
pauseLayer.loadImages("pause");
|
||
pauseLayer.setSizeToImageSize();
|
||
pauseLayer.setPos((width-pauseLayer.width)\2, 96);
|
||
enemyNumLayer.absolute=2000;
|
||
|
||
rescueGaugeLayer.setPos(185,41);
|
||
rescueGaugeLayer.setGauge("gaugeFrame04", "gauge04", 80, 100, 0);
|
||
rescueGaugeLayer.gaugeLayer.setPos(2, 1);
|
||
|
||
trainGaugeLayer.setPos(182,18);
|
||
trainGaugeLayer.setGauge("gaugeFrame_train01", "gaugeTrainPos", 85, 100, 0);
|
||
trainGaugeLayer.gaugeLayer.setPos(3, 0);
|
||
|
||
goLayer.setPos(390, 8);
|
||
|
||
font.height = 20;
|
||
}
|
||
|
||
function init2(win)
|
||
{
|
||
loadImages("m2_infobg");
|
||
setSizeToImageSize();
|
||
|
||
scoreLayer.setPos(319, 6);
|
||
scoreLayer.zeroHead = true;
|
||
scoreLayer.init(10, "numeral01");
|
||
scoreLayer.visible = true;
|
||
|
||
enemyNumLayer.setPos(354, 371);
|
||
enemyNumLayer.zeroHead = false;
|
||
enemyNumLayer.init(2, "numeral01");
|
||
enemyNumLayer.visible = true;
|
||
|
||
enemyLayer.setPos(310, 370);
|
||
enemyLayer.loadImages("m2_info_enemy");
|
||
enemyLayer.setSizeToImageSize();
|
||
enemyLayer.visible = true;
|
||
enemyLayer.absolute=1000;
|
||
|
||
pauseLayer.visible = false;
|
||
pauseLayer.loadImages("pause");
|
||
pauseLayer.setSizeToImageSize();
|
||
pauseLayer.setPos((owner.width-pauseLayer.width)\2, 144);
|
||
|
||
rescueGaugeLayer.setPos(287,62);
|
||
rescueGaugeLayer.setGauge("m2_gaugeFrame04", "m2_gauge04", 120, 100, 0);
|
||
rescueGaugeLayer.gaugeLayer.setPos(3, 2);
|
||
|
||
trainGaugeLayer.setPos(273,27);
|
||
trainGaugeLayer.setGauge("m2_gaugeFrame_train01", "m2_gaugeTrainPos", 129, 100, 0);
|
||
trainGaugeLayer.gaugeLayer.setPos(4, 0);
|
||
|
||
goLayer.setPos(617, 12);
|
||
|
||
font.height = 20;
|
||
}
|
||
|
||
|
||
function init3(win)
|
||
{
|
||
loadImages("m3_infobg");
|
||
setSizeToImageSize();
|
||
visible = true;
|
||
|
||
scoreLayer.setPos(651, 12);
|
||
scoreLayer.zeroHead = true;
|
||
scoreLayer.init(10, "numeral01b");
|
||
scoreLayer.visible = true;
|
||
|
||
enemyNumLayer.setPos(708, 742);
|
||
enemyNumLayer.zeroHead = false;
|
||
enemyNumLayer.init(2, "numeral01b");
|
||
enemyNumLayer.visible = true;
|
||
|
||
enemyLayer.setPos(618, 739);
|
||
enemyLayer.loadImages("m3_info_enemy");
|
||
enemyLayer.setSizeToImageSize();
|
||
enemyLayer.visible = true;
|
||
enemyLayer.absolute=1000;
|
||
|
||
pauseLayer.visible = false;
|
||
pauseLayer.loadImages("m3_pause");
|
||
pauseLayer.setSizeToImageSize();
|
||
pauseLayer.setPos((owner.width-pauseLayer.width)\2, 192);
|
||
|
||
rescueGaugeLayer.setPos(557,124);
|
||
rescueGaugeLayer.setGauge("m3_gaugeFrame04", "m3_gauge04", 240, 100, 0);
|
||
rescueGaugeLayer.gaugeLayer.setPos(6, 3);
|
||
|
||
trainGaugeLayer.setPos(546,54);
|
||
trainGaugeLayer.setGauge("m3_gaugeFrame_train01", "m3_gaugeTrainPos", 254, 100, 0);
|
||
trainGaugeLayer.gaugeLayer.setPos(11, 0);
|
||
|
||
goLayer.setPos(1234, 24);
|
||
|
||
font.height = 40;
|
||
}
|
||
|
||
|
||
function finalize()
|
||
{
|
||
visible = false;
|
||
|
||
invalidate scoreLayer;
|
||
invalidate enemyNumLayer;
|
||
invalidate enemyLayer;
|
||
invalidate pauseLayer;
|
||
invalidate goLayer;
|
||
invalidate rescueGaugeLayer;
|
||
invalidate trainGaugeLayer;
|
||
|
||
for(var i=0; i<playerInformLayers.count; i++){
|
||
invalidate playerInformLayers[i];
|
||
}
|
||
playerInformLayers = [];
|
||
|
||
for(var i=0; i<enemyGaugeLayers.count; i++){
|
||
invalidate enemyGaugeLayers[i];
|
||
}
|
||
enemyGaugeLayers = void;
|
||
}
|
||
|
||
function drawLine()
|
||
{
|
||
super.drawLine(...);
|
||
}
|
||
|
||
function draw(list)
|
||
{
|
||
if(owner.players.count == 0) return;
|
||
|
||
var o = opacity + opacityDelta;
|
||
if(o > 255 && opacityDelta>0){
|
||
o = 255;
|
||
opacityDelta = 0;
|
||
}
|
||
if(o < 0 && opacityDelta<0){
|
||
o = 0;
|
||
visible = false;
|
||
opacityDelta = 0;
|
||
}
|
||
opacity = o;
|
||
|
||
scoreLayer.draw(f.score);
|
||
enemyNumLayer.draw(owner.dispEnemyCount);
|
||
if(rescueGaugeLayer.enabled) rescueGaugeLayer.draw();
|
||
if(trainGaugeLayer.enabled){
|
||
if(trainGaugeLayer.frameStorage != bao.fHeader + f.trainGaugeStorage){
|
||
trainGaugeLayer.frameStorage = bao.fHeader + f.trainGaugeStorage;
|
||
trainGaugeLayer.loadImages(trainGaugeLayer.frameStorage);
|
||
trainGaugeLayer.setSizeToImageSize();
|
||
}
|
||
trainGaugeLayer.value = f.gameTime;
|
||
trainGaugeLayer.draw();
|
||
}
|
||
|
||
for(var i=0; i<playerInformLayers.count; i++){
|
||
if(sf.adjSinglePlayMode && owner.notSelectingPlayerId !== void && owner.notSelectingPlayerId == i){
|
||
// playerInformLayers[i].opacity = 128;
|
||
playerInformLayers[i].opacity = 0;
|
||
}else{
|
||
playerInformLayers[i].opacity = 255;
|
||
}
|
||
playerInformLayers[i].draw();
|
||
}
|
||
|
||
// var count = 0;
|
||
if(opacityDelta >= 0 && opacity > 0){
|
||
var count0 = 0;
|
||
var count1 = 0;
|
||
for(var i=0; i<enemyGaugeLayers.count; i++){
|
||
var l = enemyGaugeLayers[i];
|
||
if(list[i]!==void && list[i]){
|
||
if(count0 > 8) continue;
|
||
if(count1 > 8) continue;
|
||
|
||
l.visible = true;
|
||
l.value = owner.enemies[i].HP;
|
||
l.checkAndChangeAlign();
|
||
// 敵ＨＰゲージの表示位置左右振り分け
|
||
if(l.align == 1){
|
||
l.setPos(width-enemyGaugeLayers[i].width-(6*owner.cZoomRate), count1*((owner.mode==3)?43:25)+4*owner.mode-((owner.mode==2)?3:1));
|
||
count1++;
|
||
}else{
|
||
l.setPos(6*owner.cZoomRate, count0*((owner.mode==3)?43:25)+4*owner.mode-((owner.mode==2)?3:1));
|
||
count0++;
|
||
}
|
||
l.draw();
|
||
// count ++;
|
||
// if(count > 8) break;
|
||
}else{
|
||
l.visible = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
if(owner.nowSelectingPlayer.enableFreeMove && owner.tickCount>lastIndicateTick+180){
|
||
if(owner.stageLayer.reverseDirection){
|
||
if(owner.stageLayer.dispLeft > 0){
|
||
showGoIndicator();
|
||
lastIndicateTick = owner.tickCount;
|
||
}
|
||
}else{
|
||
if(owner.stageLayer.wallLayer.width/owner.sZoomRate2 > int(owner.stageLayer.dispLeft+owner.internalWidth)){
|
||
showGoIndicator();
|
||
lastIndicateTick = owner.tickCount;
|
||
}
|
||
}
|
||
}
|
||
|
||
goLayer.onRefreshFrame();
|
||
}
|
||
|
||
function showGoIndicator(storage = owner.goIndicatorStorage)
|
||
{
|
||
if(storage != ""){
|
||
goLayer.loadImages(%['storage'=>storage]);
|
||
}
|
||
}
|
||
|
||
function addPlayerInformLayer(elm)
|
||
{
|
||
var l = new PlayerInformLayer(window, this, elm);
|
||
playerInformLayers.add(l);
|
||
}
|
||
|
||
function addEnemyGauge(hp, name){
|
||
var e = new EnemyHpLayer(window, this, owner.mode);
|
||
e.setGauge(hp, name);
|
||
e.name = "EnemyHpLayer " + name;
|
||
enemyGaugeLayers.add(e);
|
||
}
|
||
|
||
function setFace(o, num)
|
||
{
|
||
for(var i=0; i<owner.players.count; i++){
|
||
if(i == o || owner.players[i] === o){
|
||
if(playerInformLayers[i] !== void) playerInformLayers[i].faceLayer.draw(num);
|
||
// if(num == 1 || num==2) owner.players[i].defaultFaceNum = getDefaultFaceNum(i);
|
||
}
|
||
}
|
||
}
|
||
|
||
function resetFace()
|
||
{
|
||
// 表情のリセット
|
||
for(var i=0; i<owner.players.count; i++){
|
||
owner.players[i].defaultFaceNum = getDefaultFaceNum(i);
|
||
setFace(i, owner.players[i].defaultFaceNum);
|
||
}
|
||
}
|
||
|
||
function resetFace2()
|
||
{
|
||
// 表情のリセット（ダメージ表情はそのまま）
|
||
for(var i=0; i<owner.players.count; i++){
|
||
owner.players[i].defaultFaceNum = getDefaultFaceNum(i);
|
||
switch(owner.informLayer.playerInformLayers[i].faceLayer.value){
|
||
case 1:
|
||
case 2:
|
||
case 7:
|
||
break;
|
||
default:
|
||
setFace(i, owner.players[i].defaultFaceNum);
|
||
}
|
||
}
|
||
}
|
||
|
||
function getDefaultFaceNum(i){
|
||
// return ((owner.players[i].extasyGaugeEnabled)? 5: ((owner.players[i].cosState==4)?6:0));
|
||
|
||
if(owner.players[i].extasyGaugeEnabled) return 5;
|
||
if(owner.players[i].cosState >= 4 && sf.adjCosVariation==4) return 6;
|
||
if(owner.players[i].cosState > 1 && owner.players[i].cosState < 4) return 5;
|
||
return 0;
|
||
|
||
}
|
||
|
||
|
||
|
||
function show()
|
||
{
|
||
visible = true;
|
||
opacityDelta = 30;
|
||
resetFace();
|
||
if(sf.showSelectIndicator > 1) owner.showSelectIndicator(owner.nowSelectingPlayerId);
|
||
}
|
||
|
||
function hide()
|
||
{
|
||
owner.iconHide();
|
||
owner.fukidashi.clear();
|
||
|
||
opacityDelta = -30;
|
||
if(owner.selectIndicator.layer.visible) owner.selectIndicator.layer.dOpacity2 = -30;
|
||
}
|
||
|
||
function hideSoon()
|
||
{
|
||
visible = false;
|
||
opacity = 0;
|
||
if(owner.selectIndicator.layer.visible) owner.selectIndicator.layer.visible = false;
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
class PlayerInformLayer extends Layer
|
||
{
|
||
var align = 0; // 表示位置 0:画面左側 ／ 1:画面右側
|
||
var playerId = 0;
|
||
var faceStorage = ""; // 表情ファイル
|
||
|
||
var faceLayer;
|
||
var gaugeFrameLayer;
|
||
var hpGaugeLayer;
|
||
var mpGaugeLayer;
|
||
var zankiLayer;
|
||
var comboLayer;
|
||
var selectCircleLayer;
|
||
var mpIndicatorLayer;
|
||
|
||
var dOpacity = 0;
|
||
|
||
var owner;
|
||
var root;
|
||
|
||
function PlayerInformLayer(win, parent, elm)
|
||
{
|
||
owner = parent;
|
||
root = owner.owner;
|
||
playerId = elm.id;
|
||
faceStorage = elm.face;
|
||
align = elm.align;
|
||
|
||
super.Layer(win, parent);
|
||
name = "playerInformLayer";
|
||
|
||
selectCircleLayer = new FrameAnimeLayer(window, this, this, root);
|
||
selectCircleLayer.name = "selectCircleLayer";
|
||
|
||
faceLayer = new FaceLayer(window, this);
|
||
faceLayer.name = "faceLayer";
|
||
|
||
gaugeFrameLayer = new .Layer(window, this);
|
||
gaugeFrameLayer.name = "gaugeFrameLayer";
|
||
|
||
hpGaugeLayer = new GaugeLayer(window, this);
|
||
hpGaugeLayer.name = "hpGaugeLayer";
|
||
hpGaugeLayer.leftDirect = true;
|
||
hpGaugeLayer.init(elm.maxHP, elm.HP);
|
||
|
||
mpGaugeLayer = new GaugeLayer(window, this);
|
||
mpGaugeLayer.name = "mpGaugeLayer";
|
||
mpGaugeLayer.leftDirect = true;
|
||
mpGaugeLayer.init(elm.maxMP, elm.MP);
|
||
|
||
zankiLayer = new NumberLayer(win, this);
|
||
zankiLayer.name = "zankiLayer";
|
||
|
||
mpIndicatorLayer = new FrameAnimeLayer(win, this, owner, root);
|
||
mpIndicatorLayer.name = "mpIndicatorLayer";
|
||
|
||
comboLayer = new ComboLayer(win, this);
|
||
comboLayer.name = "comboLayer";
|
||
|
||
absolute=100;
|
||
|
||
init();
|
||
}
|
||
|
||
|
||
function finalize()
|
||
{
|
||
visible = false;
|
||
|
||
invalidate hpGaugeLayer;
|
||
invalidate mpGaugeLayer;
|
||
invalidate faceLayer;
|
||
invalidate zankiLayer;
|
||
invalidate comboLayer;
|
||
invalidate gaugeFrameLayer;
|
||
invalidate selectCircleLayer;
|
||
invalidate mpIndicatorLayer;
|
||
|
||
super.finalize();
|
||
}
|
||
|
||
|
||
function init(){
|
||
|
||
switch(root.mode){
|
||
case 1:
|
||
if(align == 0) init1l(); else init1r();
|
||
break;
|
||
case 2:
|
||
if(align == 0) init2l(); else init2r();
|
||
break;
|
||
case 3:
|
||
if(align == 0) init3l(); else init3r();
|
||
break;
|
||
}
|
||
|
||
visible = true;
|
||
opacity = 255;
|
||
}
|
||
|
||
|
||
function init1l(win)
|
||
{
|
||
loadBg();
|
||
setPos(0,192);
|
||
|
||
gaugeFrameLayer.loadImages("info_playerL_gaugeBG");
|
||
gaugeFrameLayer.setSizeToImageSize();
|
||
gaugeFrameLayer.setPos(25,43);
|
||
gaugeFrameLayer.visible = true;
|
||
|
||
hpGaugeLayer.loadImages("gauge_playerHP");
|
||
hpGaugeLayer.gWidth = 180;
|
||
hpGaugeLayer.setPos(39,44);
|
||
hpGaugeLayer.visible = true;
|
||
hpGaugeLayer.zeroCommaAdjust = true;
|
||
hpGaugeLayer.leftDirect = true;
|
||
|
||
mpGaugeLayer.loadImages("gauge_playerMP");
|
||
mpGaugeLayer.gWidth = 140;
|
||
mpGaugeLayer.setPos(39,53);
|
||
mpGaugeLayer.height = mpGaugeLayer.gHeight = mpGaugeLayer.imageHeight / 2;
|
||
mpGaugeLayer.visible = true;
|
||
mpGaugeLayer.leftDirect = true;
|
||
|
||
faceLayer.init(fHeaderMatrix[root.mode] + faceStorage, align);
|
||
faceLayer.setPos(0, 17);
|
||
faceLayer.draw(owner.getDefaultFaceNum(playerId));
|
||
faceLayer.visible = true;
|
||
|
||
zankiLayer.setPos(2, 53);
|
||
zankiLayer.zeroHead = false;
|
||
zankiLayer.init(2, "numeral01");
|
||
zankiLayer.visible = true;
|
||
zankiLayer.alignRight = false;
|
||
|
||
comboLayer.setPos(3, 0);
|
||
comboLayer.init(1);
|
||
comboLayer.countLayer.alignRight = false;
|
||
|
||
setSelectCircleLayer();
|
||
}
|
||
|
||
|
||
function init1r(win)
|
||
{
|
||
loadBg();
|
||
setPos(228,192);
|
||
|
||
gaugeFrameLayer.loadImages("info_playerR_gaugeBG");
|
||
gaugeFrameLayer.setSizeToImageSize();
|
||
gaugeFrameLayer.setPos(7,43);
|
||
gaugeFrameLayer.visible = true;
|
||
|
||
hpGaugeLayer.loadImages("gauge_playerHP");
|
||
hpGaugeLayer.gWidth = 180;
|
||
hpGaugeLayer.setPos(9,44);
|
||
hpGaugeLayer.visible = true;
|
||
hpGaugeLayer.zeroCommaAdjust = true;
|
||
hpGaugeLayer.leftDirect = false;
|
||
|
||
mpGaugeLayer.loadImages("gauge_playerMP");
|
||
mpGaugeLayer.gWidth = 140;
|
||
mpGaugeLayer.setPos(49,53);
|
||
mpGaugeLayer.height = mpGaugeLayer.gHeight = mpGaugeLayer.imageHeight / 2;
|
||
mpGaugeLayer.visible = true;
|
||
mpGaugeLayer.leftDirect = false;
|
||
|
||
faceLayer.init(fHeaderMatrix[root.mode] + faceStorage, align);
|
||
faceLayer.setPos(188, 17);
|
||
faceLayer.draw(owner.getDefaultFaceNum(playerId));
|
||
faceLayer.visible = true;
|
||
|
||
zankiLayer.setPos(210, 53);
|
||
zankiLayer.zeroHead = false;
|
||
zankiLayer.init(2, "numeral01");
|
||
zankiLayer.visible = true;
|
||
zankiLayer.alignRight = true;
|
||
|
||
comboLayer.setPos(171, 0);
|
||
comboLayer.init(1);
|
||
comboLayer.countLayer.alignRight = true;
|
||
|
||
setSelectCircleLayer();
|
||
}
|
||
|
||
|
||
function init2l(win)
|
||
{
|
||
loadBg();
|
||
setPos(0,297);
|
||
|
||
gaugeFrameLayer.loadImages("m2_info_playerL_gaugeBG");
|
||
gaugeFrameLayer.setSizeToImageSize();
|
||
gaugeFrameLayer.setPos(36,55);
|
||
gaugeFrameLayer.visible = true;
|
||
|
||
hpGaugeLayer.loadImages("m2_gauge_playerHP");
|
||
hpGaugeLayer.gWidth = 270;
|
||
hpGaugeLayer.setPos(58,58);
|
||
hpGaugeLayer.visible = true;
|
||
hpGaugeLayer.zeroCommaAdjust = true;
|
||
hpGaugeLayer.leftDirect = true;
|
||
|
||
mpGaugeLayer.loadImages("m2_gauge_playerMP");
|
||
mpGaugeLayer.gWidth = 210;
|
||
mpGaugeLayer.setPos(58,71);
|
||
mpGaugeLayer.height = mpGaugeLayer.gHeight = mpGaugeLayer.imageHeight / 2;
|
||
mpGaugeLayer.visible = true;
|
||
mpGaugeLayer.leftDirect = true;
|
||
|
||
faceLayer.init(fHeaderMatrix[root.mode] + faceStorage, align);
|
||
faceLayer.setPos(0, 17);
|
||
faceLayer.draw(owner.getDefaultFaceNum(playerId));
|
||
faceLayer.visible = true;
|
||
|
||
zankiLayer.setPos(3, 76);
|
||
zankiLayer.zeroHead = false;
|
||
zankiLayer.init(2, "numeral01");
|
||
zankiLayer.visible = true;
|
||
zankiLayer.alignRight = false;
|
||
|
||
comboLayer.setPos(4, 1);
|
||
comboLayer.init(2);
|
||
comboLayer.countLayer.alignRight = false;
|
||
|
||
setSelectCircleLayer();
|
||
}
|
||
|
||
function init2r(win)
|
||
{
|
||
loadBg();
|
||
setPos(342,297);
|
||
|
||
gaugeFrameLayer.loadImages("m2_info_playerR_gaugeBG");
|
||
gaugeFrameLayer.setSizeToImageSize();
|
||
gaugeFrameLayer.setPos(10,55);
|
||
gaugeFrameLayer.visible = true;
|
||
|
||
hpGaugeLayer.loadImages("m2_gauge_playerHP");
|
||
hpGaugeLayer.gWidth = 270;
|
||
hpGaugeLayer.setPos(13,58);
|
||
hpGaugeLayer.visible = true;
|
||
hpGaugeLayer.zeroCommaAdjust = true;
|
||
hpGaugeLayer.leftDirect = false;
|
||
|
||
mpGaugeLayer.loadImages("m2_gauge_playerMP");
|
||
mpGaugeLayer.gWidth = 210;
|
||
mpGaugeLayer.setPos(73,71);
|
||
mpGaugeLayer.height = mpGaugeLayer.gHeight = mpGaugeLayer.imageHeight / 2;
|
||
mpGaugeLayer.visible = true;
|
||
mpGaugeLayer.leftDirect = false;
|
||
|
||
faceLayer.init(fHeaderMatrix[root.mode] + faceStorage, align);
|
||
faceLayer.setPos(282, 17);
|
||
faceLayer.draw(owner.getDefaultFaceNum(playerId));
|
||
faceLayer.visible = true;
|
||
|
||
zankiLayer.setPos(322, 76);
|
||
zankiLayer.zeroHead = false;
|
||
zankiLayer.init(2, "numeral01");
|
||
zankiLayer.visible = true;
|
||
zankiLayer.alignRight = true;
|
||
|
||
comboLayer.setPos(277, 1);
|
||
comboLayer.init(2);
|
||
comboLayer.countLayer.alignRight = true;
|
||
|
||
setSelectCircleLayer();
|
||
}
|
||
|
||
|
||
function init3l(win)
|
||
{
|
||
loadBg();
|
||
setPos(0, 594);
|
||
|
||
gaugeFrameLayer.loadImages("m3_info_playerL_gaugeBG");
|
||
gaugeFrameLayer.setSizeToImageSize();
|
||
gaugeFrameLayer.setPos(72, 110);
|
||
gaugeFrameLayer.visible = true;
|
||
|
||
hpGaugeLayer.loadImages("m3_gauge_playerHP");
|
||
hpGaugeLayer.gWidth = 540;
|
||
hpGaugeLayer.setPos(115, 114);
|
||
hpGaugeLayer.visible = true;
|
||
hpGaugeLayer.zeroCommaAdjust = true;
|
||
hpGaugeLayer.leftDirect = true;
|
||
|
||
mpGaugeLayer.loadImages("m3_gauge_playerMP");
|
||
mpGaugeLayer.gWidth = 420;
|
||
mpGaugeLayer.setPos(115, 140);
|
||
mpGaugeLayer.height = mpGaugeLayer.gHeight = mpGaugeLayer.imageHeight / 2;
|
||
mpGaugeLayer.visible = true;
|
||
mpGaugeLayer.leftDirect = true;
|
||
|
||
faceLayer.init(fHeaderMatrix[root.mode] + faceStorage, align);
|
||
faceLayer.setPos(0, 34);
|
||
faceLayer.draw(owner.getDefaultFaceNum(playerId));
|
||
faceLayer.visible = true;
|
||
|
||
zankiLayer.setPos(7, 153);
|
||
zankiLayer.zeroHead = false;
|
||
zankiLayer.init(2, "numeral01b");
|
||
zankiLayer.visible = true;
|
||
zankiLayer.alignRight = false;
|
||
|
||
comboLayer.setPos(8, 2);
|
||
comboLayer.init(3);
|
||
comboLayer.countLayer.alignRight = false;
|
||
|
||
setSelectCircleLayer();
|
||
}
|
||
|
||
function init3r(win)
|
||
{
|
||
loadBg();
|
||
setPos(683, 594);
|
||
|
||
gaugeFrameLayer.loadImages("m3_info_playerR_gaugeBG");
|
||
gaugeFrameLayer.setSizeToImageSize();
|
||
gaugeFrameLayer.setPos(21, 110);
|
||
gaugeFrameLayer.visible = true;
|
||
|
||
hpGaugeLayer.loadImages("m3_gauge_playerHP");
|
||
hpGaugeLayer.gWidth = 540;
|
||
hpGaugeLayer.setPos(28, 114);
|
||
hpGaugeLayer.visible = true;
|
||
hpGaugeLayer.zeroCommaAdjust = true;
|
||
hpGaugeLayer.leftDirect = false;
|
||
|
||
mpGaugeLayer.loadImages("m3_gauge_playerMP");
|
||
mpGaugeLayer.gWidth = 420;
|
||
mpGaugeLayer.setPos(148, 140);
|
||
mpGaugeLayer.height = mpGaugeLayer.gHeight = mpGaugeLayer.imageHeight / 2;
|
||
mpGaugeLayer.visible = true;
|
||
mpGaugeLayer.leftDirect = false;
|
||
|
||
faceLayer.init(fHeaderMatrix[root.mode] + faceStorage, align);
|
||
faceLayer.setPos(567, 34);
|
||
faceLayer.draw(owner.getDefaultFaceNum(playerId));
|
||
faceLayer.visible = true;
|
||
|
||
zankiLayer.setPos(644, 153);
|
||
zankiLayer.zeroHead = false;
|
||
zankiLayer.init(2, "numeral01b");
|
||
zankiLayer.visible = true;
|
||
zankiLayer.alignRight = true;
|
||
|
||
comboLayer.setPos(552, 2);
|
||
comboLayer.init(3);
|
||
comboLayer.countLayer.alignRight = true;
|
||
|
||
setSelectCircleLayer();
|
||
}
|
||
|
||
|
||
function draw()
|
||
{
|
||
|
||
if(root.players[playerId].pc.leaveItMode){
|
||
if(dOpacity == 0 && opacity > 128){
|
||
dOpacity = -20;
|
||
}
|
||
}else{
|
||
if(dOpacity <= 0 || opacity < 255){
|
||
dOpacity = 20;
|
||
}
|
||
}
|
||
var o = hpGaugeLayer.opacity + dOpacity;
|
||
if(o < 128){
|
||
o = 128;
|
||
dOpacity = 0;
|
||
}
|
||
if(o > 255){
|
||
o = 255;
|
||
dOpacity = 0;
|
||
}
|
||
|
||
hpGaugeLayer.opacity = o;
|
||
hpGaugeLayer.value = root.players[playerId].HP;
|
||
hpGaugeLayer.draw();
|
||
|
||
mpGaugeLayer.value = root.players[playerId].MP;
|
||
if(!root.players[playerId].pc.leaveItMode && mpGaugeLayer.width / mpGaugeLayer.gWidth < 0.25){
|
||
mpGaugeLayer.imageTop = - mpGaugeLayer.imageHeight / 2;
|
||
var mo = mpGaugeLayer.opacity;
|
||
mo += 10;
|
||
if(mo > 255) mo = 155;
|
||
mpGaugeLayer.opacity = mo;
|
||
}else{
|
||
mpGaugeLayer.imageTop = 0;
|
||
mpGaugeLayer.opacity = o;
|
||
}
|
||
mpGaugeLayer.draw();
|
||
var n = f.playerNum[root.players[playerId].chara] - 1;
|
||
if(parent.opacityDelta >= 0) zankiLayer.draw(((n>0)?n:0));
|
||
comboLayer.draw(root.players[playerId].comboCount);
|
||
|
||
selectCircleLayer.onRefreshFrame();
|
||
mpIndicatorLayer.onRefreshFrame();
|
||
}
|
||
|
||
function showMpIndicatorLayer(storage)
|
||
{
|
||
mpIndicatorLayer.visible = true;
|
||
mpIndicatorLayer.loadImages(%['storage'=>root.fHeader + storage, 'noZoom'=>true]);
|
||
}
|
||
|
||
function loadBg()
|
||
{
|
||
switch (align){
|
||
case 0:
|
||
loadImages(fHeaderMatrix[root.mode] + "info_playerL_frame" + ((root.nowSelectingPlayerId == playerId)?"1":"0"));
|
||
break;
|
||
case 1:
|
||
loadImages(fHeaderMatrix[root.mode] + "info_playerR_frame" + ((root.nowSelectingPlayerId == playerId)?"1":"0"));
|
||
break;
|
||
}
|
||
setSizeToImageSize();
|
||
}
|
||
|
||
function setSelectCircleLayer()
|
||
{
|
||
if(root.nowSelectingPlayerId == playerId){
|
||
selectCircleLayer.loadImages(%["storage"=>"SelectPlayerCircle"]);
|
||
selectCircleLayer.conductor.start();
|
||
}else{
|
||
selectCircleLayer.visible = false;
|
||
}
|
||
// if(align) selectCircleLayer.setInverse();
|
||
|
||
}
|
||
|
||
|
||
|
||
}
|
||
|
||
|
||
|
||
class GaugeLayer extends Layer
|
||
{
|
||
var leftDirect = true; // デフォルトは左側が基点（ゼロ）になるゲージ
|
||
var maxValue = 100;
|
||
var pValue = 100;
|
||
var gWidth = 100;
|
||
var gHeight = 8;
|
||
var zeroCommaAdjust = false;
|
||
var offset = 0;
|
||
|
||
var pLeft;
|
||
var pTop;
|
||
|
||
var parent;
|
||
|
||
var delta = 0;
|
||
var dispValue;
|
||
|
||
function GaugeLayer(win, parent)
|
||
{
|
||
this.parent = parent;
|
||
super.Layer(...);
|
||
visible = false;
|
||
face = dfAlpha;
|
||
type = ltAlpha;
|
||
}
|
||
|
||
function finalize()
|
||
{
|
||
super.finalize();
|
||
}
|
||
|
||
function loadImages(storage)
|
||
{
|
||
super.loadImages(...);
|
||
gHeight = imageHeight;
|
||
}
|
||
|
||
function init(max, val)
|
||
{
|
||
maxValue = max;
|
||
pValue = val;
|
||
dispValue = pValue;
|
||
}
|
||
|
||
|
||
function draw()
|
||
{
|
||
dispValue += delta;
|
||
delta /= 2;
|
||
if(Math.abs(delta) < 1){
|
||
delta = 0;
|
||
dispValue = pValue;
|
||
}
|
||
|
||
if(int(dispValue) >= maxValue){
|
||
setSize(gWidth, gHeight);
|
||
}else{
|
||
var w = int((dispValue/maxValue) * gWidth);
|
||
if(zeroCommaAdjust && pValue > 0 && w == 0) w = 1;
|
||
setSize(w, gHeight);
|
||
}
|
||
|
||
if(leftDirect){
|
||
super.setPos(pLeft, pTop);
|
||
}else{
|
||
super.setPos((gWidth-width)+pLeft, pTop);
|
||
}
|
||
}
|
||
|
||
function setPos(x, y)
|
||
{
|
||
pLeft = x;
|
||
pTop = y;
|
||
super.setPos(...);
|
||
}
|
||
|
||
property value
|
||
{
|
||
setter(v){
|
||
if(v != pValue){
|
||
delta = (v - pValue) / 2;
|
||
dispValue = pValue;
|
||
pValue = v;
|
||
}
|
||
}
|
||
getter(){
|
||
return pValue;
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
|
||
class GaugeNeedleLayer extends GaugeLayer
|
||
{
|
||
function GaugeNeedleLayer(win, parent)
|
||
{
|
||
super.GaugeLayer(...);
|
||
}
|
||
|
||
function draw()
|
||
{
|
||
dispValue += delta;
|
||
delta /= 2;
|
||
if(Math.abs(delta) < 1){
|
||
delta = 0;
|
||
dispValue = pValue;
|
||
}
|
||
|
||
if(int(dispValue) >= maxValue){
|
||
internalSetPos(gWidth);
|
||
}else{
|
||
var w = int((dispValue/maxValue) * gWidth);
|
||
if(zeroCommaAdjust && pValue > 0 && w == 0) w = 1;
|
||
internalSetPos(w);
|
||
}
|
||
}
|
||
|
||
function setPos(x, y)
|
||
{
|
||
pLeft = x;
|
||
pTop = y;
|
||
super.setPos(...);
|
||
}
|
||
|
||
|
||
function internalSetPos(v){
|
||
global.Layer.setPos(pLeft + v - width/2, pTop);
|
||
}
|
||
|
||
|
||
}
|
||
|
||
class EnemyHpLayer extends Layer
|
||
{
|
||
var image = ["gauge01a", "gauge01b", "gauge01c", "gauge01d"];
|
||
|
||
var hPadding = 2;
|
||
var vPadding = 2;
|
||
|
||
// 表示縮尺（１ドット幅であらわすＨＰの量）
|
||
var enemyHpGaugeDispLate = 2.5;
|
||
|
||
var parent;
|
||
var window;
|
||
|
||
var gaugeLayers = [];
|
||
var nameLayer;
|
||
var caption;
|
||
|
||
var mode;
|
||
|
||
var align = 1; // 表示位置 0:画面左側 ／ 1:画面右側
|
||
var alignChangeTick = 0; // align が変わった時のtick（混戦の時に左右にガチャガチャしないため）
|
||
var target = 1; // 表示位置の指定だがその通りに表示されるかは確定しない（基本はtrue）
|
||
|
||
// 一段で表示できる最大ＨＰ
|
||
var dispMax = 400;
|
||
|
||
function EnemyHpLayer(win, parent, mode)
|
||
{
|
||
this.parent = parent;
|
||
this.window = win;
|
||
this.mode = mode;
|
||
super.Layer(...);
|
||
visible = false;
|
||
|
||
target = !parent.owner.stageLayer.reverseDirection;
|
||
|
||
switch(mode){
|
||
case 1:
|
||
image = ["gauge01a", "gauge01b", "gauge01c", "gauge01d", "gauge01e"];
|
||
enemyHpGaugeDispLate = 2.8;
|
||
font.height = 11;
|
||
break;
|
||
case 2:
|
||
image = ["gauge01a", "gauge01b", "gauge01c", "gauge01d", "gauge01e"];
|
||
enemyHpGaugeDispLate = 1.6;
|
||
font.height = 11;
|
||
break;
|
||
case 3:
|
||
image = ["m3_gauge01a", "m3_gauge01b", "m3_gauge01c", "m3_gauge01d", "m3_gauge01e"];
|
||
font.height = 18;
|
||
enemyHpGaugeDispLate = 0.8;
|
||
break;
|
||
}
|
||
|
||
gaugeAdd();
|
||
nameLayer = new .Layer(window, this);
|
||
}
|
||
|
||
function finalize()
|
||
{
|
||
for(var i=0; i<gaugeLayers.count; i++){
|
||
invalidate gaugeLayers[i];
|
||
}
|
||
gaugeLayers = void;
|
||
invalidate nameLayer;
|
||
super.finalize();
|
||
}
|
||
|
||
function resetGauge(v, name){
|
||
for(var i=0; i<gaugeLayers.count; i++){
|
||
invalidate gaugeLayers[i];
|
||
}
|
||
gaugeLayers = [];
|
||
nameLayer.fillRect(0, 0, nameLayer.width, nameLayer.height, 0x00000000);
|
||
alignChangeTick = 0;
|
||
align = !target;
|
||
gaugeAdd();
|
||
setGauge(v, name);
|
||
}
|
||
|
||
|
||
function gaugeAdd()
|
||
{
|
||
var n = gaugeLayers.count;
|
||
var n2 = n % image.count;
|
||
gaugeLayers[n] = new GaugeLayer(window, this);
|
||
gaugeLayers[n].loadImages(image[n2]);
|
||
if(n >= image.count){
|
||
gaugeLayers[n].adjustGamma(2.0, 0, 255, 2.0, 0, 255, 2.0, 0, 255);
|
||
}
|
||
gaugeLayers[n].setPos(hPadding,vPadding);
|
||
gaugeLayers[n].visible = true;
|
||
gaugeLayers[n].leftDirect = false;
|
||
gaugeLayers[n].zeroCommaAdjust = true;
|
||
}
|
||
|
||
function gaugeErase()
|
||
{
|
||
var n = gaugeLayers.count - 1;
|
||
if(n < 0) return;
|
||
|
||
gaugeLayer[n].visible = false;
|
||
invalidate gaugeLayers[n];
|
||
gaugeLayers.erase(n);
|
||
}
|
||
|
||
function setGauge(v, name)
|
||
{
|
||
fillRect(0, 0, width, height, 0x00000000);
|
||
|
||
while(int(v - dispMax) > 0){
|
||
var over = int(v - dispMax);
|
||
if(over > dispMax) over = dispMax;
|
||
gaugeAdd();
|
||
var g = gaugeLayers[gaugeLayers.count-1];
|
||
g.gWidth = int(dispMax / enemyHpGaugeDispLate);
|
||
g.init(dispMax, over);
|
||
v -= over;
|
||
}
|
||
|
||
// ゲージの設定
|
||
gaugeLayers[0].gWidth = int(v / enemyHpGaugeDispLate);
|
||
gaugeLayers[0].init(v, v);
|
||
if(typeof(name) == 'Object'){
|
||
caption = name[sf.language];
|
||
}else{
|
||
caption = name;
|
||
}
|
||
|
||
setSize(gaugeLayers[0].gWidth + hPadding * 2 , gaugeLayers[0].gHeight + vPadding * 2 + (mode==3)?40:20);
|
||
|
||
// 敵の名前を表示
|
||
nameLayer.font.face = fontListP[sf.language];
|
||
nameLayer.font.height = font.height;
|
||
var w = nameLayer.font.getTextWidth(caption) + 2;
|
||
var wo = 0;
|
||
if(width < w){
|
||
wo = w - width;
|
||
gaugeLayers[0].setPos(hPadding+wo, vPadding);
|
||
width = w;
|
||
}
|
||
var tx = width - w;
|
||
var ty = gaugeLayers[0].gHeight + vPadding * 2 + 1;
|
||
|
||
nameLayer.setSize(w, nameLayer.font.getTextHeight(caption)+2);
|
||
nameLayer.setPos(tx, ty);
|
||
nameLayer.visible = true;
|
||
|
||
nameLayer.drawText(0, 1 , caption, 0x000000, 255, true);
|
||
nameLayer.drawText(2, 1 , caption, 0x000000, 255, true);
|
||
nameLayer.drawText(1, 0 , caption, 0x000000, 255, true);
|
||
nameLayer.drawText(1, 2 , caption, 0x000000, 255, true);
|
||
nameLayer.drawText(1, 1 , caption, 0xffffff, 255, true);
|
||
nameLayer.drawText(1, 1 , caption, 0xffffff, 255, true);
|
||
|
||
frameDraw(1);
|
||
}
|
||
|
||
function frameDraw(a = 1){
|
||
// ゲージの枠描画
|
||
|
||
fillRect(0, 0, width, height, 0x00000000);
|
||
var tmp = new .Layer(window, parent);
|
||
tmp.loadImages((mode==3)?"m3_gaugeFrame01":"gaugeFrame01");
|
||
|
||
var t = (a == 1)? (width - hPadding * 2 - gaugeLayers[0].gWidth): 0;
|
||
copyRect(t, 0, tmp, 0, 0, hPadding, tmp.height);
|
||
copyRect(t+hPadding+gaugeLayers[0].gWidth, 0, tmp, tmp.width-hPadding, 0, hPadding, height);
|
||
stretchCopy(t+hPadding, 0, gaugeLayers[0].gWidth, tmp.height, tmp, hPadding, 0, tmp.width-hPadding*2, tmp.height, stNearest);
|
||
|
||
invalidate tmp;
|
||
}
|
||
|
||
|
||
function checkAndChangeAlign(){
|
||
// 敵の体力ゲージを画面の左右どちらかに表示するかを決定し、表示の右揃え・左揃えを修正する
|
||
|
||
// if(sf.adjSinglePlayMode || parent.owner.players.count<2) return;
|
||
if(align == target) return;
|
||
if(parent.owner.tickCount - alignChangeTick < 30) return;
|
||
switch (target){
|
||
case 0:
|
||
for(var i=0; i<gaugeLayers.count; i++){
|
||
gaugeLayers[i].leftDirect = true;
|
||
}
|
||
nameLayer.left = 0;
|
||
if(width == nameLayer.width){
|
||
// ゲージよりも名前表示の方が幅がある場合はゲージ枠を描き直す
|
||
frameDraw(0);
|
||
gaugeLayers[0].setPos(hPadding, vPadding);
|
||
}
|
||
break;
|
||
case 1:
|
||
for(var i=0; i<gaugeLayers.count; i++){
|
||
gaugeLayers[i].leftDirect = false;
|
||
}
|
||
nameLayer.left = width - nameLayer.width;
|
||
if(width == nameLayer.width){
|
||
// ゲージよりも名前表示の方が幅がある場合はゲージ枠を描き直す
|
||
frameDraw(1);
|
||
gaugeLayers[0].setPos(width-hPadding-gaugeLayers[0].gWidth, vPadding);
|
||
}
|
||
break;
|
||
}
|
||
align = target;
|
||
alignChangeTick = parent.owner.tickCount;
|
||
}
|
||
|
||
|
||
function draw()
|
||
{
|
||
for(var i=0; i<gaugeLayers.count; i++){
|
||
gaugeLayers[i].draw();
|
||
}
|
||
}
|
||
|
||
property value{
|
||
setter(v){
|
||
var tv = v;
|
||
for(var i=0; i<gaugeLayers.count; i++){
|
||
if(tv > gaugeLayers[i].maxValue){
|
||
gaugeLayers[i].value = gaugeLayers[i].maxValue;
|
||
tv = tv - gaugeLayers[i].maxValue;
|
||
}else{
|
||
if(tv > 0){
|
||
gaugeLayers[i].value = tv;
|
||
}else{
|
||
gaugeLayers[i].value = 0;
|
||
}
|
||
tv = 0;
|
||
}
|
||
}
|
||
}
|
||
getter{
|
||
var tv = 0;
|
||
for(var i=0; i<gaugeLayers.count; i++){
|
||
tv += gaugeLayers[i].value;
|
||
}
|
||
return tv;
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
|
||
class NormalGaugeLayer extends Layer
|
||
{
|
||
var hPadding = 1;
|
||
var vPadding = 1;
|
||
|
||
var parent;
|
||
var gaugeLayer;
|
||
|
||
var pEnabled = false;
|
||
|
||
var frameStorage;
|
||
var gaugeStorage;
|
||
|
||
function NormalGaugeLayer(win, parent, type=0)
|
||
{
|
||
this.parent = parent;
|
||
super.Layer(...);
|
||
visible = false;
|
||
|
||
switch(type){
|
||
case 1:
|
||
gaugeLayer = new GaugeNeedleLayer(win, this);
|
||
break;
|
||
default:
|
||
gaugeLayer = new GaugeLayer(win, this);
|
||
}
|
||
gaugeLayer.setPos(hPadding,vPadding);
|
||
gaugeLayer.visible = true;
|
||
gaugeLayer.leftDirect = true;
|
||
gaugeLayer.zeroCommaAdjust = true;
|
||
gaugeLayer.name = "gaugeLayer";
|
||
|
||
}
|
||
|
||
function finalize()
|
||
{
|
||
invalidate gaugeLayer;
|
||
super.finalize();
|
||
}
|
||
|
||
function setGauge(f, g, w, m, v)
|
||
{
|
||
frameStorage = f;
|
||
gaugeStorage = g;
|
||
|
||
gaugeLayer.loadImages(gaugeStorage);
|
||
gaugeLayer.setSizeToImageSize();
|
||
fillRect(0, 0, width, height, 0x00000000);
|
||
|
||
init(w, m, v);
|
||
|
||
loadImages(frameStorage);
|
||
setSizeToImageSize();
|
||
|
||
}
|
||
|
||
function init(w, m, v){
|
||
// w : 全体幅(pixel)
|
||
// m : maxの値
|
||
// v : 現在値
|
||
if(w !== void) gaugeLayer.gWidth = int(w);
|
||
if(m !== void) gaugeLayer.maxValue = m;
|
||
if(v !== void) gaugeLayer.pValue = gaugeLayer.dispValue = v;
|
||
}
|
||
|
||
function draw()
|
||
{
|
||
if(!enabled) return;
|
||
gaugeLayer.draw();
|
||
}
|
||
|
||
property value{
|
||
setter(v){
|
||
// if(!enabled) return;
|
||
if(v < 0) v = 0;
|
||
if(v > gaugeLayer.maxValue+5) v = gaugeLayer.maxValue+5;
|
||
gaugeLayer.value = v;
|
||
}
|
||
getter{
|
||
return gaugeLayer.value;
|
||
}
|
||
}
|
||
|
||
property maxValue{
|
||
setter(v){
|
||
gaugeLayer.maxValue = v;
|
||
}
|
||
getter{
|
||
return gaugeLayer.maxValue;
|
||
}
|
||
}
|
||
|
||
property enabled{
|
||
setter(e){
|
||
if(e){
|
||
// value = 0;
|
||
visible =true;
|
||
pEnabled = true;
|
||
}else{
|
||
visible = false;
|
||
pEnabled = false;
|
||
}
|
||
}
|
||
getter{
|
||
return pEnabled;
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
|
||
|
||
class DirectionCircleLayer extends Layer
|
||
{
|
||
var x;
|
||
var y;
|
||
|
||
function DirectionCircleLayer(win, parent)
|
||
{
|
||
super.Layer(...);
|
||
loadImages("directionCircle");
|
||
setSize(imageWidth/9, imageHeight);
|
||
absolute = 100003;
|
||
visible = false;
|
||
hitThreshold = 256;
|
||
opacity = 255;
|
||
}
|
||
|
||
function finalize()
|
||
{
|
||
super.finalize();
|
||
}
|
||
|
||
function show(x, y)
|
||
{
|
||
this.x = x;
|
||
this.y = y;
|
||
|
||
setPos(x - width/2, y - height/2);
|
||
draw(0);
|
||
visible = true;
|
||
}
|
||
|
||
function hide()
|
||
{
|
||
visible = false;
|
||
}
|
||
|
||
function draw(s)
|
||
{
|
||
imageLeft = -width * s;
|
||
}
|
||
|
||
|
||
}
|
||
|
||
|
||
class CutinLayer extends SpriteLayer
|
||
{
|
||
var window;
|
||
|
||
var dTop;
|
||
var dLeft;
|
||
var centerPos;
|
||
var inverse;
|
||
|
||
var caller;
|
||
|
||
var layers = [];
|
||
|
||
function CutinLayer(win, par, owner, root)
|
||
{
|
||
this.window = win;
|
||
super.SpriteLayer(...);
|
||
visible = false;
|
||
|
||
conductor.subHandlers = getHandlers();
|
||
}
|
||
|
||
function finalize()
|
||
{
|
||
delLayers();
|
||
super.finalize();
|
||
}
|
||
|
||
function delLayers(){
|
||
for(var i=0; i<layers.count; i++){
|
||
layers[i].visible = false;
|
||
invalidate layers[i];
|
||
layers.erase(i);
|
||
}
|
||
}
|
||
|
||
|
||
function loadImages(elm){
|
||
if(conductor.running) return;
|
||
delLayers();
|
||
if(elm.caller !== void){
|
||
caller = elm.caller;
|
||
}else{
|
||
caller = owner.players[0];
|
||
}
|
||
fillRect(0, 0, width, height, 0x00000000);
|
||
super.loadImages(...);
|
||
}
|
||
|
||
function onRefreshFrame(){
|
||
conductor.frameProcess();
|
||
for(var i=0; i<layers.count; i++){
|
||
layers[i].conductor.frameProcess();
|
||
}
|
||
}
|
||
|
||
function clearCollisionRect()
|
||
{
|
||
// ダミー
|
||
}
|
||
|
||
function getHandlers()
|
||
{
|
||
return %[
|
||
|
||
size : function(elm)
|
||
{
|
||
// サイズの設定
|
||
internalWidth = +elm.width;
|
||
internalHeight = +elm.height;
|
||
setSize(internalWidth, internalHeight);
|
||
centerPos = internalWidth / 2;
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
pos : function(elm)
|
||
{
|
||
// 表示位置の設定
|
||
setPos(+elm.left, +elm.top);
|
||
dLeft = +elm.left;
|
||
dTop = +elm.top;
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
set : function(elm)
|
||
{
|
||
//
|
||
if(elm.clip!==void){
|
||
var a = [].split("(), ", elm.clip, , true);
|
||
var w = +a[0]; if(w > internalWidth) w = internalWidth;
|
||
var h = +a[1]; if(h > internalHeight) h = internalHeight;
|
||
setSize(w,h);
|
||
var x = (w - internalWidth) / 2;
|
||
var y = (h - internalHeight) / 2;
|
||
|
||
setImagePos(x, y);
|
||
setPos(dLeft+(internalWidth-w)/2, dTop+(internalHeight-h)/2);
|
||
for(var i=0; i<layers.count; i++){
|
||
layers[i].left = x;
|
||
layers[i].top = y;
|
||
}
|
||
}
|
||
if(elm.opacity !== void) opacity = +elm.opacity;
|
||
if(elm.visible !== void) visible = +elm.visible;
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
pause : function(elm)
|
||
{
|
||
// スプライトの動きを止める
|
||
owner.pausedByCutin = true;
|
||
return 0;
|
||
} incontextof this,
|
||
|
||
resume : function(elm)
|
||
{
|
||
// スプライトの動きを再開
|
||
owner.pausedByCutin = false;
|
||
return 0;
|
||
} incontextof this,
|
||
];
|
||
}
|
||
|
||
}
|
||
|
||
|
||
class NumberLayer extends Layer
|
||
{
|
||
var overflowLimit = true; // 桁あふれ時の動作（0:桁を増やす 1:桁を増やさず9で埋める）
|
||
var digit;
|
||
var digitOrigin;
|
||
|
||
var indWidth;
|
||
var indHeight;
|
||
|
||
var numeralLayer;
|
||
|
||
var numberStr = "";
|
||
var zeroHead = false;
|
||
var alignRight = true;
|
||
|
||
function NumberLayer(win, par)
|
||
{
|
||
super.Layer(win, par);
|
||
|
||
numeralLayer = new .Layer(win,this);
|
||
numeralLayer.name = "numeralLayer";
|
||
numeralLayer.visible = false;
|
||
}
|
||
|
||
function finalize()
|
||
{
|
||
invalidate numeralLayer;
|
||
super.finalize();
|
||
}
|
||
|
||
function init(digit, storage)
|
||
{
|
||
this.digit = digit;
|
||
digitOrigin = digit;
|
||
numberStr = " ".repeat(digit);
|
||
numeralLayer.loadImages(storage);
|
||
numeralLayer.setSizeToImageSize;
|
||
|
||
indWidth = numeralLayer.imageWidth / 10;
|
||
indHeight = numeralLayer.imageHeight;
|
||
|
||
setSize(indWidth*digit, indHeight);
|
||
fillRect(0, 0, width, height, 0x00000000);
|
||
visible = false;
|
||
opacity = 255;
|
||
|
||
draw(0);
|
||
}
|
||
|
||
function toStr(num)
|
||
{
|
||
var tmp = string(num);
|
||
if(zeroHead){
|
||
var f = "%0" + digit + "d";
|
||
return f.sprintf(num);
|
||
}else if(alignRight){
|
||
return " ".repeat(digit-tmp.length) + tmp;
|
||
}else{
|
||
return tmp + " ".repeat(digit-tmp.length);
|
||
}
|
||
}
|
||
|
||
function draw(num)
|
||
{
|
||
var str = toStr(num);
|
||
if(str.length > digit){
|
||
if(overflowLimit){
|
||
str = "9".repeat(digit);
|
||
}
|
||
}
|
||
|
||
for(var i=0; i<digit; i++){
|
||
if(str[i] != numberStr[i]){
|
||
if(str[i] == " "){
|
||
fillRect(indWidth*i, 0, indWidth, indHeight, 0x00000000);
|
||
}else{
|
||
var n = int(str[i]);
|
||
copyRect(indWidth*i, 0, numeralLayer, indWidth*n, 0, indWidth, indHeight);
|
||
}
|
||
}
|
||
}
|
||
numberStr = str;
|
||
}
|
||
|
||
}
|
||
|
||
|
||
class FaceLayer extends Layer
|
||
{
|
||
var inverse = false;
|
||
var num = 8;
|
||
var value = 0;
|
||
|
||
function FaceLayer(win, par)
|
||
{
|
||
super.Layer(...);
|
||
}
|
||
|
||
function init(storage, align){
|
||
visible = false;
|
||
loadImages(storage);
|
||
setSize(imageWidth/num, imageHeight);
|
||
imageLeft = 0;
|
||
|
||
inverse = align;
|
||
if(inverse){
|
||
flipLR();
|
||
}
|
||
}
|
||
|
||
function draw(n=0)
|
||
{
|
||
value = n;
|
||
imageLeft = - ((!inverse)? n : (num - n - 1)) * width;
|
||
}
|
||
|
||
}
|
||
|
||
|
||
class ComboLayer extends Layer
|
||
{
|
||
var parent;
|
||
var root;
|
||
|
||
var lastCount = 0;
|
||
var whenZeroTick;
|
||
|
||
var countLayer;
|
||
var subLayer;
|
||
|
||
var opacityDelta = 0;
|
||
|
||
function ComboLayer(win, par)
|
||
{
|
||
super.Layer(...);
|
||
parent = par;
|
||
root = parent.root; // bao
|
||
|
||
countLayer = new NumberLayer(window, this);
|
||
countLayer.name = "countLayer";
|
||
|
||
subLayer = new .Layer(window, this);
|
||
subLayer.name = "subLayer";
|
||
|
||
visible = false;
|
||
opacity = 0;
|
||
}
|
||
|
||
function init(mode){
|
||
switch(mode){
|
||
case 1:
|
||
countLayer.setPos(0, 0);
|
||
countLayer.zeroHead = false;
|
||
countLayer.init(3, "numeral04");
|
||
countLayer.visible = true;
|
||
countLayer.opacity = 255;
|
||
countLayer.overflowLimit = false;
|
||
|
||
if(parent.align==0){
|
||
subLayer.setPos(6, 23);
|
||
}else{
|
||
subLayer.setPos(22, 23);
|
||
}
|
||
subLayer.loadImages("combo");
|
||
subLayer.setSizeToImageSize();
|
||
subLayer.visible = true;
|
||
subLayer.opacity = 255;
|
||
|
||
setSize(countLayer.width*1.5, 36);
|
||
break;
|
||
|
||
case 2:
|
||
countLayer.setPos(0, 0);
|
||
countLayer.zeroHead = false;
|
||
countLayer.init(3, "numeral02");
|
||
countLayer.visible = true;
|
||
countLayer.opacity = 255;
|
||
countLayer.opacity = 255;
|
||
|
||
if(parent.align==0){
|
||
subLayer.setPos(17, 24);
|
||
}else{
|
||
subLayer.setPos(28, 24);
|
||
}
|
||
subLayer.loadImages("combo");
|
||
subLayer.setSizeToImageSize();
|
||
subLayer.visible = true;
|
||
subLayer.opacity = 255;
|
||
|
||
setSize(countLayer.width*1.5, 36);
|
||
break;
|
||
|
||
case 3:
|
||
countLayer.setPos(0, 0);
|
||
countLayer.zeroHead = false;
|
||
countLayer.init(3, "numeral02b");
|
||
countLayer.visible = true;
|
||
countLayer.opacity = 255;
|
||
countLayer.opacity = 255;
|
||
|
||
if(parent.align==0){
|
||
subLayer.setPos(34, 48);
|
||
}else{
|
||
subLayer.setPos(48, 48);
|
||
}
|
||
subLayer.loadImages("m3_combo");
|
||
subLayer.setSizeToImageSize();
|
||
subLayer.visible = true;
|
||
subLayer.opacity = 255;
|
||
|
||
setSize(countLayer.width*1.5, 72);
|
||
break;
|
||
}
|
||
}
|
||
|
||
function draw(count)
|
||
{
|
||
var o = opacity;
|
||
if(count > 1){
|
||
if(count != lastCount) countLayer.draw(count);
|
||
visible = true;
|
||
o += 86;
|
||
if(o > 255) o = 255;
|
||
}else{
|
||
if(count != lastCount) whenZeroTick = root.tickCount;
|
||
if(root.tickCount - whenZeroTick > 30 && o > 0){
|
||
o -= 30;
|
||
if(o < 0){
|
||
o = 0;
|
||
visible = false;
|
||
}
|
||
}
|
||
}
|
||
opacity = o;
|
||
lastCount = count;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
function getDistance(s1, s2)
|
||
{
|
||
return (s1.rootX-s2.rootX)*(s1.rootX-s2.rootX) + (s1.rootY-s2.rootY)*(s1.rootY-s2.rootY);
|
||
}
|
||
|
||
|
||
function str2dic(str)
|
||
{
|
||
var ary = [];
|
||
|
||
// クォーテーションで囲まれた部分をちゃんと一括りになるように
|
||
var tmp = str.split(/['"]/,, true);
|
||
for(var i=0; i < tmp.count; i+=2) {
|
||
// クォーテーション部分以外を空白やタブで分割
|
||
var a = tmp[i].split(/[ \t]+/,, true);
|
||
for(var j=0; j < a.count; j++){
|
||
ary.add(a[j]);
|
||
}
|
||
if(tmp[i+1] !== void){
|
||
ary[ary.count-1] += tmp[i+1];
|
||
}
|
||
}
|
||
|
||
var tag = %[ tagname:ary[0] ];
|
||
for(var i=1; i < ary.count; i++) {
|
||
if (ary[i].length <= 0) continue;
|
||
var t = ary[i].split(/=/);
|
||
var name = t[0];
|
||
t.erase(0);
|
||
var value = t.join('='); // 最初の = の後は全て纏める
|
||
|
||
if (value[0] == '"' && value[value.length-1] == '"') value = value.substr(1,value.length-2);
|
||
if (value[0] == "'" && value[value.length-1] == "'") value = value.substr(1,value.length-2);
|
||
tag[name] = (value == "") ? true : value;
|
||
}
|
||
return tag;
|
||
}
|
||
|
||
|
||
|
||
function initlayer(l=0, storage="_tr")
|
||
{
|
||
kag.fore.layers[l].visible = true;
|
||
kag.fore.layers[l].loadImages(%['storage'=>storage]);
|
||
kag.fore.layers[l].setSizeToImageSize();
|
||
}
|
||
|
||
function showLayer(o, l=0, storage="_tr")
|
||
{
|
||
initlayer(l, storage);
|
||
kag.fore.layers[l].copyRect(0, 0, o, 0, 0, o.imageWidth, o.imageHeight);
|
||
}
|
||
|