對不起
錯貼了地方
請各位無視...

130楼的问题其实只要下载一下顶楼的最新插件就行了，其实还是不是简体中文版的问题

为什么对话里有很多●这样的点

Quote:

引用第37楼rogersjk于2008-12-25 20:33发表的  :

备份的文件扔到别的文件夹试试，不要留在程序的文件夹里

同样问题，折腾了半天，最后发现是这个问题时我还真是扑通了一下……这也太邪门了……

問1下 0.91的補丁可以在補上嗎??
好像已經掛了~~

安裝補丁前我在15周的一日目出錯
安裝補丁後直接跳到16周的Ｆｌａｇ：見えない片腕
重開後案start又跳到17周的Ｆｌａｇ：夜の聖杯戦争６
請幫幫小弟
  

Quote:

引用第46楼符文剑舞于2008-12-26 15:29发表的  :
就是那个最弱英灵被伪姐妹KO掉。。
或者就是下一张开始。。总是出现：

不知道你们能不能看到图……
就是和LS那个差不多的情况。。
.......

我的情况跟你一样 也是总在这里卡

Quote:

引用第77楼duguowen于2008-12-28 18:06发表的  :
不知道怎么搞的,刚开始没多久,碰上黑白saber被干掉,后就跳出来这么个警告:




.......

对 就是这个！

问题已经解决 见http://bbs.sumisora.net/read.php?tid=10908431

没有什么进展吗？都过了几个月拉。。。期待0.91版洋


哦，我直接下好的0.9版很顺利的完成到100%了。。。。。啥问题也没遇到，比较感兴趣的是几个小游戏会汉化吗？

我存档的时候就出现了这些文字,然后就玩不了,可以告诉我怎么解决吗?(每次存档时候都是,OP过了之后也是)
// Conductor.tjs - KAG シナリオ進行処理
// Copyright (C)2001-2005, W.Dee and contributors  改変?配布は自由です


class ConductorException extends Exception
{
    // ConductorException - Conductor がタグハンドラを処理中に発生した例外を
    // 投げる時に使われる例外クラス
    function ConductorException() { super.Exception(...); }
    function finalize() { super.finalize(...); }
};

class BaseConductor extends KAGParser
{
    // BaseConductor - シナリオ進行処理のベースクラス
    var timer;
    var oneshot;
    var _interrupted = false; // 中断中か
    var timerEnabled = false; // タイマが起動中か
    var pendings; // 後回しにされたタグ
    var inProcessing = false; // timerCallback を処理中かどうか
    var reentered = false; // timerCallback 中に 再入したか
    var nextTimerTick = 0; // 次にタイマーが発動されるはずの tick

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

        timer = new Timer(timerCallback, '');
            // Timerの第二引数に空文字列を指定すると
            // 第１引数に指定した関数を直接呼び出すようになる
        oneshot = new AsyncTrigger(timerCallback, '');
            // これも同様
        oneshot.cached = true; // イベントのキャッシュを有効に

