//;# MainWindow.tjs - KAG メインウィンドウ
//;# Copyright (C)2001-2009, W.Dee and contributors 改変・配布は自由です
//;<<'END_OF_TJS_SCRIPT';

// このスクリプトは有効な perl5 スクリプトでもある

class KAGWindow extends Window
{
// KAG のウィンドウ クラス
// KAG の動作のメインな部分はここに記述してある

// 以下のうち、/*C*/ のつく変数は、末端の perl スクリプトによって
// 自動的に栞にコピーされるコードが生成される変数

var scWidth = 640; // 画面横幅
var scHeight = 480; // 画面縦幅

var aboutWidth = 320; // 「このソフトについて」ウィンドウの横幅
var aboutHeight = 200; // 同縦幅

var isFirstProcess = true; // 一番最初の process の呼び出しかどうか

var freeSaveDataMode = false; // 栞をメニューバーなどで管理せずに、個別のファイルとして管理する
var saveThumbnail = false; // サムネイルを保存するかどうか
var thumbnailWidth = 133; // サムネイルの横幅
var thumbnailDepth = 8; // サムネイルのBMPモード。8か24
// サムネイルの フルカラー化およびサイズフリー化のパッチは
// ゆん氏からいただきました。
// この場を借りてお礼申し上げます。


var snapshotLayer = void; // 画像のスナップショットを一時的に保存するレイヤ
var snapshotLockCount = 0; // ロックカウント

var lastSaveDataNameGlobal = ""; // 最後に保存したフリーセーブモードでのファイル名
/*C*/var lastSaveDataName = ""; // 最後に保存したフリーセーブモードでのファイル名

var saveDataLocation = System.dataPath; // セーブデータ保存場所

var saveDataID = "00000000-0000-0000-0000-000000000000"; // セーブデータの ID

var readOnlyMode = false; // 読み込み専用モード(データをディスクに書かない)
var dataName = "data"; // セーブデータ名
var saveDataMode = ""; // データ保存モード( "c" で暗号化 )

var recordHistoryOfStore = 0; // 通過履歴を記録するかどうか
// 0 = 自動的には記録しない 1 = 保存可能なラベルごと
// 2 = 選択肢 ( @s タグ ) ごと
var maxHistoryOfStore = 5; // 通過記録の最大数
var historyOfStore = []; // 通過履歴データ
var nextRecordHistory = false;
// 次の保存可能なラベル通過時に現在の情報を保存するかどうか

var stablePosibility = false;
// 栞を保存可能なラベル間で stable になる可能性があるかどうか

var fullScreened = false; // 現在フルスクリーンかどうか

var isMain = true; // これがメインウィンドウかどうか

var askOnClose = true; // 終了時に終了するかをユーザに聞くかどうか

var helpFile = ""; // 「ヘルプ > 目次」で開くファイル

var quakeTimer; // quake 用のタイマ
var defaultQuakeTimeInChUnit = false;
/*C*/var quaking = false; // 揺れているか
/*C*/var quakeEndTick = 0; // 揺れを終了させる tick
/*C*/var quakeHorzMax = 0; // 横振幅
/*C*/var quakeVertMax = 0; // 縦振幅
/*C*/var quakePhase = 0;

var chDefaultAntialiased; // 文字にアンチエイリアスをかけるかどうか
var chDefaultFace; // 文字のデフォルトのフォント

var initialMessageLayerVisible = true;

var historyLayer; // メッセージ履歴レイヤ
/*C*/var historyWriteEnabled = true; // メッセージレイヤに文字を出力するか
/*C*/var historyEnabled = true; // メッセージ履歴レイヤを表示可能か
var historyShowing = false; // メッセージ履歴レイヤを表示中か
var lastHistoryHiddenTick = 0; // 最後に履歴レイヤが非表示になったときの tick

/*C*/var numCharacterLayers = 0; // 前景レイヤの数
/*C*/var numMessageLayers = 1; // メッセージレイヤの数
var fore = %[]; // 表レイヤ
var back = %[]; // 裏レイヤ

var scPositionX = %[]; // 立ち絵の中心座標(X)

var tempLayer = void; // 一時的なレイヤ

var lineBreak; // 行待ち用アニメーションレイヤ
var pageBreak; // ページ待ち用グリフのアニメーションレイヤ
var clickWaiting = false; // クリック待ちかどうか

var mainConductor; // メインのコンダクタ
var extraConductor; // 予備のコンダクタ
var conductor; // 現在のコンダクタ
var usingExtraConductor = false; // 予備のコンダクタを使用中かどうか
var onExtraConductorReturn; // extraConductor から通常のコンダクタに戻るときによぶ関数

var tagHandlers; // タグのハンドラ群辞書配列

var saveMacros = true; // マクロを栞に保存するかどうか

var current; // 現在操作中のメッセージレイヤ
/*C*/var currentNum; // 現在操作中のメッセージレイヤ番号
/*C*/var currentPage; // 現在操作中のメッセージレイヤのページ(表0/裏1)
/*C*/var currentWithBack = false; // 裏画面にも文字を描画するかどうか

var bgm; // BGM オブジェクト

var numSEBuffers = 1; // 効果音バッファの数
var se = []; // 効果音バッファオブジェクト

var numMovies = 1; // ムービーオブジェクト数
// var movie; // ムービーオブジェクト
var movies = []; // ムービーオブジェクト

var transCount; // 現在進行中のトランジションの数
var moveCount; // 現在進行中の自動移動の数

var chSpeeds = %[
fast: 10, // 「高速」文字表示スピード
normal: 30, // 「普通」文字表示スピード
slow: 50, // 「遅い」文字表示スピード
];

var userChSpeed = 30; // ユーザの選んだ文字表示スピード
var userCh2ndSpeed = -1; // ユーザの選んだ 既読部分の文字表示スピード
var chNonStopToPageBreak = false; // ページ末まで一気に読み進むか ( l タグを無視するか )
var ch2ndNonStopToPageBreak = false; // 既読の部分でページ末まで一気に読み進むか
/*C*/var chUserMode = true; // 文字表示速度は現在ユーザの選んだものか
/*C*/var chSpeed = 30; // 現在の文字表示スピード
/*C*/var actualChSpeed = chSpeed; // 実際の文字表示スピード

/*C*/var beforeNoWaitActualChSpeed; // nowait に入る前の actualChSpeed
/*C*/var beforeNoWaitChUserMode; // nowait に入る前の chUserMode

/*C*/var clickSkipEnabled = true; // クリックスキップが有効か
/*C*/var nextSkipEnabled = true; // 次の選択肢(/未読)まで進むが有効か
var skipMode = 0; // スキップのモード
// 0=スキップなし, 1=クリック待ち記号まで, 2=改ページ待ち記号まで, 3=次の停止まで
// 4=早送り
var autoMode = false; // 自動読みすすみモードかどうか
var autoModePageWait = 350; // 自動読みすすみモード時の改ページ時のウェイト
var autoModeLineWait = 50; // 自動読みすすみモード時の行クリック待ち時のウェイト
// 上の二つは、ノーウェイトにしたい場合は 0 ではなくて -4 を指定すること

var skipKeyRepressed = false; // return あるいは space キー ( f キーなどではない )
// が押されると true になる ( スキップ解除時に false

var autoModePageWaits = %[
fast: 400, // 自動読みすすみモードの改ページ時 ウェイト「短い」
faster: 700, // 自動読みすすみモードの改ページ時 ウェイト「やや短い」
medium: 1000, // 自動読みすすみモードの改ページ時 ウェイト「普通」
slower: 1300, // 自動読みすすみモードの改ページ時 ウェイト「やや遅い」
slow: 2000, // 自動読みすすみモードの改ページ時 ウェイト「遅い」
];

var autoModeLineWaits = %[
fast: 180, // 自動読みすすみモードの行末 ウェイト「短い」
faster: 240, // 自動読みすすみモードの行末 ウェイト「やや短い」
medium: 300, // 自動読みすすみモードの行末 ウェイト「普通」
slower: 360, // 自動読みすすみモードの行末 ウェイト「やや遅い」
slow: 500, // 自動読みすすみモードの行末 ウェイト「遅い」
];

/*C*/var canCancelSkipByClick = true; // クリックによりスキップ状態のキャンセルができるか

/*C*/var autoWCEnabled = false; // 自動ウェイトが有効かどうか
/*C*/var autoWCChars = ""; // 自動ウェイトをかける文字
var autoWCWaits = []; // 自動ウェイトのウェイト

var timeOrigin; // resetWait で設定された時間原点
var lastWaitTime; // wait mode=until で実際に待った時間

var stableHandlers = []; // システムが安定(クリック待ち/停止)したときに呼ばれる
var runHandlers = []; // システムが走り始めたときに呼ばれる
var inStable = true; // 安定しているとき(走行中でないとき) true
var inSleep = false; // s タグで停止しているとき true

var updateBeforeCh = 0; // 文字を描画する前にいったん画面描画に入るかどうかのカウント

var messageLayerHiding = false; // ユーザによりメッセージレイヤが隠されているか

/*C*/var rightClickEnabled = true; // 右クリックが有効か
/*C*/var rightClickCall = false; // 右クリックで特定のルーチンを呼ぶか
/*C*/var rightClickJump = false; // 右クリックかで特定のラベルにジャンプするか
/*C*/var rightClickTarget = ""; // 右クリックでの呼び出し先
/*C*/var rightClickStorage = ""; // 右クリックでの呼び出し先
/*C*/var rightClickName = "default"; // 右クリックのメニュー表示名
/*C*/var rightClickCurrentMenuName = ""; // 右クリックのメニューに現在設定されている名前
var rightClickDefaultName = ""; // 右クリックのデフォルトのメニュー表示名

/*C*/var lastClickGlyphVisible; // extraConductor を使用する直前にクリック待ち記号が可視だったかどうか
var lastClickGlyphMessagePage;
// extraConductor を使用する直前のクリック待ち記号の表示されているメッセージレイヤのページ
var lastClickGlyphMessageNum; // 〃 番号
var lastClickGlyphWhich; // 〃 "page" か "line" か
var inSleepBeforeExtraConductor; // extraConductor を使用する直前が inSleep だったか

// 通常のマウスカーソル
/*C*/var cursorDefault = crArrow; // 通常のマウスカーソル
/*C*/var cursorPointed = crHandPoint; // ボタン、リンク等をポイントした時のマウスカーソル
/*C*/var cursorWaitingClick = crArrow; // クリック待ちのマウスカーソル
/*C*/var cursorDraggable = crSizeAll; // ドラッグ可能な場所用のマウスカーソル

/*C*/var supportReadingKey = VK_SPACE; // 追加の読み進みキー

/*C*/var startAnchorEnabled = false; // 「最初に戻る」が使用可能かどうか

/*C*/var storeEnabled = true; // ユーザが「栞をはさむ」メニューにアクセス可能かどうか
/*C*/var restoreEnabled = true; // ユーザが「栞をたどる」メニューにアクセス可能かどうか
var storeLabelPassed = false; // 保存可能なラベルを通過したかどうか
/*C*/var currentLabel = ""; // 現在のラベル
/*C*/var currentPageName = ""; // 現在のページ名
var currentRecordName = ""; // 現在の記録名 ( trail_ストレージ_ラベル )
var autoRecordPageShowing = false; // ラベル通過記録をするか

var numBookMarks = 10; // メニューに用意する栞のサブメニュー項目の数
var showBookMarkDate = false; // メニューに栞をはさんだ日付時刻を表示するか

var bookMarkNames = []; // メニューに設定されている栞の名前
var bookMarkDates = []; // 栞の日付
var bookMarkProtectedStates = []; // 栞が保護されているかの情報

var showFixedPitchOnlyInFontSelector = false; // フォント選択で固定ピットフォントのみを表示するか

var flags = %[]; // フラグ(ユーザ)
var pflags = %[]; // 「保存可能なラベル」を通過した時点でのフラグ(ユーザ)
var pcflags = %[]; // 〃 (コア)
var sflags = %[]; // システム変数領域(ユーザ)
var scflags = %[]; // システム変数領域(コア)
var tflags = %[]; // 一時フラグ

var tempBookMarks = []; // 一時的に保存した栞

var clickCount = 0; // 左クリックカウント
var lastMouseDownX; // 最後にクリックされた X 座標
var lastMouseDownY; // 最後にクリックされた Y 座標

var mouseKeyEnabledCount = 0; // マウスキーが有効かどうか

var kagPlugins = []; // KAG プラグイン

var keyDownHook = []; // キーが押されたときに呼び出される物
var leftClickHook = []; // 左クリックされたときに呼び出される物
var rightClickHook = []; // 右クリックされたときに呼び出される物

var padKeyMap; // パッドボタン -> ハンドラ(キーコード)。コンストラクタ内で設定
var padKeyMapReverse; // キーコード -> パッドボタン。コンストラクタ内で設定


var holdPeriodEventQueue = []; // 保留にされたムービーのピリオドイベントキュー
var isLeavePeriodEvent = false; // ムービーのピリオドイベントを保留にするかどうか
var isWaitPeriodEvent = false; // ムービーのピリオドイベント待ち状態かどうか
var waitedPeriodEventStorageName = void; // ピリオドイベント待ちをコールしたストレージ名

//------------------------------------------------------ コンストラクタ --

function KAGWindow(ismain = true, width = 0, height = 0)
{
// コンストラクタ
// 引数 : ismain : メインウィンドウとして作成されるのかどうか
super.Window(); // 親クラスのコンストラクタを呼ぶ

// コンフィギュレーション
isMain = ismain;
if(ismain)
{
(KAGWindow_config incontextof this)();
(KAGWindow_config_override incontextof this)()
if typeof global.KAGWindow_config_override != "undefined";
}

userChSpeed = chSpeed = actualChSpeed = chSpeeds.normal;
autoModePageWait = autoModePageWaits.medium;
autoModeLineWait = autoModeLineWaits.medium;

askOnClose = false if !ismain;

// saveDataLocation がフルパスでないようならば System.exePath を
// 付け加える
if(saveDataLocation.indexOf(":") == -1)
saveDataLocation = System.exePath + saveDataLocation;

// ログの出力先を saveDataLocation にする
if(ismain) Debug.logLocation = saveDataLocation;

// メニューアイテムの作成
if(ismain) (KAGWindow_createMenus incontextof this)();
if(typeof this.rightClickMenuItem != "undefined")
rightClickDefaultName = rightClickCurrentMenuName = rightClickMenuItem.caption;

if(typeof this.autoModeMediumMenuItem != "undefined")
autoModeMediumMenuItem.checked = true;
if(typeof this.windowedMenuItem != "undefined")
windowedMenuItem.checked = true;
if(typeof this.chNormalMenuItem != "undefined")
chNormalMenuItem.checked = true;
if(typeof this.ch2ndNoChangeMenuItem != "undefined")
ch2ndNoChangeMenuItem.checked = true;

if(ismain) (Menu_visible_config incontextof this)();

createBookMarkSubMenus();

// ウィンドウ外見の調整
if(ismain)
{
borderStyle = bsSingle;
innerSunken = true;
}
else
{
borderStyle = bsDialog;
innerSunken = false;
}
showScrollBars = false;
if(ismain) caption = System.title;

// システムタイトルをキャプションと同じに
if(ismain) System.title = caption;

// ウィンドウサイズの調整
if(width != 0 && height != 0)
{
// 与えられたサイズを適用
scWidth = width;
scHeight = height;
}
setInnerSize(scWidth, scHeight);

// quake 用タイマの作成
quakeTimer = new Timer(onQuakeTimerInterval, '');
add(quakeTimer);
quakeTimer.interval = 50;

// 背景レイヤの作成
fore.messages = [];
back.messages = [];
fore.layers = [];
back.layers = [];
fore.base = new BaseLayer(this, null, "表-背景");
add(fore.base);
fore.base.setImageSize(scWidth, scHeight);
fore.base.setSizeToImageSize();
back.base = new BaseLayer(this, fore.base, "裏-背景");
add(back.base);
back.base.setImageSize(scWidth, scHeight);
back.base.setSizeToImageSize();
fore.base.setCompLayer(back.base);
back.base.setCompLayer(fore.base);
fore.base.freeImage();
back.base.freeImage();

fore.base.setDefaultCursor(cursorDefault);
back.base.setDefaultCursor(cursorDefault);

// メッセージ履歴レイヤの作成
historyLayer = new HistoryLayer(this, fore.base);
add(historyLayer);

// 前景レイヤの作成
allocateCharacterLayers(numCharacterLayers);

// メッセージレイヤの作成
allocateMessageLayers(numMessageLayers, false);
current = fore.messages[0];
currentNum = 0;
currentPage = 0;
currentWithBack = false;
if(initialMessageLayerVisible)
{
fore.messages[0].visible = true;
back.messages[0].visible = true;
}

chDefaultAntialiased = fore.messages[0].defaultAntialiased;
// 文字にアンチエイリアスをかけるかどうか
chDefaultFace = fore.messages[0].userFace;
// 文字のデフォルトのフォント

if(typeof this.chAntialiasMenuItem != "undefined")
chAntialiasMenuItem.checked = chDefaultAntialiased;

// 行待ち/ページ待ちアニメーションレイヤの作成
lineBreak = new ClickGlyphLayer(this, fore.base);
add(lineBreak);
lineBreak.name = "行クリック待ち記号";
pageBreak = new ClickGlyphLayer(this, fore.base);
add(pageBreak);
pageBreak.name = "ページ末クリック待ち記号";

// タグハンドラ/コンダクタを作成
tagHandlers = getHandlers();
mainConductor = new Conductor(this, tagHandlers);
add(mainConductor);
conductor = mainConductor;
extraConductor = new Conductor(this, tagHandlers);
add(extraConductor);

// BGM オブジェクトを作成
bgm = new BGM(this);
add(bgm);

// 効果音オブジェクトを作成
for(var i = 0; i < numSEBuffers; i++)
add(se[i] = new SESoundBuffer(this, i));

// ムービーオブジェクトを作成
if(ismain)
{
for( var i = 0; i < numMovies; i++)
add(movies[i] = new Movie(this,i));
}

// デフォルトのハンドラを追加
stableHandlers.add(defaultStableHandler);
runHandlers.add(defaultRunHandler);

// システム変数の読み込み
if(ismain) loadSystemVariables();

// システム変数を反映
if(ismain)
{
setSystemStateFromSystemVariables();
setBookMarkMenuCaptions();
}

// メッセージレイヤのクリア
clearMessageLayers(false);

// ウィンドウ位置の調節
/*
if(this.width + this.left > System.desktopLeft + System.desktopWidth)
left = ((System.desktopWidth - this.width) >>1) + System.desktopLeft;
if(this.height + this.top > System.desktopTop + System.desktopHeight)
top = ((System.desktopHeight - this.height) >>1) + System.desktopTop;
*/
setPos((System.desktopWidth >= this.width) ? (System.desktopWidth - this.width) \ 2 : 0, (System.desktopHeight >= this.height) ? (System.desktopHeight - this.height) \ 2 : 0);

// パッドボタンハンドラの作成
createPadKeyMap();


// ウィンドウを表示
if(ismain) visible = true;

// 画面サイズがウィンドウサイズよりも小さい場合は
// フルスクリーンにしてみる
if(ismain)
{
if(System.screenWidth <= scWidth && System.screenHeight <= scHeight)
onFullScreenMenuItemClick(this);
}

// 前回起動時にフルスクリーンだった場合はフルスクリーンにしてみる
if(ismain)
{
if(scflags.fullScreen !== void && +scflags.fullScreen)
onFullScreenMenuItemClick(this);
}

// いったんシステム変数を書き出す
if(ismain) saveSystemVariables();
}

//------------------------------------------------------------- finalize --

function finalize()
{
// finalize メソッド
clearBgmStop();
clearBgmLabel();

// プラグインの無効化
for(var i = 0; i < kagPlugins.count; i++) invalidate kagPlugins[i];

// 前景、メッセージレイヤを無効化
for(var i = 0; i< fore.layers.count; i++) invalidate fore.layers[i];
for(var i = 0; i< back.layers.count; i++) invalidate back.layers[i];
for(var i = 0; i< fore.messages.count; i++) invalidate fore.messages[i];
for(var i = 0; i< back.messages.count; i++) invalidate back.messages[i];

// snapshotLayer を無効化
invalidate snapshotLayer if snapshotLayer !== void;

// tempLayer を無効化
invalidate tempLayer if tempLayer !== void;

// スーパークラスの finalize を呼ぶ
super.finalize(...);
}

//-------------------------------------------------- onCloseQuery/close --

function onCloseQuery()
{
saveSystemVariables();
if(!askOnClose) { super.onCloseQuery(true); return; }
super.onCloseQuery(askYesNo("終了しますか？"));
}

function close()
{
// ウィンドウを閉じる
saveSystemVariables();
super.close(...);
}

function shutdown()
{
// ウィンドウを閉じるが、終了確認を行わない
// このメソッド内で close をすると、様々な
// オブジェクトが無効化されてしまい、この
// 関数から戻った先でエラーが発生する。
// そのため、いったん AsyncTrigger を介して、
// 全てのメソッドから帰ったあとにシャットダウン
// 処理を行う。
global.shutdownTrigger =
new AsyncTrigger(handleShutdown, '');
global.shutdownTrigger.cached = true;
global.shutdownTrigger.trigger();
if(conductor.status == conductor.mRun)
conductor.interrupt();
// コンダクタが走行中の時は
// コンダクタに中断を伝える
}

function handleShutdown()
{
// shutdown() からのシャットダウン要求を
// 実際に処理するメソッド
var askOnClose_save = askOnClose;
askOnClose = false;
close();
if(this isvalid) askOnClose = askOnClose_save;
}

function closeByScript(elm)
{
// ウィンドウを閉じる
// ちょっと面倒くさいとをやっているのは
// shutdown と同じ理由
// 「いいえ」が選択されてウィンドウが閉じなかった場合は
// 'not_closed' トリガが発行され、実行は再開する。
var askOnClose_save = askOnClose;
if(elm.ask !== void && !(+elm.ask)) askOnClose = false;
global.shutdownTrigger =
new AsyncTrigger(handleCloseByScript, '');
global.shutdownTrigger.cached = true;
global.shutdownTrigger.trigger();

// closeByScript は、このハンドラが終わった直後に
// 「終了しますか？」のダイアログを表示する。
// 終了する場合はそのまま終了する。
// 終了しない場合は 'not_closed' トリガが発行され、
// 実行は継続する。
conductor.wait(%[
not_closed : askOnClose_save
? (function
{
// 実際にこれが呼ばれることはないが、一応
askOnClose = true;
} incontextof this)
: (function
{
} incontextof this)
]);
}

function handleCloseByScript()
{
// shutdown() からのシャットダウン要求を
// 実際に処理するメソッド
close();
if(this isvalid) // いいえ が選択された場合
conductor.trigger('not_closed');
}

//------------------------------------------------------ プラグイン処理 --

function forEachEventHook(method, func, arg)
{
// すべてのプラグインオブジェクトの method にたいして
// func を実行する
// func の引数には各要素と arg が渡される
if(kagPlugins.count)
{
var array = [];
array.assign(kagPlugins); // いったんコピーし、コピーした物に対して実行する
var arraycount = array.count;
for(var i =0; i<arraycount; i++)
{
var obj = array[i];
if(typeof obj[method] != "undefined")
func(obj[method], arg);
}
}
}

function addPlugin(plugin)
{
// プラグインオブジェクトを追加
kagPlugins.add(plugin);
}

function removePlugin(plugin)
{
// プラグインオブジェクトを削除
kagPlugins.remove(plugin);
}

//---------------------------------------------------------- フック処理 --

function callHook(array, arg1, arg2, arg3)
{
if(array.count)
{
var processed = false;
var newarray = [];
newarray.assign(array);
var arraycount = newarray.count;
for(var i = 0; i < arraycount; i++)
{
var func = newarray[i];
var ret = func(arg1, arg2, arg3);
processed = processed || ret;
}
return processed;
}
else
{
return false;
}
}

//------------------------------------------ パッドのキーマッピング作成 --

function createPadKeyMap()
{
// パッド入力とそれに対応する動作のマッピング。
// 標準では十字キーはキーボードのカーソルキーにマッピング、
// ボタン1 は Return、ボタン2 は ESC、ボタン3 は メッセージ履歴の表示
// にマッピングされる。
// 関数を指定した場合はボタンを押したときにはその関数が呼ばれる。

padKeyMap = %[
VK_PADLEFT => VK_LEFT,
VK_PADRIGHT => VK_RIGHT,
VK_PADUP => VK_UP,
VK_PADDOWN => VK_DOWN,
VK_PAD1 => VK_RETURN,
VK_PAD2 => VK_ESCAPE,
VK_PAD3 =>
function(ev) {
showHistoryByKey(this);
},
];

// padKeyMapReverse を作成
padKeyMapReverse = %[];
var ar = [];
ar.assign(padKeyMap);
for(var i = 0; i < ar.count; i += 2)
{
if(typeof(ar[i+1]) != "Object")
{
padKeyMapReverse[ar[i+1]] = ar[i];
}
}
}

function getKeyState(key)
{
// System.getKeyState 関数と同等だが、パッドのキーに関しても
// 反応を返す
var sg = System.getKeyState;
var state = sg(key);
if(state) return true;
var pad_key = padKeyMapReverse[key];
if(pad_key !== void)
{
// キーコード -> パッドのキーコードの変換が見つかった
return sg(pad_key);
}
return false;
}

//-------------------------------------------------------------- action --

function action(ev)
{
if(ev.type == 'onKeyDown' && ev.target === this)
{
// パッド入力に対応する処理
var handler = padKeyMap[ev.key];
if(handler !== void)
{
// ハンドラが見つかった
if(typeof(handler) == "Object")
{
// ハンドラは関数
(handler incontextof this)(ev);
}
else
{
// ハンドラはキーコード
postInputEvent('onKeyDown', %[key: handler]);
postInputEvent('onKeyUp', %[key: handler]);
}
}
}
}

//------------------------------------------------------ tempLayer 関連 --

property temporaryLayer
{
// ワークエリアとして一時的に使用できるレイヤを返す
getter()
{
if(tempLayer === void)
{
tempLayer = new KAGLayer(this, primaryLayer);
tempLayer.name = "一時ワークレイヤ";
}
return tempLayer;
}
}

//------------------------------------------------ メニューアイテム関連 --

function onExitMenuItemClick(sender)
{
close();
}

function onRightClickMenuItemClick(sender)
{
onPrimaryRightClick(); // 右クリックの動作
}

function onShowHistoryMenuItemClick(sender)
{
if(historyLayer.visible) hideHistory(); else showHistory();
}

function onSkipToNextStopMenuItemClick(sender)
{
skipToStop();
}

function onAutoModeMenuItemClick(sender)
{
if(autoMode) cancelAutoMode(); else enterAutoMode();
}

function onAutoModeWaitMenuClick(sender)
{
sender.checked = true;
autoModePageWait = sender.wait;
autoModeLineWait = sender.lwait;
}

function onBackStartMenuItemClick(sender)
{
goBackHistory();
}

function onGoToStartMenuItemClick(sender)
{
goToStartWithAsk();
}

function onChSpeedMenuItemClick(sender)
{
sender.checked = true;
userChSpeed = sender.speed;
setUserSpeed();
saveSystemVariables();
}

function onChNonStopToPageBreakItemClick(sender)
{
chNonStopToPageBreak = ! chNonStopToPageBreak;
if(typeof this.chNonStopToPageBreakItem != "undefined")
chNonStopToPageBreakItem.checked = chNonStopToPageBreak;
saveSystemVariables();
}

function onCh2ndNonStopToPageBreakItemClick(sender)
{
ch2ndNonStopToPageBreak = ! ch2ndNonStopToPageBreak;
if(typeof this.ch2ndNonStopToPageBreakItem != "undefined")
ch2ndNonStopToPageBreakItem.checked = ch2ndNonStopToPageBreak;
saveSystemVariables();
}

function onCh2ndSpeedMenuItemClick(sender)
{
sender.checked = true;
userCh2ndSpeed = sender.speed;
setUserSpeed();
saveSystemVariables();
}

function onChAntialiasMenuItemClick(sender)
{
chDefaultAntialiased = !chDefaultAntialiased;
if(typeof this.chAntialiasMenuItem != "undefined")
chAntialiasMenuItem.checked = chDefaultAntialiased;
setMessageLayerUserFont();
saveSystemVariables();
}

function onChChangeFontMenuItem(sender)
{
selectFont();
saveSystemVariables();
}

function onRestoreMenuClick(sender)
{
if(!freeSaveDataMode) return;
loadBookMarkFromFileWithAsk();
}

function onStoreMenuClick(sender)
{
if(!freeSaveDataMode) return;
saveBookMarkToFileWithAsk();
}

function onWindowedMenuItemClick(sender)
{
if(fullScreened)
{
try
{
fullScreen = false;
}
catch(e)
{
Debug.notice("ウィンドウモードに移行できませんでした : " + e.message);
}
fullScreened = fullScreen;
if(fullScreened)
fullScreenMenuItem.checked = true;
else
windowedMenuItem.checked = true;
}
saveSystemVariables();
}

function onFullScreenMenuItemClick(sender)
{
if(!fullScreened)
{
try
{
fullScreen = true;
}
catch(e)
{
Debug.notice("フルスクリーンモードに移行できませんでした : " + e.message);
}
fullScreened = fullScreen;
if(fullScreened)
fullScreenMenuItem.checked = true;
else
windowedMenuItem.checked = true;
}
saveSystemVariables();
}

function onHelpIndexMenuItemClick(sender)
{
// ヘルプファイルを開く
System.shellExecute(Storages.getLocalName(System.exePath) + helpFile);
}

function onHelpAboutMenuItemClick(sender)
{
// 「このソフトについて」ウィンドウを表示
var win = new global.KAGWindow(false, aboutWidth, aboutHeight);
win.setPos(left + ((width - win.width)>>1), top + ((height - win.height)>>1));
win.process('about.ks' ,,, true); // about.ks を immediate で表示
win.showModal(); // モード付きで表示
invalidate win;
}

function onReloadScenarioMenuItemClick(sender)
{
saveBookMark(1000, false);
loadBookMark(1000);
}

function onShowConsoleMenuItemClick(sender)
{
Debug.console.visible = true;
}

function onShowContollerMenuItemClick(sender)
{
Debug.controller.visible = true;
}

function internalSetMenuAccessibleAll(menu, state)
{
// autoEnable が true のすべてのメニュー項目の accessible に値 state を
// 設定する
if(typeof menu.autoEnable != "undefined" && menu.autoEnable)
menu.accessible = state;
if(typeof menu.stopRecur == "undefined" || !menu.stopRecur)
{
var children = menu.children;
for(var i = children.count -1; i >= 0; i--)
internalSetMenuAccessibleAll(children[i], state); // 再帰
}
}

function canStore()
{
return storeEnabled && storeLabelPassed;
}

function canRestore()
{
return restoreEnabled;
}

function setMenuAccessibleAll()
{
// メニュー項目の使用可/不可を設定する

// autoEnable が true のすべてのメニュー項目の accessible の
// 値を設定する
var notmodal = !historyLayer.visible && !messageLayerHiding;
var state = inStable && notmodal;
internalSetMenuAccessibleAll(menu, state);

// その他のメニューの使用可/不可
if(typeof this.skipToNextStopMenuItem != "undefined")
skipToNextStopMenuItem.enabled = state && !inSleep && nextSkipEnabled;

if(typeof this.rightClickMenuItem != "undefined")
rightClickMenuItem.enabled = inStable && !historyLayer.visible;

if(typeof this.showHistoryMenuItem != "undefined")
showHistoryMenuItem.enabled = inStable && !messageLayerHiding &&
historyEnabled;

if(typeof this.autoModeMenuItem != "undefined")
autoModeMenuItem.enabled = notmodal;

if(typeof this.goBackMenuItem != "undefined")
goBackMenuItem.enabled = state && isHistoryOfStoreAlive();

if(typeof this.goToStartMenuItem != "undefined")
goToStartMenuItem.enabled = state && startAnchorEnabled;

if(typeof this.storeMenu != "undefined")
{
var st = state && canStore();
var children = storeMenu.children;
if(freeSaveDataMode) storeMenu.enabled = st;
for(var i = children.count - 1; i >= 0; i--)
{
var obj = children[i];
obj.enabled = obj.orgEnabled && st;
}
}

if(typeof this.restoreMenu != "undefined")
{
var st = state && canRestore();
var children = restoreMenu.children;
if(freeSaveDataMode) restoreMenu.enabled = st;
for(var i = children.count - 1; i >= 0; i--)
{
var obj = children[i];
obj.enabled = obj.orgEnabled && st;
}
}
}

//----------------------------------------------- マウスキーを有効にする --

function enableMouseKey()
{
// マウスキーを有効にする
if(mouseKeyEnabledCount == 0)
{
useMouseKey = true;
mouseCursorState = mcsVisible;
}
mouseKeyEnabledCount++; // 参照カウンタ方式
}

function disableMouseKey()
{
// マウスキーを無効にする
mouseKeyEnabledCount --;
if(mouseKeyEnabledCount == 0) useMouseKey = false;
}

//----------------------------------------------------- システム変数関連 --

function loadSystemVariables()
{
// システム変数の読み込み
try
{
var fn = saveDataLocation + "/" + dataName +
"sc.ksd";
if(Storages.isExistentStorage(fn))
{
scflags = Scripts.evalStorage(fn);
scflags = %[] if scflags === void;
}
else
{
scflags = %[];
}

var fn = saveDataLocation + "/" + dataName +
"su.ksd";
if(Storages.isExistentStorage(fn))
{
sflags = Scripts.evalStorage(fn);
sflags = %[] if sflags === void;
}
else
{
sflags = %[];
}
}
catch(e)
{
throw new Exception("システム変数データを読み込めないか、"
"あるいはシステム変数データが壊れています(" + e.message + ")");
}
}

function setSystemStateFromSystemVariables()
{
// システム変数に基づいてシステムを設定
// (フルスクリーン関連をのぞく)
if(scflags.autoModePageWait !== void)
{
if(typeof this.autoModeWaitMenu !== "undefined")
{
var children = autoModeWaitMenu.children;
for(var i = children.count-1; i >= 0; i--)
{
var item = children[i];
if(typeof item.wait !== "undefined" && item.wait == scflags.autoModePageWait)
{
item.checked = true;
break;
}
}
}
}

if(scflags.userChSpeed !== void)
{
if(typeof this.chSpeedMenu !== "undefined")
{
var children = chSpeedMenu.children;
for(var i = children.count-1; i >= 0; i--)
{
var item = children[i];
if(typeof item.speed !== "undefined" && item.speed == scflags.userChSpeed)
{
item.checked = true;
break;
}
}
}
}

if(scflags.userCh2ndSpeed !== void)
{
if(typeof this.chSpeedMenu !== "undefined")
{
var children = ch2ndSpeedMenu.children;
for(var i = children.count-1; i >= 0; i--)
{
var item = children[i];
if(typeof item.speed !== "undefined" && item.speed == scflags.userCh2ndSpeed)
{
item.checked = true;
break;
}
}
}
}

lastSaveDataNameGlobal = scflags.lastSaveDataNameGlobal if scflags.lastSaveDataNameGlobal !== void;

bookMarkNames = scflags.bookMarkNames if scflags.bookMarkNames !== void;
bookMarkDates = scflags.bookMarkDates if scflags.bookMarkDates !== void;
bookMarkProtectedStates = scflags.bookMarkProtectedStates if scflags.bookMarkProtectedStates !== void;

autoModePageWait = scflags.autoModePageWait if scflags.autoModePageWait !== void;
autoModeLineWait = scflags.autoModeLineWait if scflags.autoModeLineWait !== void;
userChSpeed = scflags.userChSpeed if scflags.userChSpeed !== void;
userCh2ndSpeed = scflags.userCh2ndSpeed if scflags.userCh2ndSpeed !== void;

setUserSpeed();

chNonStopToPageBreak = scflags.chNonStopToPageBreak if scflags.chNonStopToPageBreak !== void;
if(typeof this.chNonStopToPageBreakItem != "undefined")
chNonStopToPageBreakItem.checked = chNonStopToPageBreak;

ch2ndNonStopToPageBreak = scflags.ch2ndNonStopToPageBreak if scflags.ch2ndNonStopToPageBreak !== void;
if(typeof this.ch2ndNonStopToPageBreakItem != "undefined")
ch2ndNonStopToPageBreakItem.checked = ch2ndNonStopToPageBreak;

chDefaultAntialiased = scflags.chDefaultAntialiased if scflags.chDefaultAntialiased !== void;
if(typeof this.chAntialiasMenuItem != "undefined")
chAntialiasMenuItem.checked = chDefaultAntialiased;
chDefaultFace = scflags.chDefaultFace if scflags.chDefaultFace !== void;

setMessageLayerUserFont();

bgm.restoreSystemState(scflags);

for(var i = 0; i<numSEBuffers; i++)
{
se[i].restoreSystemState(scflags);
}
}

function clearSystemVariables()
{
// システム変数のクリア
(Dictionary.clear incontextof sflags)();
}

function saveSystemVariables()
{
// システム変数の保存
if(!isMain) return;

// プラグインを呼ぶ
forEachEventHook('onSaveSystemVariables',
function(handler, f) { handler(); } incontextof this);

// フルスクリーン
scflags.fullScreen = fullScreened;

// 文字表示速度
scflags.autoModePageWait = autoModePageWait;
scflags.autoModeLineWait = autoModeLineWait;
scflags.userChSpeed = userChSpeed;
scflags.userCh2ndSpeed = userCh2ndSpeed;
scflags.chDefaultAntialiased = chDefaultAntialiased;
scflags.chDefaultFace = chDefaultFace;
scflags.chNonStopToPageBreak = chNonStopToPageBreak;
scflags.ch2ndNonStopToPageBreak = ch2ndNonStopToPageBreak;

// ブックマーク名
scflags.bookMarkNames = bookMarkNames; // (コピーではなくて)参照で十分
scflags.bookMarkDates = bookMarkDates;
scflags.bookMarkProtectedStates = bookMarkProtectedStates;

scflags.lastSaveDataNameGlobal = lastSaveDataNameGlobal;

// ファイルに書き込む
if(!readOnlyMode)
{
var fn = saveDataLocation + "/" + dataName +
"sc.ksd";
(Dictionary.saveStruct incontextof scflags)(fn, saveDataMode);

var fn = saveDataLocation + "/" + dataName +
"su.ksd";
(Dictionary.saveStruct incontextof sflags)(fn, saveDataMode);
}
}

//------------------------------------------------------- ゲーム変数関連 --

function internalStoreFlags(f)
{
// f に現在の状態を記録する

// KAGWindow に関するもの
(Dictionary.clear incontextof f)(); // クリア
// ここの [start_store_vars] から [end_store_vars] で囲まれた部分は
// 末端の perl スクリプトによって自動的に処理されるので、このマークを消したり
// このマークの間を編集したりしないこと。
// [start_store_vars]
f.lastSaveDataName = lastSaveDataName;
f.quaking = quaking;
f.quakeEndTick = quakeEndTick;
f.quakeHorzMax = quakeHorzMax;
f.quakeVertMax = quakeVertMax;
f.quakePhase = quakePhase;
f.historyWriteEnabled = historyWriteEnabled;
f.historyEnabled = historyEnabled;
f.numCharacterLayers = numCharacterLayers;
f.numMessageLayers = numMessageLayers;
f.currentNum = currentNum;
f.currentPage = currentPage;
f.currentWithBack = currentWithBack;
f.chUserMode = chUserMode;
f.chSpeed = chSpeed;
f.actualChSpeed = actualChSpeed;
f.beforeNoWaitActualChSpeed = beforeNoWaitActualChSpeed;
f.beforeNoWaitChUserMode = beforeNoWaitChUserMode;
f.clickSkipEnabled = clickSkipEnabled;
f.nextSkipEnabled = nextSkipEnabled;
f.canCancelSkipByClick = canCancelSkipByClick;
f.autoWCEnabled = autoWCEnabled;
f.autoWCChars = autoWCChars;
f.rightClickEnabled = rightClickEnabled;
f.rightClickCall = rightClickCall;
f.rightClickJump = rightClickJump;
f.rightClickTarget = rightClickTarget;
f.rightClickStorage = rightClickStorage;
f.rightClickName = rightClickName;
f.rightClickCurrentMenuName = rightClickCurrentMenuName;
f.lastClickGlyphVisible = lastClickGlyphVisible;
f.cursorDefault = cursorDefault;
f.cursorPointed = cursorPointed;
f.cursorWaitingClick = cursorWaitingClick;
f.cursorDraggable = cursorDraggable;
f.supportReadingKey = supportReadingKey;
f.startAnchorEnabled = startAnchorEnabled;
f.storeEnabled = storeEnabled;
f.restoreEnabled = restoreEnabled;
f.currentLabel = currentLabel;
f.currentPageName = currentPageName;
// [end_store_vars]

// perl スクリプトによって自動的に処理されないもの、いくつか。
// 自動ウェイト
f.autoWCWaits = [];
f.autoWCWaits.assign(autoWCWaits); // 自動ウェイトのウェイト

// bgm
f.bgm = bgm.store();

// 効果音
f.se = [];
for(var i = 0; i<numSEBuffers; i++)
{
f.se[i] = se[i].store();
}

// メッセージレイヤ
f.foreMessageLayers = [];
f.backMessageLayers = [];
for(var i = 0; i < numMessageLayers; i++)
{
f.foreMessageLayers[i] = fore.messages[i].store();
f.backMessageLayers[i] = back.messages[i].store();
}

// 前景レイヤ
f.foreCharacterLayers = [];
f.backCharacterLayers = [];
for(var i = 0; i < numCharacterLayers; i++)
{
f.foreCharacterLayers[i] = fore.layers[i].store();
f.backCharacterLayers[i] = back.layers[i].store();
}

// 背景レイヤ
f.foreBaseLayer = fore.base.store();
f.backBaseLayer = back.base.store();

// ウィンドウキャプション
f.caption = caption;

// コンダクタ
f.mainConductor = mainConductor.store();
if(!saveMacros) f.mainConductor.macros = void;
// マクロ情報を void で上書きすると栞中のマクロ情報は無効になる

// メッセージ履歴
if(historyLayer.storeState)
{
f.historyData = historyLayer.save();
}

// ムービー
if( isMain )
{
f.movies = [];
for( var i = 0; i < numMovies; i++)
f.movies[i] = movies[i].store();
}

// storeHook
forEachEventHook('onStore',
function(handler, f) { handler(f.flags, f.options); } incontextof this,
%[flags:f, options:void]);
}

function storeFlags()
{
// pcflags, pflags に値を書き込む

// flags -> pflags
(Dictionary.assignStruct incontextof pflags)(flags);

internalStoreFlags(pcflags);
}

function internalRestoreFlags(f, clear = true, elm = void)
{
// f から情報を読み出す
// clear が true ならばメッセージレイヤをクリアする
// se, bgm がそれぞれ true ならばその情報も反映させる
// backlay が true の場合は、表画面にロードすべきものを裏画面にロードする

// KAGWindow に関するもの
// ここの [start_restore_vars] から [end_restore_vars] で囲まれた部分は
// (略)
// [start_restore_vars]
lastSaveDataName = f.lastSaveDataName if f.lastSaveDataName !== void;
quaking = f.quaking if f.quaking !== void;
quakeEndTick = f.quakeEndTick if f.quakeEndTick !== void;
quakeHorzMax = f.quakeHorzMax if f.quakeHorzMax !== void;
quakeVertMax = f.quakeVertMax if f.quakeVertMax !== void;
quakePhase = f.quakePhase if f.quakePhase !== void;
historyWriteEnabled = f.historyWriteEnabled if f.historyWriteEnabled !== void;
historyEnabled = f.historyEnabled if f.historyEnabled !== void;
numCharacterLayers = f.numCharacterLayers if f.numCharacterLayers !== void;
numMessageLayers = f.numMessageLayers if f.numMessageLayers !== void;
currentNum = f.currentNum if f.currentNum !== void;
currentPage = f.currentPage if f.currentPage !== void;
currentWithBack = f.currentWithBack if f.currentWithBack !== void;
chUserMode = f.chUserMode if f.chUserMode !== void;
chSpeed = f.chSpeed if f.chSpeed !== void;
actualChSpeed = f.actualChSpeed if f.actualChSpeed !== void;
beforeNoWaitActualChSpeed = f.beforeNoWaitActualChSpeed if f.beforeNoWaitActualChSpeed !== void;
beforeNoWaitChUserMode = f.beforeNoWaitChUserMode if f.beforeNoWaitChUserMode !== void;
clickSkipEnabled = f.clickSkipEnabled if f.clickSkipEnabled !== void;
nextSkipEnabled = f.nextSkipEnabled if f.nextSkipEnabled !== void;
canCancelSkipByClick = f.canCancelSkipByClick if f.canCancelSkipByClick !== void;
autoWCEnabled = f.autoWCEnabled if f.autoWCEnabled !== void;
autoWCChars = f.autoWCChars if f.autoWCChars !== void;
rightClickEnabled = f.rightClickEnabled if f.rightClickEnabled !== void;
rightClickCall = f.rightClickCall if f.rightClickCall !== void;
rightClickJump = f.rightClickJump if f.rightClickJump !== void;
rightClickTarget = f.rightClickTarget if f.rightClickTarget !== void;
rightClickStorage = f.rightClickStorage if f.rightClickStorage !== void;
rightClickName = f.rightClickName if f.rightClickName !== void;
rightClickCurrentMenuName = f.rightClickCurrentMenuName if f.rightClickCurrentMenuName !== void;
lastClickGlyphVisible = f.lastClickGlyphVisible if f.lastClickGlyphVisible !== void;
cursorDefault = f.cursorDefault if f.cursorDefault !== void;
cursorPointed = f.cursorPointed if f.cursorPointed !== void;
cursorWaitingClick = f.cursorWaitingClick if f.cursorWaitingClick !== void;
cursorDraggable = f.cursorDraggable if f.cursorDraggable !== void;
supportReadingKey = f.supportReadingKey if f.supportReadingKey !== void;
startAnchorEnabled = f.startAnchorEnabled if f.startAnchorEnabled !== void;
storeEnabled = f.storeEnabled if f.storeEnabled !== void;
restoreEnabled = f.restoreEnabled if f.restoreEnabled !== void;
currentLabel = f.currentLabel if f.currentLabel !== void;
currentPageName = f.currentPageName if f.currentPageName !== void;
// [end_restore_vars]

// perl スクリプトによって自動的に処理されないもの、いくつか。

// 自動ウェイト
autoWCWaits.assign(f.autoWCWaits) if f.autoWCWaits !== void;

// ムービー
if( isMain )
{
for( var i = 0; i < numMovies; i++)
movies[i].restore(f.movies[i]);
}

// 背景レイヤ
var backlay = elm != void && elm.backlay != void && +elm.backlay;
if(backlay)
{
back.base.restore(f.foreBaseLayer);
}
else
{
fore.base.restore(f.foreBaseLayer);
back.base.restore(f.backBaseLayer);
}

// メッセージレイヤ
allocateMessageLayers(numMessageLayers);
if(backlay)
{
for(var i = 0; i < numMessageLayers; i++)
{
back.messages[i].restore(f.foreMessageLayers[i]);
}
}
else
{
for(var i = 0; i < numMessageLayers; i++)
{
fore.messages[i].restore(f.foreMessageLayers[i]);
back.messages[i].restore(f.backMessageLayers[i]);
}
}

if(clear)
{
for(var i = 0; i < numMessageLayers; i++)
{
fore.messages[i].clear();
back.messages[i].clear();
}
if(historyLayer.storeState)
{
historyLayer.load(f.historyData);
}
else
{
if(historyWriteEnabled)
{
if(historyLayer.everypage)
historyLayer.repage();
else
historyLayer.reline(), historyLayer.reline();
}
historyLayer.clearAction();
}
}

// 前景レイヤ
allocateCharacterLayers(numCharacterLayers);
if(backlay)
{
for(var i = 0; i < numCharacterLayers; i++)
{
back.layers[i].restore(f.foreCharacterLayers[i]);
}
}
else
{
for(var i = 0; i < numCharacterLayers; i++)
{
fore.layers[i].restore(f.foreCharacterLayers[i]);
back.layers[i].restore(f.backCharacterLayers[i]);
}
}

// quake 関連
restoreQuake();

// bgm
if(elm === void || elm.bgm === void || +elm.bgm)
{
bgm.restore(f.bgm);
}

// 効果音
if(elm === void || elm.se === void || +elm.se)
{
for(var i = 0; i<numSEBuffers; i++)
{
se[i].restore(f.se[i]);
}
}

// ウィンドウキャプション
caption = f.caption;
System.title = caption;

// current の設定し直し
current = (currentPage?back:fore).messages[currentNum];

// 右クリックメニュー名
if(typeof this.rightClickMenuItem != "undefined")
rightClickMenuItem.caption = rightClickCurrentMenuName;

// restoreHook
forEachEventHook('onRestore',
function(handler, f) { handler(f.flags, f.clear, f.options); } incontextof this,
%[flags:f, clear:clear, options:elm]);

}

function restoreFlags()
{
// pcflags, pflags から情報を読み出す

// ロード時、ムービーのピリオドイベント情報をクリアする
purgeMoviePeriod();

// スナップショットの破棄
freeSnapshot();

// トランジション、自動移動の停止
stopAllTransitions();
stopAllMoves();

// クリック待ち記号を隠す
hideClickGlyphs();

// メッセージ履歴を隠す
hideHistory();

// スキップのキャンセル
cancelSkip();

// pflags -> flags
(Dictionary.assignStruct incontextof flags)(pflags);

// 栞管理関連
storeLabelPassed = true;
nextRecordHistory = false;
stablePosibility = false;

// コンダクタ
currentRecordName = "";
mainConductor.restore(pcflags.mainConductor);
extraConductor.clear();
setConductorToMain();

// 読み込み
internalRestoreFlags(pcflags);

// メニュー関連
setMenuAccessibleAll();

// 実行開始
processGo();
}

function clearVariables()
{
// ゲーム変数のクリア
(Dictionary.clear incontextof flags)();
}

//--------------------------------------------------------- 通過記録管理 --

function pushHistoryOfStore()
{
// 通過記録を行う
// pflags, pcflags に情報を格納した後に呼ぶこと

if(nextRecordHistory)
{
if(stablePosibility)
{
// stablePosibility が false の場合は、
// そこのラベルで通過記録を行っても
// そこよりも前に戻るすべがないので通過記録をしない

// 辞書配列を作成
var dic = %[];

// user と core を記録
dic.user = %[];
(Dictionary.assignStruct incontextof dic.user)(pflags);
dic.core = %[];
(Dictionary.assignStruct incontextof dic.core)(pcflags);

// dic を historyOfStore の先頭に挿入
historyOfStore.insert(0, dic);

// はみ出た分を削除
if(historyOfStore.count > maxHistoryOfStore)
historyOfStore.count = maxHistoryOfStore;
}

nextRecordHistory = false;
}
}

function setToRecordHistory()
{
// 次の「保存可能なラベル」通過時に
// 通過記録を行うように設定する
// ( ただし、そのときに記録されるのは、現在の状態 )
nextRecordHistory = true;
}

function isHistoryOfStoreAlive()
{
// 通過記録が利用可能かどうかを返す
return historyOfStore.count;
}

function goBackHistory(ask = true)
{
// 通過記録をたどり、戻る

if(!isHistoryOfStoreAlive())
return false;

var result;
if(ask)
{
var prompt = "「"+ historyOfStore[0].core.currentPageName + "」まで戻りますか?";
result = askYesNo(prompt);
}
else
{
result = true;
}

if(result)
{
// user と core を pflags, pcflags に戻す
(Dictionary.assignStruct incontextof pflags)(historyOfStore[0].user);
(Dictionary.assignStruct incontextof pcflags)(historyOfStore[0].core);

// 記録の先頭を削除する
historyOfStore.erase(0);

// データを元に、栞をたどる動作をする
restoreFlags();

return true;
}
return false;
}

//--------------------------------------------------------------- 栞管理 --

function createBookMarkSubMenus()
{
// 「栞をたどる」「栞をはさむ」以下にサブメニュー項目を追加
if(freeSaveDataMode) return; // フリーセーブモードではなにもしない
if(typeof this.storeMenu !== "undefined" && storeMenu.visible)
{
for(var i = 0; i<numBookMarks; i++)
{
var item;
storeMenu.add(item = new KAGMenuItem(this, string i, 0, onBookMarkStore,
false));
item.bmNum = i;
item.orgEnabled = false;
}
}
if(typeof this.restoreMenu !== "undefined" && restoreMenu.visible)
{
for(var i = 0; i<numBookMarks; i++)
{
var item;
restoreMenu.add(item = new KAGMenuItem(this, string i, 0, onBookMarkRestore,
false));
item.bmNum = i;
item.orgEnabled = false;
}
}
}

function setBookMarkMenuCaptions()
{
// 「栞をたどる」「栞をはさむ」以下のサブメニューに
// キャプションを設定

// 栞を挟む
if(typeof this.storeMenu !== "undefined")
{
var children = storeMenu.children;
for(var i = children.count - 1; i >= 0; i--)
{
if(bookMarkDates[i] != '') // 空文字列の場合は栞がないということ
{
// 栞が存在する
var caption;
if(showBookMarkDate) caption = bookMarkDates[i] + " ";
caption += bookMarkNames[i];
var item = children[i];
item.caption = caption;
item.enabled = false;
item.orgEnabled = !bookMarkProtectedStates[i];
}
else
{
// 栞が存在しない
var item = children[i];
item.caption = "(未設定)";
item.enabled = false;
item.orgEnabled = !bookMarkProtectedStates[i];
}
}
}

// 栞をたどる
if(typeof this.restoreMenu !== "undefined")
{
var children = restoreMenu.children;
for(var i = children.count - 1; i >= 0; i--)
{
if(bookMarkDates[i] != '') // 空文字列の場合は栞がないということ
{
// 栞が存在する
var caption;
if(showBookMarkDate) caption = bookMarkDates[i] + " ";
caption += bookMarkNames[i];
var item = restoreMenu.children[i];
item.caption = caption;
item.enabled = false;
item.orgEnabled = true;
}
else
{
var item = restoreMenu.children[i];
item.caption = "(未設定)";
item.enabled = false;
item.orgEnabled = false;
}
}
}
setMenuAccessibleAll();
}

function setBookMarkProtectedState(num, s)
{
// n 番の栞の保護フラグを設定する
// s = true ならば栞に書き込み保護をする
bookMarkProtectedStates[num] = s;
setBookMarkMenuCaptions();
}

function onBookMarkStore(sender)
{
// 栞をはさむメニューが選択された
// if(!sender.parent.accessEnabled) return;
saveBookMarkWithAsk(sender.bmNum);
}

function onBookMarkRestore(sender)
{
// 栞をたどるメニューが選択された
// if(!sender.parent.accessEnabled) return;
loadBookMarkWithAsk(sender.bmNum);
}

function getBookMarkPageName(num)
{
// 栞番号 num のブックマーク名を得る
if(bookMarkDates[num] != '') // 空文字列の場合は栞がないということ
return bookMarkNames[num];
return "(未設定)";
}

function getBookMarkDate(num)
{
// 栞番号 num の日付を得る
return bookMarkDates[num];
}

function getBookMarkFileNameAtNum(num)
{
if(num >= 999) // 999 番以降は特殊なデータに用いるので
return saveDataLocation + "/" + dataName + num + ".ksd";
else
return saveDataLocation + "/" + dataName + num + (saveThumbnail?".bmp":".kdt");
}

function lockSnapshot()
{
// スナップショットをロックする
// 初めてスナップショットがロックされた時点での画面を保存する
if(snapshotLockCount == 0)
{
if(snapshotLayer === void)
snapshotLayer = new Layer(this, primaryLayer);
snapshotLayer.setImageSize(scWidth, scHeight);
snapshotLayer.face = dfAlpha;
snapshotLayer.piledCopy(0, 0, kag.fore.base, 0, 0, scWidth, scHeight);
}
snapshotLockCount ++;
}

function unlockSnapshot()
{
// スナップショットのロックを解除する
if(snapshotLockCount == 0)
throw new Exception("snapshotLockCount がアンダーフローしました");
snapshotLockCount --;
if(snapshotLockCount == 0)
{
if(snapshotLayer !== void)
invalidate snapshotLayer, snapshotLayer = void;
}
}

function calcThumbnailSize()
{
// サムネイルのサイズを計算する
// 横幅は 133 に
var ratio = scHeight / scWidth;
var w = thumbnailWidth;
var h = (int)(w * ratio);

// サムネイル用ビットマップのサイズを計算
// サムネイル用画像は 256 色 BMP または 24bit フルカラー BMP
var size;
if (thumbnailDepth == 8)
size = ((((w - 1) >> 2) + 1) << 2) * h + 1024 + 54;
else
size = (((w * 3 + 3) >> 2) << 2) * h + 54;

return %[width : w, height : h, size : size];
}

function freeSnapshot()
{
// スナップショットを強制的に破棄し、snapshotLockCount を 0 に設定する
snapshotLockCount = 0;
if(snapshotLayer !== void)
invalidate snapshotLayer, snapshotLayer = void;
}

function saveBookMarkToFile(fn, savehist = true)
{
// ファイル fn に栞を保存する
if(readOnlyMode) return false;
pcflags.storeTime = (new Date()).getTime(); // 日付を保存

// セーブデータをまとめる
var data = %[];
data.id = saveDataID;
data.core = pcflags;
data.user = pflags;
if(savehist) data.history = historyOfStore;

if(saveThumbnail)
{
// サムネイルを保存
lockSnapshot();
try
{
// サムネイルのサイズまで縮小
var size = calcThumbnailSize();
var tmp = new Layer(this, primaryLayer);
try
{
tmp.setImageSize(size.width, size.height);
tmp.face = dfAlpha;
tmp.stretchCopy(0, 0, size.width, size.height, snapshotLayer,
0, 0, snapshotLayer.imageWidth, snapshotLayer.imageHeight, stLinear);
/*
// サムネイル画像をセピア調にして保存する場合はコメントアウトを解除
tmp.doGrayScale();
tmp.adjustGamma(
1.3, 0, 255, // R gamma, floor, ceil
1.0, 0, 255, // G gamma, floor, ceil
0.8, 0, 255); // B gamma, floor, ceil
*/
try
{
// サムネイルを保存
tmp.saveLayerImage(fn, "bmp" + thumbnailDepth);

// データを保存
var mode = saveDataMode;
mode += "o" + size.size; // モード文字列に 書き込みオフセットを指定
(Dictionary.saveStruct incontextof data)(fn, mode);
}
catch(e)
{
invalidate tmp;
unlockSnapshot();
System.inform("ファイルに保存できません (ファイルを開けないか、"
"書き込み禁止です)");
return false;
}
}
catch(e)
{
invalidate tmp;
throw e;
}
invalidate tmp;
}
catch(e)
{
unlockSnapshot();
throw e;
}
unlockSnapshot();
}
else
{
// 通常のファイルに保存
try
{
(Dictionary.saveStruct incontextof data)(fn, saveDataMode);
}
catch(e)
{
System.inform("ファイルに保存できません (ファイルを開けないか、"
"書き込み禁止です)");
return false;
}
}

return true;
}

function saveBookMark(num, savehist = true)
{
// 栞番号 num に栞を保存する
if(readOnlyMode) return false;
if(bookMarkProtectedStates[num]) return false;

var ret = saveBookMarkToFile(getBookMarkFileNameAtNum(num), savehist);
if(ret)
{
// メニュー / bookMarkNames / bookMarkDates を更新
getBookMarkInfoFromData(pcflags, num);
}
return ret;
}

function getBookMarkInfoFromData(dic, num)
{
// 辞書配列 dic から栞のページ名と日付を読み出し、
// bookMarkDates[num] や bookMarkNames[num] に設定する
if(num < numBookMarks)
{
bookMarkNames[num] = dic.currentPageName;
var date = new Date();
date.setTime(dic.storeTime);
date = "%04d/%02d/%02d %02d:%02d".sprintf(
date.getYear(), date.getMonth() + 1, date.getDate(),
date.getHours(), date.getMinutes() );
bookMarkDates[num] = date;
setBookMarkMenuCaptions();
saveSystemVariables();
}
}

function loadBookMarkFromFile(fn, loaduser = true)
{
// ファイル fn から栞を読み込む
// loaduser が false の時は user を読み込まない
try
{
if(!Storages.isExistentStorage(fn)) return false; //ファイルがない

var data;

var modestr;

if(saveThumbnail)
{
// 指定オフセットからデータを読み込む
modestr += "o" + calcThumbnailSize().size;
}

data = Scripts.evalStorage(fn, modestr);

if(data.id != saveDataID)
{
System.inform("他のシステムのデータを読み込もうとしました", "エラー");
return false;
}

pcflags = data.core;
pcflags = %[] if pcflags === void;
if(loaduser)
{
pflags = data.user;
pflags = %[] if pflags === void;
}
else
{
(Dictionary.assignStruct incontextof pflags)(flags);
}
historyOfStore = data.history;
historyOfStore = [] if historyOfStore === void;
}
catch(e)
{
System.inform("栞を読み込めないか、栞が"
"壊れているか、あるいは他の形式の栞データ"
"です(" + e.message + ")", "エラー");
return false;
}

restoreFlags();
return true;
}

function loadBookMark(num, loaduser = true)
{
// 栞番号 num からデータを読み出す
return loadBookMarkFromFile(getBookMarkFileNameAtNum(num), loaduser);
}

function saveBookMarkWithAsk(num)
{
// 栞番号 num に栞を設定する
// そのとき、設定するかどうかをたずねる
if(readOnlyMode) return false;
if(bookMarkProtectedStates[num]) return false;
var prompt = "栞 ";
if(num < numBookMarks) prompt += (num + 1);
if(bookMarkDates[num] != "") // bookMarkDates が空文字の場合は栞は存在しない
prompt += "「" + bookMarkNames[num] + "」";
prompt += "に「"+ pcflags.currentPageName + "」をはさみますか?";
var result = askYesNo(prompt);
if(result) return saveBookMark(num);

こんなのが表示されて、もののけアパートがプレイできない

初めまして。上記文が全て表示されるのでしょうか？
少々確認してみますので、ご迷惑をお掛け致しますがお時間いただけますでしょうか？

わかり次第、ブログにてお伝え致します。

上記の件について、お聞きしたいことが3点ほどございます。
もし、まだプレイ出来ていないようでしたらわかる範囲でお答えしていただけると助かります。

・これはどこに表示されたのでしょうか？
・これはどういう状況で表示されたのでしょうか？
　（例えば、起動時やプレイ中など。プレイ中であれば、どんなシーンあるいはどんな操作をした時かなどできるだけ詳細にお願いします）
・ファイル破損チェックツールで、インストールされたファイルに異常がないことを確認しておられますでしょうか？

以上になります。

お手数をお掛けしておりますが、宜しくお願い致します。