930 lines
40 KiB
Text
930 lines
40 KiB
Text
|
|
class DotHScene_Plugin extends KAGPlugin
|
|
{
|
|
var window;
|
|
|
|
var timer;
|
|
var fpsTimer;
|
|
var tickCount = 0;
|
|
var fps = 0;
|
|
var fpsCount;
|
|
|
|
var mode;
|
|
|
|
var srcLayer;
|
|
var shadowLayer;
|
|
var shadowDispLayer;
|
|
|
|
// 画面サイズ
|
|
var width;
|
|
var height;
|
|
|
|
// 座標計算上の内部的なサイズ
|
|
// var internalWidth = 342;
|
|
// var internalHeight = 192;
|
|
var internalWidth = 456;
|
|
var internalHeight = 256;
|
|
|
|
// 内部的な座標から実際のレイヤー表示位置への拡大率
|
|
var cZoomRate = 3;
|
|
// stageLayerの拡大率
|
|
var sZoomRate = 1;
|
|
|
|
var bgRate = 3 / 4;
|
|
|
|
var fHeader;
|
|
var fHeader2;
|
|
var storage = void;
|
|
|
|
var bgSrcLayer;
|
|
var bgSrcLayerX;
|
|
|
|
// 各キャラのスプライト
|
|
var players = [];
|
|
var enemies = [];
|
|
var objects = [];
|
|
var others = [];
|
|
var stageLayer; //←ダミーだけどとりあえず必要
|
|
|
|
var bgLayer;
|
|
var drawLayer;
|
|
|
|
var cameraX = 0;
|
|
var cameraY = 0;
|
|
var cameraZoom = 1;
|
|
|
|
var currentCameraX = cameraX;
|
|
var currentCameraY = cameraY;
|
|
var currentCameraZoom = cameraZoom;
|
|
|
|
var dx = [];
|
|
var dy = [];
|
|
var dz = [];
|
|
|
|
var cos = [0, 0];
|
|
|
|
var enabled = false;
|
|
|
|
function DotHScene_Plugin(window, cos0=0, cos1=0)
|
|
{
|
|
super.KAGPlugin();
|
|
this.window = window;
|
|
|
|
cos[0] = cos0;
|
|
cos[1] = cos1;
|
|
|
|
// 拡大前のレイヤー
|
|
srcLayer = new Layer(window, window.fore.base);
|
|
// srcLayer.setSize(width, height);
|
|
srcLayer.opacity = 255;
|
|
srcLayer.absolute = 950;
|
|
srcLayer.visible = debugMode;
|
|
srcLayer.name = "dho.srcLayer";
|
|
|
|
bgLayer = new .Layer(window, srcLayer);
|
|
bgLayer.opacity = 255;
|
|
bgLayer.visible = true;
|
|
bgLayer.hitThreshold = 256;
|
|
bgLayer.absolute = 10;
|
|
bgLayer.name = "dho.bgLayer";
|
|
|
|
shadowLayer = new ShadowLayer(window, srcLayer, this);
|
|
shadowLayer.setSize(internalWidth, internalHeight);
|
|
shadowLayer.opacity = 128;
|
|
shadowLayer.visible = false;
|
|
shadowLayer.absolute = 20;
|
|
shadowLayer.name = "dho.shadowLayer";
|
|
|
|
shadowDispLayer = new Layer(window, srcLayer);
|
|
shadowDispLayer.opacity = 128;
|
|
shadowDispLayer.name = "dho.shadowDispLayer";
|
|
|
|
drawLayer = new DrawLayer(window, srcLayer, this);
|
|
// drawLayer.setSize(width, height);
|
|
drawLayer.opacity = 255;
|
|
drawLayer.absolute = 100000;
|
|
drawLayer.visible = true;
|
|
drawLayer.name = "dho.drawLayer";
|
|
|
|
timer = new Timer(refreshFrame, "");
|
|
timer.interval = 33.334;
|
|
timer.capacity = 1;
|
|
timer.enabled = false;
|
|
|
|
if(tf.debugMode){
|
|
// fpsを計測するタイマー。ゲームの進行には特に関係しない。
|
|
fpsCount = 0;
|
|
fpsTimer = new Timer(showFps, "");
|
|
fpsTimer.interval = 1000;
|
|
fpsTimer.enabled = false;
|
|
}
|
|
|
|
setMode(sf.HScreenMode);
|
|
shadowLayer.init();
|
|
}
|
|
|
|
function changeMode(m){
|
|
var tmp = %[];
|
|
onStore(tmp);
|
|
setMode(m);
|
|
shadowLayer.init();
|
|
setBackGround(%['storage'=>storage]);
|
|
onRestore(tmp);
|
|
}
|
|
|
|
function setMode(m){
|
|
|
|
mode = m;
|
|
switch(mode){
|
|
case 1:
|
|
// 342x192
|
|
sZoomRate = 1;
|
|
cZoomRate = 1;
|
|
fHeader = fHeaderMatrix[1];
|
|
fHeader2 = fHeaderMatrix[1];
|
|
break;
|
|
|
|
case 2:
|
|
// 513x288
|
|
sZoomRate = 1;
|
|
cZoomRate = 1.5;
|
|
fHeader = fHeaderMatrix[2];
|
|
fHeader2 = fHeaderMatrix[2];
|
|
break;
|
|
|
|
case 3:
|
|
// 1026x576
|
|
sZoomRate = 1;
|
|
cZoomRate = 3;
|
|
fHeader = fHeaderMatrix[3];
|
|
fHeader2 = fHeaderMatrix[3];
|
|
break;
|
|
}
|
|
|
|
width = internalWidth * cZoomRate;
|
|
height = internalHeight * cZoomRate;
|
|
|
|
if(srcLayer !== void) srcLayer.setSize(width, height);
|
|
if(bgLayer !== void) bgLayer.setSize(width, height);
|
|
if(shadowLayer !== void) shadowLayer.setSize(width, height);
|
|
if(drawLayer !== void) drawLayer.setSize(width, height);
|
|
|
|
shadowLayer.visible = true;
|
|
}
|
|
|
|
property sZoomRate2{
|
|
getter()
|
|
{
|
|
return cZoomRate / sZoomRate;
|
|
}
|
|
}
|
|
|
|
function finalize()
|
|
{
|
|
timer.enabled = false;
|
|
invalidate timer;
|
|
if(fpsTimer !== void) invalidate fpsTimer;
|
|
|
|
reset();
|
|
|
|
bgLayer.visible = false;
|
|
invalidate bgLayer;
|
|
shadowLayer.visible = false;
|
|
invalidate shadowLayer;
|
|
shadowDispLayer.visible = false;
|
|
invalidate shadowLayer;
|
|
drawLayer.visible = false;
|
|
invalidate drawLayer;
|
|
srcLayer.visible = false;
|
|
invalidate srcLayer;
|
|
|
|
storage = void;
|
|
bgSrcLayer = void;
|
|
}
|
|
|
|
function reset()
|
|
{
|
|
//主人公
|
|
for(var i=0; i<players.count; i++){
|
|
if(players[i] !== void) invalidate players[i];
|
|
players[i] = void;
|
|
}
|
|
players = [];
|
|
|
|
resetEnemies();
|
|
resetObjects();
|
|
resetOthers();
|
|
}
|
|
|
|
function resetWithoutPlayer()
|
|
{
|
|
resetEnemies();
|
|
resetObjects();
|
|
}
|
|
|
|
function resetEnemies()
|
|
{
|
|
//敵
|
|
for(var i=0; i<enemies.count; i++) invalidate enemies[i];
|
|
enemies = [];
|
|
}
|
|
|
|
function resetObjects()
|
|
{
|
|
//オブジェクト
|
|
for(var i=0; i<objects.count; i++) invalidate objects[i];
|
|
objects = [];
|
|
}
|
|
|
|
function resetOthers()
|
|
{
|
|
//その他オブジェクト
|
|
for(var i=0; i<others.count; i++){
|
|
invalidate others[i];
|
|
}
|
|
others = [];
|
|
}
|
|
|
|
|
|
function showFps()
|
|
{
|
|
fps = fpsCount;
|
|
if(fps > 30) fps = 30;
|
|
// window.caption = "fps : " + fps + " / HP : " + players[0].HP + " / MP : " + (int)players[0].MP + " / enemies : " + enemies.count;
|
|
fpsCount = 0;
|
|
}
|
|
|
|
function refreshFrame(){
|
|
|
|
// 主人公処理
|
|
for(var i=0; i<players.count; i++){
|
|
if(players[i] !== void && isvalid players[i]){
|
|
var p = players[i];
|
|
if(p.movingTable[0] !== void){
|
|
p.rootX += p.movingTable[0].x;
|
|
p.rootY += p.movingTable[0].y;
|
|
p.altitude += p.movingTable[0].h;
|
|
}
|
|
p.onRefreshFrame();
|
|
p.setAbsolute();
|
|
}
|
|
}
|
|
|
|
// 敵処理
|
|
for(var i=0; i<enemies.count; i++){
|
|
var e = enemies[i];
|
|
if(e.movingTable[0] !== void){
|
|
e.rootX += e.movingTable[0].x;
|
|
e.rootY += e.movingTable[0].y;
|
|
e.altitude += e.movingTable[0].h;
|
|
}
|
|
e.onRefreshFrame();
|
|
e.setAbsolute();
|
|
}
|
|
|
|
// オブジェクト
|
|
for(var i=0; i<objects.count; i++){
|
|
var o = objects[i];
|
|
if(o.movingTable[0] !== void){
|
|
o.rootX += o.movingTable[0].x;
|
|
o.rootY += o.movingTable[0].y;
|
|
o.altitude += o.movingTable[0].h;
|
|
}
|
|
o.onRefreshFrame();
|
|
o.setAbsolute();
|
|
|
|
if(o.layer.asd === void) o.deleteFlag = true;
|
|
|
|
// 削除フラグの立っているものを削除する
|
|
if(o.deleteFlag){
|
|
invalidate o;
|
|
objects.erase(i);
|
|
}
|
|
}
|
|
|
|
// その他処理
|
|
for(var i=0; i<others.count; i++){
|
|
var o = others[i];
|
|
o.onRefreshFrame();
|
|
// 削除フラグの立っているものを削除する
|
|
if(o.deleteFlag){
|
|
invalidate o;
|
|
others.erase(i);
|
|
}
|
|
}
|
|
|
|
shadowLayer.onRefreshFrame();
|
|
|
|
// 地面への影
|
|
if(mode!=1){
|
|
shadowDispLayer.fillRect(0, 0, shadowDispLayer.width, shadowDispLayer.height, 0x00000000);
|
|
shadowDispLayer.operateStretch(0, 0, width, height, shadowLayer, 0, 0, shadowLayer.width, shadowLayer.height, omAlpha, 255, stNearest);
|
|
}
|
|
|
|
// 一度srcLayerに全てコピー
|
|
srcLayer.piledCopy(0, 0, srcLayer, 0, 0, width, height);
|
|
|
|
// カメラ設定
|
|
if(dx.count > 0){
|
|
currentCameraX += dx.shift();
|
|
}else{
|
|
currentCameraX = cameraX;
|
|
}
|
|
if(dy.count > 0){
|
|
currentCameraY += dy.shift();
|
|
}else{
|
|
currentCameraY = cameraY;
|
|
}
|
|
if(dz.count > 0){
|
|
currentCameraZoom += dz.shift();
|
|
}else{
|
|
currentCameraZoom = cameraZoom;
|
|
}
|
|
|
|
// baoのレイヤーにへ転送
|
|
// bao.dispLayer2.stretchCopy(0, 0, bao.dispLayer2.width, bao.dispLayer2.height, srcLayer, 0, 0, srcLayer.width, srcLayer.height, (mode>2)?stFastLinear:stNearest);
|
|
bao.dispLayer2.stretchCopy(0, 0, bao.dispLayer2.width, bao.dispLayer2.height, srcLayer, viewLeft*cZoomRate, viewTop*cZoomRate, viewWidth*cZoomRate, viewHeight*cZoomRate, (mode>2)?stFastLinear:stNearest);
|
|
|
|
if(bao.fpsShow){
|
|
var str = "FPS : ";
|
|
if(fps < 10) str += " ";
|
|
str += fps;
|
|
bao.dispLayer2.drawText(1240-1,740,str,0x000000,255,true,255,0x000000,2);
|
|
bao.dispLayer2.drawText(1240+1,740,str,0x000000,255,true,255,0x000000,2);
|
|
bao.dispLayer2.drawText(1240,740-1,str,0x000000,255,true,255,0x000000,2);
|
|
bao.dispLayer2.drawText(1240,740+1,str,0x000000,255,true,255,0x000000,2);
|
|
bao.dispLayer2.drawText(1240,740,str,0xffffff,255,true);
|
|
}
|
|
|
|
bao.dispLayer1.assignImages(bao.dispLayer2);
|
|
|
|
|
|
// // drawLayerの消去
|
|
// if(drawLayer.drawFlag){
|
|
// drawLayer.fillRect(0, 0, width, height, 0x00000000);
|
|
// drawLayer.drawFlag = false;
|
|
// }
|
|
|
|
tickCount++;
|
|
fpsCount++;
|
|
|
|
}
|
|
|
|
function show()
|
|
{
|
|
timer.enabled = true;
|
|
if(tf.debugMode) fpsTimer.enabled = true;
|
|
enabled = true;
|
|
}
|
|
|
|
function hide()
|
|
{
|
|
timer.enabled = false;
|
|
if(tf.debugMode) fpsTimer.enabled = false;
|
|
enabled = false;
|
|
}
|
|
|
|
|
|
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 getObjectFromClassAndIndex(cl, index)
|
|
{
|
|
if(index < 0) return void;
|
|
|
|
switch(cl){
|
|
case clPlayer:
|
|
return players[index];
|
|
case clEnemy:
|
|
return enemies[index];
|
|
case clObject:
|
|
case clEffect:
|
|
return objects[index];
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------- 背景関連 --
|
|
|
|
function setBackGround(elm)
|
|
{
|
|
if(elm.storage !== void || storage!==void){
|
|
if(elm.storage!==void) storage = elm.storage;
|
|
bgLayer.loadImages(fHeader + storage);
|
|
bgLayer.setSizeToImageSize();
|
|
return;
|
|
}
|
|
if(elm.layer !== void || bgSrcLayer!==void){
|
|
if(elm.layer!==void) bgSrcLayer = elm.layer;
|
|
if(elm.x!==void) bgSrcLayerX = int(+elm.x);
|
|
|
|
var l;
|
|
var w;
|
|
var h;
|
|
var bw = internalWidth * bgRate;
|
|
var bh = internalHeight * bgRate;
|
|
|
|
l = bgSrcLayerX + internalWidth \ 2 - bw \ 2;
|
|
//dm("l : " + l + " / internalWidth : " + internalWidth + " / bw : " + bw);
|
|
switch(bao.mode){
|
|
case 1:
|
|
w = bw;
|
|
h = bh;
|
|
break;
|
|
case 2:
|
|
l = l * 1.5;
|
|
w = bw * 1.5;
|
|
h = bh * 1.5;
|
|
break;
|
|
case 3:
|
|
l = l * 1.5;
|
|
w = bw * 1.5;
|
|
h = bh * 1.5;
|
|
break;
|
|
}
|
|
//dm("l : " + l);
|
|
|
|
if(l < 0) l = 0;
|
|
if(l > bgSrcLayer.width-w) l = bgSrcLayer.width - w;
|
|
|
|
if(f.stage >= 4){
|
|
w *= 0.75;
|
|
h *= 0.75;
|
|
}
|
|
|
|
//dm("bao.stageLayer.dispLeft : " + bao.stageLayer.dispLeft + " / bgSrcLayerX : " + bgSrcLayerX + " / l : " + l + " / bw : " + bw+ " / w : " + w + " / h : " + h);
|
|
|
|
bgLayer.setSize(width,height);
|
|
bgLayer.stretchCopy(0, 0, bgLayer.width, bgLayer.height, bgSrcLayer, l, bgSrcLayer.height-h, w, h, stFastLinear);
|
|
return;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------- スプライト関連 --
|
|
|
|
function addQueue(elm)
|
|
{
|
|
var obj = getObject(elm);
|
|
if(obj !== void) obj.addQueue(elm.exp);
|
|
}
|
|
|
|
function resumeQueue(elm)
|
|
{
|
|
var obj = getObject(elm);
|
|
if(obj !== void) obj.resumeQueue();
|
|
}
|
|
|
|
function resumeQueueAll(elm)
|
|
{
|
|
for(var i=0; i<players.count; i++) 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(index);
|
|
if(enemies[id] !== void) return enemies[id];
|
|
}
|
|
var index = elm.id.indexOf("object");
|
|
if(index != -1){
|
|
var id = +elm.id.substring(index);
|
|
if(objects[id] !== void) return objects[id];
|
|
}
|
|
return void;
|
|
}
|
|
|
|
//------------------------------------------------------- 主人公キャラ関連 --
|
|
|
|
function setPlayerCostume(p, c)
|
|
{
|
|
cos[p] = c;
|
|
|
|
var l = players[p].layer;
|
|
var s = l.checkImageAndSetZoom(l.orgGraphic);
|
|
l.loadImagesSub2(s);
|
|
for(var i=0; i<objects.count; i++){
|
|
var o = objects[i];
|
|
if(o.layer.orgGraphic.indexOf(l.asd) > -1){
|
|
var s2 = o.layer.checkImageAndSetZoom(o.layer.orgGraphic);
|
|
if(s2 !== void){
|
|
o.layer.loadImagesSub2(s2);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
function setPlayer(elm)
|
|
{
|
|
var p = new CharacterSprite(window, this, elm, elm.storage);
|
|
players.add(p);
|
|
elm.storage = void;
|
|
setPlayerState(elm, p);
|
|
if(elm.shadowstorage !== void) players[players.count-1].shadowStorage = elm.shadowstorage;
|
|
}
|
|
|
|
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 = players[0];
|
|
break;
|
|
}
|
|
|
|
if(elm.storage !== void) p.loadImages(%['storage'=>elm.storage, 'inverse'=>elm.inverse]);
|
|
if(elm.enablemove ===void) elm.enablemove = false;
|
|
p.setState(elm);
|
|
if(elm.shadowstorage !== void) p.shadowStorage = elm.shadowstorage;
|
|
}
|
|
|
|
//----------------------------------------------------------- 敵キャラ関連 --
|
|
|
|
function setEnemy(elm)
|
|
{
|
|
var e = new CharacterSprite(window, this, elm, elm.storage);
|
|
e.setState(elm);
|
|
enemies.add(e);
|
|
}
|
|
|
|
function deleteEnemy(num)
|
|
{
|
|
if(num>=enemies.count) return;
|
|
invalidate enemies[num];
|
|
enemies.erase(num);
|
|
}
|
|
|
|
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 setObject(elm, obj)
|
|
{
|
|
if(elm.y !== void) elm.rooty = elm.y;
|
|
if(elm.x !== void) elm.rootx = elm.x;
|
|
if(obj !== void){
|
|
elm.generatedFrom = obj;
|
|
if(elm.exp === void){
|
|
elm.exp = "mp.scriptFrom=\'" + obj.layer.asd + "\'";
|
|
}else{
|
|
elm.exp += ",mp.scriptFrom=\'" + obj.layer.asd + "\'";
|
|
}
|
|
}
|
|
var o;
|
|
o = new ObjectSprite(window, this, elm);
|
|
o.setState(elm);
|
|
objects.add(o);
|
|
|
|
if(elm.return!==void) Scripts.eval(elm.return + " = dho.objects[dho.objects.count-1]");
|
|
return o;
|
|
}
|
|
|
|
function setEffect(elm, obj)
|
|
{
|
|
if(elm.y !== void) elm.rooty = elm.y;
|
|
if(elm.x !== void) elm.rootx = elm.x;
|
|
if(obj !== void){
|
|
elm.generatedFrom = obj;
|
|
if(elm.exp === void){
|
|
elm.exp = "mp.scriptFrom=\'" + obj.layer.asd + "\'";
|
|
}else{
|
|
elm.exp += ",mp.scriptFrom=\'" + obj.layer.asd + "\'";
|
|
}
|
|
}
|
|
var o;
|
|
o = new EffectSprite(window, this, elm);
|
|
o.setState(elm);
|
|
objects.add(o);
|
|
|
|
if(elm.return!==void) Scripts.eval(elm.return + " = dho.objects[dho.objects.count-1]");
|
|
return o;
|
|
}
|
|
|
|
function setOther(elm)
|
|
{
|
|
var o;
|
|
o = new ObjectSprite(window, this, elm);
|
|
o.setState(elm);
|
|
others.add(o);
|
|
if(elm.return!==void) Scripts.eval(elm.return + " = dho.others[dho.others.count-1]");
|
|
return o;
|
|
}
|
|
|
|
//----------------------------- 以下、KAGPlugin のメソッドのオーバーライド --
|
|
|
|
function onStore(f, elm)
|
|
{
|
|
var dic = f.dho = %[];
|
|
|
|
dic.players = [];
|
|
for(var i=0; i<players.count; i++){
|
|
if(players[i] !== void) dic.players[i] = players[i].store();
|
|
dic.players[i].storage = players[i].layer.asd;
|
|
}
|
|
|
|
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.drawLayer = drawLayer.store();
|
|
|
|
dic.cameraX = cameraX;
|
|
dic.cameraY = cameraY;
|
|
dic.cameraZoom = cameraZoom;
|
|
}
|
|
|
|
function onRestore(f, clear, elm)
|
|
{
|
|
reset();
|
|
if(f.dho === void) return;
|
|
|
|
var dic = f.dho;
|
|
|
|
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.enemies.count; i++){
|
|
setEnemy(dic.enemies[i].params);
|
|
enemies[i].restore(dic.enemies[i]);
|
|
if(typeof(enemies[i].params.return)!="undefined" && typeof(enemies[i].params.return)!="void"){
|
|
Scripts.eval(enemies[i].params.return + " = dho.enemies[dho.enemies.count-1]");
|
|
}
|
|
}
|
|
|
|
for(var i=0; i<dic.objects.count; i++){
|
|
dic.objects[i].storage = dic.objects[i].layer.storage;
|
|
setObject(dic.objects[i]);
|
|
objects[i].restore(dic.objects[i]);
|
|
if(typeof(objects[i].params.return)!="undefined" && typeof(objects[i].params.return)!="void"){
|
|
Scripts.eval(objects[i].params.return + " = dho.objects[dho.objects.count-1]");
|
|
}
|
|
if(objects[i].noStore) objects[i].deleteFlag=true;
|
|
}
|
|
|
|
for(var i=0; i<dic.others.count; i++){
|
|
dic.others[i].storage = dic.others[i].layer.storage;
|
|
setOther(dic.others[i]);
|
|
others[i].restore(dic.others[i]);
|
|
if(typeof(others[i].params.return)!="undefined" && typeof(others[i].params.return)!="void"){
|
|
Scripts.eval(others[i].params.return + " = dho.others[dho.others.count-1]");
|
|
}
|
|
if(others[i].noStore) others[i].deleteFlag=true;
|
|
}
|
|
|
|
if(dic.drawLayer !== void) drawLayer.restore(dic.drawLayer);
|
|
|
|
cameraX = dic.cameraX;
|
|
cameraY = dic.cameraY;
|
|
cameraZoom = dic.cameraZoom;
|
|
|
|
currentCameraX = cameraX;
|
|
currentCameraY = cameraY;
|
|
currentCameraZoom = cameraZoom;
|
|
|
|
}
|
|
|
|
function onStableStateChanged(stable)
|
|
{
|
|
}
|
|
|
|
function onMessageHiddenStateChanged(hidden)
|
|
{
|
|
}
|
|
|
|
function onCopyLayer(toback)
|
|
{
|
|
}
|
|
|
|
function onExchangeForeBack()
|
|
{
|
|
srcLayer.parent = window.fore.base;
|
|
}
|
|
|
|
function onSaveSystemVariables()
|
|
{
|
|
}
|
|
|
|
|
|
property viewWidth
|
|
{
|
|
getter(){
|
|
return internalWidth / currentCameraZoom;
|
|
}
|
|
}
|
|
|
|
property viewHeight
|
|
{
|
|
getter(){
|
|
return internalHeight / currentCameraZoom;
|
|
}
|
|
}
|
|
|
|
property viewLeft
|
|
{
|
|
getter(){
|
|
var l = (internalWidth - viewWidth) / 2 + (currentCameraX);
|
|
if(l < 0) l = 0;
|
|
if(l + viewWidth > internalWidth) l = internalWidth - viewWidth;
|
|
return l;
|
|
}
|
|
}
|
|
|
|
property viewTop
|
|
{
|
|
getter(){
|
|
var t;
|
|
t = (internalHeight - viewHeight) / 2 + (currentCameraY);
|
|
if(t < 0) t = 0;
|
|
if(t + viewHeight > internalHeight) t = internalHeight - viewHeight;
|
|
return t;
|
|
}
|
|
}
|
|
|
|
|
|
function getMovePoints(p1, p2, frame, accel=0)
|
|
{
|
|
var p = [];
|
|
var a = [];
|
|
|
|
if(accel == 0){
|
|
var d = (p2 - p1) / frame;
|
|
for(var i=0; i<frame; i++){
|
|
p[i] = d;
|
|
}
|
|
}else{
|
|
var d = (p2 - p1) / Math.pow(frame, Math.abs(accel)+1);
|
|
for(var i=0; i<=frame; i++){
|
|
a[i] = d * Math.pow(i, Math.abs(accel)+1);
|
|
}
|
|
if(accel > 0){
|
|
for(var i=0; i<frame; i++){
|
|
p[i] = a[i+1] - a[i];
|
|
}
|
|
}else{
|
|
for(var i=0; i<frame; i++){
|
|
p[i] = a[frame - i] - a[frame - i - 1];
|
|
}
|
|
}
|
|
}
|
|
return p;
|
|
}
|
|
|
|
|
|
function getMovePoints2(p1, p2, frame, accel=0){
|
|
var tmp1;
|
|
var tmp2;
|
|
|
|
tmp1 = getMovePoints(p1, (p2+p1)/2, int(frame/2), accel);
|
|
tmp2 = getMovePoints((p2+p1)/2, p2, int(frame/2), -accel);
|
|
|
|
for(var i=0; i<tmp2.count; i++){
|
|
tmp1.add(tmp2[i]);
|
|
}
|
|
|
|
return tmp1;
|
|
}
|
|
|
|
|
|
function moveCamera(x, y, z, f=0){
|
|
x = +x;
|
|
y = +y;
|
|
z = +z;
|
|
f = +f;
|
|
|
|
if(f < 2){
|
|
dx = [];
|
|
dy = [];
|
|
dz = [];
|
|
if(x !== void) currentCameraX = cameraX = x;
|
|
if(y !== void) currentCameraY = cameraY = y;
|
|
if(z !== void) currentCameraZoom = cameraZoom = z;
|
|
return;
|
|
}
|
|
|
|
cameraX = x;
|
|
cameraY = y;
|
|
cameraZoom = z;
|
|
|
|
dx = getMovePoints2(currentCameraX, x, f, 1);
|
|
dy = getMovePoints2(currentCameraY, y, f, 1);
|
|
dz = getMovePoints2(currentCameraZoom, z, f, 1);
|
|
|
|
|
|
//dm('dx');
|
|
//
|
|
// for(var i=0; i<dx.count; i++){
|
|
// dm(dx[i]);
|
|
// }
|
|
//dm('dy');
|
|
// for(var i=0; i<dx.count; i++){
|
|
// dm(dy[i]);
|
|
// }
|
|
//dm('dz');
|
|
// for(var i=0; i<dx.count; i++){
|
|
// dm(dz[i]);
|
|
// }
|
|
|
|
}
|
|
|
|
function resetCamera(f=0){
|
|
moveCamera(0, 0, 1, f);
|
|
}
|
|
|
|
|
|
function setStep(num){
|
|
for(var i=0; i<players.count; i++){
|
|
if(players[i]!==void && isvalid players[i]){
|
|
players[i].layer.conductor.mp.step = num;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
function delete_dho(){
|
|
if(typeof(global.dho) != 'undefined' && isvalid global.dho){
|
|
dho.hide();
|
|
kag.removePlugin(dho);
|
|
invalidate dho;
|
|
}
|
|
}
|