        pendings = [];
    }

    function finalize()
    {
        // finalize()
        invalidate timer;
        invalidate oneshot;
        super.finalize(...);
    }

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

    function timerCallback()
    {
        // 次の要素を得る
        nextTimerTick = timer.interval + System.getTickCount();
        var obj;
        try
        {
            if(inProcessing)
            {
                // 再入
                reentered = true;
                timer.interval = 0;
                return;
            }
            inProcessing = true;
            for(;;)
            {
                if(pendings.count > 0)
                {
                    // 後回しにされたタグがある場合
                    obj = pendings[0];
                    pendings.erase(0);
                }
                else
                {
                    // 後回しにされたタグがないので次のタグを得る
                    obj = getNextTag(); // 次のタグを得る

                    // getNextTag() の中で、pendings に追加された (iscript など)
                    if(pendings.count > 0)
                    {
                        pendings.add(obj);
                        continue;
                    }
                }

                if(obj === void)
                {
                    // シナリオ終了
                    timer.enabled = false;
                    timerEnabled =false;
                    onStop();
                    inProcessing = false;
                    reentered = false;
                    return;
                }
                else
                {
                    // onTag を呼ぶ
                    var step = onTag(obj);
                    if(step === void)
                        throw new Exception("onTag が void を返しました (" + obj.tagname + ")"
                            "( おそらくタグハンドラの戻り値を返し忘れた )");
                    step = int step; // step を数値に
                    if(step == 0)
                    {
                        // ウェイトを掛けずに次へ
                        timer.interval = 0;
                        continue;
                    }
                    else if(step < 0)
                    {
                        switch(step)
                        {
                        case -5: // いったんイベントを処理(現在のタグは後回し)
                            pendings.insert(0, obj);
                            oneshot.mode = atmAtIdle;
                            oneshot.trigger(); // トリガ
                            timer.interval = 0; // タイマは停止
                            inProcessing = false;
                            reentered = false;
                            return;
                        case -4: // いったんイベントを処理
                            oneshot.mode = atmAtIdle;
                            oneshot.trigger(); // トリガ
                            timer.interval = 0; // タイマは停止
                            inProcessing = false;
                            reentered = false;
                            return;
                        case -3: // 後回ししてブレーク
                            pendings.insert(0, obj);
                            timer.interval = 0; // タイマは停止
                            inProcessing = false;
                            reentered = false;
                            return;
                        case -2: // ブレーク
                            timer.interval = 0; // タイマは停止
                            inProcessing = false;
                            reentered = false;
                            return;
                        case -1: // シナリオ終了
                            timer.interval = 0;
                            timer.enabled = false;
                            timerEnabled = false;
                            onStop();
                            inProcessing = false;
                            reentered = false;
                            return;
                        }
                    }
                    else
                    {
                        // 次へ
                        if(timer.interval != step)
                        {
                            timer.interval = step;
                            nextTimerTick = step + System.getTickCount();
                        }
                        inProcessing = false;
                        reentered = false;
                        return;
                    }
                }
            }
            inProcessing = false;
            reentered = false;
        }
        catch(e)
        {
//            Debug.logAsError();
            timer.enabled = false;
            timerEnabled =false;
            onStop();
            inProcessing = false;
            var msg = "エラーが発生しました\n"
                "ファイル : " + curStorage + "   行 : " + (curLine+1) + "\n"
                "タグ : " + (obj === void ? "不明" : obj.tagname)
                + " ( ← エラーの発生した前後のタグを示している場合もあります )\n"
                + e.message;
            if((typeof e.trace) != "undefined") dm("trace : " + e.trace);
            dm(msg);
            throw new ConductorException(msg);
//            System.inform(msg, "エラー");
        }
    }

    function onTag()
    {
        // オーバーライドすること
        return -1;
    }

    function onStop()
    {
        // (シナリオの)停止時に呼ばれる。
        // stop() から呼ばれるわけではない。
        // オーバーライドすること。
    }

    function startProcess(immediate = false)
    {
        // シナリオ進行開始
        // immediate = false の場合は非同期で実行を開始するので、
        // このメソッド内でタグハンドラが呼ばれることはない
        // 次のイベント配信のタイミングで最初のタグハンドラが呼ばれる。
        // immediate = true の場合は、このメソッド内で初回のタグハンドラが
        // 処理されるため、呼び出し側はこのメソッドの実行が終わったら
        // すぐに吉里吉里に制御を戻す(すべての関数から抜ける)ようにするべき。
        resetInterrupt();
        timer.interval = 0; // 初期インターバル
        timerEnabled = true;
        if(!_interrupted)
        {
            timer.enabled = true; // タイマー開始
            if(immediate)
            {
                timerCallback();
            }
            else
            {
                oneshot.mode = atmExclusive;
                    // イベントが配信されるまで他の非同期イベントをブロック
                oneshot.trigger(); // トリガ
            }
        }
    }

    function start()
    {
        // タイマ開始
        timerEnabled = true;
        timer.enabled = true;
    }

    function stop()
    {
        // タイマ停止
        timer.enabled = false;
        timerEnabled = false;
    }

    property interrupted
    {
        getter() { return _interrupted; }
        setter(x)
        {
            if(!x)
            {
                // enable
                if(timerEnabled)
                {
                    timer.interval = 0;
                    timer.enabled = true;
                    oneshot.mode = atmExclusive;
                        // イベントが配信されるまで他の非同期イベントをブロック
                    oneshot.trigger(); // トリガ
                }
            }
            else
            {
                // disable
                oneshot.cancel();
                timer.enabled = false;
            }
            _interrupted = x;
        }
    }

    function assign(src)
    {
        // src の状態をこのオブジェクトにコピー
        var t = timer;
        var st = src.timer;
        t.enabled = false;
        t.interval = st.interval;
        nextTimerTick = src.nextTimerTick;
        if(st.enabled && st.interval != 0)
        {
            // タイマ interval の調整
            var delta = nextTimerTick - System.getTickCount();
            if(delta > 0) t.interval = delta; else t.interval = 1;
        }
        t.enabled = st.enabled;
        timerEnabled = src.timerEnabled;
        _interrupted = src._interrupted;
        if(src.pendings.count > 0)
            pendings.assignStruct(src.pendings);
        else
            pendings.clear();
        super.assign(src);
    }

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

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

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

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

    function enqueueTag(tag)
    {
        pendings.add(tag);
    }
}


class Conductor extends BaseConductor
{
    // Conductor - シナリオ進行処理
    /*const*/ var mStop = 0; // 停止
    /*const*/ var mRun = 1; // 動作中
    /*const*/ var mWait = 2; // 待ち

    var owner;
    var handlers;
    var status = mStop;
    var timeOutTimer;
    var waitUntil = %[];
    var lastTagName = ''; // 直前のタグ名

    function Conductor(owner, handlers)
    {
        // コンストラクタ
        super.BaseConductor();
        ignoreCR = global.ignoreCR;
        debugLevel = tkdlVerbose;
        this.owner = owner;
        this.handlers = handlers;
        timeOutTimer = new Timer(onTimeOut, '');
    }

    function finalize()
    {
        // finalize()
        invalidate timeOutTimer;
        super.finalize(...);
    }

    function run(immediate = false)
    {
        // 実行の開始
        // immediate=true の場合は、
        // このメソッドを実行したらすぐに吉里吉里に制御を戻す
        // (すべての関数から戻る)こと
        status = mRun;
        startProcess(immediate);
    }

    function sleep()
    {
        // 実行の停止
        status = mStop;
        stop();
    }

    function wait(until)
    {
        // 待ち
        // until = trigger で用いるシグナル名とコールバック関数の
        // 辞書配列
        status = mWait;
        stop();
        (Dictionary.assign incontextof waitUntil)(until);
    }

    function waitWithTimeOut(until, timeout)
    {
        // 待ちを行うが、タイムアウトがある
        // タイムアウト時には 'timeout' がトリガされるので
        // ハンドラを定義すること。
        if(timeout == 0) timeout = 1; // timeout が 0 の場合は 1 に
        status = mWait;
        stop();
        (Dictionary.assign incontextof waitUntil)(until);
        timeOutTimer.interval = timeout;
        timeOutTimer.enabled = true;
    }

    function onTimeOut()
    {
        // timeOutTimer がタイムアウトした
        timeOutTimer.enabled = false;
        trigger('timeout'); // 自分自身で timeout をトリガする
    }

    function trigger(name)
    {
        // waitUntil 内にシグナル名 name が存在すれば、実行再開、
        // 同時に waitUntil に登録されたメソッド(リスタートハンドラ)を呼ぶ
        // シグナル名に _arg がついたものが waitUntil 内にあれば、
        // それを引数としてハンドラに渡す
        // waitUntil はクリアされる
        if(status != mWait) return false;
        var func = waitUntil[name];
        if(func !== void)
        {
            var arg = waitUntil[name + '_arg'];
            if(arg !== void) func(arg); else func();
            (Dictionary.clear incontextof waitUntil)();
            run();
            return true;
        }
        else
        {
            return false;
        }
    }

    function onTag(elm)
    {
        // タグの処理
        var tagname = elm.tagname;
        var handler = handlers[tagname];
        if(handler !== void)
        {
            var ret = handler(elm);
            lastTagName = tagname;
            return ret;
        }
        return onUnknownTag(tagname, elm);
    }

    function onStop()
    {
        // BaseConductor.onStop オーバーライド
        // 停止時に呼ばれるのでステータスを mStop にする
        status = mStop;
        if(owner.conductor == this) handlers.s(); // ハンドラの s (停止) を呼ぶ
    }

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

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

    function restore(dic)
    {
        // restore オーバーライド
        super.restore(...);
        lastTagName = '';
    }

    function onScenarioLoad()
    {
        return owner.onConductorScenarioLoad(...);
    }

    function onScenarioLoaded()
    {
        return owner.onConductorScenarioLoaded(...);
    }

    function onLabel()
    {
        return owner.onConductorLabel(...);
    }

    function onJump()
    {
        return owner.onConductorJump(...);
    }

    function onCall()
    {
        return owner.onConductorCall(...);
    }

    function onReturn()
    {
        return owner.onConductorReturn(...);
    }

    function onAfterReturn()
    {
        return owner.onConductorAfterReturn(...);
    }

    function onScript()
    {
        return owner.onConductorScript(...);
    }

    function onUnknownTag()
    {
        return owner.onConductorUnknownTag(...);
    }

}

不知道是我电脑缘故还是什么

我按APP安装的默认目录名为Fate／hollow ataraxia
之后进入游戏 退出 再进 会出现2个例外通知..

多次实验之后发现把默认安装目录的 ／ 这个符号去掉
改为例如Fate HA之类的再进 就没有例外通知的产生了
大概／这个符号属于特殊符号.....

不知道有没有帮助.

windows里文件名都不能含有某堆符号...其中就有这个...

我所使用 的是VISTA HOME BASIC系统。

我的安装方法是：使用虚拟光驱将 ISO 那个文件甲读出来
→打开
→将里面的 setup 的文件甲复制出来
→将免CD补丁复制进去
→将汉化补丁复制进去
→游戏能正常运行了

→但是，当我想要存档的时候，便弹出来一句日文，具体意思应该就是：无法写入之类之类的，然后游戏强行退出，再进游戏。便没有存档了~~

安装方法是朋友告诉我的，他也是使用那安装方法，玩的很正常。她是XP的系统

希望各位高人能指教指教，说说到底是系统出了问题，还是哪方面。 教教菜鸟我~
感激不尽
问题补充：好了
各位，我经人介绍说。在进入游戏的第一画面，输入名字时输入一个日文名字就能解决这个问题。我照办了，果然 便能正常的进行存档了。 在次先谢谢了。。。。。。。。。。。。。。

但是！！！！！！！！！！！！！1

只是能正常存档~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~我存档后，退出游戏。。再进游戏，发现不能进入了，弹3个 窗口出来，日文的，什么意思我也不懂。然后，我将 fateha_savedata 这个文件甲里的存档删除掉，便能正常进入游戏了。。。但是，存档就没有了啊。。。。晕死
还望各位达人玩家们再帮帮小弟我~~~~

话说，何时更新一下进度表呢…………
严重等待1.00…………

不过不急不催，慢慢弄好就好…………

这是我玩汉化0.9版找到的翻译错误和未汉化部分, 我是从进度20%左右开始完汉化版的, 所以这里的错误补全.
当然所有的学术场景/全部通关后的租房子场景/图片文字都没汉化. 不包括在这个文件中.

找翻译的错误.rar

个位汉化组的朋友辛苦了!! 谢谢你们的伟大工作, 才让我们玩到这个期待已久的游戏!

有些正常对话中会出现一段日文未翻译........数量很少   但是存在

还有就是为什么不能存档?  一存档就自动跳出 只能中断存档

出現了這視窗，怎麼辦
玩不到了
是１６周目"見えない片腕"那兒

我安装好游戏,没有任何问题.然后打0.9汉化补丁,进入游戏运行没有问题,保存退出.第二次进入时就报错,说什么文件坏了无法进入游戏.存档和安装路径相同,而且都是英文路径没中字.请问这是不是补丁的问题?

怎么好像都是些比较XX的部分出错呵？

載點掛了吶~~希望能更新一下