关于AWK的絮絮叨叨

2012-05-29T15:06:00.014+08:00

* 没啥特别重要的知道的可说的东西。

* HelloWorld首先：awk 'BEGIN{print "helloworld"}'

* 写在文件里，开头用 #!/bin/awk -f

* 变量不声明即有默认值，根据类型是0或空字符串。变量是全局的，局部通过函数的参数的形式来实现。

* awk可用来处理文本数据，和排版输出文本。

* 默认以一行为一条记录，$1 $2 ...依次为每行的字段（共NF个）。分割行和字段的方式可以自定义，文本的处理过程中是以行为单位触发处理事件的。

* 记录用正则FS分割，当前行号是NR

* 变量x用“x+0”转为数字，用“x ""”转换为字符串，比较运算符当有一侧为字符串时，都自动转换为字符串。

* 识别的方式可以在识别过程中修改。

* 有一堆系统变量可以读取和设置。

* awk文件由多个“pattern { action }”构成，当模式的条件匹配后，会执行对应的命令。

* 在规则中next和exit仅作用于当前行的匹配。

* 模式可以是空或BEGIN/END或正则表达式或条件语句

* 关联数组是字符串到变量值的映射，in操作符可用于if判断和for循环，具体使用方法照着示例代码用即可。

* 多维数组，即C语言中数组的数组，是用SUBSEP拼接下标。

* man 可参阅 http://www.manpagez.com/man/1/awk/ 。

* man里有教程、用法、示例和参考列表。

* 自带里数学/字符串/数组/IO/系统方面的一些函数。

* 字符串连接是空格，逗号是分隔符。

* 自定义的函数不可以复制给变量。

* 基本语法和C和bc都差不多。

* 正则表达式扮演了很重要的角色，比perl的正则功能上简单。

* 交互接受用户输入可以用“getline input "-"”，然后使用input变量即可（留空则$0）。

* 输出有print语句和printf函数，可输出到屏幕或文件。

* 可以干bc/sed/shell可以干的活，可以放在shell里面干活，可配合管道（getline，print，system）使用。

* 执行命令或输出到文件，相同字符串的所代表可以一直使用，直到close它。例如“while(getline<"file">0)”是从文件不断读取行。

* 输出到错误输出使用“print message I "cat 1>&2"”。

* 命令行的参数ARGC、ARGV需在BEGIN中处理，之后将被当作是读入的文件名。

* the awk language里有实现若干排序算法和对awk文法进行解析的例子。

* 若干常见实例参考::《SED 单行脚本快速参考》的 awk 实现 http://linuxtoy.org/archives/sed-awk.html 。

* mawk在windows下可用。

* ideone.com里也有awk可玩。

* 写python然后“python -c 'for i in file("a.txt"):print i'”作用和“awk '{print $0}' a.txt”差不多。

* 不论手段，在更高效的前提下，把文本处理完就行。

* 有时候不用来处理文本也行。

* 不用awk也行。

* 很多情况用文本编辑器也行。

* 若干示例
+ 显示文件：awk '{print}'
+ 加行号：awk '{print NR,$0}'
+ 去行号：awk '{sub(/^[0-9]+ /,"");print}'
+ 统计行数：awk 'END{print NR}'
+ 排序：awk '{A[NR]=$0}END{asort(x);for(i=1;i<=NR;i++)print A[ i]}'
+ 计算均值：awk '{S+=$0}END{print S/NR}'
+ 另一种均值写法：awk 'BEGIN{for(i=1;i

代码小练习三 - 图

2012-05-23T21:27:00.002+08:00

继续代码小练习系列，理念是写出简单有趣的代码，虽然践行得有点失败的说。

* 图的广度优先搜索

代码很粗暴，可以用来走走迷宫求求无权图的最短路径。
此外把Queue换成Stack就是深度优先搜索了，递归也行。

type graph = int list*(int*int) list
let g = ([1;2;3;4],[(1,2);(2,3);(3,4);(3,1);(2,4)])
let bfs (g:graph) s =
    let q = Queue.create() in
    let module S = Set.Make(struct type t = int let compare = compare end) in
    let set = ref (S.add s S.empty) in
    let rec loop c = begin
        print_int c;
        List.iter
            (fun (x,y)->if x==c && not (S.mem y !set) then begin
                (set := (S.add y (!set))); Queue.push y q end)
            (match g with _,edges->edges);
        if Queue.is_empty q then () else loop (Queue.pop q);
    end in loop s;;
bfs g 1;;

* 有权无向连通图的最小生成树

MinimumSpanningTrees就是用那啥Kruskal和Prim，往生成树中贪婪地添加最优边。
关于所添加的最优的边的选择，前者是图中权最小的边，后者是生成树相邻的边。

type weight=int
and vertex=int
and edge=vertex*vertex*weight
and graph=vertex list*edge list
let g = ([1;2;3;4],[(1,2,2);(2,3,3);(3,4,2);(1,3,4);(2,4,2)])
let mst_kruskal g=
    let s = Hashtbl.create 0 in
    let rec find_set (x:vertex) =
        if x=(try (Hashtbl.find s x) with Not_found->x)
        then x else find_set (Hashtbl.find s x) in
    let union x y = Hashtbl.replace s (find_set x) (find_set y) in
    let module P = Set.Make(
        struct type t = vertex*vertex let compare = compare end) in
    let a = ref P.empty in
    let edges = List.sort (fun (_,_,w1) (_,_,w2)->w1-w2) (snd g) in
    List.iter (fun (x,y,z)->if find_set(x)<>find_set(y) then
        begin union x y; a := (P.add (x,y) (!a)) end) edges;
    P.iter (fun (x,y)->begin Printf.printf "\\/(%d,%d)" x y end) !a;
;;
mst_kruskal g;;

g = ([1,2,3,4],[(1,2,2),(2,3,3),(3,4,2),(1,3,4),(2,4,2)])
def mst_prim(g,r):
    k,p,q,w={r:0},{},g[0][:],dict(sum([[[(x,y),z],[(y,x),z]] for x,y,z in g[1]],[]))
    while q: u = min(q,key=lambda x:k.get(x,float('+inf'))); q.remove(u)
        for v in set([y for x,y,_ in g[1] if x==u]+[x for x,y,_ in g[1] if y==u]):
            if v in q and w[(u,v)]<k.get(v,float('+inf')):
                k[v], p[v] = w[(u,v)], u
    return p
print mst_prim(g,1)

* 带权有向图的单源最短路径

Single-Source Shortest Paths可从起点按照距离动态规划。
Dijkstra可以得到从单一起点到其他所有顶点的距离及路径。
Bellman-Ford当负权边存在时路径若经过负圈则路径不存在。

g = ([1,2,3,4],[(1,2,2),(2,3,3),(3,4,2),(1,3,4),(2,4,2)])
def dijkstra(g,s,t):
    q, w = g[0][:], {(x,y):z for x,y,z in g[1]}
    d, p = {i:0 if i==s else float('+inf') for i in g[0]}, {}
    while q:
        u = min(q,key=lambda x:d[x]); q.remove(u)
        if u==t:
            f = lambda i:[i]+([] if i==s else f(p[i]))
            return list(reversed(f(t)))
        for v in {y for x,y,_ in g[1] if x==u}:
            if d[v] > d[u] + w[(u,v)]:
                d[v], p[v] = d[u]+w[(u,v)], u
    return None
print dijkstra(g,1,4)

g2 = ([1,2,3,4],[(1,2,2),(2,3,3),(3,4,2),(3,1,-9),(2,4,2)])
g3 = ([1,2,3,4],[(1,2,2),(2,3,3),(3,4,2),(3,1,-4),(2,4,2)])
def bellman_ford(g,s,t):
    d, p = {i:0 if i==s else float('+inf') for i in g[0]}, {}
    for i in range(len(g[0])-1):
        for u,v,w in g[1]:
            if d[v] > d[u] + w:
                d[v], p[v] = d[u]+w, u
    if any(d[v] > d[u] + w for u,v,w in g[1]):
        return None
    f = lambda i:[i]+([] if i==s else f(p[i]))
    return list(reversed(f(t)))
print bellman_ford(g,1,4)
print bellman_ford(g2,1,4)
print bellman_ford(g3,1,4)

好吧，咱承认是在对着书敲的代码，脑子已经不大清楚了囧。
这里的Dijkstra改改就是Prim，虽然作用不同代码结构一样。

* 任意两点间的最短路径

All-Pairs Shortest Paths，用Floyd-Warshall算法动态规划，一次得到图中任意两点间距离。

g = ([1,2,3,4],[(1,2,2),(2,3,3),(3,4,2),(3,1,4),(2,4,2)])
def floyd_warshall(g):
    n = len(g[0])
    d = [[float('+inf')]*n for i in g[0]]
    t = {v:k for k,v in enumerate(g[0])}
    for u,v,w in g[1]:
        d[t[u]][t[v]] = min(d[t[u]][t[v]],w)
    for k in range(n):
        for i in range(n):
            for j in range(n):
                d[i][j] = min(d[i][j],d[i][k]+d[k][j])
    return [(u,v,d[t[u]][t[v]]) for u in g[0] for v in g[0]]
print "\n".join("%s->%s : %s"%(u,v,w) for u,v,w in floyd_warshall(g))

* 网络流的最大流

Maximum Flow，可以通过不断添加流量到增广路上（Augmenting Path）计算。
其中增广路通过广度优先搜索在剩余网络（Residual Network）上查找得到。

g = ([1,2,3,4],[(1,2,2),(2,3,3),(3,4,2),(3,1,4),(2,4,2)])
g2 = ([1,2,3,4],[(1,2,3),(2,3,3),(3,4,2),(3,1,4),(2,4,2)])
g3 = ([1,2,3,4],[(1,2,5),(2,3,3),(3,4,2),(3,1,4),(2,4,2)])
g4 = (['s','o','p','q','r','t'],[('s','o',3),('s','p',3),('o','p',2),('o','q',3),('p','r',2),('r','t',3),('q','r',4),('q','t',2)])
def edmonds_karp(g,s,t):
    w = dict(sum(([[(u,v),w],[(v,u),0]] for u,v,w in g[1]),[]))
    f = {i:0 for i in w.keys()}
    def bfs():
        q, u, p = [], s, []
        while u!=t:
            q.extend(p+[e] for e in w.keys() if e[0]==u and e not in p and f[e]<w[e])
            if not q: return None
            p = q.pop(0)
            u = p[-1][1]
        return p
    for p in iter(bfs,None):
        c = min(w[e]-f[e] for e in p)
        for u,v in p:
            f[(u,v)] += c
            f[(v,u)] -= c
    return sum(f[e] for e in w.keys() if e[0]==s)
print edmonds_karp(g,1,4)
print edmonds_karp(g2,1,4)
print edmonds_karp(g3,1,4)
print edmonds_karp(g4,'s','t')

这里没理解错什么吧，有些细节还未考虑过，感觉有不大对劲。。

* A*搜索与拓扑排序

代码小练习二 - 优先队列

2012-05-21T16:22:00.005+08:00

继续代码小练习，优先队列，还会有些其他的应用的例子吧。

* Binary Heap

实现上PriorityQueue可以用BinaryHeap结构，也可用于排序。这里的数组下标为方便是从0而没有从1开始算的。

def heapify(lst,i,size=None,less=lambda x,y:x<y):
    left, right = 2*i+1, 2*(i+1)
    size = size if size else len(lst)
    largest = i
    if left<size and less(lst[largest],lst[left]):#lst[left]>lst[largest]:
        largest = left
    if right<size and less(lst[largest],lst[right]):
        largest = right
    if largest!=i:
        lst[i],lst[largest] = lst[largest], lst[i]
        heapify(lst,largest,size=size)
def build_heap(lst):
    for i in range(int(len(lst)/2),-1,-1):
        heapify(lst,i)
def heap_sort(lst):
    build_heap(lst)
    for i in range(len(lst)-1,0,-1):
        lst[0], lst[i] = lst[i], lst[0]
        heapify(lst,0,size=i)
class PriorityQueue:
    def __init__(self,less=lambda x,y:x<y):
        self.less = less
        self.container = list()
    def push(self,x):
        lst = self.container
        parent = lambda x:int((i-1)/2)
        lst.append(x)
        i = len(lst)-1
        p = parent(i)
        while i>0 and self.less(lst[p],lst[i]):
            lst[i],lst[p] = lst[p], lst[i]
            i = p; p = parent(i)
    def pop(self):
        if not self.empty():
            lst = self.container
            x, lst[0] = lst[0], lst[-1]
            lst.pop()
            heapify(lst,0,less=self.less)
            return x
        else:
            raise "underflow"
    def top(self):
        if not self.empty():
            return self.container[0]
        else:
            raise "empty"
    def size(self):
        return len(self.container)
    def empty(self):
        return self.size()==0


* Huffman Coding

一个PriorityQueue的实际的例子，用于数据压缩。

#include <iostream>
#include <vector>
#include <queue>
#include <map>
#include <bitset>
#include <cstring>
using namespace std;
struct Node {
    char data;
    int freq;
    Node* left;
    Node* right;
    explicit Node(char data,int freq)
        :data(data),freq(freq),left(NULL),right(NULL) {
    }
    explicit Node(Node* left,Node* right)
        :data('\0'),freq(left->freq+right->freq),left(left),right(right) {
    }
    ~Node(){
        if(left)
            delete left;
        if(right)
            delete right;
    }
    bool isLeaf() const {
        return left==NULL or right==NULL;
    }
};
struct NodeCmp {
    bool operator()(const Node* n1,const Node* n2) {
        return n1->freq > n2->freq;
    }
};
Node* huffman_tree(const map<char,int>& entries) {
    priority_queue<Node*,vector<Node*>,NodeCmp> pq;
    for(map<char,int>::const_iterator it=entries.begin(); it!=entries.end(); ++it )
        pq.push(new Node(it->first,it->second));
    int n = entries.size();
    //while(pq.size()>1){
    for(int i=0; i<n-1; i++) {
        Node* x = pq.top();
        pq.pop();
        Node* y = pq.top();
        pq.pop();
        Node* n=new Node(x,y);
        pq.push(n);
    }
    return pq.top();
}
void huffman_count(string text,map<char,int>& result) {
    for(unsigned i=0; i<text.size(); i++)
        result[text[i]]++;
}
void huffman_travel(Node* node,vector<bool>& code,map<char, vector<bool> >& result) {
    if(node->isLeaf())
        result[node->data] = code;
    else {
        {
            vector<bool> left(code);
            left.push_back(false);
            huffman_travel(node->left,left,result);
        }{
            vector<bool> right(code);
            right.push_back(true);
            huffman_travel(node->right,right,result);
        }
    }
}

void huffman_code(Node* tree,map<char, vector<bool> >& result) {
    vector<bool> empty;
    huffman_travel(tree,empty,result);
}
void huffman_print(map<char, vector<bool> >& code) {
    cout<<"dict\n";
    for (map<char, vector<bool> >::iterator i=code.begin() ; i != code.end(); ++i ) {
        cout << i->first << " => ";
        for(vector<bool>::iterator j=i->second.begin(); j!=i->second.end(); ++j) {
            cout <<((*j)?'1':'0');
        }
        cout<<endl;
    }
}
void huffman_print(vector<bool>& code) {
    cout<<"list\n";
    for(unsigned i=0; i<code.size(); i++)
        cout<<code[i];
    cout<<endl;
}
void huffman_print(const char* code) {
    cout<<"string\n"<<code<<endl;
}
Node* huffman_encode(const string& text,map<char, vector<bool> >& dict,vector<bool>& result) {
    map<char,int> entries;
    huffman_count(text,entries);
    Node* tree = huffman_tree(entries);
    huffman_code(tree,dict);
    for(unsigned i=0; i<text.size(); i++) {
        const vector<bool>& append = dict[text[i]];
        copy(append.begin(),append.end(),back_insert_iterator< vector<bool> >(result));
    }
    return tree;
}
void huffman_decode(vector<bool>& code,Node* const tree,string& result) {
    Node* p = tree;
    for(unsigned i=0; i<code.size(); i++) {
        bool bit = code[i];
        p = (bit==false)?p->left:p->right;
        if(p->isLeaf()) {
            result.push_back(p->data);
            p = tree;
        }
    }
}
int main(int argc, char **argv) {
    const char* text = "William Shakespeare (baptised 26 April 1564; died 23 April 1616) was an English poet and playwright, widely regarded as the greatest writer in the English language and the world's pre-eminent dramatist. He is often called England's national poet and the \"Bard of Avon\". His surviving works, including some collaborations, consist of about 38 plays, 154 sonnets, two long narrative poems, and several other poems. His plays have been translated into every major living language and are performed more often than those of any other playwright.";
    map<char, vector<bool> > code;
    vector<bool> encode;
    Node* tree = huffman_encode(text,code,encode);
    huffman_print(code);
    huffman_print(encode);
    cout<<"bit length "<<strlen(text)*sizeof(char)*8<<"->"<<encode.size()<<endl;
    string decode;
    huffman_decode(encode,tree,decode);
    huffman_print(decode.c_str());
    delete tree;
    return 0;

代码练习 - 容器

2012-05-09T19:44:00.004+08:00

一组简单的代码练习，实现了基本的容器类型。
小小的活动手指，了解相关的运行调试编译环境。

* 代码练习一，简单的双向链表。

增删元素时，节点对前后节点的引用可千万别弄错呦。
包括自己的以及前后节点的都得修改，有遗漏就糟糕了。
依赖调试就不好了，得能够手写一遍就正确才可以的。

class DList(object):
    """
    Doubly linked list
    link: http://www.w3schools.com/jsref/jsref_obj_array.asp
    """
    class Node:
        def __init__(self,item,prev,next):
            self.item = item
            self.prev = prev
            self.next = next
    def __init__(self):
        self.sentinel = self.Node(None,None,None)
        self.sentinel.prev = self.sentinel
        self.sentinel.next = self.sentinel
        self.len = 0
    def length(self):
        for k,v in enumerate(self,1):
            pass
        else:
            assert k == self.len
            return k
    def __len__(self):
        return self.len
    def shift(self):
        if self.sentinel.next is self.sentinel:
            raise Exception("empty")
        self.len -= 1
        node = self.sentinel.next
        self._remove(node)
        return node.item
    def unshift(self,item):
        self.len += 1
        #self._insert(item,self.sentinel.next)
        self.sentinel.next = self.Node(item,self.sentinel,self.sentinel.next)
        self.sentinel.next.next.prev = self.sentinel.next
        return self.len
    def push(self,item):
        self.len += 1
        self._insert(item,self.sentinel)
        #self.sentinel.prev = self.Node(item,self.sentinel.prev,self.sentinel)
        #self.sentinel.prev.prev.next = self.sentinel.prev
        return self.len
    def pop(self):
        if self.sentinel.prev is self.sentinel:
            raise Exception("empty")
        self.len -= 1
        node = self.sentinel.prev
        self._remove(node)
        #self.sentinel.prev.prev.next = self.sentinel.prev.next
        #self.sentinel.prev = self.sentinel.prev.prev
        return node.item
    def indexOf(self,item):
        for k,v in enumerate(self):
            if v==item:
                return k
        else:
            return -1
    def lastIndexOf(self,item):
        for k,v in enumerate(reversed(self)):
            if v==item:
                return k
        else:
            return -1
    def slice(self,start,end):
        l = self.__class__()
        length = self.length()
        begin = start+length if start<0 else start
        stop = end+length if end<0 else end
        for k,v in enumerate(self):
            if k >= stop:
                break
            if k >= begin:
                l.push(v)
        return l
    @classmethod
    def _remove(cls,node):
        node.prev.next = node.next
        node.next.prev = node.prev
    @classmethod
    def _insert(cls,item,node):
        node.prev.next = cls.Node(item,node.prev,node)
        node.prev = node.prev.next
    def splice(self,start,howmany,*items):
        l = self.__class__()
        length = self.length()
        begin = start+length if start<0 else start
        stop = begin + howmany
        k, p = 0, self.sentinel.next
        while p is not self.sentinel:
            if k >= stop:
                break
            if k >= begin:
                l.push(p.item)
                self._remove(p)
                self.len -= 1
            p = p.next
            k += 1
        for i in items:
            self.len += 1
            self._insert(i,p)
        return l
    def _copy(self):
        l = self.__class__()
        for i in self:
            l.push(i)
        return l
    def concat(self,*lists):
        l = self._copy()
        for i in lists:
            for j in i:
                l.push(j)
        return l
    def join(self,sep):
        assert hasattr(sep,'join')
        return sep.join(map(str,self))
    def reverse(self):
        p = self.sentinel
        while True:
            q = p.next
            p.prev, p.next = p.next, p.prev
            p = q
            if p is self.sentinel:
                break
    def sort(self,cmp=lambda x,y:x-y):
        rest = self.sentinel.next
        while rest is not self.sentinel:
            m, p =rest, rest.next
            while p is not self.sentinel:
                if cmp(p.item,m.item)<0:
                    m = p
                p = p.next
            if rest is m:
                rest = m.next
            #self._remove(m);self._insert(m.item,rest)
            m.prev.next, m.next.prev = m.next, m.prev
            m.prev, m.next = rest.prev, rest
            rest.prev.next, rest.prev = m, m
    def __iter__(self):
        p = self.sentinel.next
        while p is not self.sentinel:
            yield p.item
            p = p.next
    def __reversed__(self):
        p = self.sentinel.prev
        while p is not self.sentinel:
            yield p.item
            p = p.prev
    def __str__(self):
        return ','.join(map(str,self))
    def __repr__(self):
        return '[%s]'%', '.join(map(str,self))
    def valueOf(self):
        return str(self)
    def toString(self):
        return repr(self)
    def map(self,proc):
        l = self.__class__()
        for i in self:
            l.push(proc(i))
        return l
    def forEach(self,proc):
        for i in self:
            proc(i)

这里通过私有的remove和insert方法来增删节点比直接增删节点要不容易错一些。

* 代码小练习二，仿JavaScript数组的实现。

接着前面的那一个再做个小练习，不过咱好菜呀，居然写得好费尽的感觉（沮丧。
下标和范围什么的总是搞错，单个函数一长的话就头晕晕的了，而且最后还是依赖调试了。
这样是不行的，真的不行的，在非类型安全的语言或者纸张上书写的话这样就写不出正确的代码是不行的。
嘛，或许再熟练一些就会好一些吧，对于常见的情况抽象为函数或固定的代码。恩，或许就是这样的。

<script>
var print = function(x) {
    document.write(x);
    document.writeln("<br>");
};
var p = print;
print("hello world");
function JArray() {
    var that = (this instanceof arguments.callee) ? this : new arguments.callee();
    if(arguments.length == 1 && this instanceof arguments.callee)
        that.length = arguments[0];
    else {
        that.length = 0;
        for(var i = 0; i < arguments.length; i++)
            that.push(arguments[i])

    }
    return that;
};
JArray.prototype.push = function(item) {
    this[this.length] = item;
    return ++this.length;
};
JArray.prototype.pop = function(item) {
    if(this.length == 0)
        return undefined;
    this.length--;
    var item = this[this.length];
    delete this[this.length];
    return item;
};
JArray.prototype.shift = function() {
    if(this.length == 0)
        return undefined;
    var item = this[0];
    for(var i = 0; i < this.length; i++)
        this[i] = this[i + 1];
    this.length--;
    delete this[this.length]
    return item;
};
JArray.prototype.unshift = function(item) {
    for(var i = this.length; i > 0; i--)
        this[i] = this[i - 1];
    this[0] = item;
    return ++this.length;
};
JArray.prototype.join = function(sep) {
    var sep = sep || ',';
    var string = this.length == 0 ? "" : this[0];
    for(var i = 1; i < this.length; i++) {
        string += sep + this[i];
    };
    return string;
};
JArray.prototype.toString = function(item) {
    return this.join();
};
JArray.prototype.slice = function(start, end) {
    var array = new this.constructor();
    var start = start < 0 ? start + this.length : start;
    var end = end || this.length;
    end = end < 0 ? end + this.length : end;
    for(var i = start; i < end && i < this.length; i++)
        array.push(this[i]);
    return array;
};
JArray.prototype.indexOf = function(item) {
    for(var i = 0; i < this.length; i++)
        if(this[i] == item)
            return i;
    return -1;
};
JArray.prototype.lastIndexOf = function(item) {
    for(var i = this.length - 1; i >= 0; i--)
        if(this[i] == item)
            return i;
    return -1;
};
JArray.prototype.concat = function() {
    var array = new this.constructor();
    for(var i = 0; i < this.length; i++)
        array.push(this[i]);
    for(var i = 0; i < arguments.length; i++)
        for(var j = 0; j < arguments[i].length; j++)
            array.push(arguments[i][j]);
    return array;
};
JArray.prototype.splice = function(index, howmany, item1) {
    var array = new this.constructor();
    var index = index < 0 ? index + this.length : index;
    var howmany = Math.min(this.length - index, howmany);
    var end = index + howmany;
    for(var i = index; i < end; i++)
        array.push(this[i]);
    var itemnum = arguments.length - 2;
    if(howmany > itemnum) {
        var eat = howmany - itemnum;
        for(var i = end; i < this.length; i++)
            this[i - eat] = this[i];
        for(var i = this.length - eat; i < this.length; i++)
            delete this[i];
        this.length -= eat;
    } else {
        var room = itemnum - howmany;
        for(var i = this.length - 1; i >= index; i--)
            this[i + room] = this[i];
        this.length += room;
    }
    for(var i = 0; i < itemnum; i++)
        this[index + i] = arguments[i + 2];
    return array;
};
JArray.prototype.reverse = function(start, howmany, item1) {
    for(var i = 0, j = this.length - 1; i < j; i++, j--) {
        var tmp = this[i];
        this[i] = this[j];
        this[j] = tmp
    };
};
JArray.prototype.sort = function(cmp) {
    var cmp = cmp || (function(x, y) {
        return x < y ? -1 : 1
    });
    var partition = function(array, x, y) {
        var pivot = array[x];
        var z = x;
        for(var i = x + 1; i < y; i++) {
            var tmp = array[i];
            if(cmp(tmp, pivot) < 0) {
                z++;
                array[i] = array[z];
                array[z] = tmp;
            }
        }
        array[x] = array[z];
        array[z] = pivot;
        return z;
    };
    var qsort = function(array, x, y) {
        if(x < y) {
            var z = partition(array, x, y);
            qsort(array, x, z);
            qsort(array, z + 1, y);
        }
    };
    qsort(this, 0, this.length);
    return this;
};
JArray.prototype.forEach = function(proc) {
    for(var i = 0; i < this.length; i++)
        proc(this[i])
};
JArray.prototype.every = function(proc) {
    for(var i = 0; i < this.length; i++)
        if(!proc(this[i]))
            return false;
    return true;
};
</script>

测试代码没有贴，不过最好其实还是给每个方法都对应几种情况写好自动测试为好吧这样。
好写细节和js本身的Array不一样，比如一些可选参数的情况，这里仅做拙劣的练习就不完善它了。
link: https://developer.mozilla.org/en/JavaScript/New_in_JavaScript/1.6#Array_extras

* 代码小练习三，简单的关联数组。

一个简单的关联数组，key限定为字符串类型。

#include <iostream>
#include <cstring>
using namespace std;
template<class T>
class Hash{
    class NotFound{};
    class Full{};
    struct Entry{
        const char* key;
        T value;
        };
    int _capacity;
    Entry* table;
    Entry* search(const char* key){
        int hash = strhash(key)%_capacity;
        for(int i=hash;i<hash+_capacity;i++){
            Entry* entry = &table[i%_capacity];
            if(entry->key==NULL || streq(entry->key,key))
                return entry;
        }
        return NULL;
    }
public:
    static int strhash(const char* str){
        int hash = 0;
        for(const char* p = str; *p; p++)
            hash = 31 * hash + *p;
        return hash;
        }
    static bool streq(const char* str1,const char* str2){
            return !strcmp(str1,str2);
        }
    Hash(int capacity)
        :_capacity(capacity),table(new Entry[capacity]){
            for(int i=0;i<capacity;i++)
                table[i].key = NULL;
        }
    ~Hash(){
        delete[] table;
        }
    void put(const char* key,T value){
        Entry* entry = this->search(key);
        if(entry){
            if(entry->key==NULL)
                entry->key = key;
            entry->value = value;
        }else
            throw Full();//"Full";
        }
    void del(const char* key){
        Entry* entry = this->search(key);
        if(entry && entry->key){
            entry->key=NULL;
        entry->value=NULL;
        }
    }
    T get(const char* key){
        Entry* entry = this->search(key);
        if(entry && entry->key)
            return entry->value;
        else
            throw NotFound();//"Not Found";
    }
    bool has(const char* key){
        Entry* entry = this->search(key);
        return entry && entry->key;
    }
    };
int main(int argc, char **argv)
{
    cout<<"hello world"<<endl;
    Hash<int> hash(100);
    cout<<hash.has("a")<<endl;
    hash.put("a",125);
    hash.put("b",128);
    cout<<hash.has("a")<<endl;
    cout<<hash.has("b")<<endl;
    cout<<hash.get("b")<<endl;
    hash.del("b");
    cout<<hash.has("b")<<endl;
    //cout<<hash.get("c")<<endl;
    return 0;
}

* 代码练习四，优先队列。

Blogger后台截图留恋

2012-04-25T19:57:00.011+08:00

由于Blogger比Gmal更早一些，所以帐号就不是Gmail的帐号了。
这个后台界面挺让人怀念的，毕竟用了很长时间，被GPlus了真讨厌呢。
有些是草稿，这个貌似之前说到过了，没想到挺占屏幕的。
没写过什么有价值的东西，都是自言自语胡思乱想的东西。
以前blogger和youtube都是可以很方便就能上的站点呢。
当初google还不强推什么googleplus这个整合地令人讨厌的东西呢。
当初墙还对ssl无奈呢，当初网页不是css布局，科技发展真是飞快呀。
当初知道窗口原来还可以用标题栏拖动位置，还真是吃了一惊呢。
当初还对着键盘敲着dir，然后进wps，然后打字打字打字只会打字呢。
回忆真是无趣，明明未来将获得更美好的东西，明明回忆是蕴含着——
希望，财富，信念，憧憬，活力的的过去时光，
何必总以未来的没有到来而让回忆就总染上了橘红色的悲伤气氛呢。

所谓“永恒”呢，或许它不是历史长河中注定的一尘不变的遗忘，而是在过去与将来的种种的不相干的事物之中呈现出来的一致面。一份由过去的经验与财富给当前留下的踏实感，一份由未来可以继续传递下去的憧憬和希望，这些都是由“永恒”所连接起的美好回忆与期盼的那一份璀璨纽带。

一种Scheme语言中基于消息传递的面向对象机制上 -- 语言机制

2012-04-08T21:04:00.011+08:00

以下代码是单纯为了试一试在Scheme里面使用使用面向对象机制而写。
大致可行不过仍需完善，利用更多常见的使用情况还需要单独地特别考虑一下。

代码贴在这里格式乱掉了。。。

其实OO有很多中实现方式，这里主要是使用闭包了。
闭包有天然的作用域可以作为访问控制
----
http://pastebin.com/ifbtVEPS

;#lang r5rs
;(define error display)
;;;一种Scheme语言中基于消息传递的面向对象机制上 -- 语言机制 - Closure
;;;面向对象的机制的实现方式很都多种，常见的比如基于向量和隐藏this指针的。
;;;这里是基于程序语言中的闭包特性来实现的，尝试了面向对象机制中的一些常见情况。
;;;参考1 OCaml http://caml.inria.fr/pub/docs/u3-ocaml/ocaml-objects.html
;;;参考2 SICP http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-17.html
;;;参考3 R5RS http://www.schemers.org/Documents/Standards/R5RS/HTML/
;;;查找对象方法的时间复杂度依赖所用实现的case语句的实现方式，若有优化则为O(1)。

;;;========================= 定义部分 ============================

;;;function send
;;;向对象发送消息
;;;type = closure * symbol * object list -> object
;;;example. (send pair 'set-car! 1) == (set-car! pair 1)
(define (send object method . arguments)
(cond ((object method)
=>(lambda (x) (apply x arguments)))
(else (error "method missing"))))
;;;function interface
;;;检验对象是否实现方法，注意方法名一致不能保证方法的语义正确
;;;type = symbol list -> (closure -> boolean)
;;;example. sequence? == (interface 'car 'cdr)
(define (interface . methods)
(lambda (object)
(let loop ((methods methods))
(cond ((null? methods) #t)
((not (object (car methods))) #f)
(else (loop (cdr methods)))))))
;;;functon coerce
;;;将对象绑定的若干方法表示为列表，用于调用泛型函数使用
;;;type = symbol list -> procedure list
;;;example. (coerce 'car 'cdr)
(define (coerce . methods)
(map (lambda (method)
(lambda (object . arguments) (apply send object method arguments)))
methods))
;;;function method
;;;从对象链中查找方法
;;;type = symbol * closure list -> (procedure | false)
;;;example. ((method 'car pair)) == (send pair 'car)
(define (method symbol . objects)
(let loop ((protos objects))
(cond ((null? protos) #f)
(((car protos) symbol) => (lambda (x) x))
(else (loop (cdr protos))))))
;;;macro object
;;;创建对象
;;;syntax = (object (prototypes ...) ((method (arguments ...) body ...) ...))
;;;example. (send (object () ((one () 1)))) 'one) == 1
(define-syntax object
(syntax-rules ()
((_ (prototypes ...) ((method-name (arguments ...) body ...) ...))
(lambda (m)
(case m
((method-name) (lambda (arguments ...) body ...)) ...
(else (apply method m (list prototypes ...))))))))
;;;macro thunk
;;;用于延迟绑定
;;;syntax = (thunk object)
;;;example. (thunk 0)
(define-syntax thunk
(syntax-rules () ((_ x) (lambda () x))))
;;;;macro object2
;;;上述“macro object”的 rich 版本
;;;syntax = (object2 self (prototype-news ...) ((slot value) ...) ((method (arguments ...) body ...) ...) init ...)
;;;example. <404>
(define-syntax object2;define
(syntax-rules ()
((_ self (prototype-news ...) ((slot value) ...) ((method (arguments ...) body ...) ...) init ...)
(letrec ((slot value) ...
(self
(lambda (m)
(case m
((method) (lambda (arguments ...) body ...)) ...
(else (let loop ((protos (list (prototype-news (lambda () self)) ...)))
(cond ((null? protos) #f)
(((car protos) m) => (lambda (x) x))
(else (loop (cdr protos))))))))))
init ... self))))
;;;object top-object2
;;;用于继承树的根节点
(define (top-object2 this)
(object2 self () () ((init () (this)))))
;;;function new
;;;用来构造一个对象
(define (new class . arguments)
(define self (apply send (class (thunk self)) 'init arguments))
self)
;;;========================= 示例部分 ============================

;;;* 示例一 Pair::mcons
;;;该示例用来演示如何创建一个对象
;;;定义A
(define (mcons0 x y)
(lambda (m)
(case m
((car) (lambda () x))
((cdr) (lambda () y))
((set-car) (lambda (z) (set! x z)))
((set-cdr) (lambda (z) (set! x z)))
((->pair) (lambda ()(cons x y)))
(else #f))))
;;;定义B
(define (mcons x y)
(object ()
((car () x)
(cdr () y)
(set-car (z) (set! x z))
(set-cdr (z) (set! y z))
(->pair () (cons x y)))))
;;;泛型
(define (mcar mpair)
((mpair 'car)))
(define (mcdr mpair)
((mpair 'cdr)))
(define (set-mcar mpair obj)
((mpair 'set-car) obj))
(define (set-mcdr mpair obj)
((mpair 'set-cdr) obj))
(define (mpair->pair mpair)
((mpair '->pair)))
;;;使用
(let example-1 ()
(define x (mcons 1 2))
(display (mcdr x))
(newline))

;;;* 示例二 sequence
;;;该示例用来演示接口和泛型的使用
(define sequence? (interface 'car 'cdr))
(define (mlist . objects)
(if (null? objects) '()
(mcons (car objects) (apply mlist (cdr objects)))))
(define (for-each0 p lst)
(cond ((null? lst) '())
(else (p (car lst)) (for-each p (cdr lst)))))
(define (mfor-each p lst)
(cond ((null? lst) '())
(else (p (mcar lst)) (mfor-each p (mcdr lst)))))
(define (generic-for-each prod lst car cdr)
(cond ((null? lst) '())
(else (prod (mcar lst)) (generic-for-each prod (mcdr lst) car cdr))))
(define (mrange start end step)
(letrec ((self (object()
((car () start)
(cdr () (let ((x (+ (send self 'car) step)))
(if (cond ((> step 0) (<= start x end))
((< step 0) (>= start x end))
(else (error "mrange")))
(mrange x end step) '())))))))
self))
(let example-2 ()
(define x (mlist 1 2 3 4 5))
(mfor-each display x)
(display (sequence? x))
;(mfor-each display (mrange 0 10 2))
;(generic-for-each display (mrange 0 10 2) mcar mcdr)
(apply generic-for-each display (mrange 0 -10 -3) (coerce 'car 'cdr))
(newline))

;;;* 示例三 slots
;;;该示例用来演示构造器和私有成员
(define (box x)
(letrec ((value '())
(self (object()
((ref () value)
(set! (x) (set! value x))
(add! (x) (send self 'set! (+ x (send self 'ref))))))))
(set! value x)
self))
(let example-3 ()
(define x (box 1))
(display (send x 'ref))
(send x 'set! 2)
(display (send x 'ref))
(send x 'add! 2)
(display (send x 'ref))
(newline))

;;;* 示例四 inheritance
;;;该示例用来演示扩充一个类
(define (mlist2 . objects)
(define super (apply mlist objects))
(define self
(object (super)
((for-each (prod) (apply generic-for-each prod self (coerce 'car 'cdr))))))
self)
(let example-4 ()
(define x (mlist2 1 2 3 4 5))
(mfor-each display x)
(send x 'for-each display)
(newline))

;;;* 实例五 virtual/override
;;;该示例用来演示模板方法模式
(let example-5 ()
(define (hello name)
(letrec((self
(object ()
((name () (name))
(say () (for-each display (list "hello " (send self 'name) "!\n")))))))
self))
(send (hello (lambda () "world0")) 'say)
(define (hello-world)
(define super (hello (lambda () (send self 'name))))
(define self (object (super) ((name () "world1"))))
self)
(send (hello-world) 'say)
(define (hello2 this)
(object ()
((name () "")
(say () (for-each display (list "hello " (send (this) 'name) "!\n"))))))
(define (hello-world2)
(define self
(object
((hello2 (thunk self)))
((name () "world2"))))
self)
(send (hello-world2) 'say)
(define (hello-world3)
(define self
(object2 self (top-object2 hello2) ()
((name () "world3"))))
self)
(send (hello-world3) 'say)
(define (hello-world4 this)
(define self
(object2 self (top-object2 hello2) ()
((name () "world4"))))
self)
(send (new hello-world4) 'say)
(newline))

;;;待续一种Scheme语言中基于消息传递的面向对象机制下 -- 使用模式

-----小改动，直接放在下面了----
不过话说这样更像Java而不是OCaml了。。。

(define-syntax object3;define
(syntax-rules (using method)
((_ ((method-name (arguments ...) body ...) ...))
(lambda (m)
(case m
((method-name) (lambda (arguments ...) body ...)) ...
(else #f))))
((_ super class using (traits ...) self ((slot value) ...) method ((method-name (arguments ...) body ...) ...))
(letrec ((super (class (lambda () self)))
(slot value) ...
(self
(lambda (m)
(case m
((method-name ) (lambda (arguments ...) body ...)) ...
(else (let loop ((protos (list super (traits (lambda () self)) ...)))
(cond ((null? protos) #f)
(((car protos) m) => (lambda (x) x))
(else (loop (cdr protos))))))))))
self))
((_ super class self ((slot value) ...) method ((method-name (arguments ...) body ...) ...))
(_ super class using () self ((slot value) ...) method ((method-name (arguments ...) body ...) ...)))
((_ super class self method ((method-name (arguments ...) body ...) ...))
(_ super class using () self () method ((method-name (arguments ...) body ...) ...)))
))
(define (root this)
(object3 ((init () (this)))))
(define (new class . arguments)
(define self (class (thunk self)))
(apply send (class (thunk self)) 'init arguments)
self)
(define (hello-world6 this)
(object3 super root using (hello2) self () method
((init () (send super 'init))
(name () "world6")
(say1 () (send (this) 'say)))))
(send (new hello-world6) 'say1)

-----
这样下去，干脆定义一个define-class算了。。。
用super表示父类（只有一个父类）this表示子类的对象，self表示当前类的对象。
这样好像把问题弄得复杂一下子就全部放在表面的问题。
由于用的是R5RS的“高级”“卫生”宏/语法，所以功能上有较多约束，不过有这些约束写起来还是更清爽了一些。
----
补充，感觉还是让object语法“小”一些比较好，多父类的判断可以移到语法宏的外面。
此外，多个原型也可以在子类中选择的调用，即不止一个spuer代表某个原型吧。
恩，其实OCaml里的对象是作为一种结构来实现的，要类型的话让闭包返回类型的联合也成吧。
嘛，这里也没多说清楚是怎么回事情，不过就是再补充一下了。

堆文的恶趣味

2012-04-06T17:04:00.012+08:00

曾一直有断断续续地写些篇幅较短的小说作为娱乐，文字多为含含糊糊的叙述描写，风格大多只是为了体现某些方面趣味，内容有时语无伦次。
现在想这种趣味不能使得写出的文字有什么质量，不过缺失这种趣味的话，又觉得没什么自己来写的必要了。
既然定位于自娱自乐了，那么发扬之前的趣味来继续扩展一些，并学习一点新的趣味增添其中，还是一件蛮有趣味的事情吧。

* 趣味一信息流动

即严格地在文本的阅读顺序中控制读者对整个故事知道什么，以怎样的顺序知道哪些事实，以及不同的事实之间存在着何种关联。
这就像有的侦探小说或者电影在观众的脑海里留下许多零散的画面片段，但是又巧妙的串联在一起，使得故事呈现出一种立体感。

* 趣味二情节和叙述两条线索

故事情节本身是一条线索，而故事表现出来的是另一条线索，即叙事线和情节严格的分为两条线来处理。
叙事线本身也是一个有开端有发展有结局的故事，不过这个故事是作为叙述来使用的，而故事本身仍然是真正的故事情节本身。
通常来说可以用“寻找”“回忆”“失忆”“表现/真相”“历史/现实”这样的行为动机来构成表面的叙事线索。
一般让读者在读完整个故事后，能够在自己的脑海中补完一条连续的情节线出来，这个时候让叙事线淡化。

* 趣味三故事的情节以设定来代替叙事

这个是关于情节构思方面的，即在构思的时候注重整理故事中的各个事件间的关联和关系，之间的影响以及是关于主题或话题的哪个方面的观点和视角。
并不一定要说情节就是构思发生的某个故事那样的，而是说情节本身是一种事实一种为了内容的需要而产生的一种设定。
文本故事性和趣味性可以通过叙事线来加强，而真正要讲述的故事本身是一多角度立体感的存在。

* 趣味四人物的行为动机和人物间的影响

整个叙述过程之中，一直围绕着人物的自身行动的动机来展开，即由于人物自身的某种目的来进行行动来构成故事。
通常可以众多人物各自的行动都作为动机来推动叙事，并且人物之间的互动会使得各自的行动的动机发展并互相产生影响。
这种人物自身的动机的发展，是用来交代真正的情节线的一个很重要的手段，并且人物间的互动也是很主题之间相关的。

* 趣味五叙事按照场景来划分，简化结构

按照场景来划分，每个场景有固定的发生的环境（固定的也可以是运动的，是整体即可），有场景参与的人物。
每个场景考虑交代了那些事实，又对叙事起到了怎样的推动作用，整个故事文本便通过这样若干场景以某种较为简单的结构构成。
本身已经已经在叙事线和情节线上够折腾的了，所以以场景构成的叙事线就一定要简单明了，并尽可能的简化。

* 趣味六人物细腻的情感

故事的主题与话题是一方面，是作为文本的内容存在。而叙述的表现力是主要注重在人物的情感方面，包括人物对于自身，对于他人，对于现实，对于曾经所发生过的事情的看法观点态度情绪等等方面来作为故事所展现的风景的载体。

* 趣味七世界观和历史观

整个故事的发生环境，简单的说就是非现实世界的日常故事。
即发生的环境可以是架空的，可以是科幻或奇幻，以及适合于适合于情节的在某种规则制约下的世界。不过就情节本身而言，要尽可能的呈现出一种属于日常的平平常常的故事那样的故事。
背景是明显虚构的，但是要让故事本身有种真实的在这个背景下发生着的样子，人物有各自的信仰和社会角色，而不是一个单薄的存在。
这个世界有其过去发生过去的事情，人们知道的事情，将来要面对的事情。每个人物也有过去的故事，这个过去的会成为他面对他人时的一个要素。
不同人物的过去现在以及未来都有交织的可能性，这种交织和发展，成为了故事的一个重要的叙事方式。
到底人物线怎么使用，是平行还是主次还是轮换还是其他的混合方式，这在实际运用中有发挥的余地。

* 趣味八景色和对话

景色和对话都是很有表现力的情节叙述方式，不过要避免因为使用得不得当而造成地情节不明了或叙述的错乱。
景色和对话都是很适合让人物敞开心扉讲述属于他自己的故事的这样一种场景，用一种敞开心扉的态度来让人物和观众都作为一种读者的立场存在。
情节和对话也都是很容易用来推动情节的，侧重于用景色和对话来讲述真正的情节线即可。运用对话中的情绪和对话参与者间关于事实的互动来推动叙述。

* 趣味九人物和读者的立场

让叙事线里的主角和读者都置于去获得整个故事的一种身份的这样一种一致的立场上。
明确在叙事之中考虑不同的人物各自找到什么以及读者知道什么，这样的信息与事实的传递会影响到整个故事的叙事过程中的每个人物（包括读者）的立场和动机。
当然不能限定死了读者的身份是怎样的，需要给读者自身存在感容纳和参与的众多余地。叙事线和情节线是一个方面，不过读者的整个阅读过程也是重要的体验与参与的过程，并同时有着旁观和亲历者的双重身份。这也是之前划分出单独的叙事线出来的一个理由所在。

* 趣味十人物的性格刻画

这是需要的，很是需要的。有抽象的说是某类属性的人物，也有具体说是经历的哪些事情认识哪些人物以及对它们都有什么身份和态度来构成的一个人物。
不过性格特征明显一些的话人物就要容易辨认得多，这样也让情节的叙述明朗许多。
虽然个人很想在淡化情节和运用设定来展现情感方面寻找些许趣味，不过人物方面不小心就路人了的感觉。

* 趣味十一节奏和音乐的氛围

其实就是指氛围了，在表面平淡的场景之中，有一种持续的氛围所笼罩，通常是抒情性的，还是不错的。

* 趣味十二以故事来讲述对故事的看法

比如这里对于文本的趣味说了好些个人的喜好，其实这些喜好是可以通过一个具体的小说来展现出来，而不是这里通过文字的形式来说它是什么。
也就是说，故事文本是用来讲述对故事或者对于主题的一个多方面的审视的存在。既在以某种叙事方式讲述着一个故事，并同时以这样的一个故事表达着对于故事本身以及对于故事的叙述的方式的的一种看法。

* 趣味十三故事的主题

这个通常老套一点就行了。比如成长友谊感情什么听起来乐观有趣鼓舞人心的的东西都可以。

* 趣味十四短篇形式的篇幅

一个单独的完整的小故事即可，视角小些篇幅和情节都简化指留明了的主线相关物，然后故事也要有立体感。

* 其他的补充

看需要在补充吧。以上内容并没有好好的构思，只是想到什么然后就列为一点写下来了，也不知太片面或者考虑的不周全。
既然是作为一篇随手写写记录记录的东西，自己明知要改动的话可以让内容在明了和完整些许吧。
不过这里仅仅是流水的记录，记录下当前先想到的一些趣味的可能性，然后就不再继续，就暂且写到这里了吧。

-----

叙述之间从高潮部分插入，既故事一开始就是某个事件正在高潮的部分。然后再把故事具体的展开。这样先尽可能把把故事涉及的话题的全貌展示出来，然后再具体地增加立体感。

本想写篇心情日记的

2012-03-24T11:05:00.008+08:00

早上在床上被窝里缩了好久一直没起来，在这个安静的早晨里，感觉可以让脑子安静地去想象身边和周围的事情，于是就忽然有了有话说的感觉。如果刷微博的话确实是只言片语就了，不过想到咱是或许把微博更多地作为一个沟通和记录来用的话，在那种轻浮感之中来写日记只是觉得心里空荡荡的。于是还是起来打开电脑写写日志好了。
以上便是开场，然后正文什么的本该是继续写下去的。不过等到洗完澡抚摸着键盘的时候，却又感到自己变得拘谨起来。所谓心情这种东西，一方是源于自己的心里的想法，一方面也是出于对自身情境的掩饰。就像乐观有时不是因为对结果的肯定，而是因为有可为结果所做的行动并获得可预计的回报；就像悲观有时不是因为能力的不足或意外的挫折，而是因为有时对风险的一种自我保护中需要一种推脱的借口。于是其中重要的事情便变成了是在做出怎样的一种行为，而所谓心情什么的就只变成了行为的表现方式的一种附属物了。
所以说什么是满足什么是奢望，各自又会对应着什么样的行为，这是一件很微妙的事情。那些觉得一无是处不思进取的行为，或许就是值得骄傲并足以信赖的伙伴呢。并且在这同时可以再有一份心态，去创造机遇迎接变化便是了。
或许过多的折腾只是改变了塑料瓶的的形状，压缩了它的体积让水看起来可以满一些，不过可能其实水却流失了。空或满的感官对于结果而言只是参照，心情对于言语亦只是想法与心态的婉转表达，原本想到的那些思绪还是不打算具体地写成什么了。
这里，大体就写这些了。

https://twitter.com/#!/LennaHammer/status/183384888844632064

存活确认

2012-02-17T21:58:00.009+08:00

看了一下后台“编辑帖子”列表，里面有好多写废了的文，或者认为不适合发布的内容。
它们有的是开了个标题没写的，有的是涉及私事的，有的内容太幼稚的，有的在别处贴过的，有的涉及18x内容。
内容有长有短，目前帖数是占据了公开帖数的三分之一了，和生活里的经历一起，构成了海平面下的冰川。
最近是习惯在本地用文本编辑器编辑来再发出来，不知道那里还有什么写废的东西没。

不过自己都知道是些写废的或者不愿意贴出来的东西，在这里说出来看起来也没什么意义。
现在看大多数的博客或者日志之类都是想他人展现自己，一个积累并分享价值的一个平台吧。
不过，咱这里呀，咱是完全当一个私人空间来看待，当作一个自言自语的地方了。
甚至比推特微博之类的地方还要清静的感觉，一个可以容忍着自己继续幼稚或者犯傻的地方。

那些曾经想回避的话题，在这个草稿箱里依然是难寻踪迹。如果将来遗忘了，那就可能是真的永远的遗忘了。那些其中经历的不愉快，那些其中收获的快乐，或许有那么一天，将会永远的消失在记忆的深处了吧。

此刻，就总能想到一个孤单的身影呢。
一个人孤单的裹在被子里的小男孩，伸出头来，数着窗外天空里的那片星星。

----
久久，这里就没留下过什么了，这大概是荒废了吧。

----
回想过去的这半年——
奶奶病倒了，目前语言和记忆都受到印象，有些事情我这里先记着吧，暂时不写了。
准备了一场考试，可惜自己太没有勇气了，总是缩手缩脚的，这样可不行。
虽然最主要的事情便是忙这考试了，可以如果未达到的目的话，这半年的意义也就不明显了。
不过期间也看了一些书了，也算是有所收获吧，于是也可以欣慰一些。
坑了一个Scheme实现，初步实现了大体的功能，然后就一直坑着了。
UUShare关闭了，几年记忆的实物就这么消失了，谢谢河马的最后时刻备份。
开始用小号玩着推特和微博，谢谢啊七和河马的在使用上的帮助，留下点足迹。
在KeyFc申请了版主，详情以后写，算有点经历和想法吧，可惜自己不珍惜便被退了。
写了两篇文，一篇Clannad的同人当论坛活动，参与了一篇Key同人剧本，以后整理过来吧。
推了些许游戏和小说和动漫，不过进度都很慢来着。
现在想来，这些折腾的意义如何，也不甚明了了。
可是毕竟半年的时光过去了，就这样原原本本的写下来吧。
想做到很多事情，可是又无能为了，或者不愿去做，然后增加了许多烦恼吧。

----
想象近几天习惯了用刷推特微博来消磨时间了，大概也出于自身在很多方面无能为力的失落感吧。
这样便觉得自己所作的都是毫无意义，然后便对未来有了无助恐慌和害怕作出任何的事情了。

几个感觉不错的应用

2012-01-01T14:25:00.015+08:00

很水的一帖，翻了翻手机和硬盘，看看有什么好玩的东西。。。
* Stranded 一个孤岛生存类游戏，Win32
http://stranded.unrealsoftware.de/s2_infos.php
* RogueLight 很有冒险感觉的的rogue游戏，Win32
http://gamejolt.com/freeware/games/rpg/roguelight/1425/
* POWDER 一个地图紧凑的图形rogue游戏，按键少，PC/Mobile
http://www.zincland.com/powder/
* QDict Android平台的字典
http://mail.ustc.edu.cn/~wchao911/
* MDict WM平台的字典
http://www.octopus-studio.com/
* Cool Reader 简洁强大的电子书阅读器，Android平台
http://coolreader.org/e-index.htm
* MX Video Player Android上的视频播放器，媒体管理功能真心不错，自动生成列表记录媒体是否播放过播放到哪里
http://sites.google.com/site/mxvpen/
* RepliGo Reader Android上性能和不错的PDF阅读器，支持书签重排笔记
http://www.cerience.com/products/reader/
* Harmony 一个DOOM2的同人，怀旧感，Win32
http://www.rabotik.nl/
* Scratch 教学与原型的创造力，PC
http://scratch.media.mit.edu/
* AlReader 以前在WM手机上用的
http://www.alreader.com/
* TCPMP/CorePlayer 以前在WM手机上用的
http://corecodec.com/products/coreplayer/
* 云端 Win32上的应用虚拟化分发应用，还在用0.9版
http://yunduan.cn/
* RocketDock 放在桌面右边，然后把桌面图标关了
PuzzleCollectionPortable 一堆桌面解谜游戏
http://www.chiark.greenend.org.uk/~sgtatham/puzzles/
* BTLocal 貌似能用的搜索辅助工具
* minijoe 看着玩玩
http://code.google.com/p/minijoe/
* onscripter nscripter的开源实现，多平台
* wintersweet Win32上挺方便的字典
* dunwich 看着玩玩
http://marijnhaverbeke.nl/dunwich/
* Clark Productions 一个Basic的rogue游戏
http://users.freebasic-portal.de/rdc/programs.html
* MPlayer 必备
* 魔王录有格子感的动作要素淡化的动作游戏
* 金庸群侠传console_rpg 字符游戏的感觉还挺不错的
http://code.google.com/p/flaswf/source/browse/trunk/JYtrpgYDZS/?r=223
* Notepad++ 文本编辑器，加tagview插件
* 简易三国志2 增强版文本界面游戏？
http://ishare.iask.sina.com.cn/f/11573234.html
* everything 我已经不记得文件在哪个目录里了

OHRRPGCE
http://en.wikipedia.org/wiki/OHRRPGCE
monster2
http://www.nooskewl.com/node/29/
Gravity Bone
http://blendogames.com/
WinFF - Free Video Converter
http://winff.org/html_new/
漂亮同人堂
http://www.acgmix.net/web/index.htm
Simon Tatham's Portable Puzzle Collection
http://www.chiark.greenend.org.uk/~sgtatham/puzzles/
rocksndiamonds
http://www.artsoft.org/rocksndiamonds/
Ori, Ochi, Onoe
http://games.renpy.org/game/o3.shtml
StorytellingAlice
scummvm
leidao
mldonkey
mplayer
Audacity

简易Roguelike制作流程【转/待译】

2011-11-20T16:00:00.004+08:00

原文地址：roguebasin.roguelikedevelopment.org

How to Write a Roguelike in 15 Steps

This is a rough route map for the creators of roguelikes. I'm well aware that there are many possible routes and that no two journeys are the same -- this is a description of one of possibilities and maybe will help you to plan your own.
Please add your comments -- maybe we could make this article really helpful. What are your own routes?

Contents
1 Step 1 - Decide to write a game
2 Step 2 - Hello world!
3 Step 3 - It's a boy!
4 Step 4 - The map
5 Step 5 - Saving/Loading
6 Step 6 - It's alive! Alive!
7 Step 7 - Interaction
8 Step 8 - Data files
9 Step 9 - Items
10 Step 10 - Magic
11 Step 11 - Simple game
12 Step 12 - Levels
13 Step 13 - Experience
14 Step 14 - Citizens
15 Step 15 - Free at last

Step 1 - Decide to write a game

Most of you will have this step behind you already, but there are some hints about the direction of the first step. The best reason to start developing your own roguelike game is to create a game that you will enjoy playing yourself.
Don't start by asking around about the definition of roguelike game -- you don't need it. If the game you write is not considered roguelike by others, but it's still fun to play for you -- you succeeded. It's not like there's some kind of a contest to write a game meeting certain specifications.
Don't plan too much. Of course, if you want certain things in your game, you must write it so that there is room for them -- but don't even try to anticipate everything -- it's just impossible. When you write a design doc, you make a lot of decisions. Most of the decisions can't be made without performing some test first -- usually by writing small programs utilizing given feature. It's best to make the decisions when your project has already reached appropriate stage -- when you don't need to write an additional program, because your project already has everything you need.
It's no fun to just proceed according to plan -- leave some space for improvisation. Don't be afraid about making mistakes or implementing something in an inflexible way -- you can improve it when you need it -- most of the time it will be ok.

Step 2 - Hello world!

Prepare your programming environment. Choose your language and platform, choose appropriate compilers/interpreters, editor, version control, automated build, and other utilities. Set them up so that you're comfortable with them.
Decide on which libraries you're going to use -- it can change later, but it's usually a painful change. Don't think too much about portability -- it can be fixed later. Think about what you need and what you're comfortable with.
Decide on the language you want to write comments and object names in your code, as well as the language you want to be used in your game. It's strongly recommended to use English in your source code -- you can get more help this way from others.
Don't worry about i18n yet; translation is usually a very late step in the development process.
Write a simple 'Hello world!' program and test whether it works. Test your libraries, etc. -- you don't want any surprises.
Start coding.

Step 3 - It's a boy!

Start with screen output and keyboard input. Decide preemptively on your screen layout (easy, you can change it later) and make the routines that display map characters, status lines and messages.
Make the routine to read key-presses (no config files, no keys redefinition).
Make a '@ walking around the empty screen' demo. Play with it a little, clean things up, play some more, imagining the game is finished and you're playing it.
Make the message handling routines -- especially for the debugging messages -- they come in handy.

Step 4 - The map

Decide on your map structure. Don't over-generalize -- you can add things later. Make your (empty) map displayed on the screen. Scrolled if you need it. Add some elements to your map to see if they are displayed correctly (just hard-code them, you don't need a level generator yet).
Make your '@' appear on the map -- not as it's element at first, just as a cursor. Test the scrolling, maybe make a 'look' command.
Now turn '@' into creature. You still don't have time implemented, so the keyboard-reading routines will just move it around the map. Include the checks for walls in the movement code. Maybe add doors and open/close commands.

Step 5 - Saving/Loading

Read the map from a file instead of hard-coding it. You can play with it and test different configurations if you make it human-readable from the start.
Add the 'save' command and the procedures to save your game -- the map at first, then, gradually, all of other game elements. From now on, when you implement something that needs saving, also implement saving it as soon as possible.
Here's a handy article about save files and how to implement them; it's worthwhile to read when planning ahead what form you'll save things in.
Once you work with files, you can make your preferences and keybindings config files. Again, if you make them human-readable, you'll save yourself a lot of trouble.
Now, when you're not sure how any element of the game works, you can save the game to a file and just check it.

Step 6 - It's alive! Alive!

Implement other creatures (monsters) and time. Add a single monster to begin with. Give him some simple AI (like, say, stay still, or maybe move randomly).
Start with my turn-your turn, then implement the time system you want (or, usually, a simplification of it and gradually make it more complicated later).
Remember to test everything as you go.

Step 7 - Interaction

Add stats for your creatures. A simplification of the ones you envisioned, probably. It's best to add stats as they are needed, not because they 'look cool', but you might not be able to resist ;).
Make the creatures notice each other -- bump, attack, etc. Gradually improve their AIs, so that they can chase the player.
Implement and test the combat system -- without equipment for now, just hardcode the values. Do lots of testing.

Step 8 - Data files

Move the creature, map features, etc. definitions to data files. Forget about scripting for now If something cannot be moved -- just leave it for now.

Step 9 - Items

Add items. For start, just objects you can pick up -- no properties. Gradually give them properties, kinds, stats, etc., implement inventory, picking up and dropping, equipping and using (no effects yet), also stacking, containers (if you want them), etc.
This step usually requires lots of testing to balance.

Step 10 - Magic

Add item effects, special monster attacks, spells. Add items and monsters to test them. You don't need all the possible effects right away, just the ones that are needed for the next step.

Step 11 - Simple game

Try to make a simple, hard-coded game. Play it and give it to your friends. Test the mechanics you've implemented so far. See if the game is fun.
Change everything you need to change. Don't forget to test a lot. Always ask someone to test the game's 'fun factor', or test it yourself after a while; it's hard to notice some things right away.
This step should take a pretty long time, until you've got a playable, fun mini-game.

Step 12 - Levels

Write your level generators. Implement moving between the levels, a wilderness and/or town if you want them, saving the levels on level change if you want them to be persistent (so that they don't take up memory).
Spread your monsters and items on different depths. Add more monsters and items, with their effects, as needed.

Step 13 - Experience

Start developing your experience system and skill system. Tune the monsters' and items' stats. Make character generation screen, classes, races, and whatever else you need.
Playtest your game frequently.

Step 14 - Citizens

Add NPCs, shopkeepers, and simple quests if you need them. Keep adding features and tuning the stats.

Step 15 - Free at last

Start adding and testing all the 'unique' features you thought were so cool months (years?) ago, when you started the whole thing. Revise your opinions of them and see if they fit the game.
Write your pet random plot generator, factions system, infinite wilderness generator, neural network AI, or other unique feature, since you can now test it in a working game.

Original version submitted to rec.games.roguelike.development by Radomir 'The Sheep' Dopieralski

算24【备份】

2011-11-20T15:14:00.006+08:00

以前写过，不过这次应该代码好看些了吧。

#!python2
from itertools import *
from operator import *
calc24 = lambda a,b,c,d:list(set(sum((
(o(p(i,q(j,k)),l)==24 and ["(%s%s(%s%s%s))%s%s"%s] or [])+
(o(i,p(q(j,k),l))==24 and ["%s%s((%s%s%s)%s%s)"%s] or [])+
(o(i,p(j,q(k,l)))==24 and ["%s%s(%s%s(%s%s%s))"%s] or [])+
(o(p(i,j),q(k,l))==24 and ["(%s%s%s)%s(%s%s%s)"%s] or [])+
(o(p(q(i,j),k),l)==24 and ["(((%s%s%s)%s%s)%s%s)"%s] or [])
for nums,opp in [((a,b,c,d),(add,sub,mul,lambda x,y:truediv(x,y) if y else float('nan')))]
for j,i,k,l in permutations(nums) for o,p,q in product(opp,repeat=3)
for r in [dict(zip(opp,("+","-","*","/")))] for s in [(i,r[o],j,r[p],k,r[q],l)]),[])))

>>> calc24(6,6,6,6)
['6+((6+6)+6)', '(((6+6)+6)+6)', '(6+(6+6))+6', '(6+6)+(6+6)', '(((6-6)-6)*6)', '(6-6)*(6+6)', '6+(6+(6+6))']
>>> calc24(2,3,8,9)
['(8/(9*3))-2', '8/(2/(9-3))', '8*(9-(2*3))', '8*((9/3)-2)', '(((9*3)/2)-8)', '(8*2)/(9-3)', '(((9/3)*8)-2)', '(9/3)-(2/8)', '(9*3)-(8/2)', '8*(9-(3*2))', '(9*(3-2))*8', '(9*(2-3))*8']

下面这个考虑了交换律的重复。故意写个很累赘的样子，
而且为了吻合IEEE还把mapcan和format等等都替换了一下。

(define (calc24 a b c d)
  (define (flat-map p x)
    (apply append (map p x)))
  (define (filter p x)
    (cond ((null? x) '())
          ((p (car x)) (cons (car x) (filter p (cdr x))))
          (else (filter p (cdr x)))))
  (define (drop-one x lst)
    (cond ((null? lst) '())
          ((equal? x (car lst)) (cdr lst))
          (else (cons (car lst) (drop-one x (cdr lst))))))
  (define (perm lst)
    (if (null? lst)
        '(())
        (flat-map
         (lambda (x)
           (map (lambda (y) (cons x y))
                (perm (drop-one x lst))))
         lst)))
  (define (pow lst n)
    (if (zero? n) '(())
        (flat-map
         (lambda (x)
           (map (lambda (y) (cons x y))
                (pow lst (- n 1))))
         lst)))
  (define (buld-exp num ops)
    (apply
     (lambda (i j k l)
       (apply
        (lambda (o p q)
          (list
           `(,o (,p ,i ,j) (,q ,k ,l))
           `(,o (,p ,i (,q ,j ,k)) ,l)))
        ops))
     num))
  (define (eval-exp exp)
    (if (list? exp)
        (let ((arg (map eval-exp (cdr exp)))
              (/ (lambda (x y)
                   (if (zero? y) +nan.0 (/ x y)))))
          (case (car exp)
            ((+) (apply + arg))
            ((-) (apply - arg))
            ((*) (apply * arg))
            ((/) (apply / arg))
            ((--) (apply - (reverse arg)))
            ((//) (apply / (reverse arg)))
            (else (error "op?"))))
        exp))
  (define (show-exp exp)
    (define (bin-op-str op arg)
      (apply (lambda (x y)
               (string-append "(" x op y ")"))
             (map (lambda (x)
                    (if (number? x) (number->string x) x)) arg)))
    (if (list? exp)
        (let ((arg (map show-exp (cdr exp)))
              (/ (lambda (x y) (if (zero? y) +nan.0 (/ x y)))))
          (case (car exp)
            ((+) (bin-op-str "+" arg))
            ((-) (bin-op-str "-" arg))
            ((*) (bin-op-str "*" arg))
            ((/) (bin-op-str "/" arg))
            ((--) (bin-op-str "-" (reverse arg)))
            ((//) (bin-op-str "/" (reverse arg)))
            (else (error "op?"))))
        exp))
  (define (unique lst)
    (if (null? lst) '()
        (cons (car lst)
              (unique
               (filter (lambda (x)
                         (not (equal? x (car lst)))) lst)))))
  (unique
   (flat-map
    (lambda (x)
      (flat-map
       (lambda (y)
         (flat-map
          (lambda (z)
            (if (= 24 (eval-exp z))
                (list (show-exp z))
                '()))
          (buld-exp x y)))
       (pow '(+ - * / -- //) 3)))
    (perm (list a b c d)))))

(calc24 2 3 8 9)
("(((9-3)/2)*8)" "(8/(2/(9-3)))" "((8/2)*(9-3))" "((9-3)/(2/8))" "((9-3)*(8/2))" "((8*(9-3))/2)" "((9-(2*3))*8)" "((9-(3*2))*8)")
(calc24 6 6 6 6)
("((6+6)+(6+6))" "((6+(6+6))+6)" "((6*6)-(6+6))" "(((6*6)-6)-6)")

更多的不同语言写的可以看这个：
http://rosettacode.org/wiki/24_game/Solve

乱如备份下平时在npp里面用来插入行首空格的东西。
能用，不过貌似可能会干出多余的事情来，比如不仅仅是行首的情况。
另外使用前务必先用一下npp自带的转义& < > "的菜单命令。

editor.pyreplace(r"^ ", r" ")
def s():editor.pysearch(r"  " ,lambda x,y:rp())
def rp():editor.pyreplace(r"  ", r"  ") and False or s()
s()

如果要变成算24的游戏的话，还要一个随机数生成，和表达式计算的东西。

存活确认

2011-11-19T23:26:00.003+08:00

觉得blogger最近登录不便，所以这段时间有点当长文回收的地方在用了。暂且不说有多少内容，仅仅是那堆放腾起的尘埃，也够让自己呛一阵的。不过其实呢，既然这里作为一个自己感到自在的地方，也不必总太多估计。可以有一些过程中的，不成熟的，零时的，盲目的，白痴的想法也写出来。因为作为结果而言，至少是作为一个暂且还达不到的，或者没有做到的事情来说，其中的过程也是不可欠缺的。缺少了或者说完全的抛弃了愚昧的状态，却反而回避很多需要的或者说感到满足或欣喜的结果的话，失去和得到的就不是同一事物的不能层面，而是皆至于无的状态了。所以，在这里，还是来发帖确认一下成活吧。以前烦了很多傻了，以后还是会继续来犯傻，同时再多展示一些令人欣慰的事情吧。

【怀旧向】关于ASCII风格Game的简单尝试 Part-I

2011-10-25T23:04:00.005+08:00

堆了一个大体的框架，暂时没有实在的内容，还需要进一步抽象出可供不同数据复用的类型和模型出来。
目前是用一个修改版的TinyScheme做解释器，增加了平台实现相关的clrscr、inkey（=getch）、exit三个用于终端界面的函数。
为了以后移植方便，语言特性限定在IEEE和R5RS的最小子集的交集。
即无eval且call/cc只能局部跳出用，并只用到最基本的两种数字类型。

本来在别处写了一点说明和注释，价值不大就不搬过来了。
代码这里合并为单文件。

(define (require name)
;(push! *loaded*)
(load (string-append (symbol->string name) ".ss")))

;;;=====(load "core.ss")=====
(define (filter pred list)
(cond
((null? list) '())
((pred (car list))
(cons (car list) (filter pred (cdr list))))
(else (filter pred (cdr list)))))
(define (curry fun . args)
(lambda x
(apply fun (append args x))))
(define (assert ture . msgs)
(if (not ture) (begin (for-each (lambda (x) (display x)) msgs) (error))))

;;;=====(require 'util)=====
(define (wait-key)
(define (co key-map)
(define (co lst)
(cons
(char-downcase
(string-ref (symbol->string (car lst)) 0))
(cadr lst)))
(map co key-map))
(define key-map
(co '((w u)(s d)(a l)(d r)(z a)(x b)(c s))))
(let loop ()
(cond
((assoc (inkey) key-map)
=>(lambda (x) (if x (cdr x) (loop)))))))
;;;key-test
;(clrscr)
;(let loop ()
; (let ((c (inkey)))
; (display (char->integer c))
; (newline)
; (loop)))

;;;=====(require 'view)=====
(define (dispatch->callable host)
(define (object message . args)
(apply (host message) args))
object)

;;;choose:a modal scene
(define (ui-choose msg . items)
(define (show vec cur)
(define cur (modulo cur (vector-length vec)))
(clrscr)
(display msg)
(newline)
(do ((i 0 (+ i 1))) ((= i (vector-length vec)) 1)
(display (if (= i cur) " * " " "))
(display (vector-ref vec i))
(newline))
(let ((k (wait-key)))
(case k
((u) (show vec (- cur 1)))
((d) (show vec (+ cur 1)))
((a) (+ cur 1))
(else (show vec cur)))))
(show (list->vector items) 0))
;(display (ui-choose "where to go?" "walk" "eat" "sleep"))

;;;(int*int->())->(symbol->procedure)
(define (make-movable call-with-this-new-position)
(define position (list 0 0))
(define (position-ref)
position)
(define (position-copy)
(append position))
(define (position-set! x y)
(set-car! position x)
(set-car! (cdr position) y))
(define (move dx dy)
(let ((new-x (+ dx (car position)))
(new-y (+ dy (cadr position))))
;;tail-rec/cps
(call-with-this-new-position this new-x new-y)))
(define (dispatch message)
(case message
((position-ref) position-ref)
((position) position-copy)
((position-set!) position-set!)
((put) position-set!)
((move) move)
(else (error message))))
(define this (dispatch->callable dispatch))
this)
;;;ui-display-map
(define (map-view-display width height call-with-char-position)
(do ((y 0 (+ y 1))) ((= y height))
(do ((x 0 (+ x 1))) ((= x width))
(let ((chr (call-with-char-position x y)))
(if (or (not chr) (null? chr))
(display ".")
(display chr))))
(display "\n")))
;;;with-system-mune
(define (input-and-move move)
(case (wait-key)
((u) (move +0 -1))
((d) (move +0 +1))
((l) (move -1 +0))
((r) (move +1 +0))))
;;assoc-all
(define (assoc-all obj alist)
(let ((f (filter (lambda (x) (equal? (car x) obj)) alist)))
(if (null? f) #f f)))
;;make-pos-list
(define (pos-list-of-strs map-data)
'(demo-data
("##....###"
"#.$.....#"
"#.....@.#"
"#.$..####"))
(let loop ((x 0) (y 0) (w 0) (h 0)(it map-data) (ret '()))
(cond
((null? it)
(cons (list w h) ret));return this
((= x (string-length (car it)))
(loop 0 (+ y 1) (max x w) (+ h 1) (cdr it) ret))
((equal? (string-ref (car it) x) #\.)
(loop (+ x 1) y w h it ret))
(else
(loop (+ x 1) y w h it
(cons (list (list x y) (string-ref (car it) x)) ret))))))
;;;pos-list
(define (make-pos-list string-list-data)
(define _ (pos-list-of-strs string-list-data))
(define (dispatch message)
(case message
((width)
(lambda () (caar _)))
((height)
(lambda () (cadar _)))
((data-ref)
(lambda ()(cdr _)))
(else (error message))))
(dispatch->callable dispatch))
;;;=====(require 'view2)=====

;;;=====(require 'data)=====
(define (make-state)
(define alist-data (list))
(define (dispatch message)
(case message
((get)
(lambda (key)
(cond ((assoc key alist-data)=>(lambda (x) (cdr x)))(else #f))))
((put)
(lambda (key value)
(let ((ptr (assoc key alist-data)))
(if ptr (set-cdr! ptr value)
(set! alist-data (cons (cons key value) alist-data))))))
((save)
(lambda (file)
(call-with-output-file file
(lambda (port)
(write alist-data port)))))
((load)
(lambda (file)
(call-with-input-file file
(lambda (port)
(let ((sexp (read port)))
(if (eof-object? sexp)
(set! alist-data (list))
(set! alist-data sexp)))))))
(else (error message))))
dispatch)
;;;=====(require 'deprecate)=====

;;;=====(require 'main)=====
;;;make-map-modelA

;;;one map
(define (show-map-scene5)
(define (map-event p x y)
(cond
((assoc (list x y) (filter (lambda (x) (eqv? #\$ (cadr x))) map-objs))
(clrscr)
(display "hello world")
(inkey))
((assoc (list x y) map-objs)
=>(lambda (x) '()))
(else (p 'put x y)))
(map-loop))
(define p (make-movable map-event))
(define budr1 (make-pos-list
'("......................"
".......#.......#......"
"..........#......$...."
".....$................"
".............#........"
"......#..............."
"...............#......"
"........#.....#.......")))
(define map-objs
(cons
(list (p 'position-ref) "@")
(budr1 'data-ref)));map this
(define (map-char-of-pos x y);map-show make this simpler
(let ((lst (assoc-all (list x y) map-objs)));map-objs
(if (not lst) "." (cadr (car lst)))))
(define (map-loop)
(clrscr)
(display "[map]\n")
(map-view-display (budr1 'width) (budr1 'height) map-char-of-pos)
(input-and-move (curry p 'move)))
(map-loop))
(show-map-scene5)

(exit)

参考代码：
http://www.zincland.com/powder/
http://roguebasin.roguelikedevelopment.org
http://users.freebasic-portal.de/rdc/programs.html
http://marijnhaverbeke.nl/dunwich/
http://www.cs.cmu.edu/Groups/AI/lang/scheme/code/fun/advent.scm

等之后有空的时间来安排一个剧本来写完整吧，最近不会继续打理这个了。
上面说的东西是在自娱自乐，能够用来开心一下就目的达成。

【挖一挖】关于文化娱乐方面的 Part-A

2011-09-05T01:43:00.002+08:00

* 【挖一挖】
来写一些有印象的文化娱乐类的东西吧。

* Mario
偏向SFC的Super Mario World，玩法比之前丰富了，手感一如既往优秀。不同的关卡间有不同的主题和风格（话说有几个外传关卡变化得很牵强，但是SMW就感觉有亮点和贴切）顺便说下个人是非常不喜欢Zelda系列，每次攻击的时候感觉浑身不自在。

* FFTA
顺便把整个FF系列也在这里说了，首先抱怨下对FF战斗系统的不满，就是始终不适应（我知道100%逃跑是故意的）。另一个不满就是不停地跑存档点有时候会感觉到单调和无聊了，整个游戏玩法的亮点不断（对玩法和设定上亮点的期待和满足是件很有乐趣的感觉，不然就是重复刷关了）不过流程的整体感觉得有些分散了。估计是由于制作人的不同，系列中不同的风格有很强的辨识感的，所以这里在集中说下FF5和FF6吧。FF5的感觉是和伙伴一起在世界上闯关冒险的意思，一路上培养职业并利用能力的特性和属性来类似于动作游戏闯关一般去迷宫或城堡（路很简单，但是要注意敌人出现的种类和方式）里找Boss（FF向来100%逃跑率，并支持低等级去打Boss）。战斗是动态的，杀起血来也很快，如果所准备的战斗配备和战术安排不当的话，不会死撑太长时间（有时第一趟就是去送死的）。并且练级只是和副职业有关，主职业是可以自由转职的，这让战斗可以关注于当前的战斗本身。整个游戏过程被Boss划分为一个个区域，每个部分都是一个单独的关卡，强制流程使得战斗和情节都有节奏的进行着并在不同的关卡里面展示出不同的模式和玩法。有难度的同时，具有了乐趣和挑战性。不过FF5里面情节是串联作用了，紧凑有趣而不在于带入感什么的。至于FF6的战斗个人就觉得玩不来，而情节模式和表现方式方面则代表了随后的几款FF。FF6里情节是按照区域来展开的，每个区域里面有完整的流程，并有侧重的内容和一个大的目标。这样并不一定是走路Boss的模式了，而有可能有一些子任务或者阶段。跑路方面FF6比FF5麻烦一些，感觉像拖时间。由于情节是按照区域和类似于章节的形式来组织的，所以在表现的方式上相比之前要丰富了。战斗上面的亮点在于装备技能然后用熟练度记住技能，不过战斗本身我是觉得拼技能（这比等级重要）了，战斗上面每个职业（人物是固定职业）有不同的操作方式（不过其目的是代入感，但是对发挥战术有麻烦），有些地雷很拖慢节奏。情节上的一个亮点是刻画群像，利用人物间的经历相互补充、影响、团结，使得故事的展开显示出了立体感，并有了暗示核战争之类的意思。不过就是从比较开场和整个游戏过程，个人还是偏爱于FF5的叙事节奏和动作过关的感觉。至于后来的从FF7开始，有了CG动画，这是一种用镜头运用（焦点和位置）和场景调度构成的新的表达方式。特别是在FF8中丰富的镜头语言来增加画面的表现力。后来的FFX算是人物刻画和氛围渲染上塑造的更强烈的一作了，整个故事是一个旅途，但是哪怕是仅仅走路和不断穿插的强制时间，都在这种强烈的氛围之下变得有所含义。然后上面还有很强力的音乐没有说到，这个可以单独拿出来说，可惜这里不说了，总之就是很贴合和表现场景和人物。而且虽然上面说了好些牢骚，还是觉得FF的特性太显著和有亮点了，不同于大多数RPG侧重的冒险那一方面的感觉。
那啥标题是FFTA，话说那是因为觉得包括KH:CoM和FFCC的情节走上另一种套路，并且显得更为成熟一些。（例如FFTA是说主角和他们的伙伴们在生活中各有各不顺心的地方，然后在幻想世界里通过彼此的交锋，又以新的心态开始真正的生活。）在这几个游戏中，情节的表现是侧重于玩家知道什么和主角和其他角色们知道什么。情节是通过角色们的互动表现出来的，而不需要在这个进展的流程中让设定好的事件本身有如何的发展。角色被置于魔法科技的世界之中，让角色的身份、角色的经历、角色的性格成为了情节存在的方式，通过角色间信息和态度的发展和一个相当明显的强制人物线来推动情节的进行，和对某个或若干个关键词的表现里。让战斗成为交代人物关系和控制情节节凑的方式，在带入感方面比以往的FF要更加强烈一些，试图通过玩家控制角色的活动方式来影响玩家对整个情节的认识和情绪的渲染积蓄和迸发。主题方面侧重于了真实、记忆、梦想、愿望，这些属于个人方面的，而在先前的主题上如和平、友情、亲情、爱情、抗争、命运（还有水晶、多世界和故事年表中的环，以及女主必然公主，主角必然对其有好感）有所淡化。顺便说下FFT的几个相关作品的战斗模式很有亮点，注重节奏的同时，又控制住了节奏使得适合发挥策略。
说到水晶，FF1里有说，这是魔法的来源，FF6之后也会以魔石（前者是天然的，这个是合成的）的形态出现。在主题上，水晶代表目标、力量和欲望。
更多见www.ffsky.com那里的一些专题和讨论吧。

* Breath of Fire II
正好和FF互补，满足下个人喜好的另一面。章节式情节，每段有侧重的角色和地图。地雷用自动战斗，并注重地图机关的策略和Boss战的判断。亮点是路人NPC的对话也成为了交代情节的一部分，可以补充事件背景，可以来体现人物间的态度。整个故事情节和交予玩家的行动选择亦是用来体现此的。游戏中事件不是属于地图，而是某时刻在地图上发生，这样有了参与到人物任务事件的感觉，并且连续发生的一段情节也不会让事件点显得突兀，使得角色的行动不是为了触发情节而是成为了情节的一部分。

* 特鲁尼克大冒险
战斗很有亮点，系统也很丰富（魔法，地图属性，伙伴、宠物...），不多说了。顺便说下GBA上有几个战斗不错的游戏，战略类如鬼武者幽游白书公主同盟，还有几个即时控制多兵力一起玩的，还有在即使的行动中融入RPG的感觉的（例如思考数值上的行为寻则什么的）。

* Pokemon
战斗就是走过场，不过真的很有代入感。在那个时间里去各自认识了更多的人并获得了PM和徽章。

* 吾国吾民
林语堂的文字是很喜欢的，不过目前这个小说金华烟云还没看过，它是设定在一个立场摇摆的特殊年代。从一些短篇的散文中，一直可以觉得林的文字中对生活场景的描写充满着的情感的，十分具有杀伤力。说到小说的话，我这里有淡化情节而去关注到文字和写法的想法，因为情节可以仅看作故事设定的一个附属物。文字显得比鲁迅（写作入门用）要贴近读者些。《京华烟云》的电视剧渲染出来了面朝朦胧的未来去寻求的气氛。

* 五星饭店(?)
高中时候考到的电视剧，侦破、恋爱、成长多种要素被结合到了一起。不过让我印象最为深刻的是该电视剧的叙事方式，有一些段落着重关键的场景铺成大量的对话（类似于独白，因为是个人主导的）然后跳跃掉连接的行动的过程，也也一些段落没有对话完全依靠风景和镜头运动来体现时间轴的变动并体现出人物那时候的想法。情节是采取意外经历然后等级清零的处理，主题是关于真实与去做什么的事情，信息的细节的悬念穿梭全剧。

* 情书
是岩井俊二的小说和电影，这里说的是小说，平实的叙述推动着一幕幕的场景的发展。故事由藤井树的意外作为开端，以渡边博子和同名女生藤井树各种的生活和来往的信件作为发展，信件里回忆起了死去的藤井树的学生生活。在回想之中让一段逝去的经历变得清晰，变得真相和情感一直在那里，却一直没有旁人来察觉。人们在行动中探索者未来，同时也在明白着现在的由来。过去发生的事情并没有改变，而只是过去不可能一层事件的表象，当一个发生的事件阻隔在现在和过去的时候，一切的所为都被固定在一个有限的范围之中，去打开思绪外的一片世界。话说自己对看起来像是水面一样反射着表象却由于故事的发展充满了运动的态势的文字完全没有免疫力。

* 东方快车谋杀案
一直想能够看完阿加莎·克里斯蒂的全部作品，每个小说之间有着一致的写法但又每次阅读都能感到惊喜。小说的文本由对话和动作构成，并把内容按章节风格，文本的进行中透过所给的视角的信息不断的引导着读者的关注点，将故事以平稳的叙述化作眼前的一个舞台。读者透过这样的一个戏剧化（冲突和发展，发现真相的过程）的展示面，通过一个充满压力（凶杀案，已经发生的和将可能发生的）的时间和空间里面，去仔细的观察和打量每个人物。线索和行动在故事中进行着，人物间在互动同时也在展现着自身。有时候有动机的不止是一个人，他们都是整个故事背景中的一个视角，代表着一种可能性，是故事中的一个因素而只是没有往这方面发展。但是正是由于各种的可能性，使得这些小说有了更宽广的感觉。故事进行越往后，可能性在发生着收束，同时在放眼于远方的时候视线又忽视眼前灰色的角落，直到真相揭开视角的迷雾才最终散去。此刻恍然大悟，并将可能性组成一个清晰广阔的整体了。目前看过的印象中的还有《无人生还》《底牌》《怪屋》……

* 电视人·萤
论村上春树的国内出版物中，挪威的森林会较容易的接触到。不过这里是说的是两本短篇小说集，因为这里想要着重展示的其作品中把生活以异常的形态体现出真实的写法。这里举个有些距离的例子，比如轻小说文学少女中学姐经常吃书页有时会让主角写三题然后还吃出甘甜和苦涩来。吃书可以看出人物对文字的一种态度，可以看作是仅仅形容一种程度。但是故事不是把吃书这一行为停留在抽象的意象当中，而是具体地写，作为故事中发生的一件事性来写，当作了故事中理当发生的一件事情来写，以本来仅仅是意象层面的东西变成了一种存在着的真实。将意象具体化，并有由于意象来源于真实，当幻想的意象被放置于一个身边的世界中的时候，起初的突兀感便会转化为对其中真实成分的认同感。意象与真实成为了故事存在的一个支柱，与现代人的时代背景在一起，成为笼罩起整个小说的氛围。

* 警世通言
三言的第二本，明朝话本小说，故事题材各异，背景都是中国古代。小说的主题有点强加给人的意味，显得纸片化。不过确实是那时候的生活的展示，比较一些历史小说读起来觉得较贴近人些。并且每篇小说是以故事作为一个载体，传递着其中的主旨愿望和偏好。文字叙述也平易近人，写法上有现实有仙化的。

* 芥川龙之介
不得不说其短篇小说十分有魅力，大多都是十分压抑的，有让人喘气的压迫感。不要被《竹林中》迷惑了，以为是整个风格的代表。这篇仅仅是扑朔迷离，而不是更常见的对人物心态中的隐藏的一面的冲刷出色彩。虽然说灰色的文字常读不大好，不过他的每一篇小说风格各异的背景设定总能带给人创造力的感觉。故事并不是要发生什么事情，而是可以使得背景设定被展开为立体的存在。不论是真实或是神话，或者是发生来哪里，故事的背景都蕴含着那个世界中冲突的要素将要发展的一个全貌。

* Wikipedia
作为查阅资料的线索是十分有用的，有词条、词条的关联，以及词条所处的若然分类索引。可以用来建立对已有作品的整体概念，在构建设定的时候也可以作为查阅的资料和初始点。

* Lucky☆Star
目前自己觉得最耐看的一个漫画/动画，大段大段脑残（被指莫名其妙）的吐槽体现生活中发生过却没有注意到的细节。原作是关于学生的ACG生活的四格欢乐型漫画，每话内的话题是有连续关联的，并体现了不同人物的性格。

* 寒蝉鸣泣之时
暂且指TV版，游戏版还没动。先来说下类似的动画（后出）的原著（比寒蝉早）。《魍魉之匣》强调的是意外，案件本身没有复杂的手法，但是将同一个背景（二战之后）之下相干和不相干的事情串联在一起，显得扑朔迷离又意味深长。《尸鬼》给吸血鬼故事增加了人的犹豫，当吸血鬼依然能保留生者的思维的时候，它与人类双方的死活就存在态度情感和选择。然后话题回到寒蝉上，推理和多周目是亮点，解释着不同的可能性，同时也有着不会改变的和发生进步的一方面。对话是推动人物之间相了解相关心并团结的突破口，当人物的对话相互敞开的时候，正是胜利的期待放在面前的时候。

* 云之彼端，约束的地方
新海诚的作品中个人偏爱的一部，有不少第一人称的旁白，设定很抽象概括的感觉。情节方面前作星之声更能明显的体现出用设定来作为情感表达的依托这样的模式，不过这作显得更成熟些，作画和音乐都有明显的作者印记。

* 寂静岭
这里着重指1代以及电影版，顺便也指整个游戏系列的共同之处。故事的主题即事件的起因，这是故事最后揭开的内容，正是主角继续未来所需要正视的阴影。主角的经历过程，不仅是自己当前的，也是对往事的浮现和建立联系的过程，用探索场景来发现存在的故事。恐怖的来源有往事的幻象和外界宗教组织的压力。游戏玩起来有些累人，电影感觉代表了此类游戏的情节风格了。
同类型游戏零混合了现代都市和传统仪式，情节设定上觉得很有味道，情节展开有一步步回到历史上的某个关键时刻的感觉。

* 天堂电影院
长镜头很多，用回忆来美化回忆。有关于老者对主角成长的关注，关于Love的遗憾的悠长的曲调。

* Narcissu
某短篇GalGame，无选项可自动播放，其文字的情感与氛围相当显著。属于和别人在一个同时自己又弥散于两个人的空间里的那种感觉。同类型的有2和120元冬（其他几个季节的不喜欢）。文字有主角自己表达和故事情节发展的对话，看似随意的交融在一起，和声般在秋风里寻求着暖意。

* Kanon，Air
个人更偏向于Kanon，不过对着两者不是觉得喜欢，而是认可优秀。冬季和夏季的小镇给人的存在感十分强烈，情节中发生在不同地点背景图让人熟悉的这个地方，并了解了这里发生过的事情。形式上是好感度分支进人物线交代的人物的现状，然后在人物线上主角试图去了解人物帮助人物，最终解开了隐藏的心结。选项的设置使得玩家的操作和主角的情绪置于一致（开朗或内敛）然后真心去推人物线。泣系的风格让日常的情节有轻松和欢笑，而当回忆和现实两条线索交织在一起的时候，就释放了人物被能够表达出来的情感。

* School days
分支设定很神奇，包含两种情感偏向的曲折发展，内容以对话推动故事。用动画和限时选项（把未选算在内）来表现故事，发生着故事各种可能性。在主角的选择中，角色不是等待攻略，而是主动在情节中用行动和言语来影响主角的判断，让六话的情节在角色的互动之中推动着。这种三角形的恋爱故事，通过每一周目的玩家倾向（居然每个角色在情节安排上有引导主角改变倾向的主动行为），也算有带入感吧（像真实之泪那种也是故意纠结于感情方面的故事）。

* 动漫类
这个写起来就有些乱了，所以这里就不展开写了。鬼泣，豹头王，舞hime，妖精旋律...什么的就归类于此吧（有原作的这里不算在内）。

* South Park ， The Simpsons ， Futurama
美国动画中的代表，一话一个故事（偶尔有莫名其妙的话），情节紧凑展开让人关注。通常是根据现实中的事情来建立所表达的内容，把事件的争议置于公开来增进各方观点间的交流和改进。

* 逆转裁判 2
和地图事件型不同的是，体现出了与人物在言语上的对抗，并且有效的控制住了情节进展的节奏。有RPG的战斗感，道具和信息便是武器，在一个言语回合中判断着突破点。此外在地图事件中也体现出了时间的要素，使得每个角色在过程中都是不断行动。情节上说主线有一条人物的态度作为线索的，同时让回忆和未来清晰。GBA上的其他侦探类和它有模式上的差异，柯南侧重限时问答，One是行动决策，Q侦探是触发对话中的关键词。

* 妹妹公主
指两个TV动画以及GBA上游戏，以个发生的小故事来表达纯粹地想在一起的心愿，选项表示主角的行动和对角色的了解和态度。

* GalGame
算是一大类型，最近比较适合（节奏相协调的意思）这个，热衷于多周目全结局，以及选项和情节的配合。

* 补充
想到了一些（或许仅仅是碰巧想到了而已），然后就选择了一些来简介了一下。反映下个人的口味，顺便也算作是推广向文字吧。字数不多内容简略，且有自言自语不知所云的倾向。
话说很喜欢一系列小说和游戏中有相似和相异存在，在较平稳地对期待感的满足时有总是在期待有特别的东西出现。有时故事老套一些没有关系，但是要在意是如何把故事叙述和表现出来的，甚至利用设定来淡化情节线本身。

【挖一挖】关于PE50的存档

2011-08-28T20:45:00.011+08:00

* ProjectEuler

在projecteuler.net，很多小的程序题，可以用来练习键盘指法。限制比较宽松，只要不是很过分，暴力过关也没有关系。
虽说要尽量多用用数学知识来求解吧，不过拿出图灵完备的机器来辅助过关话，其实能算是很正当的方式呦。
高德納学派的可以用ASM，习惯传统方式可以用C++，天书般的J，函数式的Haskell，各种数学计算系统，或者偷懒用用Python，这些都是可以的做法。
既然我这里纯粹是出于娱乐目的的过关而已，就以Python2为主要工具了，也恰巧手头可以使用。

下面的内容算是流程的记录，这里粘贴在一个页面里而已。当初是正确的得到结果，并且性能可以说得过去，在这里就不再做什么改进了。

话说 Level 1 的内容实在十分基础了，没什么好说的了，下面闪入正文吧。

* Problem 1

print sum(i for i in xrange(1000) if (i%3==0) or (i%5==0))

这题的较好的做法是用等差数列求和，注意不把项记录重复了。

* Problem 2

(let loop ((s 0) (a 1) (b 2))
  (if (> b 4000000)
      s
      (loop (if (even? b) (+ s b) s) b (+ a b))))

这道题的优化方法是利用数列满足：奇偶奇奇偶奇奇偶奇...来计算。

* Problem 3

(let loop ((x 600851475143) (i 2))
  (if (> i (sqrt x))
      x
      (if (zero? (remainder x i))
          (loop (/ x i) i)
          (loop x (+ i 1)))))

偷懒可以用Maxima的factor函数，或者手写用正整数数列不断去除它，最后留下来的就是结果。

* Problem 4

(let loop ((r 0) (i 100) (j 100))
  (cond
    ((= i 1000) r)
    ((= j 1000) (loop r (+ i 1) (+ i 1)))
    (else
     (let* ((p (* i j))
            (s (string->list (number->string p))))
       (loop (if (and (equal? s (reverse s)) (> p r)) p r) i (+ j 1))))))

纯暴力，考虑了乘法交换积不变。不过这里回文判断实现得大不好，貌似可以推导出什么数学式子。

* Problem 5

(do((i 1 (+ i 1))
    (s 1 (lcm s i)))
  ((> i 20) s))

最小公倍数的算法貌似是欧几里德发明的。

* Problem 6

print sum(i for i in range(101))**2-sum(i**2 for i in range(101))

又暴力了，不过数列求和有那啥啥公式来着，不知道那些数学软件优化了没。

* Problem 7

(define (prime? x)
  (let loop ((i 2))
    (cond ((> (* i i) x) #t)
          ((zero? (remainder x i)) #f)
          (else (loop (+ 1 i))))))
(let loop ((i 2) (n 0))
  (if (prime? i)
      (if (= n 10000)
          i
          (loop (+ i 1) (+ n 1)))
      (loop (+ i 1) n)))

判断质数，后面会遇到更加丰富的用法的。

* Problem 8

import operator
s= ...
print max(reduce(operator.mul,map(int,s[i:i+5])) for i in xrange(len(s)-4))

又是暴力...题目字面的意思...不说什么了...

* Problem 9

a, b, c = 200, 375, 425

我才不告诉人家我是慢慢试出来的呢...

* Problem 10

m = 2000000
s = [True] * m
s[0] = False
s[1] = False
for i in xrange(2,m):
    if not s[i]:
        continue
    j = 2
    while True :
        k = i * j
        if k >= m:
            break
        s[k] = False
        j+=1
print sum(i for i,v in enumerate(s) if v)

传说中的划杠杠法，终于没有出现尾递归...

* Problem 11

from operator import mul
x = [
...
]
def s(r1,r2,d):
    return max(reduce(mul,[x[i+d[0]*n][j+d[1]*n] for n in range(4)]) for i in r1 for j in r2)
print max(
    s(xrange(0,20-3),xrange(0,20-0),(+1,+0)),
    s(xrange(0,20-0),xrange(0,20-3),(+0,+1)),
    s(xrange(0,20-3),xrange(0,20-3),(+1,+1)),
    s(xrange(0,20-3),xrange(0+3,20),(+1,-1)),
    )

字符串数据源直接拿正则表达式处理了，然后是幸好没差点把尝试的情况和范围弄错掉。

* Problem 12

(define (factor x)
  (let loop ((x x) (i 2) (n 1) (r '()))
    (if (> i (sqrt x))
        (cons x r)
        (if (zero? (remainder x i))
            (loop (/ x i) i (+ n 1) (cons i r))
            (loop x (+ i 1) n r)))))
(define (factor-exp x)
  (let ((x (factor x)))
    (let loop ((a (cdr x))(b '())(c (car x))(d 1))
      (if (null? a)
          (cons d b)
          (if (not (= (car a) c))
              (loop (cdr a) (cons d b) (car a) 1)
              (loop (cdr a) b c (+ d 1)))))))
(define (factor-num x)
  ;(assert (> x 1))
  (apply * (map (lambda (x) (+ x 1)) (factor-exp x))))
(let loop ((s 0)(i 1))
  (if (> (factor-num s) 500)
      s
      (loop (+ s i) (+ i 1))))

这题暴力的话效率实在不够，只好手疼地用排列组合的知识来优化一下了。

* Problem 13

x=[
...
]
print str(sum(x))[:10]

性能居然够，那我就不手疼了，不然从左往右算？根据100个n位数的和的位数肯定小于(n+3)来着...Java也有自带类似的库的说。

* Problem 14

m = 1000000
c = {}
c[1]=1
def n(x):
    if x in c:
        return c[x]
    if x%2==0:
        nx = x/2
    else:
        nx = 3*x+1
    v = n(nx)+1
    c[nx] = v
    return v
mx=0
mv=1
for i in xrange(1,m):
    t = n(i)
    if t>mx:
        mx, mv = t, i
print mv

代码写丑了我会直接说出来吗...这题超过边界不记忆的话估计性能也够了。

* Problem 15

load(functs);
combination(20+20,20);

这貌似是学排列组合的例题，那么就数学软件Maxima应对吧。
或者从左上角一步一步往右下角慢慢迭代推过去也是可以的。

* Problem 16

print sum(map(int,str(2**1000)))

依然高精度，性能没有问题就不优化了。

* Problem 17

(define (en n)
  ;(assert (<= 1 n 1000))
  (cond
    ((zero? n) "")
    ((= n 1000) "onethousand")
    ((zero? (remainder n 100))
     (string-append (en (quotient n 100)) "hundred"))
    ((< 100 n 1000)
     (string-append (en (quotient n 100)) "hundredand" (en (remainder n 100))))
    ((< 19 n 100)
     (string-append (vector-ref #("ten" "twenty" "thirty" "forty" "fifty" "sixty" "seventy" "eighty" "ninety") (- (quotient n 10) 1)) (en (remainder n 10))))
    ((< n 20)
     (vector-ref #("one" "two" "three" "four" "five" "six" "seven" "eight" "nine" "ten" "eleven" "twelve" "thirteen" "fourteen" "fifteen" "sixteen" "seventeen" "eighteen" "nineteen") (- n 1)))))
(do ((i 1 (+ i 1))(s 0 (+ s (string-length (en i)) )))((= i 1001) s))

我这里zero?的处理不大合代码的逻辑，只是在题目的范围内还不会影响到结果。不过这题其实扳手指算一个总数出来也就可以了。

* Problem 18

x = [
...
]
m = [[0]*i for i in range(1,len(x)+1)]
m[0][0]=x[0][0]
for i in range(len(x)-1):
    for j in range(i+1):
        print i, j
        t = m[i][j]+x[i+1][j]
        if m[i+1][j] < t:
            m[i+1][j] = t
        m[i+1][j+1] = m[i][j]+x[i+1][j+1]
print max(m[len(m)-1])

传统的DP题终于出现了呵，这里是手工用正则表达式获得数据后按照套路来处理。

* Problem 19

def getDaysOfMouth(yyyy,mm):
    _daysOfMouth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    def isLeap(y):
        return y%4==0 and y%400!=0
    return 29 if mm==1 and isLeap(yyyy) else _daysOfMouth[mm]
daysAfter = 0
daysOfSunday = 0
mod = sum(getDaysOfMouth(1990,m) for m in range(12)) % 7
for y in range(1901,2001):
    for m in range(12):
        if daysAfter%7==6 - mod :
            daysOfSunday += 1
        daysAfter += getDaysOfMouth(y,m)
print daysOfSunday

数字中用来好多魔法，千万小心别出Bug，这算法是代替手工操作的，需要小心和测试。话说一些语言的标准库里可是有Date和Calendar，而后者中能获取到星期相关的信息的。

* Problem 20

from math import factorial
print sum(map(int,str(factorial(100))))

高精度计算，拆位处可不涉及字符串，不过解释语言内置方法实现的比自己写的会效率好一些。

* Problem 21

c={}
def d(x):
    if x in c:
        return c[x]
    else:
        d = sum(i for i in xrange(1,x) if x%i==0)
        c[x] = d
        return d
s = 0
for i in range(1,10000):
    a = i
    b = d(a)
    if d(b)==a and a!=b:
        s += a
print s

前面某题做过求因数的优化了，这题暴力的话勉强够了。从实际命中的情况看，缓存用定长10000的数组对这题其实效率更好。

* Problem 22

f = open("names.txt","r")
l = f.readline()
c = l.split(",")
c.sort()
def s(x):
    return sum(ord(i)-ord('A')+1 for i in x[1:-1])
print sum(s(v)*i for i,v in enumerate(c,start=1))

第六行的里把引号过滤掉就目的达到，话说这次终于在IO方面没法省事直接内嵌数据了。

* Problem 23

m = 28123
def d(x):
    return sum(i for i in xrange(1,x) if x%i==0)
a = {}
for i in xrange(1,m):
    if d(i) > i:
        a[i] = True
def c(x):
    return any(True for i in xrange(1,x) if i in a and x-i in a)
print sum(i for i in xrange(1,m+1) if not c(i))

虽然结果对，但是像目前这样不优化的肯定超时。用Py2.7的特性可以把生产字典写为单行，可以省掉5~7th行。
另外用列表类型要注意Py的下标为负数也能取到元素，别弄错了。列表的话就写作“... a = [None]*m ... if a[i] and a[x-i] ... ”。

* Problem 24

from itertools import permutations,islice
print "".join(map(str,[i for i in islice(permutations(range(10)),999999,1000000)][0]))

某种意义的开挂，不过Py2的itertools代码明显不如Py3美观。优化的方法是位数从左到右计算可能的个数，排列的情况其实只用阶乘，然后手工调试出结果即可。

* Problem 25

(let loop ((a 1) (b 1) (n 1))
  (if (= (string-length (number->string a)) 1000)
      n
      (loop b (+ a b) (+ n 1))))

在Scheme里用尾递归表示迭代是相当好用的，有named-let和do两个宏可用。

* Problem 26

from itertools import count
def c(x):
    c = {}
    r = 1
    for i in count(0):
        t = r%x
        if t==0:
            return 0
        elif t in c:
            return i-c[r%x]
        else:
            c[t] = i
        r*=10
m, v = 0, 0
for i in range(1,1000):
    t = c(i)
    if t>v:
        m ,v = i ,t
print m

这里是模拟手工操作，不过貌似有数学推导式来着。

* Problem 27

from math import *
from itertools import *
c = {}
def p(x):
    if x in c:
        return c[x]
    else:
        p = (x==2 or
             (x>2 and x%2!=0 and
              all(x%i!=0 for i in xrange(3,int(sqrt(x))+1,2))))
        c[x] = p
        return p
def q(n,a,b):
    return n**2+a*n+b
m, v = (), 0
for a in xrange(-999,1000):
    for b in xrange(-999,1000):
        for x in count(0):
            if not p(q(x,a,b)):
                if x-1>v:
                    m,v=(a,b),x-1
                break
print m[0]*m[1]

怎么就没有带参数的max函数呢，不然派生一个Comparable类型出来更加累赘啊。

* Problem 28

size = 1001
def delta(x):
    return (x+2)**2-x**2
s,d = 1,1
for i in xrange(1,size,2):
    d += delta(i)
    s += d
print s*4-sum(range(2,size,2))*(1+2+3)-4+1

先算了右上角，然后扩展到四个角。其中用到的递推式（4~7th中的d）貌似可以化简。

* Problem 29

print len(set(a**b for a in xrange(2,101) for b in xrange(2,101)))

唉，又暴力了，居然性能还行，那就不用优化了。不用大数运算的话，其实重复项也只是底数呈指数关系的项。注意指数如果展开的话，不能用浮点数运算。

* Problem 30

from math import *
from operator import pow
from itertools import *
w = 0
for i in count(1):
    if 9**5*i < 10**i:
        w = i
        break
def t():
    for digits in product(range(10),repeat=w):
        m = reduce(lambda x,y:x*10+y,digits)
        if m!=0 and m!=1 and m==sum(i**5 for i in digits):
            yield m
print sum(t())

当位数达到一定大小后，和的最大值就已经满足不了位数了。由于多项式函数==o(指数函数) ，从而可以求出全部解。

* Problem 31

from itertools import *
r = 200
p = [1,2,5,10,20,50,100,200]
n = 0
def t(s,pc):
    if pc>=len(p):
        return
    for i in count(0):
        l = s+i*p[pc]
        if l == r:
            global n
            n+=1
        if l >= r:
            return
        t(l,pc+1)
t(0,0)
print n

这次代码真的写丑了，不过运行效果良好。

* Problem 32

from itertools import *
digits2int = lambda ds: reduce(lambda h,l:10*h+l,ds)
def enum():
    for i in permutations(range(1,10)):
        for j in range(1,9):
            for k in range(j+1,9):
                if not (j-1)+(k-j-1)+1 <= k < (j-1)+(k-j-1)+3:
                    continue
                a,b,c = map(digits2int,(i[0:j],i[j:k],i[k:9]))
                if a*b==c:
                    yield c
print sum(set(enum()))

目前性能不行，如果把permutations展开写的话，可能可以免去一些方向的尝试。

* Problem 33

from functools import *
from itertools import *
from operator import *
from fractions import *
print apply(Fraction,reduce(partial(map,mul),((10*a+b,10*b+c) for a,b,c in product(range(1,10), repeat=3) if a<c and (10*a+b)*c==(10*b+c)*a))).denominator

好吧我承认这题很简单，但是我一开始愣是没明白题目要做什么。约分可以请欧几里德来算得最大公约数做除数，其他没什么好说的。

* Problem 34

from math import *
print sum(x for x in xrange(3,10**6) if sum(map(factorial,map(int,str(x))))==x)

以每一位都是9的情况和函数间的高阶关系来考虑上限，然后暴力。上限的位数是最大使得“factorial(9)*i>=10**i-1”成立的正整数。顺带说些Py带的若干函数是C实现的，性能比手工写要好很多。

* Problem 35

from math import *
from itertools import *
m = 10**6
s = [False,True] * (m/2)
s[0:3] = False, False, True
for i in xrange(3,m,2):
    if not s[i]:
        continue
    j = 2
    while True :
        k = i * j
        if k >= m:
            break
        s[k] = False
        j+=1
def primep(x):
    return s[x]
def rotations(x):
    s = str(x)
    return [s[i:len(s)]+s[0:i] for i in range(len(s))]
def cpp(x):
    return all(map(
        lambda t:primep(int("".join(t))),rotations(x)))
print len([True for i,v in enumerate(s) if v and cpp(i)])

一开始的时候每没意识到要优化，后来就好多了。有点等价代码的草稿，被我擦掉了。

* Problem 36

pp = lambda x:(lambda s:s==s[::-1])(str(x))
d2b = lambda x:"{:b}".format(x)
print sum(i for i in xrange(1,10**6) if pp(i) and pp(d2b(i)))

按照题目的意思来就可以了，没有遇到很糟糕的性能。

* Problem 37

from math import *
from itertools import *
from functools import *
m = 10**6
s = [False,True] * (m/2)
s[0:3] = False, False, True
for i in xrange(3,m,2):
    if not s[i]:
        continue
    j = 2
    while True :
        k = i * j
        if k >= m:
            break
        s[k] = False
        j+=1
primep = lambda x:s[x]
truncate = lambda x:(lambda s:
            imap(partial(map,int),
             ((s[:i+1],s[i:]) for i in range(len(s)))))(str(x))
tpp = lambda x:all(primep(a) and primep(b) for a,b in truncate(x))
t = [i for i in xrange(10,m) if tpp(i)]
print len(t)
print sum(t)

题目里说十一个，所以就算了这么一些，得到了answer。代码中用到了惰性求值，不然性能会很糟糕，避免了列表被完全展开。虽然没有编译时优化惰性求值有多余的开销，不过不必要的计算才是这里最影响性能的东西。

* Problem 38

from itertools import *
from functools import *
def t(x):
    "int->int"
    s = ""
    for i in count(start=1):
        s += str(x*i)
        if '0' in s:
            return 0
        if 9==len(s)==len(set(s)):
            return int(s)
        elif 9<=len(s):
            return 0
print max(t(reduce(lambda a,b:a*10+b,j,9))
       for i in range(0,4) for j in permutations(range(1,9),i))

需要尝试位数小于5的数，并注意没有零出现。

* Problem 39

print(reduce((lambda f,s:f if f[1]>s[1] else s),((m,len([a for a in xrange(1,m/3) for b in xrange(a,(m-a)/2) for c in (m-a-b,) if b-a<c<a+b and a**2+b**2==c**2])) for m in xrange(1001)))[0])

性能啊性能啊

* Problem 40

from operator import *
from itertools import *
from functools import *
print reduce(mul,(int(v) for i,v in islice(enumerate(chain.from_iterable(imap(str,count()))),1000001) if i in (1,10,100,1000,10000,100000,1000000)))

边迭代边判断即可。

* Problem 41

from math import *
from itertools import *
primep = lambda x:(x==2 or (x>2 and x%2!=0 and all(x%i!=0 for i in xrange(3,int(sqrt(x))+1,2))))
print max(k for i in range(1,10) for j in permutations(range(1,i+1),i) for k in (reduce(lambda x,y:10*x+y,j,0),) if primep(k))

就是题目字面的意思。

* Problem 42

c = (open("words.txt","r").readline()[1:-1]).split('","')
v = lambda x:sum(ord(i)-ord('A')+1 for i in x)
t = lambda n:(n*(n+1))/2
ts = [1]
def tp(x):
    while ts[-1]<x:
        ts.append(t(len(ts)+1))
    return x in ts
print len([i for i in c if tp(v(i))])

还有明显的优化空间，不过没感觉到性能瓶颈。

* Problem 43

from itertools import *
digits2int = lambda it:reduce(lambda a,b:10*a+b,it,0)
satisfy = lambda x:all(imap(lambda a,b:a%b==0,(digits2int(x[j:j+3]) for j in xrange(1,8)),(2,3,5,7,11,13,17)))
print sum(digits2int(i) for i in permutations(range(10)) if satisfy(i))

来多说说一些关于permutations函数的话题吧这里，因为最近用得较多了。话说STL里面也有同样作用的函数提供，而自己实现的话可以简单地利用树的遍历。

* Problem 44

from math import *
#from bisect import *
from itertools import *
p = lambda n:n*(3*n-1)/2
#ps = [p(1)]
#def pp(x):
# while ps[-1]<x:ps.append(p(len(ps)+1))
# return (lambda i:i<len(ps) and ps[i]==x)(bisect_left(ps,x))
pp = lambda x:((1+sqrt(1+24*x))/6)%1==0
print list(islice((p(i)-p(j) for i in count(1) for j in xrange(1,i) if (lambda x,y:pp(x+y) and pp(x-y))(p(i),p(j))),1))[0]

注释掉的代码是被重写了的，用了一元二次方程的求根公式（结合函数图形看，其实这里用错了，还没来及修改）。不用bin-search用hash-set貌似也行。

* Problem 45

(let loop ((i 286) (j 166) (k 144))
  (let ((t (* i (+ i 1) 1/2))
        (p (* j (- (* 3 j) 1) 1/2))
        (h (* k (- (* 2 k) 1))))
    (cond ((= t p h) t)
          ((<= t (min p h)) (loop (+ i 1) j k))
          ((<= p (min t h)) (loop i (+ j 1) k))
          ((<= h (min t p)) (loop i j (+ k 1)))
          (else #f))))

话说好久没用Scheme来写写了。

* Problem 46

from math import *
from itertools import *
oddp = lambda x:x%2!=0
primep = lambda x:(x==2 or (x>2 and x%2!=0 and all(x%i!=0 for i in xrange(3,int(sqrt(x))+1,2))))
conjecturep = lambda x:any(i for i in xrange(2,x) if primep(i) and sqrt((x-i)*.5)%1==0)
failp = lambda x:oddp(x) and not primep(x) and not conjecturep(x)
for i in count(4):
    if failp(i):
        print i
        break
#from functools import *
#from operator import *
#print list(islice(ifilter(failp,count(4)),1))[0]

直接算吧，然后直接答案取走。这里注释掉的是最后几行另一种运行很慢的写法。

* Problem 47

(define (factor x)
  (let loop ((x x) (i 2) (r '()))
    (if (> i (sqrt x))
        (cons x r)
        (if (zero? (remainder x i))
            (loop (/ x i) i (cons i r))
            (loop x (+ i 1) r)))))
(define (unique-sroted-list x)
  (define (list-not-starts-with xs x)
    (cond ((null? xs) '())
          ((eq? (car xs) x)
           (list-not-starts-with (cdr xs) x))
          (else xs)))
  (if (null? x) '()
      (cons (car x)
            (unique-sroted-list
             (list-not-starts-with (cdr x) (car x))))))
(define (number-of-distinct-primes x)
  (length (unique-sroted-list (factor x))))
(do ((n 1 (+ n 1))
     (a 0 (number-of-distinct-primes n))
     (b 0 (if (= a 4) (+ b 1) 0)))
  ((= b 4)(- n 4 2)))

现在越来越觉得Scheme代码想撮面团拧麻花的样子。理解清楚题意才是最重要的，然后运用对应的知识即可。

* Problem 48

last_ten_digits = lambda x:str(x) if x<10**11 else str(x)[-10:]
print last_ten_digits(sum(int(last_ten_digits(i**i)) for i in xrange(1,1001)))

求指数过程中只保留10位即可，可以获得更好的性能。以Python的性能还是算了，内置函数和手写落差太大，还是不修改了。

* Problem 49

from math import sqrt
print (lambda c:(lambda p:[''.join(map(str,(i,j,k))) for a in xrange(len(c)) for b in xrange(a+1,len(c)) for i,j,k in [(c[a],c[b],2*c[b]-c[a])] if k>j and k in p and sorted(str(i))==sorted(str(j))==sorted(str(k))])(set(c)))(filter(lambda x:(x==2 or (x>2 and x%2!=0 and all(x%i!=0 for i in xrange(3,int(sqrt(x))+1,2)))),range(1000,10000)))

把for语句压缩为单行代码后的产物，“import”那行不算数。

* Problem 50

m = 10**6
def prime(m):
    s = [False,True] * (m/2)
    s[0:3] = False, False, True
    for i in xrange(3,m,2):
        if not s[i]:
            continue
        j = 2
        while True :
            k = i * j
            if k >= m:
                break
            s[k] = False
            j+=1
    primep = lambda x:s[x]
    primes = tuple(i for i in xrange(m) if primep(i))
    return primep,primes
primep, primes = prime(m)
mr = 0
r = 0
for i in xrange(len(primes)):
    su = sum(primes[i:i+22])
    for j in xrange(i+22,len(primes)):
        lp = j-i+1
        su += primes[j]
        if su>=m:
            break
        if primep(su):
            if lp>mr:
                mr,r = lp,su
print r

一开始不专心弄复杂题目意思了，造成了不必要的浪费，本来是很简单的问题。这次未用函数式风格，话说控制不好状态的变化很容易出错的说。

* Level 1

前50题就是这些了，这是些算全部题目的 Level One 部分。
撒花，撒花。
接下来朝着别的目标前进吧，就先暂且做这几道题作为练手和娱乐了。

其实吧PE的前50道题目还是比较浅显的，因为涉及到的数据结构和数学上的知识点不是很多。
题目差不多都是根据题目的意思直接翻译为代码，把程序语言作为一个强大的计算器来使用。
所以在这前50道题里，更关注的是对机算工具的使用，而不是问题本身的经验积累。
那么其中有什么积极的价值呢，我想，或多或少总是有的吧，我只能这么说了。
上面的代码太偷懒了，不知道这种懒惰时候会让自己对正常向的使用态度有副作用呢。
好害怕...
其他的就不多说了，收工。

----
此外Problem 8试了试common lisp，不过代码没写漂亮，所以上面整理时被我略去了。
<blockquote>(defparameter s ...)
(reduce #'max (loop for i from 1 to (- (length s) 5) collect (reduce #'* (map 'list #'(lambda (x) (parse-integer (string x))) (subseq s i (+ i 5))))))</blockquote>

如果想临时试试代码的话可以用用codepad.org或者ideone.com。

----
最初在uushare发贴说一天一题，然后在QQ空间上整理出了上文，然后又把纯文字版备份于此（可惜格式图片都丢失了）。

【挖一挖】WQX和单文件小游戏

2011-08-27T16:35:00.007+08:00

作为可看作是集合了电子辞典，编程计算器，个人信息助理以及互动多媒体终端的这样一个东西，上面看起来还是有些有趣的东西的。还曾有一个写了一半的文字来记录以下从中能够想到的用法。

出发点是下面两个链接，然后来转一些片段：
http://www.emsky.net/bbs
http://javatar.iteye.com/category/7525

RPG引擎原理讲解！作者：杨芹勍[Coolsoft(R)]
------------------------------------------------------------------------------------------------------
当我在发布“动物园历险记”之前，我在许多文曲星网站都发了游戏的剧情、内容和规模预告的帖子。可想而知，当你在没有玩这个游戏的时候肯定也不会相信GVBasic能处理那么复杂的剧情。和大家一样，那些回帖的人都说不可能有那么强的引擎能撑得住。但是当游戏发布时……这主要是归功于我花了一个星期才研究出来的“对象处理思想”。这个思想的用途是处理RPG剧情的前后关系。首先试用在《逃离校园》上，然后是《医院惊魂》，最后才与《动物园历险记》玩美地结合。如果想知道这个思想的具体函意，请往下看。
这个思想的灵感主要是来源于PC上许多编程软件的“面象对象”的思想。它可以把一个窗体、一个控件、一段代码等都看成是一个对象，每个对象都有自己的属性、事件和方法。一个对象可以激活另外一个对象，同时也可以终止一个对象。同样，文曲星屏幕上任何一个图形都可以看成是一个对象，这就是所谓的“对象处理思想”。当然我们并不是把屏幕上每个图形都看成是一个对象，而是处理一些和剧情有关的图形，那些图形所包含的信息就是我们要处理的剧情。我们可以把信息保存在数据文件里面，然后在主程序里面处理它们，这样就节省掉很多主程序的字节。
1、剧情信息格式
大家在地图安装文件“ZOOSC.BAS”里面是不是发现许多形如“ABTBCMBSA”这种奇怪的字符串？这就是地图上面的对象所包含的信息。下面让我们来详细分析一下这些信息所保存的格式：
首先，我们令A等于1，B等于2……Z等于26等等（用ASCII码表示就是CHR$(T+64)，T=1,2,3……），为什么要那么做呢？是因为由于RPG包含的元素很多，如果这些元素大于或等于10的话处理起来会很麻烦，且保存起来很不方便。等一下你就会理解啦！
然后来看一下剧情信息包含的元素和保存的格式：
屏幕X坐标屏幕Y坐标条件条件值字幕处理1 处理值1 处理2 处理值2
一共有9个元素，每个元素占位一个字节。
“屏幕Y坐标”就是屏幕上的1～5行，“X坐标”与我们平常习惯的不同，它算的是汉字的相对坐标，如果在屏幕上有一行字“一二三四”，那么“三”的实际X坐标是5，相对坐标是3。
“条件”就是你要实现这个剧情需要的条件识别符，如用“L”代表等级、“S”代表道具。“条件值”就是条件所对应的值，如多少等级、什么道具。如“SA”表示条件为必须要有第一个道具（“A”代表“1”！）剧情才能继续。
“字幕”就是你完成某个条件以后屏幕上弹出的对话字幕。通常RPG有很多人物对话，由于“字幕”这个元素只占一格，如果用1、2、3来表示那么只能有9条对话。那怎么行啊？所以我们可以用A、B、C～~代替。“~”的ASCII码值为126，那么从“A”～“~”中间有64个空位，比9大多啦！现在你可以理解为什么用这些东西代替了吧！
“处理”和“条件”大同小异，只不过“处理”是得到什么东西而不是条件那样需要什么东西罢了。
注意：在这些元素中不是每个元素都会用到，如果不用的元素请用“@”代替，因为“@”代替“0”。
下面让我们来看看一些常规的“条件”和“处理”分别对应的识别码。
条件：
H：有某道具；
L：达到多少等级；
T：几点钟；
Z：需要某特殊剧情；
N：不需要某特殊剧情。
处理：
C：跳转地图；
M：遇到某敌人；
S：得到某道具；
Z：处理某特殊剧情。
什么叫特殊剧情呢？特殊剧情就是指不改变玩家状态（道具、时间、等级），而只改变游戏进度的剧情。如在动物园历险记中，一开始有个小孩，你必须请教他才能钻狗洞进动物园。而你请教那个小孩，没有改变你任何状态，它只会给一个特殊变量附值，表明已经问过了。然后到狗洞前信息会引导程序去判断这个特殊变量的值，看看你是否问过小孩。如果小孩对应的处理信息为ZA，那么狗洞对应的条件信息为ZA。如果你想搞一个问过小孩就不能进狗洞，那么狗洞对应的条件信息应改为NA。
大家在玩动物园的时候肯定会有进某所房子或出某所房子的时候。这就是跳转语句起的作用。每一个跳转值都对应一个跳转字符串，这个等一下再说。
下面我们来进行举例分析：
在屏幕的第一行、第三格有一个图形，碰到它会遇到一号敌人，会出现第二个对话，打赢了得到第三个道具，怎么表示？很简单：CA@@BMASC。注意，由于没有条件，条件那两栏用@填充。
如果有某种道具时显示一段字幕，没有时显示另外一段字幕时怎么表示？这时，我们应该把符合条件的字幕放在“处理值2”栏目里面，把不符合条件的字幕放在“字幕”栏目里面。打个比方，在屏幕上第四行、第五格有一个图案，碰它需要有第二个道具，如果有则显示第二段对话，且得到三号道具，没有则显示第三段对话：DESBCSC@B。注意，如果使用了这种信息的格式就不能使用处理元素2。
如果一幅地图里面有多个图形关系到剧情，那么可以把这些信息连起来，如“AB@@CCM@@CD@@DSA@@”，表示在地二行第一格和第四行的第三格都有剧情信息。注意，每一幅地图中所包含剧情信息的图形不能超过7个，否则引擎程序会出错！
2、跳转信息格式：
好了，了解了剧情信息格式之后，让我们来了解一下前面提到的“跳转地图”的含意。动物园一共有9*10幅地图。底下两行存放的是室内的地图，上面则存放的是外景地图：
──门─│┌─植─
─猴└─停│┌┬虎
┌┴─熊│└饲└┐
│游┌─水┐─出┘
└┤│鸟─┤┌─┐
鳄│卖┬─│└┐厕
│桥─┤象┴┐入│
医──饭──办─┘
＊＊＊＊＊＊＊＊＊
＊＊＊＊＊＊＊＊＊
同样，我们把整个地图看成是一个大集合，每一幅地图看成是一个元素。比如说，把“门”这幅地图看成是一个元素，它在大地图里的第二行的第三格，一行一行地数，每一行有九格，那么它在集合里为第十二个元素，再取元素号+32的ASCII码值（注：这里有别于前面的+64，因为RPG地图很多，127-64幅地图远远不够），再加上需要跳转到的那幅地图的屏幕X、Y轴坐标就可以啦！如“ABC”代表第33幅（“A”对应65号ASCII码，65-32=33）地图屏幕上第三行的第二格。由于RPG的跳转信息很多，所以我们可以在安装程序中拿一个字符串一个接一个地保存跳转信息，把第一个用“A”代替……如：“ACDBEFJIC”为跳转信息字符串，那么第二个跳转信息为“BEF”，在剧情信息中可以用处理值“CB”来实现。
实例请叁看ZOOSC.BAS中第140～150行。
3、地图的制作与显示：
不止十个网友问我：为什么动物园的地图显示得那么快？而且还是在助手里面。答案是我在安装时就生成好了地图保存到随机文件中，玩的时候马上读出来整屏显示，浪费了安装时间而节约了游戏时间。看看ZOOSC.BAS的第170行到180行，这里保存了所有地图要用到的图形的总集合，把地一个图形命名为“A”……再在底下的数据中写下“ABSEHD...”之类的50（文曲星每一屏只能显示50个图形）个字节就可以了。如何让地图数据和剧情信息相结合呢？？那么你就在地图数据上后面加一个“,”号，在加上剧情信息就可以了。如：
DATA "ASCDVDFEFGGGGBVVVFFFCCDAAAAACDFVGGDAAAAABBBFFAASAQ","AB@@CSA@@"
注意，如果一幅地图上没有一个图形和剧情有关，那么请用“@”代替剧情信息，引擎程序会自动识别，千万不能空着！
由于我们是把地图先生成好再用随机文件形式写进文件（详见ZOOSC.BAS的第250行到第300行），所以在主程序中我们可以用随机文件的形式打开，令其长度为100，然后100个字地读取数据，在用余兄的批量法显示到屏幕上。由于NC系列和PC2ka系列不支持批量法，你可以用以下方法显示地图：
假定MP$为从地图文件读取的长度为100的字符串变量。
LOCATE 1,1:PRINT LEFT$(MP$,99);
POKE 803,ASC(MID$(MP$,100))
PRINT ;
万事大吉！这个方法对所有机型都试用，只不过速度比批量法稍微慢一点。
4、人物对话保存方法：
在安装程序ZOOSA.BAS和ZOOSB.BAS中，大多数保存的都是人物对话，人物对话可以用DATA来保存和READ读取，详见ZOOSA.BAS。如果想实现两个人的对话，请在第一个人的话后加上一个“*”号，然后再加上第二个人的话。这样，引擎会在显示玩第一句话时停着，再显示下一句话。如果你觉得如果对话写不满的话，你可以重新写一段对话，然后在上一句对话的末尾加上这一句对话的索引号（A、B、C……），引擎会分析并且跳到这段对话来。
5、游戏引擎详解：
激动人心的时刻到了！大家打好前面关于数据剧情方面的基础后，引擎方面就不成问题了！如果你想用我这个引擎发布RPG，你只要写数据文件，只改一点点引擎就可以做出很个性化的RPG，大家看好了！
在这里，我要以最稳定的“动物园历险记”的引擎ZOO.BAS做为叁考，请大家准备好。
打开ZOO.BAS，跳到第9510行，我们先看看变量的含义。
S$～屏幕内容字符串，用批送法声明；
MS$～剧情信息分析变量，用于玩家碰屏幕上的图形时存放当前图形所包含的剧情，长度为7，不包括X、Y坐标；
NG$()～游戏介绍字符串组，用于新游戏时介绍游戏起因；
WD$()～道具名称字符串组；
WI$()～道具图标字符串组；
DD$()～敌人名称字符串组；
DI$()～敌人图标字符串组；
S$()～人物对话（就是前面说的字幕）字符串组；
FN$()～剧情信息字符串组，引擎开始时会读取数据文件放到此字符串组中；
DD()～敌人生死状态数组，0代表生，1代表死；
MT()～玩家道具状态数组，0代表未找到，1代表未使用，2代表已使用；
MZ()～游戏特殊剧情处理数组，前面讲过的，如果符合条件就把这个数组里的某个变量存为1，然后由程序来读取该变量是否为1；
MX：玩家在屏幕上的相对X坐标；
MY：玩家在屏幕上的Y坐标；
MP：玩家所在地图为地图集合里的哪一幅地图；
MLV：玩家等级；
MEX：玩家经验值；
MB：玩家血量。
……
重要的处理代码对应的行号：
20：按键响应子程序；
150：人物对话（字幕）显示子程序；
400：道具列表及道具的选择和使用子程序；
2500：遇敌战斗和升级的子程序；
4600：游戏通关画面及评论代码；
5000：游戏开始标志；
5110～5240：玩家移动控制代码；
5230：随机遇敌代码；
5250～5320：剧情信分离代码，它可以把玩家人物碰到的图形的剧情信息分离出来，由于玩家碰时以确定了XY坐标，所以分离出的信息不含XY坐标元素；
5330～5720：剧情信息分析代码，用于分析我们前面提到的具有相同格式的RPG剧情信息；
5840：地图的读取以及显示代码；
5880：系统菜单选项代码。
好了，下面就让我们来分析一下这些代码中的重要的代码。这可能会让你很晕，但是，为了做出好玩的RPG，晕一些也无所谓了:P。
先来看一下剧情分离代码，从5250行开始。先了解一下原理。由于每一幅地图对应相应的剧情信息（包括“@”空信息）保存在数据文件里，进入引擎一开始会读取它，且每一幅地图的剧情信息用FN$()这个字符串组来保存，由于每一幅地图对应相应的FN$，所以很容易可知道玩家所在地图的FN$，再加以分析就可以了。引擎不是玩家每走一步都判断一次，这样会慢得让你发晕（像天之剑一样），而是如果玩家碰到了障碍物时才读取相应的信息判断。那么如何从该地图的剧情信息中分离出该障碍物所对应的剧情呢？前面我们讲过剧情信息保存的格式，为9个字节，一个连一个地组成该地图包括的剧情。这样，我们可以先读取FN$()前面两个XY的值，看看与玩家所在XY坐标是否相符，如果不相符则跳过这个剧情信息再读取下一个信息的XY，直到相符为止。如果读玩了整段信息还没有找到与玩家XY相同的坐标，BEEP，表示玩家所碰到的图形与剧情无关。
下面来看看代码：
5250 FOR T=1 TO LEN(FN$(MP)) STEP 9
5260 IF ASC(MID$(FN$(MP),T))-64<>TX THEN 5280
5270 IF ASC(MID$(FN$(MP),T+1))-64=TY THEN LSET MS$=MID$(FN$(MP),T+2,7):5300
5280 NEXT
5290 GOTO 5170
5300 TJD=ASC(LEFT$(MS$,1)):TJ=ASC(MID$(MS$,2))-64:SH=ASC(MID$(MS$,3))-64
5310 CLD1=ASC(MID$(MS$,4,1)):CL1=ASC(MID$(MS$,5))-64
5320 CLD2=ASC(MID$(MS$,6,1)):CL2=ASC(MID$(MS$,7))-64
5210～5220行为判断信息中的XY值与玩家所碰的XY是否相等，等的话给临时信息字符串MS$赋除了XY信息之外的其它7个字节信息值，注意这里要用到“LSET”。原因是你用常规方法给一个字符串重新赋值后，GVB会重新分配缓冲区保存且不清除原来的值，多次之后会影响到其它固定的变量的缓冲区，导致其它变量的变化。就像“逃离校园”和“医院惊魂”那样玩久了会出乱码一样。而用LSET可以不移动缓充区直接在原来的缓冲区写。
下面来介绍一下5300行到5320行变量的意思：
TJD～条件标识对应的ASC数值；
TJ～条件值；
SH～字幕值；
CLD1～第一个处理标识对应的ASC值；
CL1～第一个处理值……
注意：在动物园的测试版中，标识符用字符串变量代替，在正式版改为用数变量代替，原因以经讲过了，就是为了防止缓冲区溢出。
从5330行开始就是剧情分析代码了：
5300：分析特殊剧情条件；
5370：分析等级条件；
5375：分析需要某道具的条件；
5420：分析时间条件（如在动物园中不到时间不能进水族馆）；
5430：分析没有某特殊剧情的条件……
只要你把标识值变成对应的ASCII码，你就可以知道是什麽意思啦！
那麽进小卖部、芝麻开门怎麽写呢？你只要先把这些代码写入引擎，在用特殊的标识符写进剧情就可以了。如5520～5560行。
从5590～5650行为跳转地图的处理代码，注意读取跳转地图信息时为3个字3个字地读出来（5600行），在加以分析。
让我们再来看看引擎刚开始所需要读取的东西，看9500～9640行。
9530：声明批送法和向缓冲区申请7个字节的剧情分离变量MS$；
9540～9545：声明变量；
9550～9630：读取游戏相关信息，道具图标、道具名字、敌人图标、敌人名字、游戏介绍、人物对话、地头蛇对话、芝麻开门、剧情信息、跳转地图信息。
读取这些东西按照先後顺序附与标识值，如一号道具的图标为WI$(1)。
9640行为用随机方式打开地图文件，因为一个屏幕可以放下100个字符，所以可以令它的读取长度为100，然後100个字100个字地读取任何地图显示到屏幕上，这就是随机文件的好处。这个文件不要关闭，便於可以在程序里面随时读取。

RPG“伏魔剑”源程序
0 :
1 GRAPH
2 DIM WZ(5,21),DM$(4,19):X(6)=3:Y(6)=19
6 MO=100 :GOSUB 4101: GOTO 30
10 IF T$="b" THEN T=1:19
11 IF T$="n" THEN T=2:19
12 IF T$="m" THEN T=3:19
13 IF T$="g" THEN T=4:19
14 IF T$="h" THEN T=5:19
15 IF T$="j" THEN T=6:19
16 T=10
19 RETURN
30 LOCATE 1,1:PRINT " 《伏魔英雄传》"," 超经典RPG互动游戏"," V1.2增强版"
40 LOCATE 4,4:PRINT " 正在读取数据";
50 BOX 40,70,120,73,0,2
54 OPEN "FMYXZDATA" FOR INPUT AS #1
55 INPUT #1,NDFL$: FOR A=1 TO 10:INPUT #1,AE$(A):B=0.808*A+41:LINE B,70,B,73:NEXT
56 FOR A=1 TO 6:INPUT #1,YPM$(A):C=0.808*A+B:LINE C,70,C,73:NEXT :INPUT #1,YDTX$
58 FOR A=1 TO 2:INPUT #1,MAP$(A):B=0.808*A+C:LINE B,70,B,73:NEXT
60 FOR A=1 TO 4:INPUT #1,CD$(A):C=0.808*A+B:LINE C,70,C,73:NEXT
70 FOR A=1 TO 9:INPUT #1,HG$(A):B=0.808*A+C:LINE B,70,B,73:NEXT
80 FOR A=1 TO 7:INPUT #1,ZP$(A):C=0.808*A+B:LINE C,70,C,73:NEXT
90 FOR A=1 TO 9:INPUT #1,DR$(A):B=0.808*A+C:LINE B,70,B,73:NEXT
100 FOR A=1 TO 5:INPUT #1,MZ$(A):C=0.808*A+B:LINE C,70,C,73:NEXT
110 FOR A=1 TO 5:INPUT #1,GZ$(A):B=0.808*A+C:LINE B,70,B,73:NEXT
120 FOR A=1 TO 6:INPUT #1,WG$(A):C=0.808*A+B:LINE C,70,C,73:NEXT
130 FOR A=1 TO 6:INPUT #1,YP$(A):B=0.808*A+C:LINE B,70,B,73:NEXT
140 FOR A=1 TO 4:INPUT #1,MF$(A):C=0.808*A+B:LINE C,70,C,73:NEXT
150 FOR A=-1 TO 1 STEP 2: FOR AA=1 TO 9 STEP 2
151 INPUT #1,DM$((2.5+A)+A*0.5,AA*2+A)
152 B=0.808*A+C:LINE B,70,B,73:NEXT :NEXT
160 FOR A=1 TO 5:INPUT #1,AAA$(A):C=0.808*A+B:LINE C,70,C,73:NEXT
165 FOR A=1 TO 10:INPUT #1,RW$(A):INPUT #1,NA$(A):B=0.808*A+C:LINE B,70,B,73:NEXT
185 FOR A=1 TO 6:INPUT #1,YP(A):C=0.808*A+B:LINE C,70,C,73:INPUT #1,GX(A):NEXT
186 FOR A=1 TO 4:INPUT #1,MF(A):INPUT #1,XG(A):B=0.808*A+C:LINE B,70,B,73:NEXT
189 INPUT #1,AA
190 INPUT #1,BB
191 FOR A=1 TO 4:INPUT #1,BE$(A):NEXT
200 CLOSE #1
210 CLS:PRINT AAA$(1);
220 T$=INKEY$:A=0:GOSUB 10
225 IF T=1 THEN GOSUB 9175
230 ON T GOTO 300,9110,9800:BEEP: GOTO 220
300 CLS:PRINT MAP$(1);:POKE 803,AA:PRINT ;
305 LOCATE 1,9:PRINT RW$(2);: FOR I=1 TO 3000:NEXT
310 FOR I=2 TO 4:LOCATE I-1,9:PRINT "※";:LOCATE I,9:PRINT RW$(2);
315 FOR J=1 TO 2000:NEXT :NEXT : FOR I=1 TO 1000:NEXT
320 CLS:PRINT CD$(1);:T$=INKEY$
325 CLS:PRINT MAP$(1);:POKE 803,AA:PRINT ;:LOCATE 4,9:PRINT RW$(2);
330 FOR I=0 TO 80:LINE 0,I,160,I,2: FOR J=1 TO 100:NEXT :NEXT
335 CLS:PRINT MAP$(1);:POKE 803,AA:PRINT ;:BOX 0,0,160,80,1,2
340 FOR I=0 TO 80:LINE 0,I,160,I,2: FOR J=1 TO 100:NEXT :NEXT
345 FOR I=1 TO 1000:NEXT
350 FOR I=2 TO 4:CLS:PRINT CD$(I);:T$=INKEY$:NEXT
355 FOR I=1 TO 1000:NEXT
360 CLS:PRINT MAP$(2);:POKE 803,BB:PRINT ;: FOR I=1 TO 1000:NEXT
365 LOCATE 5,11:PRINT RW$(3);: FOR I=1 TO 2000:NEXT
370 LOCATE 5,11:PRINT " ";:LOCATE 4,11:PRINT RW$(3);
380 FOR J=1 TO 2000:NEXT
381 LOCATE 4,11:PRINT " ";:LOCATE 3,11:PRINT RW$(3);: FOR I=1 TO 2000:NEXT
385 FOR I=1 TO 3:CLS:PRINT HG$(I);:T$=INKEY$:NEXT
390 CLS:PRINT MAP$(2);:POKE 803,BB:PRINT ;
395 LOCATE 3,11:PRINT RW$(3);: FOR I=1 TO 2000:NEXT
400 LOCATE 4,11:PRINT RW$(3);:LOCATE 3,11:PRINT " ";: FOR I=1 TO 2000:NEXT
405 LOCATE 4,13:PRINT RW$(3);:LOCATE 4,11:PRINT " ";: FOR I=1 TO 2000:NEXT
410 LOCATE 5,11:PRINT RW$(1);: FOR I=1 TO 2000:NEXT
415 LOCATE 4,11:PRINT RW$(1);:LOCATE 5,11:PRINT " ";
420 FOR J=1 TO 2000:NEXT
421 LOCATE 3,11:PRINT RW$(1);:LOCATE 4,11:PRINT " ";
422 FOR J=1 TO 2000:NEXT
425 FOR I=4 TO 9:CLS:PRINT HG$(I);:T$=INKEY$:NEXT
500 X=3:Y=11:Q=Q+1:B=1
505 GET #1,1
506 CLS:PRINT MAP$;:LOCATE X,Y:PRINT RW$(1);
507 LOCATE 5,1:PRINT DM$(X,Y);" ";
510 T=ASC(INKEY$):IF (T>19 AND T<24) OR (T=13 OR T=113) THEN 515 ELSE BEEP:510
515 IF T=20 THEN X=X-1:IF X<1 THEN BEEP:X=1:505
520 IF T=21 THEN X=X+1:IF X>4 THEN BEEP:X=4:505
525 IF T=22 THEN Y=Y+2:IF Y>19 THEN BEEP:Y=19:505
530 IF T=23 THEN Y=Y-2:IF Y<1 THEN BEEP:Y=1:505
535 IF T=113 THEN GOSUB 9300: GOTO 505
536 IF T>13 THEN 505
540 IF X=4 THEN 570
541 IF X=2 OR X=3 THEN BEEP:505
545 IF Y=1 THEN 600
550 IF Y=5 THEN 700
555 IF Y=9 THEN 800
560 IF Y=13 THEN 4500
561 IF Y=17 THEN 590
565 BEEP: GOTO 505
570 IF ((Y=3)+(Y=7)+(Y=15)+(Y=19)) THEN 590
575 IF Y=11 THEN 576 ELSE 580
576 IF A=0 THEN 2000 ELSE IF A=1 THEN 5000
580 BEEP: GOTO 505
590 CLS:PRINT "请问你找谁？";:T$=INKEY$: GOTO 505
600 G=1
601 C=17:D=16:PP=1
602 CLS:PRINT "********";DM$(X,Y);:LOCATE 1,13:PRINT "********";YDTX$;
606 LOCATE 5,3:PRINT "× × ";
611 LOCATE 5,1:PRINT YPM$(PP);"×";YPS(PP);
612 LOCATE 5,13:PRINT MO;:BOX C,D,C+48,D+15,1,2:E=C:F=D
620 T=ASC(INKEY$):IF (T<24 AND T>19) OR T=13 OR T=27 THEN 625 ELSE BEEP:620
625 IF T=20 THEN D=D-16:PP=PP-1:IF D<16 THEN D=48:PP=PP+3
630 IF T=21 THEN D=D+16:PP=PP+1:IF D>48 THEN D=16:PP=PP-3
635 IF T=23 THEN C=C-80:PP=PP-3:IF C<17 THEN C=97:PP=PP+6
640 IF T=22 THEN C=C+80:PP=PP+3:IF C>97 THEN C=17:PP=PP-6
645 IF T=27 THEN 505
647 IF T>13 THEN 678
650 IF G=2 THEN 4550
655 IF MO665 MO=MO-YP(PP):YPS(PP)=YPS(PP)+1
675 IF YPS(1)+YPS(2)+YPS(3)+YPS(4)+YPS(5)+YPS(6)>50 THEN YPS(PP)=YPS(PP)-1:MO=MO+YP(PP):680
678 BOX E,F,E+48,F+15,1,2: GOTO 606
680 LOCATE 5,1:PRINT "携带的物品太多了！";:T$=INKEY$: GOTO 606
700 CLS:PRINT "********客栈********";AAA$(2);
710 T$=INKEY$
720 IF T$="n" THEN 505 ELSE IF T$<>"y" THEN BEEP:710
730 IF MO<200 THEN CLS:PRINT "对不起！你没那么多钱啊！我们这不赊账！再见！":731 ELSE 735
731 T$=INKEY$: GOTO 505
735 FOR II=-1 TO 0: FOR I=0 TO 80: FOR J=1 TO 100:NEXT :LINE 0,I,160,I,(-2)*II:NEXT :NEXT
740 MO=MO-200:MP=MPP:HP=HPP:CLS:PRINT "欢迎下次再来！":T$=INKEY$: GOTO 505
800 IF Q>5 THEN QT=QT+1:IF QT>3 THEN QT=3
801 IF QT=3 THEN CLS:PRINT ZP$(7):T$=INKEY$:505
805 IF Q=5 AND QT=2 THEN CLS:PRINT ZP$(6);:T$=INKEY$:QT=3:505
820 CLS:PRINT ZP$(Q);:T$=INKEY$: GOTO 505
1100 G=G+7:H=H+7
1120 FOR J=1 TO 0 STEP -1: FOR JJ=0 TO 7:BOX G-JJ,H-JJ,G+JJ,H+JJ,1,J
1130 FOR JJJ=1 TO 150:NEXT :NEXT :NEXT
1135 RETURN
1200 BOX 144,32,159,47:LOCATE 5,1:PRINT NB$(6);KP(6);"/";KPP(6);: FOR I=1 TO 2500
1205 NEXT :IF Q=10 THEN 1206 ELSE 1210
1206 I=RND(1):IF I>0.4 THEN 1240
1207 I=ABS(X(1)-X(6)):J=ABS(Y(1)-Y(6)):IF I=0 AND J=2 THEN 1245
1208 IF I=1 AND J=0 THEN 1245 ELSE 2019
1210 IF Y(1)=15 AND X(1)=3 THEN 1240
1211 IF Y(1)=17 THEN 1220
1212 IF Y(1)=19 THEN 1230
1213 GOTO 2019
1220 IF X(1)=2 OR X(1)=4 THEN 1240
1221 IF X(1)=3 THEN 1245
1222 GOTO 2019
1230 IF X(1)<>1 THEN 1245
1235 IF X(1)>14 THEN 1240
1240 ON Q GOTO 1500,1600,1500,1600,1500,1600,1500,1600,1500,1700
1241 GG=Q*86+INT(RND(1)*(10-Q)*8): GOTO 2940
1245 GG=Q*69+INT(RND(1)*(10-Q)*3): GOTO 8400
1500 II=0:H=X(1)*16-8:G=Y(1)*8-3
1510 FOR I=20 TO 160 STEP 2:II=II+0.2:ELLIPSE I,31,II,II*2
1520 FOR J=1 TO 50:NEXT :NEXT
1524 FOR I=-1 TO 0: FOR J=0 TO 7:CIRCLE G+4,H,J,1,-1*I: FOR II=1 TO 50:NEXT :NEXT :NEXT
1530 GOSUB 9995: GOTO 1241
1600 FOR II=20 TO 120:I=0.23*II:J=0.08*II
1610 DRAW II,35-I:DRAW II,33-J:DRAW II,29+J:DRAW II,27+I
1620 FOR JJ=1 TO 5:NEXT :NEXT
1630 FOR II=1 TO 0 STEP -1: FOR I=0 TO 7
1640 CIRCLE 120,8,I,1,II:CIRCLE 120,24,I,1,II:CIRCLE 120,40,I,1,II:CIRCLE 120,56,I,1,II
1650 CIRCLE 136,8,I,1,II:CIRCLE 136,24,I,1,II:CIRCLE 136,40,I,1,II:CIRCLE 136,56,I,1,II
1660 CIRCLE 152,8,I,1,II:CIRCLE 152,24,I,1,II:CIRCLE 152,40,I,1,II:CIRCLE 152,56,I,1,II
1680 NEXT :NEXT :GOSUB 9995: GOTO 1241
1700 FOR I=144 TO 80 STEP -1:DRAW I,I*0.625-50:FOR II=1 TO 50 :NEXT:NEXT
1702 FOR II=0 TO 60:LINE 76,II,84,II:FOR I=1 TO 50:NEXT:NEXT
1705 FOR II=80 TO 160:LINE II,52,II,60:LINE 160-II,52,160-II,60:NEXT
1710 FOR II=56 TO 6 STEP -16:FOR J=1 TO 0 STEP -1:FOR JJ=0 TO 7:FOR I= 8 TO 160 STEP 16
1715 CIRCLE I,II,JJ,1,J:NEXT:NEXT:NEXT:GOSUB 9995:NEXT
1720 GOSUB 9995:GOTO 1241
1999 IF Q=10 THEN KP(6)=40000:KPP(6)=KP(6):2001 ELSE 2001
2000 X(1)=1:Y(1)=1:R=R+1:RR=0:NPC$(1)=RW$(1):KP(6)=Q*2678:KPP(6)=KP(6): GOTO 1999
2001 FOR I=2 TO 5:KP(I)=Q*50+R*10:J=INT(RND(1)*7)+4:NPC$(I)=RW$(J):NB$(I)=NA$(J):X(I)=I-1
2002 KPP(I)=KP(I):Y(I)=INT(RND(1)*10)*2+1:IF Y(I)=Y(1) AND X(I)=X(1) THEN 2002
2003 IF R=INT(R/5)*5 AND Y(I)=Y(6) AND X(I)=X(6) THEN 2002
2004 NEXT :GJL=Q*14+R*4:VW=4:WV=4:S=0
2005 GET #1,R+1:B=0:IF R=20 THEN A=1
2009 IF R<>INT(R/5)*5 THEN 2019
2010 NB$(6)=AE$(Q):IF R<50 THEN 2015
2011 IF RR=1 THEN 2019 ELSE FOR I=1 TO 5:CLS:PRINT MZ$(I);:T$=INKEY$:NEXT :RR=0: GOTO 2019
2015 IF RR=0 THEN CLS:PRINT DR$(Q):T$=INKEY$:RR=1
2019 GOSUB 9995:IF VW=0 THEN RR=1:2001
2020 IF KP(6)>0 THEN 2025 ELSE CLS:PRINT AE$(Q);"被击败。"
2021 IF Q<5 THEN PRINT "得到";AE$(Q):LOCATE 2,9:PRINT "灵珠";BE$(Q);: GOTO 2023
2022 IF R=50 THEN T$=INKEY$: GOTO 5100
2023 T$=INKEY$: GOTO 500
2025 FOR I=1 TO 4: FOR J=1 TO 19 STEP 2:WZ(I,J)=0:NEXT :NEXT
2028 FOR I=2 TO 5:IF KP(I)=0 THEN 2029 ELSE WZ(X(I),Y(I))=I
2029 NEXT :IF R=INT(R/5)*5 THEN WZ(3,19)=6
2041 S=S+1:IF S=6 AND R=INT(R/5)*5 THEN 1200
2042 IF S=1 THEN 3000 ELSE IF S>5 THEN S=0:2041 ELSE IF KP(S)=0 THEN 2041
2043 GG=GJL: GOTO 2051
2050 GOTO 2019
2051 GOSUB 9994
2052 LOCATE 5,1:PRINT NB$(S);KP(S);"/";KPP(S);" ";:C=Y(S)*8-8:D=X(S)*16-16
2053 BOX C,D,C+15,D+15:IF X(S)>X(1) AND Y(S)>Y(1) THEN 2100
2055 IF X(S)>X(1) AND Y(S)=Y(1) THEN 2200
2060 IF X(S)>X(1) AND Y(S)2065 IF X(S)=X(1) AND Y(S)>Y(1) THEN 2400
2070 IF X(S)=X(1) AND Y(S)2075 IF X(S)Y(1) THEN 2600
2080 IF X(S)2085 IF X(S)2100 E=ABS(X(1)-X(S)):F=ABS(Y(1)-Y(S))/2
2110 IF E+F>3 THEN 2150
2120 IF E=1 AND F=2 THEN GOSUB 7000: GOTO 8800
2130 IF E=1 AND F=1 THEN GOSUB 7050: GOTO 8800
2140 IF E=2 AND F=1 THEN GOSUB 7100: GOTO 8800
2150 IF E=1 THEN GOSUB 7600: GOTO 2050
2160 IF E>1 THEN GOSUB 7650: GOTO 2050
2200 E=ABS(X(1)-X(S))
2220 IF E=1 THEN 8800
2230 IF E=2 THEN GOSUB 8000: GOTO 8800
2240 IF E=3 THEN GOSUB 8050: GOTO 8800
2300 E=ABS(X(1)-X(S)):F=ABS(Y(1)-Y(S))/2
2310 IF E+F>3 THEN 2350
2320 IF E=1 AND F=2 THEN GOSUB 7150: GOTO 8800
2330 IF E=1 AND F=1 THEN GOSUB 7200: GOTO 8800
2340 IF E=2 AND F=1 THEN GOSUB 7250: GOTO 8800
2350 IF E=1 THEN GOSUB 7700: GOTO 2050
2360 IF E>1 THEN GOSUB 7750: GOTO 2050
2400 F=ABS(Y(1)-Y(S))/2:E=0
2420 IF F=1 THEN E=1:8800
2430 IF F=2 THEN GOSUB 8100: GOTO 8800
2440 IF F=3 THEN GOSUB 8150: GOTO 8800
2450 GOSUB 8600: GOTO 2050
2500 F=ABS(Y(1)-Y(S))/2:E=0
2520 IF F=1 THEN E=1:8800
2530 IF F=2 THEN GOSUB 8200: GOTO 8800
2540 IF F=3 THEN GOSUB 8250: GOTO 8800
2550 GOSUB 8500: GOTO 2050
2600 E=ABS(X(1)-X(S)):F=ABS(Y(1)-Y(S))/2
2610 IF E+F>3 THEN 2650
2620 IF E=1 AND F=2 THEN GOSUB 7300: GOTO 8800
2630 IF E=1 AND F=1 THEN GOSUB 7350: GOTO 8800
2640 IF E=2 AND F=1 THEN GOSUB 7400: GOTO 8800
2650 IF E=1 THEN GOSUB 7800: GOTO 2050
2660 IF E>1 THEN GOSUB 7850: GOTO 2050
2700 E=ABS(X(1)-X(S)):F=ABS(Y(1)-Y(S))/2
2720 IF E=1 THEN 8800
2730 IF E=2 THEN GOSUB 8300: GOTO 8800
2740 IF E=3 THEN GOSUB 8350: GOTO 8800
2800 E=ABS(X(1)-X(S)):F=ABS(Y(1)-Y(S))/2
2810 IF E+F>3 THEN 2850
2820 IF E=1 AND F=2 THEN GOSUB 7450: GOTO 8800
2830 IF E=1 AND F=1 THEN GOSUB 7500: GOTO 8800
2840 IF E=2 AND F=1 THEN GOSUB 7550: GOTO 8800
2850 IF E=1 THEN GOSUB 7900: GOTO 2050
2860 IF E>1 THEN GOSUB 7950: GOTO 2050
2900 X(S)=X(S)-1:GOSUB 9995: FOR JJ=1 TO 1000:NEXT :RETURN
2910 X(S)=X(S)+1:GOSUB 9995: FOR JJ=1 TO 1000:NEXT :RETURN
2920 Y(S)=Y(S)-2:GOSUB 9995: FOR JJ=1 TO 1000:NEXT :RETURN
2930 Y(S)=Y(S)+2:GOSUB 9995: FOR JJ=1 TO 1000:NEXT :RETURN
2940 GOSUB 9995:HPPP=GG+INT(RND(1)*DJ/2):HP=HP-HPPP:IF HP>0 THEN 2950 ELSE 2960
2950 GOSUB 9994:LOCATE 5,1:PRINT "你的体力下降了";HPPP;: FOR I=1 TO 1500:NEXT : GOTO 2025
2960 CLS:LOCATE 2,5:PRINT "你的体力不支，"," 昏了过去……"
2970 FOR I=0 TO 80:LINE 0,I,160,I,2: FOR J=0 TO 100:NEXT :NEXT
2980 T$=INKEY$:CLOSE #1:POKE 199,155
3000 W=0:V=0
3005 GOSUB 9994
3006 LOCATE 5,1:PRINT NA$(1);"HP:";HP;"/";HPP;
3010 T=ASC(INKEY$):IF (T>19 AND T<24) OR (T=13 OR T=113) THEN 3020 ELSE BEEP:3010
3020 IF T=13 THEN T=24
3025 IF T=113 THEN T=25
3030 ON T-19 GOTO 3100,3200,3400,3300,3600,3040
3040 GOSUB 9900: GOSUB 9995:GOTO 3006
3100 X(S)=X(S)-1:W=W-1:IF X(S)=0 THEN BEEP:X(S)=1:W=W+1
3102 IF ABS(W)+ABS(V)>3 OR WZ(X(S),Y(S))>0 THEN X(S)=X(S)+1:W=W+1:BEEP:3010
3110 GOSUB 9995: GOTO 3010
3200 X(S)=X(S)+1:W=W+1:IF X(S)=5 THEN BEEP:X(S)=4:W=W-1
3210 IF ABS(W)+ABS(V)>3 OR WZ(X(S),Y(S))>0 THEN X(S)=X(S)-1:W=W-1:BEEP:3010
3220 IF X(S)=4 AND Y(S)=19 AND R<>INT(R/5)*5 THEN RR=0:2000
3226 GOSUB 9995: GOTO 3010
3300 Y(S)=Y(S)-2:V=V-1:IF Y(S)<1 THEN BEEP:Y(S)=1:V=V+1
3310 IF ABS(W)+ABS(V)>3 OR WZ(X(S),Y(S))>0 THEN Y(S)=Y(S)+2:V=V+1:BEEP:3010
3326 GOSUB 9995: GOTO 3010
3400 Y(S)=Y(S)+2:V=V+1:IF Y(S)>19 THEN BEEP:Y(S)=19:V=V-1
3410 IF ABS(W)+ABS(V)>3 OR WZ(X(S),Y(S))>0 THEN Y(S)=Y(S)-2:V=V-1:BEEP:3010
3425 IF X(S)=4 AND Y(S)=19 AND R<>INT(R/5)*5 THEN RR=0:2000
3426 GOSUB 9995: GOTO 3010
3500 GOSUB 9400: GOTO 3005
3600 GOSUB 9994:LOCATE 5,1:PRINT "①攻 ②法 ③物 ④防";
3610 T$=INKEY$:IF T$=CHR$(27) THEN 3005
3611 GOSUB 10:ON T GOTO 3670,3900,3660,3620:BEEP: GOTO 3610
3620 U=0: GOTO 2019
3660 GOSUB 9400:GOSUB 9995:IF T$="Y" THEN 2019 ELSE 3600
3670 PP=1=5
3700 IF X(1)-1=0 THEN 3702
3701 IF WZ(X(1)-1,Y(1))<>0 THEN U=U+1:UU(U)=WZ(X(1)-1,Y(1))
3702 IF X(1)+1=5 THEN 3704
3703 IF WZ(X(1)+1,Y(1))<>0 THEN U=U+1:UU(U)=WZ(X(1)+1,Y(1))
3704 IF Y(1)-2<0 THEN 3706
3705 IF WZ(X(1),Y(1)-2)<>0 THEN U=U+1:UU(U)=WZ(X(1),Y(1)-2)
3706 IF Y(1)+2=21 THEN 3708
3707 IF WZ(X(1),Y(1)+2)<>0 THEN U=U+1:UU(U)=WZ(X(1),Y(1)+2)
3708 K=1
3709 IF PP=2 AND MP3712 IF U>0 THEN 3714
3713 BEEP:LOCATE 5,1:PRINT "目标不在范围内！ ";:T$=INKEY$: GOTO 3600
3714 GOSUB 9994:LOCATE 5,1:PRINT NB$(UU(K));
3715 PRINT KP(UU(K));"/";KPP(UU(K));:G=Y(UU(K))*8-8
3716 H=X(UU(K))*16-16:BOX G,H,G+15,H+15
3717 T=ASC(INKEY$):IF (T>19 AND T<24) OR (T=27 OR T=13) THEN 3719 ELSE BEEP:3717
3719 IF T=27 THEN U=0:3600
3720 IF U=0 THEN 3712
3725 IF T<>13 THEN 3735
3726 IF T=13 THEN ON PP GOTO 3730,6001
3730 IF T=13 THEN GOSUB 1100:GGLL=GGL
3731 KP=KP(UU(K)):KPPP=GGLL+INT(RND(1)*DJ)
3732 KP(UU(K))=KP(UU(K))-KPPP:IF KP(UU(K))>0 THEN 3733 ELSE 3790
3733 GOSUB 9995:GOSUB 9994:LOCATE 5,1:PRINT NPC$(UU(K));"体力下降了";KPPP;:T$=INKEY$: GOTO 3820
3735 K=K+1:BOX G,H,G+15,H+15,0,2:IF K>U THEN K=1
3740 ON P GOTO 3714,3714,6536,6940,3714
3790 WV=VW
3791 KP(UU(K))=0:JP=KPP(UU(K))+INT(RND(1)*DJ):JY=JY+JP:WZ(X(UU(K)),Y(UU(K)))=0:VW=VW-1
3792 I=INT(RND(1)*200):IF I>49 THEN MO=MO+INT(KPP(UU(K))/7)+INT(RND(1)*(DJ/2)):PC$="金币"
3795 IF I=49 THEN YPS(3)=YPS(3)+1:PC$=YP$(3)
3797 IF I=48 THEN YPS(6)=YPS(6)+1:PC$=YP$(6)
3801 IF I<48 AND I>26 THEN YPS(4)=YPS(4)+1:PC$=YP$(4)
3802 IF I<27 AND I>5 THEN YPS(1)=YPS(1)+1:PC$=YP$(1)
3803 IF I<6 AND I>2 THEN YPS(2)=YPS(2)+1:PC$=YP$(2)
3805 IF I<3 THEN YP(5)=YP(5)+1:PC$=YP$(5)
3806 IF UU(K)<6 THEN 3808 ELSE LOCATE 5,1:PRINT NB$(6);:LOCATE 5,9:PRINT "被打败了！";
3807 T$=INKEY$:LOCATE 5,1: GOTO 3809
3808 GOSUB 9995:LOCATE 5,1:PRINT NB$(UU(K));"被打败了！";:T$=INKEY$:LOCATE 5,1
3809 PRINT "得到";PC$;" ";:T$=INKEY$:LOCATE 5,1:PRINT "获得经验值";JP;
3810 T$=INKEY$:IF JY>=JYZ THEN GOSUB 4100
3820 IF P=3 THEN 6536 ELSE IF P=4 THEN 6940 ELSE 3620
3900 P=1:GOSUB 9994
3910 LOCATE 5,1:PRINT MF$(P);" ";
3920 T=ASC(INKEY$):IF T=20 OR T=21 OR T=13 OR T=27 THEN 3921 ELSE 3920
3921 IF T=21 THEN P=P+1:IF P>4 THEN BEEP:P=4:3920
3922 IF T=20 THEN P=P-1:IF P<1 THEN BEEP:P=1:3920
3923 IF T=27 THEN GOSUB 9995: GOTO 3600
3924 IF T<>13 THEN 3910
3925 ON P GOTO 6000,6400,6400,6900
4100 I=HPP:J=MPP:G=GGL:GOSUB 4101:GOTO 4110
4101 DJ=DJ+1:JYZ=DJ*300-200:HPP=DJ*38+50-DJ*4:MPP=DJ*19+(40-DJ*6):GGL=DJ*21+(40-DJ*9)
4105 HP=HPP:MP=MPP:RETURN
4110 LOCATE 5,1:PRINT "你升级了！";DJ;"级 ";:T$=INKEY$:JY=0:GOSUB 9994
4111 LOCATE 5,1:PRINT "体力＋";HPP-I;:T$=INKEY$:GOSUB 9994
4112 LOCATE 5,1:PRINT "法力＋";MPP-J;:T$=INKEY$:GOSUB 9994
4113 LOCATE 5,1:PRINT "攻击力＋";GGL-G;:T$=INKEY$
4115 RETURN
4500 G=2: GOTO 601
4550 IF YPS(PP)<=0 THEN BEEP: GOTO 620
4560 YPS(PP)=YPS(PP)-1:MO=MO+INT(YP(PP)/2): GOTO 606
5000 CLS:PRINT MAP$(1);:POKE 803,AA:PRINT ;
5002 LOCATE 1,3:PRINT "※※※※※※※";:LOCATE 3,1:PRINT RW$(1);
5004 LOCATE 2,19:PRINT RW$(2);:LOCATE 3,19:PRINT "";: FOR I=1 TO 5000:NEXT
5006 FOR I=1 TO 2:CLS:PRINT GZ$(I);:T$=INKEY$:NEXT
5008 CLS:PRINT MAP$(1);:POKE 803,AA:PRINT ;
5010 LOCATE 1,3:PRINT "※※※※※※※";:LOCATE 3,1:PRINT RW$(1);
5011 LOCATE 3,19:PRINT "";:LOCATE 2,19:PRINT RW$(2);
5012 LOCATE 3,3:PRINT "";:LOCATE 4,3:PRINT "";: FOR I=1 TO 2000:NEXT
5014 FOR I=3 TO 13 STEP 2
5016 LOCATE 3,I:PRINT "※";:LOCATE 4,I:PRINT "※";
5020 FOR J=1 TO 2000:NEXT :NEXT
5022 LOCATE 3,15:PRINT "※※※";:LOCATE 4,15:PRINT "※※※";: FOR I=1 TO 5000
5024 NEXT : FOR I=3 TO 9 STEP 2:II=20-I
5026 LOCATE 3,I-2:PRINT "※";
5028 LOCATE 2,II:PRINT "※";
5030 FOR J=1 TO 2000:NEXT :NEXT :LOCATE 3,9:PRINT "※";
5031 LOCATE 2,9:PRINT RW$(1): FOR I=1 TO 5000:NEXT
5032 FOR I=3 TO 5:CLS:PRINT GZ$(I):T$=INKEY$:NEXT
5034 CLS:PRINT MAP$(2);:POKE 803,BB:PRINT ;
5036 FOR I=5 TO 2 STEP -1: FOR J=1 TO 2000:NEXT :II=I+1:IF II>5 THEN II=5
5038 LOCATE II,11:PRINT " ";:LOCATE I,11:PRINT RW$(3);:NEXT
5040 CLS:PRINT WG$(1);:T$=INKEY$
5042 CLS:PRINT MAP$(2);:POKE 803,BB:PRINT ;:LOCATE 3,11:PRINT RW$(3);
5044 FOR I=1 TO 3: FOR J=1 TO 2000:NEXT
5046 ON I GOTO 5048,5050,5052
5048 LOCATE 3,11:PRINT RW$(3): GOTO 5054
5050 LOCATE 4,11:PRINT RW$(3);:LOCATE 3,11:PRINT " ";: GOTO 5054
5052 LOCATE 4,13:PRINT RW$(3);:LOCATE 4,11:PRINT " ";
5054 NEXT :LOCATE 5,11:PRINT RW$(2);: FOR I=1 TO 2000:NEXT
5055 LOCATE 4,11:PRINT RW$(2);:LOCATE 5,11:PRINT RW$(1);: FOR I=1 TO 2000:NEXT
5056 LOCATE 3,11:PRINT RW$(2);:LOCATE 4,11:PRINT RW$(1):LOCATE 5,11:PRINT " ";
5058 FOR I=1 TO 2000:NEXT
5060 FOR I=2 TO 6:CLS:PRINT WG$(I);:T$=INKEY$:NEXT
5062 A=0:X=3:Y=11:QT=2 : GOTO 505
5100 CLS:PRINT MAP$(1);:POKE 803,AA:PRINT ;
5102 LOCATE 1,3:PRINT "※※※※※※※";
5104 LOCATE 4,1:PRINT RW$(2);:LOCATE 4,19:PRINT RW$(1);: FOR I=1 TO 2000:NEXT
5106 FOR I=3 TO 9 STEP 2:II=20-I
5108 LOCATE 4,I-2:PRINT "※";:LOCATE 4,II:PRINT "※";
5110 FOR J=1 TO 2000:NEXT :NEXT
5112 FOR I=1 TO 10:CIRCLE 79+I,48-I*3,I,1:CIRCLE 81-I,48-I*3,I,1
5114 FOR J=1 TO 400:NEXT :NEXT :T$=INKEY$:LOCATE 3,8:PRINT "全剧终":T$=INKEY$
5116 FOR I=0 TO 80:LINE I,0,I,80:LINE 160-I,0,160-I,80:NEXT : FOR I=1 TO 2000:NEXT
5118 GOTO 9800
6000 PP=2: GOTO 3700
6001 G=Y(UU(K))*8-5:H=X(UU(K))*16-8
6010 FOR I=0 TO 63:LINE G,I,G+8,I: FOR J=1 TO 50:NEXT :NEXT
6020 FOR I=-1 TO 0: FOR J=0 TO 7:CIRCLE G+4,H,J,1,-1*I: FOR II=1 TO 50:NEXT :NEXT :NEXT
6030 GGLL=XG(1):MP=MP-MF(1):GOSUB 9995: GOTO 3731
6100 G=Y(UU(K))*8:H=X(UU(K))*16-8: FOR I=7 TO 55 STEP 4
6110 CIRCLE G,I,8,0,1: FOR J=1 TO 150:NEXT :NEXT
6115 FOR I=-1 TO 0: FOR J=0 TO 7:CIRCLE G,H,J,1,-1*I
6120 FOR II=1 TO 100:NEXT :NEXT :NEXT
6130 RETURN
6200 G(1)=Y(UU(K))*8-2:H(1)=X(UU(K))*16-8
6210 G(2)=G(1)-16:H(2)=H(1):IF G(2)<0 THEN G(2)=G(1)
6220 G(3)=G(1):H(3)=H(1)-16:IF H(3)<0 THEN H(3)=H(1)
6230 G(4)=G(1):H(4)=H(1)+16:IF H(4)>60 THEN H(4)=H(1)
6240 G(5)=G(1)+16:H(5)=H(1):IF G(5)>160 THEN G(5)=G(1)
6250 FOR I=-1 TO 0: FOR J=0 TO 7: FOR II=1 TO 5
6255 CIRCLE G(II),H(II),J,1,-1*I:NEXT
6260 FOR JJ=1 TO 20:NEXT :NEXT :NEXT
6270 RETURN
6300 GOTO 6900
6310 FOR III=1 TO 10:G=INT(RND(1)*120)+20:H=INT(RND(1)*24)+20:I=INT(RND(1)*10)+10
6315 FOR II=1 TO 0 STEP -1: FOR J=0 TO I:CIRCLE G,H,J,1,II
6320 NEXT :NEXT :GOSUB 9995:NEXT :MP=MP-MF(4)
6330 RETURN
6400 U=0:K=1:IF MP6402 U=0:K=1:IF X(1)-2<1 THEN 6405
6404 IF WZ(X(1)-2,Y(1))<>0 THEN U=U+1:UU(U)=WZ(X(1)-2,Y(1))
6405 IF X(1)-1=0 THEN 6416
6406 IF Y(1)-2<0 THEN 6410
6408 IF WZ(X(1)-1,Y(1)-2)<>0 THEN U=U+1:UU(U)=WZ(X(1)-1,Y(1)-2)
6410 IF WZ(X(1)-1,Y(1))<>0 THEN U=U+1:UU(U)=WZ(X(1)-1,Y(1))
6412 IF Y(1)+2>19 THEN 6416
6414 IF WZ(X(1)-1,Y(1)+2)<>0 THEN U=U+1:UU(U)=WZ(X(1)-1,Y(1)+2)
6416 IF Y(1)-4<0 THEN 6420
6418 IF WZ(X(1),Y(1)-4)<>0 THEN U=U+1:UU(U)=WZ(X(1),Y(1)-4)
6420 IF Y(1)-2<0 THEN 6424
6422 IF WZ(X(1),Y(1)-2)<>0 THEN U=U+1:UU(U)=WZ(X(1),Y(1)-2)
6424 IF Y(1)+2>19 THEN 6432
6426 IF WZ(X(1),Y(1)+2)<>0 THEN U=U+1:UU(U)=WZ(X(1),Y(1)+2)
6428 IF Y(1)+4>19 THEN 6432
6430 IF WZ(X(1),Y(1)+4)<>0 THEN U=U+1:UU(U)=WZ(X(1),Y(1)+4)
6432 IF X(1)+1>4 THEN 6500
6434 IF Y(1)-2<0 THEN 6438
6436 IF WZ(X(1)+1,Y(1)-2)<>0 THEN U=U+1:UU(U)=WZ(X(1)+1,Y(1)-2)
6438 IF WZ(X(1)+1,Y(1))<>0 THEN U=U+1:UU(U)=WZ(X(1)+1,Y(1))
6440 IF Y(1)+2>19 THEN 6444
6442 IF WZ(X(1)+1,Y(1)+2)<>0 THEN U=U+1:UU(U)=WZ(X(1)+1,Y(1)+2)
6444 IF X(1)+2>4 THEN 6500
6446 IF WZ(X(1)+2,Y(1))<>0 THEN U=U+1:UU(U)=WZ(X(1)+2,Y(1))
6500 IF K>U THEN K=1:6506 ELSE IF U>0 THEN 6506
6502 BEEP:LOCATE 5,1:PRINT "目标不在范围内！";:T$=INKEY$: GOTO 3600
6506 GOSUB 9995:LOCATE 5,1:PRINT NB$(UU(K));KP(UU(K));"/";
6507 PRINT KPP(UU(K));:G=Y(UU(K))*8-8:H=X(UU(K))*16-16
6508 BOX G,H,G+15,H+15:IF P=2 THEN 6526
6510 IF X(UU(K))-1=0 THEN 6514
6512 BOX G,H-16,G+15,H-1
6514 IF X(UU(K))+1=5 THEN 6518
6516 BOX G,H+16,G+15,H+31
6518 IF Y(UU(K))-2<0 THEN 6522
6520 BOX G-16,H,G-1,H+15
6522 IF Y(UU(K))+2>19 THEN 6526
6524 BOX G+16,H,G+31,H+15
6526 T=ASC(INKEY$):IF (T>19 AND T<24) OR T=13 OR T=27 THEN 6528 ELSE BEEP:6526
6528 IF T=27 THEN U=0:3600
6530 IF T<>13 THEN K=K+1:6500
6534 IF T=13 AND P=2 THEN GOSUB 6100:GGLL=XG(2):MP=MP-MF(2): GOTO 3731
6535 IF T=13 AND P=3 THEN GOSUB 6200:GGLL=XG(3):M=0:N=UU(K):MP=MP-MF(3): GOTO 3731
6536 M=M+1:IF M>4 THEN 3620
6537 FOR I=1 TO 4: FOR J=1 TO 19 STEP 2:WZ(I,J)=0:NEXT :NEXT
6538 FOR I=2 TO 6:WZ(X(I),Y(I))=I
6539 NEXT :ON M GOTO 6540,6544,6548,6552
6540 IF X(N)>1 THEN IF WZ(X(N)-1,Y(N))>1 THEN UU(K)=WZ(X(N)-1,Y(N)):3731
6542 GOTO 6536
6544 IF X(N)<4 THEN IF WZ(X(N)+1,Y(N))>1 THEN UU(K)=WZ(X(N)+1,Y(N)):3731
6546 GOTO 6536
6548 IF Y(N)>1 THEN IF WZ(X(N),Y(N)-2)>1 THEN UU(K)=WZ(X(N),Y(N)-2):3731
6550 GOTO 6536
6552 IF Y(N)<19 THEN IF WZ(X(N),Y(N)+2)>1 THEN UU(K)=WZ(X(N),Y(N)+2):3731
6554 GOTO 3620
6900 IF MP6910 GOSUB 6310:M=0
6915 M=M+1:IF KP(M)=0 THEN 6940
6920 IF M=6 AND R<>INT(R/5)*5 THEN 6940
6930 GGLL=XG(4):UU(K)=M: GOTO 3731
6940 IF M<7 THEN 6915 ELSE 3620
7000 IF WZ(X(1)+1,Y(1))=0 THEN GOSUB 2920:GOSUB 2920:RETURN
7010 IF WZ(X(1),Y(1)+2)=0 THEN GOSUB 2920:GOSUB 2900:RETURN
7020 IF WZ(X(1)+1,Y(1)+2)=0 THEN GOSUB 2920:E=0:RETURN
7030 GOSUB 2900:E=0:RETURN
7050 IF WZ(X(1)+1,Y(1))=0 THEN GOSUB 2920:RETURN
7060 IF WZ(X(1),Y(1)+2)=0 THEN GOSUB 2900:RETURN
7080 IF X(1)>1 THEN IF WZ(X(1)-1,Y(1)+2)=0 THEN GOSUB 2900:GOSUB 2900:E=0:RETURN
7090 IF Y(1)>1 THEN IF WZ(X(1)+1,Y(1)-2)=0 THEN GOSUB 2920:GOSUB 2920:E=0:RETURN
7095 E=0:RETURN
7100 IF WZ(X(1)+1,Y(1))=0 THEN GOSUB 2920:GOSUB 2900:E=1:RETURN
7110 IF WZ(X(1),Y(1)+2)=0 THEN GOSUB 2900:GOSUB 2900:E=1:RETURN
7120 IF WZ(X(1)+1,Y(1)+2)=0 THEN GOSUB 2900:E=0:RETURN
7130 GOSUB 2920:E=0:RETURN
7150 IF WZ(X(1)+1,Y(1))=0 THEN GOSUB 2930:GOSUB 2930:RETURN
7160 IF WZ(X(1),Y(1)-2)=0 THEN GOSUB 2930:GOSUB 2900:RETURN
7170 IF WZ(X(1)+1,Y(1)-2)=0 THEN GOSUB 2930:E=0:RETURN
7180 GOSUB 2900:E=0:RETURN
7190 E=0:RETURN
7200 IF WZ(X(1)+1,Y(1))=0 THEN GOSUB 2930:RETURN
7210 IF WZ(X(1),Y(1)-2)=0 THEN GOSUB 2900:RETURN
7230 IF X(1)>1 THEN IF WZ(X(1)-1,Y(1)-2)=0 THEN GOSUB 2900:GOSUB 2900:E=0:RETURN
7240 IF Y(1)<19 THEN IF WZ(X(1)+1,Y(1)+2)=0 THEN GOSUB 2930:GOSUB 2930:E=0:RETURN
7245 E=0:RETURN
7250 IF WZ(X(1)+1,Y(1))=0 THEN GOSUB 2930:GOSUB 2900:E=1:RETURN
7260 IF WZ(X(1),Y(1)-2)=0 THEN GOSUB 2900:GOSUB 2900:E=1:RETURN
7270 IF WZ(X(1)+2,Y(1)+2)=0 THEN GOSUB 2930:RETURN
7280 IF WZ(X(1)+1,Y(1)-2))=0 THEN GOSUB 2900:RETURN
7300 IF WZ(X(1)-1,Y(1))=0 THEN GOSUB 2920:GOSUB 2920:RETURN
7310 IF WZ(X(1),Y(1)+2)=0 THEN GOSUB 2910:GOSUB 2920:RETURN
7320 IF WZ(X(1)-1,Y(1)+2)=0 THEN GOSUB 2920:E=0:RETURN
7330 GOSUB 2910:E=0:RETURN
7350 IF WZ(X(1)-1,Y(1))=0 THEN GOSUB 2920:RETURN
7360 IF WZ(X(1),Y(1)+2)=0 THEN GOSUB 2910:RETURN
7380 IF X(1)<4 THEN IF WZ(X(1)+1,Y(1)+2)=0 THEN GOSUB 2910:GOSUB 2910:E=0:RETURN
7390 IF Y(1)>1 THEN IF WZ(X(1)-1,Y(1)-2)=0 THEN GOSUB 2920:GOSUB 2920:E=0:RETURN
7395 E=0:RETURN
7400 IF WZ(X(1)-1,Y(1))=0 THEN GOSUB 2920:GOSUB 2910:E=1:RETURN
7410 IF WZ(X(1),Y(1)+2)=0 THEN GOSUB 2910:GOSUB 2910:E=1:RETURN
7420 IF WZ(X(1)-2,Y(1))=0 THEN GOSUB 2920:RETURN
7430 IF WZ(X(1)-1,Y(1)+2)=0 THEN GOSUB 2910:RETURN
7450 IF WZ(X(1)-1,Y(1))=0 THEN GOSUB 2930:GOSUB 2930:RETURN
7460 IF WZ(X(1),Y(1)-2)=0 THEN GOSUB 2930:GOSUB 2910:RETURN
7470 IF WZ(X(1)-1,Y(1)-2)=0 THEN GOSUB 2930:E=0:RETURN
7480 IF WZ(X(1),Y(1)-4)=0 THEN GOSUB 2910:E=0:RETURN
7490 E=0:RETURN
7500 IF WZ(X(1)-1,Y(1))=0 THEN GOSUB 2930:RETURN
7510 IF WZ(X(1),Y(1)-2)=0 THEN GOSUB 2910:RETURN
7530 IF X(1)<4 THEN IF WZ(X(1)+1,Y(1)-2)=0 THEN GOSUB 2910:GOSUB 2910:E=0:RETURN
7540 IF Y(1)<19 THEN IF WZ(X(1)-1,Y(1)+2)=0 THEN GOSUB 2930:GOSUB 2930:E=0:RETURN
7545 E=0:RETURN
7550 IF WZ(X(1)-1,Y(1))=0 THEN GOSUB 2930:GOSUB 2910:E=1:RETURN
7560 IF WZ(X(1),Y(1)-2)=0 THEN GOSUB 2910:GOSUB 2910:E=1:RETURN
7570 IF WZ(X(1)-2,Y(1))=0 THEN GOSUB 2930:RETURN
7580 IF WZ(X(1)-1,Y(1-2))=0 THEN GOSUB 2910:RETURN
7600 IF WZ(X(S),Y(S)-4)=0 THEN GOSUB 2920:GOSUB 2920:RETURN
7610 IF WZ(X(S)-1,Y(S)-2)=0 THEN GOSUB 2920:GOSUB 2900:RETURN
7620 IF WZ(X(S),Y(S)-2)=0 THEN GOSUB 2920:RETURN
7630 GOSUB 2900:RETURN
7650 IF WZ(X(S)-1,Y(S)-2)=0 THEN GOSUB 2920:GOSUB 2900:RETURN
7660 IF Y(S)>3 THEN IF WZ(X(S),Y(S)-4)=0 THEN GOSUB 2920:GOSUB 2920:RETURN
7670 IF WZ(X(S)-2,Y(S))=0 THEN GOSUB 2900:GOSUB 2900:RETURN
7680 I=RND(1):IF I>0.5 THEN 7690
7685 GOSUB 2900:RETURN
7690 GOSUB 2920:RETURN
7700 IF WZ(X(S),Y(S)+4)=0 THEN GOSUB 2930:GOSUB 2930:RETURN
7710 IF WZ(X(S)-1,Y(S)+2)=0 THEN GOSUB 2930:GOSUB 2900:RETURN
7720 IF WZ(X(S),Y(S)+2)=0 THEN GOSUB 2930:RETURN
7730 GOSUB 2900:RETURN
7750 IF WZ(X(S)-1,Y(S)+2)=0 THEN GOSUB 2930:GOSUB 2900:RETURN
7760 IF Y(S)<17 THEN IF WZ(X(S),Y(S)+4)=0 THEN GOSUB 2930:GOSUB 2930:RETURN
7770 IF WZ(X(S)-2,Y(S))=0 THEN GOSUB 2900:GOSUB 2900:RETURN
7780 I=RND(1):IF I>0.5 THEN 7790
7785 GOSUB 2930:RETURN
7790 GOSUB 2900:RETURN
7800 IF WZ(X(S),Y(S)-4)=0 THEN GOSUB 2920:GOSUB 2920:RETURN
7810 IF WZ(X(S)+1,Y(S)-2)=0 THEN GOSUB 2920:GOSUB 2910:RETURN
7820 IF WZ(X(S),Y(S)-2)=0 THEN GOSUB 2920:RETURN
7830 IF WZ(X(S)+1,Y(S))=0 THEN GOSUB 2910:RETURN
7850 IF WZ(X(S)+1,Y(S)-2)=0 THEN GOSUB 2920:GOSUB 2910:RETURN
7860 IF Y(S)>3 THEN IF WZ(X(S),Y(S)-4)=0 THEN GOSUB 2920:GOSUB 2920:RETURN
7870 IF WZ(X(S)+2,Y(S))=0 THEN GOSUB 2910:GOSUB 2910:RETURN
7880 I=RND(1):IF I>0.5 THEN 7890
7885 GOSUB 2910:RETURN
7890 GOSUB 2920:RETURN
7900 IF WZ(X(S),Y(S)+4)=0 THEN GOSUB 2930:GOSUB 2930:RETURN
7910 IF WZ(X(S)+1,Y(S)+2)=0 THEN GOSUB 2930:GOSUB 2910:RETURN
7920 IF WZ(X(S),Y(S)+2)=0 THEN GOSUB 2930:RETURN
7930 IF WZ(X(S)+1,Y(S))=0 THEN GOSUB 2910:RETURN
7950 IF WZ(X(S)+1,Y(S)+2)=0 THEN GOSUB 2930:GOSUB 2910:RETURN
7960 IF Y(S)<17 THEN IF WZ(X(S),Y(S)+4)=0 THEN GOSUB 2930:GOSUB 2930:RETURN
7970 IF WZ(X(S)+2,Y(S))=0 THEN GOSUB 2910:GOSUB 2910:RETURN
7980 I=RND(1):IF I>0.5 THEN 7990
7985 GOSUB 2910:RETURN
7990 GOSUB 2930:RETURN
8000 IF WZ(X(1)+1,Y(1))=0 THEN GOSUB 2900:E=1:RETURN
8010 IF Y(1)<19 THEN IF WZ(X(1)+1,Y(1)+2)=0 THEN GOSUB 2900:GOSUB 2930:RETURN
8020 IF Y(1)>1 THEN IF WZ(X(1)+1,Y(1)-2)=0 THEN GOSUB 2900:GOSUB 2920:RETURN
8030 IF Y(1)<19 THEN IF WZ(X(1)+2,Y(1)+2)=0 THEN GOSUB 2930:RETURN
8040 IF Y(1)>1 THEN IF WZ(X(1)+2,Y(1)-2)=0 THEN GOSUB 2920:RETURN
8045 E=0:RETURN
8050 IF WZ(X(1)+1,Y(1))=0 THEN GOSUB 2900:GOSUB 2900:E=1:RETURN
8060 IF WZ(X(1)+2,Y(1))=0 THEN GOSUB 2900:RETURN
8070 IF Y(1)>1 THEN IF WZ(X(1)+2,Y(1)-2)=0 THEN GOSUB 2900:GOSUB 2920:RETURN
8080 IF Y(1)<19 THEN IF WZ(X(1)+2,Y(1)+2)=0 THEN GOSUB 2900:GOSUB 2930:RETURN
8090 E=0:RETURN
8100 IF WZ(X(1),Y(1)+2)=0 THEN GOSUB 2920:E=1:RETURN
8110 IF X(1)>1 THEN IF WZ(X(1)-1,Y(1)+2)=0 THEN GOSUB 2920:GOSUB 2900:E=0:RETURN
8120 IF X(1)<4 THEN IF WZ(X(1)+1,Y(1)+2)=0 THEN GOSUB 2920:GOSUB 2910:E=0:RETURN
8130 IF X(1)>1 THEN IF WZ(X(1)-1,Y(1)+4)=0 THEN GOSUB 2900:E=0:RETURN
8140 IF X(1)<4 THEN IF WZ(X(1)+1,Y(1)+4)=0 THEN GOSUB 2910:E=0:RETURN
8145 E=0:RETURN
8150 IF WZ(X(1),Y(1)+2)=0 THEN GOSUB 2920:GOSUB 2920:E=1:RETURN
8160 IF WZ(X(1),Y(1)+4)=0 THEN GOSUB 2920:E=0:RETURN
8170 IF X(1)>1 THEN IF WZ(X(1)-1,Y(1)+4)=0 THEN GOSUB 2900:GOSUB 2920:RETURN
8180 IF X(1)<4 THEN IF WZ(X(1)+1,Y(1)+4)=0 THEN GOSUB 2910:GOSUB 2920:RETURN
8190 E=0:RETURN
8200 IF WZ(X(1),Y(1)-2)=0 THEN GOSUB 2930:E=1:RETURN
8210 IF X(1)<4 THEN IF WZ(X(1)+1,Y(1)-2)=0 THEN GOSUB 2930:GOSUB 2910:RETURN
8220 IF X(1)>1 THEN IF WZ(X(1)-1,Y(1)-2)=0 THEN GOSUB 2930:GOSUB 2900:RETURN
8230 IF X(1)<4 THEN IF WZ(X(1)+1,Y(1)-4)=0 THEN GOSUB 2910:E=0:RETURN
8240 IF X(1)>1 THEN IF WZ(X(1)-1,Y(1)-4)=0 THEN GOSUB 2900:E=0:RETURN
8245 E=0:RETURN
8250 IF WZ(X(1),Y(1)-2)=0 THEN GOSUB 2930:GOSUB 2930:E=1:RETURN
8260 IF WZ(X(1),Y(1)-4)=0 THEN GOSUB 2930:RETURN
8270 IF X(1)>1 THEN IF WZ(X(1)-1,Y(1)-4)=0 THEN GOSUB 2900:GOSUB 2930:RETURN
8280 IF X(1)<4 THEN IF WZ(X(1)+1,Y(1)-4)=0 THEN GOSUB 2910:GOSUB 2930:RETURN
8290 E=0:RETURN
8300 IF WZ(X(1)-1,Y(1))=0 THEN GOSUB 2910:E=1:RETURN
8310 IF Y(1)>1 THEN IF WZ(X(1)-1,Y(1)-2)=0 THEN GOSUB 2910:GOSUB 2920:RETURN
8320 IF Y(1)<19 THEN IF WZ(X(1)-1,Y(1)+2)=0 THEN GOSUB 2910:GOSUB 2930:RETURN
8330 IF Y(1)>1 THEN IF WZ(X(1)-2,Y(1)-2)=0 THEN GOSUB 2920:RETURN
8340 IF Y(1)<19 THEN IF WZ(X(1)-2,Y(1)+2)=0 THEN GOSUB 2930:RETURN
8345 E=0:RETURN
8350 IF WZ(X(1)-1,Y(1))=0 THEN GOSUB 2910:GOSUB 2910:E=1:RETURN
8360 IF WZ(X(1)-2,Y(1))=0 THEN GOSUB 2910:RETURN
8370 IF Y(1)>1 THEN IF WZ(X(1)-2,Y(1)-2)=0 THEN GOSUB 2910:GOSUB 2920:RETURN
8380 IF Y(1)<19 THEN IF WZ(X(1)-2,Y(1)+2)=0 THEN GOSUB 2910:GOSUB 2930:RETURN
8390 E=0:RETURN
8400 IF X(1)-X(S)=0 THEN 8450
8410 I=Y(1)*8:J=X(1)*16-16: FOR III=-1 TO 0
8415 FOR II=0 TO 7:LINE I+II,J,I+II,J+15,III^2:LINE I-II,J,I-II,J+15,III^2
8420 FOR JJ=1 TO 100:NEXT :NEXT :NEXT : GOTO 2940
8450 I=Y(1)*8-8:J=X(1)*16-8: FOR III=-1 TO 0
8455 FOR II=0 TO 7:LINE I,J+II,I+15,J+II,III*III:LINE I,J-II,I+15,J-II,III*III
8470 FOR JJ=1 TO 100:NEXT :NEXT :NEXT : GOTO 2940
8500 IF WZ(X(S),Y(S)+4)=0 THEN GOSUB 2930:GOSUB 2930:RETURN
8510 IF WZ(X(S),Y(S)+2)=0 THEN GOSUB 2930:RETURN ELSE RETURN
8600 IF WZ(X(S),Y(S)-4)=0 THEN GOSUB 2920:GOSUB 2920:E=0:RETURN
8610 IF WZ(X(S),Y(S)-2)=0 THEN GOSUB 2920:RETURN ELSE RETURN
8800 IF E=1 THEN 8400 ELSE 2050
9000 CLS:PRINT "①存档一","②存档二","③存档三","④存档四","⑤存档五";
9011 T$=INKEY$:IF (T$="b")+(T$="n")+(T$="m")+(T$="g")+(T$="h") THEN 9012 ELSE BEEP:9011
9012 GOSUB 10:LOCATE T,9:PRINT "保存中…";
9013 CLOSE #1:OPEN "DJFMJsave"+STR$(T) FOR OUTPUTAS#1
9020 WRITE #1,A,B,X,Y,MO,DJ,HP,HPP,MP,MPP,JY,JYZ,GGL,Q,R,M(1),N(1),QT,W,V
9040 FOR I=2 TO 6:WRITE #1,KP(I),KPP(I):NEXT
9050 FOR I=1 TO 6:WRITE #1,YPS(I):NEXT
9060 FOR I=1 TO 5:WRITE #1,X(I),Y(I),WZ(X(I),Y(I)):NEXT :CLOSE #1:GOSUB 9175:RETURN
9110 CLS:PRINT "①存档一","②存档二","③存档三","④存档四","⑤存档五";
9111 T$=INKEY$:IF (T$="b")+(T$="n")+(T$="m")+(T$="g")+(T$="h") THEN 9112 ELSE BEEP:9111
9112 GOSUB 10:LOCATE T,9:PRINT "载入中…";
9113 OPEN "DJFMJsave"+STR$(T) FOR INPUT AS#1
9120 INPUT #1,A,B,X,Y,MO,DJ,HP,HPP,MP,MPP,JY,JYZ,GGL,Q,R,M(1),N(1),QT,W,V
9140 FOR I=2 TO 6:INPUT #1,KP(I),KPP(I):NEXT
9150 FOR I=1 TO 6:INPUT #1,YPS(I):NEXT
9160 FOR I=1 TO 5:INPUT #1,X(I),Y(I),WZ(X(I),Y(I)):NEXT
9170 CLOSE #1:GOSUB 9175: GOTO 9180
9175 OPEN "FMYXZMAP" FOR RANDOM AS #1 LEN=128:FIELD #1,128 AS MAP$:RETURN
9180 RR=0:IF B=1 THEN 505 ELSE CLS:GOTO 2050
9200 CLS:PRINT "本程序由薛顺健开发设计，本着要把游戏做得更好的原则，但我的时间和精";
9210 PRINT "力有限，还望各位用户见谅！";:T$=INKEY$: GOTO 9300
9300 GET #1,56:CLS:PRINT MAP$;:GOSUB 9994
9320 T$=INKEY$:GOSUB 10
9325 IF T<1 OR T>6 THEN 9320
9330 I=1:ON T GOTO 9350,9360,9390,9500,9200,9800
9340 BEEP: GOTO 9320
9350 RETURN
9360 P=1:CLS:PRINT "*****";NA$(1);"的状态";"*****";: GOTO 9370
9365 T=ASC(INKEY$):IF T=20 OR T=21 OR T=27 THEN 9366 ELSE BEEP:9365
9366 IF T=20 THEN P=P-1:IF P=0 THEN BEEP:P=1:9365
9367 IF T=21 THEN P=P+1:IF P=3 THEN BEEP:P=2:9365
9368 IF T=27 AND I=1 THEN 9300 ELSE IF T=27 AND I=0 THEN 9900
9369 ON P GOTO 9370,9380
9370 LOCATE 2,1:PRINT SPC (69);
9371 LOCATE 2,1:PRINT "等级：";DJ;"级","经验：";JY;"/";JYZ,"体力：";HP;"/";HPP;
9375 GOTO 9365
9380 LOCATE 2,1:PRINT SPC (69);
9381 LOCATE 2,1:PRINT "法力：";MP;"/";MPP,"攻击力：";GGL,"金钱：";MO;
9385 GOTO 9365
9390 CLS:PRINT "①存档","②读档"
9391 T$=INKEY$:IF T$="b" OR T$="n" OR ASC(T$)=27 THEN 9392 ELSE BEEP:9391
9392 GOSUB 10:IF T=1 THEN GOSUB 9000: GOTO 9300
9393 IF T=2 THEN CLOSE #1: GOTO 9110
9394 IF ASC(T$)=27 THEN 9300
9400 CLS:PRINT "①";YP$(1);"×";:LOCATE 1,11:PRINT "④";YP$(4);"×";
9401 LOCATE 2,1:PRINT "②";YP$(2);"×";:LOCATE 2,11:PRINT "⑤";YP$(5);"×";
9402 LOCATE 3,1:PRINT "③";YP$(3);"×";:LOCATE 3,11:PRINT "⑥";YP$(6);"×";
9403 LOCATE 4,15:PRINT RW$(1);
9410 LOCATE 1,9:PRINT YPS(1);:LOCATE 1,19:PRINT YPS(4);
9411 LOCATE 2,9:PRINT YPS(2);:LOCATE 2,19:PRINT YPS(5);
9412 LOCATE 3,9:PRINT YPS(3);:LOCATE 3,19:PRINT YPS(6);
9415 T$=INKEY$:GOSUB 10
9416 IF T$=CHR$(27) THEN S=1:9490
9417 GXX(T)=GX(T):GXX(3)=HPP-HP:GXX(6)=MPP-MP
9418 IF T<4 AND HPP9419 IF T>3 AND MPP9420 IF YPS(T)=0 THEN BEEP:9415
9421 IF T>3 AND MP=MPP THEN LOCATE 5,1:PRINT AAA$(5);:BEEP:9415
9422 IF T<4 AND HP=HPP THEN LOCATE 5,1:PRINT AAA$(4);:BEEP:9415
9430 IF T>3 THEN PR$="法力＋":MP=MP+GXX(T) ELSE PR$="体力＋":HP=HP+GXX(T)
9460 YPS(T)=YPS(T)-1: FOR II=1 TO 0 STEP -1: FOR I=0 TO 9:CIRCLE 120,56,I,1,II
9470 FOR J=1 TO 100:NEXT :NEXT :NEXT :LOCATE 4,15:PRINT RW$(1);
9480 LOCATE 5,1:PRINT PR$;GXX(T);:T$=INKEY$:T$="Y"
9490 GOSUB 9994:RETURN
9500 GOSUB 9400: GOTO 9300
9800 CLS:PRINT " 程序设计：薛顺健 E-mail:wqstar028@mai l.china.com"
9810 PRINT " QQ:12068232 有空请和我联系！";
9820 T$=INKEY$:BOX 0,0,160,80,1,2:FOR I=1 TO 2000:NEXT:FOR I=0 TO 80
9821 BOX I,I/2,160-I,80-I/2,0,0:FOR J=1 TO 50 :NEXT:NEXT
9825 CLS:LOCATE 2,7:PRINT "谢谢使用！":LOCATE 3,9:PRINT "再见！"
9830 FOR I=1 TO 4000:NEXT:POKE 199,155
9900 GET #1,55:CLS:PRINT MAP$;:LOCATE 5,16:PRINT " ";:I=0
9910 T$=INKEY$:GOSUB 10:ON T GOTO 9920,9360,9930,9800:BEEP: GOTO 9910
9920 GOSUB 9994:RETURN
9930 GOSUB 9000: GOTO 9900
9994 LOCATE 5,1:PRINT " ";:RETURN
9995 GET #1,R+1
9996 LOCATE 1,1:PRINT MAP$;:LOCATE X(1),Y(1):PRINT RW$(1);: FOR J=2 TO 5:IF KP(J)=0 THEN 9998
9997 LOCATE X(J),Y(J):PRINT NPC$(J);
9998 NEXT :IF R=INT(R/5)*5 THEN WZ(3,19)=6
9999 RETURN

说到RPG的话，BBK上有个完成度还行的
http://kfxsmxd.5d6d.com/bbs.php

想怀旧的话，还有古物Apple][，不过自己是没有经历到那么久远的事情。
SuperCard和QBasic/VB6是什么已经没有人在意了。

不过现在这年头，拿Scratch或者PyGame或者Processing都不算复杂的事情，还天生跨平台。

不过多少这些也只是小群体的自娱自乐罢了。

说到RPG的话，当行为和氛围一致的时候是最有感觉的。哪怕仅仅是路过一片风景，也有其中蕴含的情感。一路上考虑人物的培养和行动的选择与策略以及人物之间内心和态度的发展。
----
好吧，我想到 FF7/10 和 sola 了，当然风格和类型是不限于此了。

【挖一挖】levelup.cn的论坛ACG小说版的某些内容

2011-08-27T15:58:00.005+08:00

去年的时候从bingj.com的页面存档里挖出来的，现转过来做纪念。
挖取的目标是http://archive.bbs.levelup.cn/showforum-67-(\d+).aspx
挖取的结果是http://www.uudisc.com/group/10240/topic/37165
以下的便是当初挖取结果的内容，不过那里也快挂了。
话说levelup也出过此方面的杂志，也已经早早的挂了，仅还可以搜索到目录。

[轻小说]《月兔的银色方舟》作者：[日]鴨志田一
[轻小说]《白山同学与黑色手提袋》第一卷作者：[日铃木铃
[轻小说]《攻壳机动队——宇宙生化人》作者：[日]远藤明范
[游戏小说]《水仙》全一卷作者：[日]片冈とも
[轻小说]《がく×ぶる》（第一卷）作者：[日]本田透
[杂书？]《征服世界有可能的吗》作者：[日]冈田斗司夫
[轻小说]《莱茵河的囚徒》作者：[日]田中芳树
雛形
[轻小说]《杀×爱》作者：风见周（0~4）
[轻小说]《魔女宅急便》作者：角野荣子（全）
[轻小说]《新本格魔法少女莉丝佳》作者：西尾维新（1~2）
[輕小說]《狼與辛香料》作者：[日]支仓冻沙（13+短篇）12/17更新
[轻小说] 《文学少女》作者：野村美月（1-8+短篇完）12/17日更新
[轻小说]《仰望半月的夜空》作者：桥本纺（1-8卷+2短篇完结）
[轻小说]《离别的钢琴奏鸣曲 1~2》作者：杉井光 12/9更新第2卷
[轻小说] 这本轻小说真厉害！2009年前10名作品集合！
[轻小说]《超人家族一家和乐!? 》作者：桥本和也（1～4）12/9更新第4卷
[轻小说]《电波系彼女三卷全》作者：片山宪太郎
[轻小说]《冰箱上的洞》作者：KOMUGI
[轻小说]《初恋魔法电击》作者：明日香正太（1-9完整版未完）
[排行榜] 这本轻小说真厉害2010
[轻小说]《电波男》作者：本田透（适合宅人群= =）
求书~~~~知道三毛的进来哈
[轻小说]《魔法少女奈叶》作者：都筑真纪（全）
[日本小说]《人间失格》作者：太宰治
[遊戲劇本]《真月譚月姬》作者：[日]奈须きのこ（完整版）
[遊戲小說]《格蘭蒂亞》作者：[日]細江ひろみ
[轻小说]《圣魔之血长篇+短篇》作者：吉田直在
[轻小说] 《便·当味噌炖青花鱼290元》作者：朝浦（第1卷未完）
[輕小說]《百花缭乱》作者：すずきぁきら（2卷未）11/30更新
[轻小说]《影≒光 Shadow Light》作者：影名浅海（1~5）
[游戏相关] 《潜龙谍影 - Metal Gear Solid 官方小说》
[轻小说]《银盘万花筒》作者：海原零（1~9）
[推理侦探]《白夜行》作者：东野圭吾
[轻小说]《神样家族》作者：桑岛由一（1~7）
[合集小说]乙一作品集[共32篇]
[轻小说]《风之圣痕》作者：山门敬宏（1~6+短篇）
[轻小说]《空罐少女！》作者：蓝上陆/铃平ひろ（1~4）
[轻小说]《骷髅恋人》作者：平坂读（1~5）
[轻小说]《眼镜男与断头少女》作者：藤原祐（1~2）
[妖怪小说]《巷说百物语》作者：京极夏彦（1~4完结）
[国产轻小说]《長安幻夜》原作：面堂兄漫画：韩露（漫友人气连载）
[輕小說]《虚轴少女ResinCastMilk》作者：[日]藤原佑（1-5）
[漫画改编]《黑血》原案/漫画：赵佳
[輕小說]《触摸魔女》作者：[日]镜裕之
银河铁道之夜
哈里7：哈里波特与死圣
[遊戲相關]《Tales of Symphonia 拉塔特斯克的骑士世界之愿》作者：[日]矢島さら
[輕小说] 《乃木坂春香的秘密》作者：[日]五十岚雄策（10卷）11/09更新

[輕小說]《IS》作者：[日]弓弦イズル
[轻小说]《电波女与青春男01》作者：入间人间
[轻小说]《奇诺之旅》作者：时雨泽惠一（1-12+外+PS2剧本）11/6更新
[动漫相关]《云之彼端约定之地》原作：新海诚
[轻小说]《打工魔法师》作者：椎野美由贵（1～8）10/25更新第8卷
给寺院拍照照片出来后我惊呆了（恐怖）
[輕小說]《Campione!神不值得信奉》作者：[日]丈月城
[轻小说]《灼眼的夏娜》作者：高桥弥七郎 10/21更新19卷
[轻小说]谷川流作品集（部分附插画），纳米盘
[推理小说]《魔术的耳语》作者：宫部美雪
[轻小说]《亲亲坏老爹》作者：野村美月（1-4卷）9/22更新
[畅销经典]《肖申克的救赎》作者：斯蒂芬·金
[轻小说]《听到涛声》作者：冰室冴子（1～2+番外篇）
[轻小说]《MAMA》作者：红玉ぃづき
[推理小说]《猎捕史奈克》作者：宫部美雪
[轻小说]《超妹大战》作者：古桥修之（1～2）
[动漫相关]《名侦探柯南江神原的魔女》作者：平良隆久
[推理小说]《火车》作者：宫部美雪
[轻小说]《幻影父亲》作者：深泽美潮
[輕小說]《Resin Cast Milk 虚轴少女的日常》作者：[日]藤原佑
[轻小说]《吊线木偶症候群》作者：乾久留美
[轻小说]《不適合少女的職業》作者：櫻庭一樹
[轻小说]《镇魂练习曲》作者：北泽大辅（1～3）
[动漫相关]《L改变世界洛杉矶BB连续杀人案件》作者：西尾维新
[动漫小说] 《反逆的鲁路修官方小说朱之轨迹》作者：岩佐守（完）
[动漫相关]《空中杀手》作者：森博嗣（完）
[2009]这本轻小说最厉害TOP50！
[轻小说]《在暗夜中寻找羔羊》作者：穗史贺雅也（1～3完结）
[輕小說]《我甜蜜的苦涩委内瑞拉》作者：[日]森田季节
[輕小說]《机巧魔神》作者：[日]三雲岳斗
[輕小說]《東京吸血鬼金融》作者：[日]真藤順丈
[輕小說]《闲狼作家是美少女妖怪？》作者：[日]杉井光
[輕小說]《梅格＆賽隆》作者：[日]时雨泽惠一
[轻小说]《盖棺论定！》作者：文冈あちら
[剧情小说]《流行之神》作者：不详
[轻小说]《凛子与昭介の故事&Yaorozu》作者：土塀赋之古户真智子
[轻小说]《此处前方是荒野》作者：水无神知宏
[轻小说]《串刺少女》作者：木村航（1～3完结）
[輕小說]《幸运机会！》作者：[日]有泽真水
《精子战争》
两本工具书：完全复仇手册，完全失踪手册
[推理小说]《他人事》作者：平山梦明
[遊戲相關]《命运传奇命运传承者》作者：[日]矢島さら（上下全）9/19更新
[轻小说]《心灵侦探八云》作者：神永学（1～2）
[惊悚小说]《ZOO》作者：[日]乙一
[轻小说]《疾走！青春期的帕拉贝伦》作者：深见真（1～2）
[推理小說]《狂骨之夢》作者：[日]京极夏彦（上下全）
[轻小说]《MM一族》作者：松野秋鸣（1-8未） 9/12更新
[轻小说]《9S》作者：[日]叶山透（1-9+Memories+SS，未完结）
[短篇轻小说]《辉石之花》作者：河屋一

[轻小说]《七人武器店》（1-2）作者：[日]大乐绚太（未完结）
[轻小说]《魔法战士李维》作者：[日]水野良（未完结）
[轻小说]《春季限定草莓塔事件》作者：米泽穗信
[推理小说]《铁鼠之槛》作者：京极夏彦
[輕小說]《學生會的日常》作者：[日]葵せきな（1卷未）
[资料收集]英雄无敌生物背景考究
[輕小說]《佰物語》广播剧全对话翻譯. 作者：[日]西尾維新
[轻小说]《壳中少女》作者：冲方丁（全）
[科幻军事]《光晕》（1～4全）作者：[美] 埃里克·尼伦德&威廉·C·迪茨 [中
[轻小说]《终焉的年代记》作者：川上稔（1-3上未完） 8/24更新
《灵异知识普及资料》作者：不详
[轻小说]《在遙遠彼方的小千》作者：日日日（全一卷）
[轻小说]《拯救你的最初咒语》作者：须堂项（1~2未完）
[轻小说]《捨棄在八月的路上》作者：伊藤たかみ（全一卷）
[幻想小说]《妖藩记鬼剑众》作者：菊地秀行
[剧情小说]《最终幻想VI》作者:不详
[官方小说]《怪物猎人2G魂之继承者1-5》作者：冰上惠一
[轻小说]《神灯女仆1-4》作者：夏绿
[奇幻经典]被遗忘的国度系列（包含部分英文原著）更新《血脉+无星之夜》
[游戏相关]《秋之回忆1-3+从今以后》作者:不详
[轻小说]《七姬物语1-4》作者：高野和
[轻小说]《狂恋声优宝贝》作者：木本雅彦
[轻小说]《彈珠汽水》作者：[日]鴻野貴光（全一卷）
[輕小說]《小齒輪！》作者：[日]樋口司
[热门小说]《凉宫春日的忧郁》作者：谷川流
【科幻】《光晕三部曲》作者：[美] 埃里克·尼伦德威廉·C·迪茨
[轻小说]《女帝·龍凰院麟音的初恋第一卷》作者：[日]风见周
[动漫相关]《晴空之Air1-6》作者：不详
[轻小说]《学校的阶梯》作者：櫂末高彰（1～9+短篇未完）8/8更新
[剧情小说]《寄生前夜2》作者：不详
强烈推荐《战神
[轻小说]《神样灵感少女+传说灵感少女》作者：松原真琴/小畑健（8/1更新完结）
城寨书房版规
电子书资源获取流程及阅读、排版工具
[轻小说]《抱歉咯?二之宫同学》作者：铃木大辅（1卷未）
求书求助专贴
[轻小说]《重回那天》作者：健速（全一卷）
[灵异小说]《怪谈新耳袋》作者：木原浩胜、中山市朗
[轻小说]《请别忧伤了，二之宫君1-10全》作者：钤木大辅
[轻小说]《流星慢舞》作者：桥本纺
【奇幻】《被遗忘的国度》系列：伊尔明斯特之旅
[轻小说]《放学后的征服世界》作者：わかつきひかる
[短篇轻小说]《可疑的少女与危险的少年》作者：深见真
[轻小说]《新罗德斯岛战记》作者：【日】水野良（全）
[轻小说]《七都市物语（全）》作者：田中芳树
[轻小说]《XXXHOLIC兰德尔特环的粉尘]》作者：西尾维新
[动漫相关]《L改变世界+外传》作者:西尾维新
[轻小说]《Black Blood Brother》作者：あざの耕平（1-5+外） 7/7更新
[轻小说]《郭德堡变奏曲》作者：五代ゆぅ
[轻小说]《逃离学校！》作者：谷川流

[轻小说]《郭德堡变奏曲》作者：五代ゆぅ
[轻小说]《逃离学校！》作者：谷川流
[轻小说]《电击!!神盾5少女》作者：谷川流（1～2 全）
[轻小说]《铁拳灵感少女》作者：松原真琴/小畑健
[游戏相关]《潜龙谍影4官方小说下》（已完结）作者：伊藤计划
[轻小说]《我的亲爱主人！？》作者：鹰野佑希（1-5完） 7/4更新
[轻小说]《斩鬼夜鸟子1-3》作者：树田省治
[轻小说]《单恋的麒麟1-2》作者：志村一矢
[轻小说]《神曲奏界異色協奏》作者：淺井ラボ、あざの耕平、神野奧那、三田誠
[轻小说]《欢迎来到NHK!》作者：滝本竜彦
[短篇小说]《月之雨物语》作者：古茶（全）
[轻小说]《云霄飞车》作者：山田悠介（全）
[轻小说]《某一天，炸弹从天而降》作者：古桥秀之（全）
[游戏小说]《最终幻想Ⅶ~On the way to a smile》（那那岐篇神罗篇尤菲篇）
[轻小说]《罗德岛战记+罗德岛传说+新罗德斯岛战记》作者：水野良
[轻小说]《替身伯爵系列 1》作者：清家未森
[轻小说]《天空之钟响彻惑星》作者：渡濑草一郎（1-9）
皆杀的田中芳树！二十枚入~
[轻小说]《晴空之下，突然……（全）》作者：田中芳树
[轻小说]《自卫队三部曲第一部盐之街》作者：有川浩
[恐怖小说]《第十三种人格的恐怖》作者：贵志祐介
[轻小说]《虚轴少女1-5 Resin Cast Milk》作者：藤原祐
[轻小说]《虫之歌》作者：岩井恭平（9卷+BUG系列+外传）
[轻小说]《我的爱马很凶恶》作者：新井辉
[轻小说]《Bad！Daddy 亲亲坏老爹1-3》作者：不詳
[畅销小说]《天竺热风录》作者：田中芳树（波澜壮阔的盛唐再现）
[轻小说]《三月.七日》作者：森桥ビソゴ（1～2 全）
[轻小说]《本格推理委员会》作者：日向正道（全）
[动漫相关]《闪光的哈萨维》作者:不详
[轻小说]《绯弹的亚里亚1～3》作者：赤松中学
[轻小说]《战斗司书与虚言者的宴会》作者：山形石雄
[日本科幻]《寄生前夜》作者：濑名秀明
[游戏剧本]《最终幻想X-2外传你所吹响的口哨》作者：ベニー松山
阴阳师第①-⑧卷全集》作者：[日]梦枕貘 TXT
[短篇轻小说]《夏天，真纪子与MD-WalkMan的故事》作者：紅玉いづき
[轻小说]《幽灵恋人1～4》作者：平坂读
[轻小说]《一切终将远去》作者：山本文绪
[轻小说]《幽灵少女与科学少年1～2》作者：飞田甲
[轻小说]《烟囟町的赤魔与绝望少年 1 》作者：ゆうきりん
[推理小说]《“犀川&萌绘”系列》作者：森博嗣（1～2未完）
[轻小说]《虎跃龙笑狮王争霸！》作者：嬉野秋彦（1～2未完）
[推理小说]《姑获鸟之夏》作者：京极夏彦
[轻小说]《消极的快乐、电锯的边缘》作者：泷本龙彦（全）
[轻小说]《快打城市 slum online》作者：樱坂洋
[轻小说]《ALL YOU NEED IS KILL》作者：樱坂洋
[轻小说]《青叶君与宇宙人1~3》作者：松野秋鸣
[轻小说]《加速世界第一卷》作者：不詳
[轻小说]《吉永家的石像怪1-11》作者：田口仙年堂
[轻小说]《无头骑士异闻录 DuRaRaRa！！1-2》作者：成田良悟
[流行小说]药师寺凉子怪奇事件簿（1~7卷）作者：田中芳树

[轻小说]《莉莉亚＆特雷兹》作者：时雨泽惠一（全）
[游戏相关]《寂静岭》作者：山下定
[动漫相关]《战斗妖精·雪风》作者：神林长平
[輕小說]《抽签勇者1-8》作者:清水文化
[动漫相关]《今日起是魔王17-20》作者:乔林知
[轻小说]《DoubleDown—以小博大的勘缲郎》作者：西尾维新（全）
[轻小说]《艾莉森》作者：时雨泽惠一（全）
[轻小说]《自卫队三部曲第二部空之中》作者：有川浩（全）
[轻小说]《淑女骑士团 Lady General》作者：千田诚行（未完）
[动漫相关]《君吻》作者：日暮茶坊（未完）
[架空都市]《波罗的海复仇记（全）》作者：田中芳树
[架空都市]《梦幻都市（全）》作者：田中芳树
[轻小说]《黑龙潭异闻短篇集（全）》作者：田中芳树
[历史傳记]《海嘯》作者：田中芳树
[轻小说]《狂乱家族日记》作者：日日日
[轻小说]《钢铁白兔骑士团》作者：舞阪洸（1-6卷未完）5/31日更新
[日系耽美]《三千世界鸦杀1-13+番外前传+090601更新丧神之碑》作者：津守时生
[轻小说]《复仇之虎（全）》作者：田中芳树
[轻小说]《风翔万里（全）》作者：田中芳树
[轻小说]《绞缬城绮谭（全）》作者：田中芳树
[轻小说]《灼热的龙骑兵（3本全）》作者：田中芳树
[轻小说] 《圣诞节的恐怖分子》作者：佐藤友哉（全一卷）
[轻小说]《神的记事本》作者：杉井光（1-3卷未完）
[历史傳记]《奔流》作者：田中芳树
[历史傳记]《红尘》作者：田中芳树
[動漫相关]《星之声》作者：新海诚
[影视相关]《变形金刚电影版前傳昨日幽靈》作者：不詳
[轻小说]《我的狐仙女友1-4》作者：西野胜海
[剧情小说]《潜龙谍影4爱国者之枪》作者：不详
[轻小说]《你我崩坏的世界》作者：西尾纬新
[轻小说]《DDD》作者：奈须きのこ（1-2卷未完）
[轻小说]《侵略少女与谎言庭院》作者：清水マリコ（1卷全）
[轻小说]《公主+天国》作者：風見周（第1卷未完）
[推理小说] 《秋叶原@DEEP》作者：石田衣良（全）
[动漫相关]《PHANTOM OF INFERNO 无间地狱》作者：虚渊玄
[轻小说]《战斗司书 1-7》作者：山形石雄
[轻小说]《碧阳学园学生会议事錄1-3+外傳》作者：葵せきな
[轻小说]《伊里野的天空 UFO的夏天》作者：秋山瑞人（1-4+短篇全）
[动漫小说] 《魍魉之匣》作者：京极夏彦（全）
[轻小说]《黑猫1-2》作者：大崎知仁
[轻小说]《我的世界守护者》作者：谷川流
[轻小说]《轻小说的快乐写法》作者：本田透
[轻小说]《学院人体练金术一卷全》作者：筱崎一夜
[官方小说]《女神侧身像希尔梅丽娅2》作者：梅村崇翻译：YULA、翔月
[轻小说]《伯爵与妖精11-16+短篇》作者：谷瑞惠
[轻小说]《临界杀机》作者：神崎紫电（1-2未完）
[轻小说]《魔法目录》作者：鎌池和马（1-8卷）
[轻小说] 《空之轨迹长篇同人炎の轨迹》作者：夏木の友人帐
[動漫相關]《女王之刃独角兽之剑》作者：冲田荣次
[轻小说]《惡女來敲門》作者：织田兄第

[轻小说]《高校女仆警察1-4》作者：沢上水也
[轻小说]《风之圣痕 1-6卷+外传》作者：山门敬弘（靈異類）
[官方小说]《JOJO的奇妙冒险》作者:乙一
[动漫相关]《灼眼的夏娜17、18》作者：高桥弥七郎
[轻小说]《狼与辛香料》作者：支仓冻砂（1-10卷）
[轻小说]《绝望的世界1~腐蚀篇》作者：宫谷俊二
[轻小说]《永生之酒》作者：成田良悟（1-6未完）
[轻小说]《对某个飞行员的追忆》作者：犬村小六翻译：demongod
[人物传记]《德川家康》作者：山冈庄八
[剧情小说]《零~月蚀的假面》作者:不详
[官方小说]《失落的奥德赛番外塞丝、敏篇》作者：重松清翻译：夜蓝
[游戏剧本]《奥丁领域》作者:不详（DOC下载慎入！）
[剧情小说]《聖女之歌》作者：不详
[同人小说]《恶魔城审判时之缝隙》作者：有须hideki
[游戏剧本] 《CLANNAD》中文剧本作者：不详
[剧情小说]《合金装备》作者：不详
[剧情小说]《晓之女神》作者：不详
[剧情小说]《莎木》作者：不详
[军事小说]《环形世界》作者：菲立普·狄克（光环原案）
[动漫小说] 《女王之刃》TV版很黄很暴力作者：不知道（1-3未完）
[轻小说]《月兔公主》作者:野村美月
[轻小说] 《扉之外~the outside of door》作者：土桥真二郎（1-3全）
[剧情小说]《王国之心2》作者：不详
[剧情小说]《荒野兵器4 上》作者：不详
[剧情小说] 《王国之心Ⅱ》序章剧情小说作者：LightLucifer
[官方小说]《战国basara2》作者：不详
[轻小说]《新橙路》作者：松本泉寺田宪史
[轻小说]《银之镇魂歌》作者：吉原理惠子
[动漫相关]《苍穹之巨龙》作者:冲方丁
[动漫相关]《钢壳都市雷吉欧斯1-7+番外》作者：雨木シュウスケ
[中文剧本]《最终幻想战略版》作者:天幻
[剧情小说]《银河游侠》作者:不详
[动漫相关]《今日起是魔王1-16》作者:乔林知
[动漫相关]《最终兵器彼女全》作者:不详
[游戏相关]《最终幻想11 官方小说-守护之剑》作者:不详
[D&D]《时光之轮：世界之眼1-5》作者：罗伯特·乔丹
[剧情小说]《大神》作者：不详
[轻小说]《图书馆战争1~4全》作者:有川浩（09年2月2更新番外）
[官方小说]《女神侧身像两卷全》作者：梅村崇
[游戏小说]《北欧女神》作者：不详
[游戏小说]《女神侧身像希尔梅丽娅》作者：不详
[动漫相关]《天是红河岸外传魔之时代的黎明》作者：筱原千绘
[轻小说]《我家有个狐仙大人1-6》作者：柴村仁译者：张信儀
[动漫相关]《攻壳机动队宇宙生化人》作者：远藤明范翻译：赵玲
[轻小说]《寒蝉鸣泣之时1-5》作者：龙骑士07
[动漫相关]《真·天地无用_魉皇鬼1-2》作者:不详
[轻小说]《风之大陆1-9》作者：河竹圣
[轻小说]《黑执事上》作者：不详
[官方小说]《宿命传说苍黑的追忆》原作：矢島さら翻译：子云
[轻小说]《悖德之城（全）》作者：桑原水菜

此外，还有个城寨书房的全区资源索引帖，放在下面：

A
[轻小说]《艾莉森》作者：时雨泽惠一（全）
[轻小说]《阿妮丝与爱摆臭脸的魔法使》1-3卷作者：[日]花房牧生
[轻小说]《ALL YOU NEED IS KILL》作者：樱坂洋 (全)
[轻小说]《莉莉亚＆特雷兹》作者：时雨泽惠一（全）
[游戏相关]《奥丁领域古温托丽篇》作者：不详
[游戏剧本]《奥丁领域》作者:不详（DOC下载慎入！）

B
[轻小说] 《便·当味噌炖青花鱼290元》作者：朝浦（第1卷未完）
[轻小说]《白山同学与黑色手提袋》第一卷作者：[日铃木铃
[推理侦探]《白夜行》作者：东野圭吾
[轻小说]《不適合少女的職業》作者：櫻庭一樹
[轻小说]《凛子与昭介の故事&Yaorozu》作者：土塀赋之古户真智子
[輕小說]《佰物語》广播剧全对话翻譯. 作者：[日]西尾維新话
[轻小说]《冰箱上的洞》作者：KOMUGI
[轻小说]《抱歉咯二之宫同学》作者：铃木大辅（1卷未）
[輕小說]《百花缭乱》作者：すずきぁきら（1卷未）
[轻小说]《本格推理委员会》作者：日向正道（全）
[轻小说]《Black Blood Brother》作者：あざの耕平（1-3+外）
[架空都市]《波罗的海复仇记（全）》作者：田中芳树
[历史傳记]《奔流》作者：田中芳树
[影视相关]《变形金刚电影版前傳昨日幽靈》作者：不詳
[轻小说] 《笨蛋，测验，招唤兽》作者：井上坚二（1-5+外传未完）
[游戏小说]《北欧女神》作者：不详
[轻小说]《悖德之城（全）》作者：桑原水菜
[游戏相关]《薄暮传说剧情小说》作者：沙下夜雪
[奇幻经典]《被遗忘的国度系列（包含部分英文原著）》更新《血脉+无星之夜》
[官方小说]《瀞灵庭的阴谋之秋》作者：不详
[动漫相关]《Black Blood Brothers S1》作者：あざの耕平
[日本文学]《白夜的吊钟》作者：田中芳树
[轻小说]《伯爵与妖精1-10》作者：谷瑞惠
[轻小说]《伯爵与妖精11-16+短篇》作者：谷瑞惠
[奇幻合集]《被遗忘国度—短篇集》作者：[美]R·A·萨尔瓦多
[轻小说]《伯爵与妖精》作者：谷瑞惠（日）（1-7卷，同名动漫原著）
[资料典故]《本能寺三劫之变的传说》作者：青树秀吉
[奇幻合集]《被遗忘国度》系列：伊尔明斯特之旅
C
[游戏剧本] 《CLANNAD》中文剧本作者：不详
[动漫相关]《出包王女危险的闺房私语》作者：[日]若月光
[动漫相关]《初恋限定冬季写真》作者：[日]平林佐和子
[輕小說]《创立！？三星学生会》作者：[日]佐々原史绪
[游戏小说]《尘骸魔京》作者：[日]海法纪光
[轻小说]《超钢女雪拉》1~9未完+番外作者：寺田とものり
[轻小说]《菖蒲的少女革命！》第一卷作者：[日]志茂文彦
[輕小說]《触摸魔女》作者：[日]镜裕之
[轻小说]《超妹大战》作者：古桥修之（1～2）
[轻小说]《此处前方是荒野》作者：水无神知宏
[轻小说]《超人家族一家和乐!? 》作者：桥本和也（1～3）
[轻小说]《串刺少女》作者：木村航（1～3完结）
[轻小说]《春季限定草莓塔事件》作者：米泽穗信 (1+解说)
[轻小说]《重回那天》作者：健速（全一卷）
[轻小说]《初恋魔法电击》作者：明日香正太（1-9完整版未完）
[轻小说]《虫之歌》作者：岩井恭平（9卷全+BUG系列+外传）
[輕小說]《抽签勇者1-8》作者:清水文化
[动漫相关]《苍穹之巨龙》作者:冲方丁
[畅销小说]《创龙传1-13卷》作者：田中芳树
[剧情小说]《超级机器人大战OG》作者：不详
[轻小说]《彩云国物语1-14+番外+特典+外传》作者：雪乃纱衣
[轻小说]《铳姬1-4》作者：高殿円
[轻小说]《传说中勇者的传说1-4+外传总而言之的传勇传1-2》作者：镜贵也
[动漫相关]《超时空要塞边界》官方小说第1、2卷作者：小太刀右京
[轻小说]《纯情罗曼史》作者：藤崎都（BL，慎入）
[剧情小说]《重生传说》作者：卡伦
[轻小说]《虫师官方小说》原作：漆原友纪脚本：大友克洋
[国轻小说]《長安幻夜》原作：面堂兄漫画：韩露（漫友人气连载）
[轻小说]《穿越时空的少女》作者:筒井康隆(短篇全)
D
[轻小说]《单恋的麒麟1-2》作者：志村一矢
[轻小说]《电波女与青春男01》作者：入间人间
[轻小说]《吊线木偶症候群》作者：乾久留美
[輕小說]《刀語》作者：[日]西尾維新（未完）
[輕小說]《東京吸血鬼金融》作者：[日]真藤順丈
[轻小说]《彈珠汽水》作者：[日]鴻野貴光（全一卷）
[轻小说]《电波系彼女三卷全》作者：片山宪太郎
[恐怖小说]《第十三种人格的恐怖》作者：贵志祐介
[轻小说]《打工魔法师》作者：椎野美由贵（1～6）
[轻小说]《电波男》作者：本田透（适合宅人群= =）
[轻小说]《DoubleDown—以小博大的勘缲郎》作者：西尾维新（全）
[轻小说]《DDD》作者：奈须きのこ（1-2卷未完）
[轻小说]《对某个飞行员的追忆》作者：犬村小六翻译：demongod
[动漫相关]《地狱少女-彼岸花》作者：天羽沙夜
[畅销小说]《达·芬奇密码、天使与魔鬼、数字城堡、骗局》作者：丹·布朗
[剧情小说]《大神》作者：不详
[台湾戏剧]《大霹雳》作者：不详
[侦探推理]《东野圭吾推理小说合集》作者：东野圭吾
[人物传记]《德川家康》作者：山冈庄八
[人物传记]《德川家康》作者：[曰]松本清张译者：高仁
E
[游戏小说]《恶魔城审判时之缝隙》作者：有须hideki (未完待译)
[轻小说]《恶魔同盟》作者：うえお久光（1～5）
[轻小说]《惡女來敲門》作者：织田兄第

F
[动漫小说] 《反逆的鲁路修官方小说朱之轨迹》作者：岩佐守（完）
[轻小说]《风之圣痕》作者：山门敬宏（1~6+短篇）
[轻小说]《放学后的征服世界》作者：わかつきひかる
[轻小说]《绯弹的亚里亚1～3》作者：赤松中学
[轻小说]《复仇之虎（全）》作者：田中芳树
[轻小说]《风翔万里（全）》作者：田中芳树
[轻小说] 《扉之外~the outside of door》作者：土桥真二郎（1-3全）
[轻小说]《风之大陆1-9》作者：河竹圣
[轻小说]《风之圣痕》第一卷作者：山门敬弘
[轻小说]《废气公主》作者：榊一郎
[轻小说]《FATE ZERO》
G
[轻小说]《公主+天国》作者：風見周（第1卷未完）
[轻小说]《攻壳机动队——宇宙生化人》作者：[日]远藤明范
[遊戲小說]《格蘭蒂亞》作者：[日]細江ひろみ
[轻小说]《钢铁白兔骑士团》作者：舞阪洸（1-6卷未完）5/31日更新
[轻小说]《盖棺论定！》作者：文冈あちら
[轻小说]《管家后宫学园》作者：上月司（1卷未）
[推理小说]《姑获鸟之夏》作者：京极夏彦(京极堂系列01)(世界上没有不可思议的事）
[轻小说]《高校女仆警察1-4》作者：沢上水也
[动漫相关]《攻壳机动队宇宙生化人》作者：远藤明范翻译：赵玲
[动漫相关]《高达系列八部合集》
[动漫相关]《钢壳都市雷吉欧斯1-7+番外》作者：雨木シュウスケ
[轻小说]《钢壳都市雷吉欧斯》作者：雨木シュウスケ（1-8+外,前传,短篇未完）
[轻小说]《钢壳都市雷吉欧斯》作者：雨木シュウスケ（1-8+外,前传,短篇未完）
[游戏相关]《光明之泪双龙骑士》作者：加纳新太
[游戏相关]《薄暮传说剧情小说》作者：沙下夜雪
[灵异小说]《怪谈新耳袋》作者：木原浩胜、中山市朗
[动漫相关]《钢の錬金术师》作者：井上真
[游戏相关]《光明之泪双龙骑士》作者：未知
[动漫相关]《高达W外传左手持镰，右手拥你》作者：皆川由佳
[动漫相关]《高达OO P（前传）第一卷》作者：矢立肇
[官方小说]《高达00之二捕获高达》作者：木村畅
[官方小说]《高达00 天人组织》作者：木村畅
[游戏相关]《鬼泣4剧情小说》作者:不详
[游戏相关]《鬼哭街》作者：虚渊玄
[轻小说] 《谷川流作品集》（部分附插画），纳米盘
[畅销小说]《鬼吹灯Ⅱ之黄皮子坟&南海归墟&怒晴湘西&巫峡棺山》（全）作者：天下霸唱
[畅销小说]《鬼吹灯精绝古城&龙岭迷窟&云南虫谷&昆仑神宫》作者：天下霸唱
[官方小说]《怪物猎人官方小说1~4》作者:ゆうきりん
[科幻军事]《光晕》（1～4全）作者：[美] 埃里克·尼伦德&威廉·C·迪茨
[科幻军事]《光晕三部曲》作者：[美] 埃里克·尼伦德威廉·C·迪茨
H
[轻小说]《虎跃龙笑狮王争霸！》作者：嬉野秋彦（1～2未完）
[輕小說]《欢迎你！美少女游戏的世界》作者：[日]田尾典丈
[推理小说]《黑死馆杀人事件》作者：小栗虫太郎（日本推理四大奇书）
[轻小说]《欢迎来到血吸村》第一卷作者：[日]阿智太郎
[轻小说]《幻兽少年》1-2卷作者：[日]梦枕貘
[推理小说]《火车》作者：宫部美雪
[轻小说]《幻影父亲》作者：深泽美潮
[短篇轻小说]《辉石之花》作者：河屋一
[轻小说]《黑魂少女》作者：[日]上月雨音（未完结）
[輕小說]《化物語》作者：西尾維新（上卷未）
[轻小说]《紅》作者：片山憲太郎
[历史傳记]《红尘》作者：田中芳树
[轻小说]《黄昏色的咏使》作者：细音启（1-6卷）
[历史傳记]《海嘯》作者：田中芳树
[轻小说]《黑龙潭异闻短篇集（全）》作者：田中芳树
[轻小说]《黑猫1-2》作者：大崎知仁
[军事小说]《环形世界》作者：菲立普·狄克（光环原案）
[轻小说]《欢迎来到NHK!》作者：滝本竜彦
[剧情小说]《合金装备2》作者：不详
[剧情小说]《荒野兵器4 上》作者：不详
[轻小说]《黑执事上》作者：不详
[日系耽美]《海盗风云》作者：松冈夏树
[轻小说]《寒蝉鸣泣之时1-5》作者：龙骑士07
[轻小说]《寒蝉鸣泣之时》鬼隐篇作者：龙骑士070
[日本文学]《红蔷薇新娘1-3》作者：田中芳树
[游戏相关]《火焰之纹章暗黑龙与光之剑》作者：不详
[漫画改编]《黑血》原案/漫画：赵佳
[游戏相关]《幻想传说沉寂的历史》原作：祭紀りゅーじ翻译：子云、清雨
[动漫相关]《《横行霸道4(GTA4)》剧情小说》作者：不详
[英国童话]《哈尔的移动城堡中英两版》作者：DianaWynneJones
[奇幻合集]《哈利·波特全集》（HTML格式电子书全7本中文合辑收藏版）[附下载]
[畅销小说]《黑质三部曲黄金罗盘&魔法神刀&琥珀望远镜》作者：菲利普·普尔曼
[轻小说]《欢迎加入HNK》作者：滝本龙彦
[现代神话]《河图洛书》作者：不动（来自新干线的超人气连载）
I

[輕小說]《IS》作者：[日]弓弦イズル

J

[轻小说]《吉永家的石像怪1-11》作者：田口仙年堂
[輕小說]《娇蛮猫娘大横行！》作者：[日]松智洋
[轻小说]《静流姐与无言的公主们》作者：[日]上远野浩平
[輕小說]《机巧魔神》作者：[日]三雲岳斗
[轻小说]《疾走！青春期的帕拉贝伦》作者：深见真（1～2）
[轻小说]《将花束献给月亮与你》作者：[日]志村一矢
[动漫相关]《机动战士高达UNICORN 0096》作者：[日]福井晴敏（1-6）
[轻小说]《9S》作者：[日]叶山透（1-9+Memories+SS，未完结）
[轻小说]《静流姐与执拗的死者们》作者：上远野浩平
[轻小说]《加速世界第一卷》作者：不詳
[动漫相关]《机动战舰大和號琉璃由A到B的故事》作者：不詳
[动漫相关]《君吻》作者：日暮茶坊（未完）
[轻小说]《绞缬城绮谭（全）》作者：田中芳树
[剧情小说]《莎木》作者：不详
[剧情小说]《寄生前夜2》作者：不详
[动漫相关]《今日起是魔王1-16》作者:乔林知
[动漫相关]《今日起是魔王17-20》作者:乔林知
[官方小说]《JOJO的奇妙冒险》作者:乙一
[日本科幻]《寄生前夜》作者：濑名秀明
[侦探惊忪]《金田一全集》作者：横沟正史
[官方小说]《寂静岭》作者：山下定
[官方小说]《寂静岭2》作者：山下定
[推理侦探]《金田一少年的事件薄》作者：天树征丸
[日本文学]《甲贺忍法帖》作者：山田风太郎
[官方小说]《机动战士高达0080口袋里的战争》作者：山口宏、结城恭介
[官方小说]《机动战士高达0079+外传-密会》作者：富野由悠季
[历史典故]《剑与禅：宫本武藏》
[合集汇总]《九州实体书汇总》
K
[轻小说]《空之境界》作者：奈须きのこ（全）
[轻小说]《看着月亮说着谎话》第一卷作者：[日]日日日
[轻小说]科学超电磁炮特典小说，全八话
[轻小说]《矿物质超女》作者：冬樹忍（1~6）
[轻小说]《骷髅恋人》作者：平坂读（1~5）
[轻小说]《空罐少女！》作者：蓝上陆/铃平ひろ（1~4）
[推理小說]《狂骨之夢》作者：[日]京极夏彦（上卷未）
[轻小说]《壳中少女》作者：冲方丁（全）
[短篇轻小说]《可疑的少女与危险的少年》作者：深见真
[轻小说]《肯普法》作者：筑地俊彦（1-3未）
[轻小说]《肯普法10.5》作者：筑地俊彦
[轻小说]《快打城市 slum online》作者：樱坂洋 (全)
[轻小说]《空之中》作者：有川浩（全）
[轻小说]《狂乱家族日记1-6》作者：日日日
[轻小说] 《空之轨迹长篇同人炎の轨迹》作者：夏木の友人帐
[轻小说]《狂恋声优宝贝》作者：木本雅彦
[动漫相关]《空中杀手》作者：森博嗣（完）

L
[轻小说]《罗德岛战记+罗德岛传说+新罗德斯岛战记》作者：水野良
[轻小说]《莱茵河的囚徒》作者：[日]田中芳树
[轻小说]《离别的钢琴奏鸣曲 1》作者：杉井光
[推理小说]《猎捕史奈克》作者：宫部美雪
[輕小說]《狼與辛香料》作者：[日]支仓冻沙（11,12卷）
[輕小說]《蘿球社！》作者：[日]蒼山サグ
[轻小说]《流星慢舞》作者：桥本纺
[轻小说]《铁拳灵感少女》作者：松原真琴/小畑健
[剧情小说]《流行之神》作者：不详
[轻小说]《临界杀机》作者：神崎紫电（1-2未完）
[轻小说]《零之使魔1-16+外传》作者：ヤマグチノボル
[动漫相关]《L改变世界+外传》作者:西尾维新
[动漫相关]《L改变世界+外传》作者:西尾维新
[动漫相关]《龙虎斗1-6》作者：未知
[轻小说]《龙眠》作者：宫部美幸
[轻小说]《LUCK*STAR杀人事件》作者：竹井10日
[轻小说]《狼與辛香料1-9》作者：支仓冻砂
[轻小说]《狼与辛香料》作者：支仓冻砂（1-10卷）
[动画外传]《另一个冰轮丸》作者：松永真琴译者:Youyuan
[日本文学]《柳生忍法帖》作者：山田风太郎
[剧情小说]《龙背上的骑士1+2》作者：不详
[动漫相关]《L改变世界洛杉矶BB连续杀人案件》作者：西尾维新
[热门小说]《凉宫春日的忧郁》八部全
[游戏小说]《零~月蚀的假面》作者:不详
[游戏小说]《零·ZERO》作者：不详
[游戏小说]《零·红蝶》作者：不详
[游戏小说]《零·刺青之声》作者：不详
[轻小说]《罗德斯岛战记》
[轻小说]《零之使魔ゼロづ使い魔小说1-14+番外》作者：ヤマグチノボル(更新到第12卷)
[轻小说]《凉宫春日的忧郁》

M
[轻小说]《魔法目录1-6+ss+外传》作者：镰池和马
[一般小说]《魔王》作者：[日]伊坂幸太郎
[轻小说]《魔女宅急便》作者：角野荣子（全）
[推理小说]《魔术的耳语》作者：宫部美雪
[轻小说]《MAMA》作者：红玉ぃづき
[輕小說]《梅格＆賽隆》作者：[日]时雨泽惠一
[轻小说]《魔法战士李维》作者：[日]水野良（未完结）
[轻小说]《魔法**目录》作者：镰池和马（9.10卷）
[轻小说]《某一天，炸弹从天而降》作者：古桥秀之（全）
[轻小说]《MM一族》作者：作者：松野秋鸣（1-5卷）
[架空都市]《梦幻都市（全）》作者：田中芳树
[轻小说]《魔法目录》作者：鎌池和马（1-8卷）
[动漫相关]《名侦探柯南江神原的魔女》作者：平良隆久
[畅销小说]《暮光之城 1-4部（英文版）》作者：斯蒂芬妮·梅尔
[轻小说]《魔法人力派遣公司》第1~2卷作者：三田诚
[日本文学]《麻辣教师GTO 颠覆北海道》作者:不详
[动漫游戏]《魔界战记迪斯凯亚1-6全》作者：神代创
[动漫相关]《秒速五厘米》作者：新海诚
[轻小说]《魔法少女奈叶》作者：都筑真纪（全）
[资料分享]《魔法书与恶魔学》
[游戏小说]《魔兽世界官方小说+同人》作者：多人
[游戏相关]魔兽世界小说三部曲

N
[轻小说]《你我崩坏的世界》作者：西尾纬新
[推理小说]《脑髓地狱》作者：梦野久作（日本推理四大奇书）
[轻小说]《女帝·龍凰院麟音的初恋第一卷》作者：[日]风见周
[动漫小说] 《女王之刃》TV版很黄很暴力作者：不知道（1-3未完）
[動漫相關]《女王之刃独角兽之剑》作者：冲田荣次
[轻小说] 《乃木坂春香的秘密》作者：五十岚雄策（0-9卷未完） 5/14日更新
[官方小说]《女神侧身像两卷全》作者：梅村崇
[官方小说]《女神侧身像负罪者》作者：不详
[游戏小说]《女神侧身像希尔梅丽娅》作者：梅村崇
[官方小说]《女神侧身像希尔梅丽娅2》作者：梅村崇翻译：YULA、翔月
[剧情小说]《逆转裁判4》翻译：清雨（游小说）
[奇幻经典]《纳尼亚传奇2 凯斯宾王子》作者：[英] C·S·刘易斯
O
[动漫相关]《one piece》作者:不详
P
[动漫相关]《PHANTOM OF INFERNO 无间地狱》作者：虚渊玄
[轻小说]《pulp》作者：森桥ビソゴ（1~3）
Q
[轻小说]《七姬物语1-4》作者：高野和
[轻小说]《轻小说社》作者：平坂读（1~2）
[轻小说]《企鹅之夏(ペンギン·サマー)》全一卷作者：[日]六塚光
[轻小说]《犬神》作者：有沢まみず（1~12）
[轻小说]《七人武器店》（1-2）作者：[日]大乐绚太（未完结）
[轻小说]《亲亲坏老爹》作者：野村美月（1-3卷）
[轻小说]《青叶君与宇宙人1~3》作者：松野秋鸣 (全)
[轻小说]《七都市物语（全）》作者：田中芳树
[轻小说]《晴空之下，突然……（全）》作者：田中芳树
[轻小说]《侵略少女与谎言庭院》作者：清水マリコ（1卷全）
[剧情小说]《潜龙谍影4爱国者之枪》作者：不详
[轻小说]《轻小说的快乐写法》作者：本田透
[游戏相关] 潜龙谍影 - Metal Gear Solid [官方小说] (1卷全)
[推理小说] 《秋叶原@DEEP》作者：石田衣良（全）
[动漫相关]《晴空之Air1-6》作者：不详
[游戏相关]《秋之回忆1-3+从今以后》作者:不详
[轻小说]《奇诺之旅》作者：时雨泽惠（1-11+外+PS2剧本）
[轻小说]《奇诺之旅1-10全》作者:时雨沢恵一
[游戏相关]《潜龙谍影4官方小说》（下）作者：伊藤计划
[轻小说]《[欢迎加入NHK》作者：泷本龙彦
[游戏相关]《潜龙谍影4官方小说》（上）作者：伊藤计划
[动漫相关]《全金属狂潮短片集》作者：贺东招二等
[动漫相关]《全金属狂潮1-11》作者：贺东招二
[游戏剧情]《寄生前夜2》作者：不详

R
[轻小说]《人间系列》作者：西尾纬新（第3卷）
[轻小说] 《ROOM NO.1301》作者：新井辉（1-7卷未完）9/13更新
[轻小说] 《R.O.D》作者：仓田英之（第1卷未完）
[历史研究]《日本战国史》作者:赤军（国产）
[日本小说]《人间失格》作者：太宰治
[资料收集]《日本战国明将用兵哲学》作者:不详

S
[轻小说]《三坪房间的侵略者！？第一卷》作者：健速
[推理小说]《世纪末的侦探神话》作者：清凉院流水
[輕小說]《SH@PPLE》作者：[日]竹岡葉月
[游戏小说]《水仙》全一卷作者：[日]片冈とも
[轻小说]《杀×爱》作者：风见周（0~4）
[轻小说]《神样家族》作者：桑岛由一（1~7）
[轻小说]《神之游戏1～3》作者：宮崎柊羽
[輕小說]《428被封锁的涩谷》作者：[日]北岛行德
[恐怖小说]《尸鬼》作者：[日]小野不由美（完结）
[轻小说]《捨棄在八月的路上》作者：伊藤たかみ（全一卷）
[輕小說]《傷物語》作者：[日]西尾維新
[轻小说]《神样灵感少女》作者：松原真琴/小畑健
[轻小说]《神曲奏界異色協奏》作者：淺井ラボ、あざの耕平、神野奧那、三田誠
[轻小说] 《圣诞节的恐怖分子》作者：佐藤友哉（全一卷）
[轻小说]《淑女骑士团 Lady General》作者：千田诚行（未完）
[轻小说]《神的记事本》作者：杉井光（1-3卷未完）
[轻小说]《神灯女仆1-4》作者：夏绿
[轻小说] 《ROOM NO.1301》作者：新井辉（1-7卷+番外未完）
[轻小说]《说谎的男孩与坏掉的女孩》作者：入间人间（1-3未完）
[剧情小说]《聖女之歌》作者：不详
[动漫相关]《闪光的哈萨维》作者:不详
[轻小说]《少年阴阳师1～20》作者:结城光流
[D&D]《时光之轮：世界之眼1-5》作者：罗伯特·乔丹
[动漫相关]《水星领航员ARIA四季之风的赠礼》作者：岡田麿里藤咲ぁゅな浦畑达彦吉田玲子
[日系耽美]《三千世界鸦杀1-13+番外+前传》作者：津守时生
[官方小说]《生化危机官方小说（Resident Evil）（1-8）》原著：S·D·Perry
[官方小说]《宿命传说苍黑的追忆》原作：矢島さら翻译：子云
[游戏相关]《失落的奥德赛番外篇》作者：松重清翻译：夜蓝
[官方小说]《失落的奥德赛番外塞丝、敏篇》作者：重松清翻译：夜蓝
[官方小说]《宿命传说官方小说苍黑的思念》原作：矢島さら翻译：子云
[轻小说]《死后文》作者：雨宫谅
[百合向耽美]《圣母在上1-12》作者：今野绪雪
[轻小说]《水星领航员水之都与哀伤的歌姬》作者：藤咲ぁゅな
[动漫相关]《死神的歌谣》作者：长谷川启介
[游戏小说]《失落的奥德赛千年之梦永远的旅人》原作：重松清翻译：夜蓝
[人文历史]《十字军骑士》作者：显克维支（EXE,TXT双版本）
[轻小说]《十二国记全集+外传》作者：小野不由美
[轻小说]《少年残像》原作：由贵香织里
[轻小说]《圣魔之血》作者：吉田直

T
[轻小说]《同居五重奏！》作者：越后屋铁舟（1卷未完）
[轻小说]《他能在那天逃过死亡吗》作者：[日]小木君人
[遊戲相關]《Tales of Symphonia 拉塔特斯克的骑士世界之愿》作者：[日]矢島さら
[推理小说]《铁鼠之槛》作者：京极夏彦
[推理小说]《他人事》作者：平山梦明
[轻小说]《TIGER X DRAGON》作者：竹宫ゆゆこ（9卷）
[轻小说]《听到涛声》作者：冰室冴子（1～2+番外篇）
[轻小说]《逃离学校！》作者：谷川流 (1~6全)
[轻小说]《替身伯爵系列 1》作者：清家未森
[轻小说]《天空之钟响彻惑星》作者：渡濑草一郎（1-9）
[军事小说]《汤姆克兰西部分军事小说》作者：汤姆克兰西
[动漫相关]《天是红河岸外传魔之时代的黎明》作者：筱原千绘
[动漫相关]《太空堡垒－麦克罗斯传奇》作者：未知
[畅销小说]《马法尔年代记1-3全》作者：田中芳树
[轻小说]《图书馆战争1~4全》作者:有川浩（09年2月2更新番外）
[动漫相关]《太空堡垒－南十字军》作者：[美] 杰克·麦金尼【上、下册完整版】
[漫画相关]《天使迷梦1-6全+番外+前传》作者：游素兰（台湾）
[影视文学]《跳跃大搜查线》作者：不详
[畅销小说]《天竺热风录》作者：田中芳树（波澜壮阔的盛唐再现）
U

V

W
[轻小说]《无头骑士异闻录 DuRaRaRa！！1-2》作者：成田良悟
[轻小说]《我们的蔬菜不够》作者：浅沼广太（1~4）
[轻小说]《我的朋友很少第二卷》作者：平坂読
[轻小说]《我的腐女友》作者：ぺんたぶ（1~2）
[轻小说]《我的朋友很少》（第一卷）作者：[日]平坂読
[轻小说]《伪物语（下）》作者：[日]西尾维新
[輕小說]《無頭騎士異聞錄DuRaRaRa！！》作者：[日]成田良悟（3卷未）
[悬疑小说]《无人生还》作者：阿加莎·克里斯蒂
[輕小說]《偽物語》作者：[日]西尾維新（上卷未）
[輕小說]《我甜蜜的苦涩委内瑞拉》作者：[日]森田季节
[輕小說]《物質幽靈》作者：[日]葵せきな（未完）
[轻小说]《我的亲爱主人！？》作者：鹰野佑希（1-5完） 7/4更新
[轻小说]《我们的田村同学》作者：竹宫ゆゆこ（1～2+短篇）
[轻小说]《我的爱马很凶恶》作者：新井辉
[轻小说]《“文学少女”见习生の、初恋》作者：野村美月
[轻小说] 《我的妹妹不可能那么可爱》作者：伏见司（1+短篇未完）
[轻小说]《我的世界守护者》作者：谷川流
[轻小说]《我的狐仙女友1-4》作者：西野胜海
[轻小说] 《文学少女》作者：野村美月（1-8+番外完）5/6日更新
[动漫小说] 《魍魉之匣》作者：京极夏彦（全）
[剧情小说] 《王国之心Ⅱ》序章剧情小说作者：LightLucifer
[剧情小说]《王国之心2》作者：不详
[轻小说]《我家有个狐仙大人1-6》作者：柴村仁译者：张信儀
[现代文学]《五百年吸血鬼惊世传奇》作者：伊丽莎白·科斯托娃
[影视相关]《我是传奇英文版》作者：理查德·马瑟森
[日本耽美]《王朝春宵罗曼史1-4》作者：不详
[日本小说]《为夜空的双子座衬上深红蔷薇》作者：冈崎裕信原案：田中芳树
[轻小说]《万岁系列1-8全》作者：三浦勇雄
[悬疑恐怖]《午夜凶铃1-4》作者：铃木光司
[资料收集]《五轮书：地之卷》作者：宫本武藏
[资料收集]《五轮书：火之卷》作者：宫本武藏

X
[短篇轻小说]《夏天，真纪子与MD-WalkMan的故事》作者：紅玉いづき
[推理小说]《献给虚无的供物》作者：中井英夫（日本推理四大奇书）
[推理小说]《匣中的失乐》作者：竹本键治（日本推理四大奇书）
[轻小说]《新本格魔法少女莉丝佳》作者：西尾维新（1~2）
[妖怪小说]《巷说百物语》作者：京极夏彦（1~4完结）
[輕小說]《虚轴少女ResinCastMilk》作者：[日]藤原佑（1-5）
[輕小說]《闲狼作家是美少女妖怪？》作者：[日]杉井光
[輕小說]《Resin Cast Milk 虚轴少女的日常》作者：[日]藤原佑
[輕小說]《幸运机会！》作者：[日]有泽真水
[轻小说]《心灵侦探八云》作者：神永学（1～2）
[輕小說]《學生會的日常》作者：[日]葵せきな（1卷未）
[輕小說]《小齒輪！》作者：[日]樋口司（1卷未）
[轻小说]《学生会的一己之见》作者：[日]葵せきな（1-3+外未完）
[轻小说]《掀起世界危机！》作者：佐藤了
[轻小说]《学校的阶梯》作者：櫂末高彰（1～8+短篇未完）
[推理小说]《“犀川&萌绘”系列》作者：森博嗣（1～2未完）
[動漫相关]《星之声》作者：新海诚
[轻小说]《消极的快乐、电锯的边缘》作者：泷本龙彦（全）
[轻小说]《戏言系列》作者：西尾维新（1-10完结）
[轻小说]《学院人体练金术一卷全》作者：筱崎一夜
[剧情小说]《晓之女神》作者：不详
[游戏对话]《仙剑奇侠传四》作者：上海软星
[轻小说]《新橙路》作者：松本泉寺田宪史
[轻小说]《吸血鬼骑士1-4》作者：藤咲あゆな
[推理侦探]《嫌疑犯X的献身》作者：东野圭吾（神探伽利略系列）
[轻小说]《吸血鬼猎人D》作者：菊地秀行插话：天野喜孝
[剧情小说]《新鬼武者梦之黎明》作者：不详
[轻小说]《XXXHOLIC兰德尔特环的粉尘]》作者：西尾维新
[畅销经典]《肖申克的救赎》作者：斯蒂芬·金
[轻小说]《星界系列》作者：森冈浩之
[轻小说]《幸运☆星 ONLINE》原作：美水かがみ著：竹井10日
[军事科幻]《星之海洋》全作者：charlesp
[国产耽美]《希露芙斯战记（5中篇）》作者：七月
[轻小说]《新罗德斯岛战记》作者：【日】水野良（全）

Y

[轻小说]《幽灵恋人1～4》作者：平坂读 (全)
[轻小说]《阴沉少女与黑魔法之恋》作者：熊谷雅人（1~3）
[轻小说]《遥仰凰华》番外+游戏剧本作者：冈田留奈
[轻小说]《月兔的银色方舟》作者：[日]鴨志田一
[轻小说]《眼镜男与断头少女》作者：藤原祐（1~2）
[合集小说]乙一作品集[共32篇]
[轻小说]《影≒光 Shadow Light》作者：影名浅海（1~5）
[轻小说]《银盘万花筒》作者：海原零（1~9）
[轻小说]《仰望半月的夜空》作者：桥本纺（1-8卷+2短篇完结）
[遊戲相關]《命运传奇命运传承者》作者：[日]矢島さら（上卷未）
[轻小说]《云霄飞车》作者：山田悠介（全）
[短篇小说]《月之雨物语》作者：古茶（全）
[轻小说]《一切终将远去》作者：山本文绪 (全)
[轻小说]《幽灵少女与科学少年1～2》作者：飞田甲
[轻小说]《烟囟町的赤魔与绝望少年 1 》作者：ゆうきりん
[幻想小说]《妖藩记鬼剑众》作者：菊地秀行 (全)
[轻小说]《伊里野的天空 UFO的夏天》作者：秋山瑞人（1-4+短篇全）
[轻小说]《银之镇魂歌》作者：吉原理惠子
[剧情小说]《银河游侠》作者:不详
[轻小说]《月兔公主》作者:野村美月
[魔幻小说]《夜访吸血鬼》作者：安妮·赖斯
[宇宙战争]《铁达尼亚1-3卷》作者：田中芳树
[轻小说]《银魂 3年Z班的银八老师1-3》作者：不详
[轻小说]《银河铁道之夜》
[游戏人]《樱花大战3 前传巴黎前夜· 北大路花火篇》作者：赤堀悟
[游戏人]《樱花大战3 前传巴黎前夜·古妮西露篇》作者：赤堀悟
[游戏人]《樱花大战3 前传巴黎前夜·艾莉卡篇》作者：赤堀悟
[动漫相关]《云之彼端约定之地》原作：新海诚
[游戏剧本]《XENOGEARS（异度装甲）》+《世界观解疑》
[英国童话]《哈尔的移动城堡中英两版》作者：DianaWynneJones
[轻小说]《永生之酒》作者：成田良悟（更新1~8）
[轻小说]《亚普菲兰特》作者：田中芳树
[日本文学]《亚也日记》作者：木藤亚也（又名：一公升的眼泪）
[流行小说]药师寺凉子怪奇事件簿（1~7卷）作者：田中芳树
[科幻经典]《银河英雄传说》
[轻小说]《BACCANO(永生之酒)第1-6卷》作者：]成田良悟
[轻小说]《阴阳师物语 1》

Z
[轻小说]《斩鬼夜鸟子1-3》作者：树田省治
[轻小说]《战斗！暴风少女！》作者：佐佐原始绪（1~2）
[轻小说]《最后大魔王》作者：水城正太郎（1~5）
[杂书？]《征服世界有可能的吗》作者：[日]冈田斗司夫
[轻小说]《战斗司书与终章猛兽》作者：山形石雄（系列第八作）
[轻小说]《在暗夜中寻找羔羊》作者：穗史贺雅也（1～3完结）
[轻小说]《镇魂练习曲》作者：北泽大辅（1～3）
[惊悚小说]《ZOO》作者：[日]乙一
[轻小说]《在遙遠彼方的小千》作者：日日日（全一卷）
[轻小说]《拯救你的最初咒语》作者：须堂项（1~2未完）
[轻小说]《终焉的年代记》作者：川上稔（1-2未完）
[轻小说]《战斗司书与虚言者的宴会》作者：山形石雄
[游戏小说]《最终幻想Ⅶ~On the way to a smile》（那那岐篇神罗篇尤菲篇）
[轻小说]《灼热的龙骑兵（3本全）》作者：田中芳树
[官方小说]《战国basara2》作者：不详
[轻小说]《自卫队三部曲第一部》作者：有川浩
[动漫相关]《真·天地无用_魉皇鬼1-2》作者:不详
[剧情小说]《战争机器》作者：不详
[动漫相关]《最终兵器彼女全》作者:不详
[剧情小说]《战神：奥林匹斯之链》作者：城寨某人（-，-！）
[人物传记]《织田信长》作者：山冈庄八
[剧情小说] 最终幻想系列剧情小说》
[港漫相关]《中华英雄》作者：不详
[历史记载]《中国武将列传》作者:田中芳树
[中文剧本]《最终幻想战略版》作者:天幻
[剧情小说]《最终幻想VI》作者:不详
[剧情小说]《最终幻想XII》作者：不详
[游戏相关]《最终幻想11 官方小说-守护之剑》作者:不详
[游戏相关]《最终幻想7游戏剧本+剧情小说》作者：不详
[游戏剧本]《最终幻想10剧情小说》作者：慕容非
[剧情小说]《最终幻想IX》作者：不详
[官方小说]《FF7AC On The Way to a Smile丁塞尔篇/蒂法篇》作者：ベニー松山
[游戏剧本]《最终幻想X-2外传你所吹响的口哨》作者：ベニー松山
[轻小说]《灼眼的夏娜》作者：高桥弥七郎（0~16卷、附加S卷）0
[专题收集]《战国趣闻录(番外篇*2)》.

嘛...娱乐而已的东西嘛...这里是一个链接也没有的...

lightnovel.cn曾打包放出过东西，不过风格有些区别。

ed2k://|file|%5B%E8%BD%BB%E4%B9%8B%E5%9B%BD%E5%BA%A6%5D%E8%BD%BB%E5%B0%8F%E8%AF%B4%E5%90%88%E9%9B%86VOL.1%5B2009-09%5D%5Blightkingdom.lightnovel.collection.vol1%5D.zip|183888376|98448761c16748b1742080b7953db837|h=sa2xcobe5uypgofn4fnfdyfvlx66it3c|/
ed2k://|file|%5B%E8%BD%BB%E4%B9%8B%E5%9B%BD%E5%BA%A6%5D%E8%BD%BB%E5%B0%8F%E8%AF%B4%E5%90%88%E9%9B%86VOL.2%5B2009-10%5D%5Blightkingdom.lightnovel.collection.vol2%5D.7z|2222403|c659f06bc7ecfc05219fc63117bd4872|h=ffr6ennkgx534gjt6ijih5ag755ycheb|/
ed2k://|file|%5B%E8%BD%BB%E4%B9%8B%E5%9B%BD%E5%BA%A6%5D%E8%BD%BB%E5%B0%8F%E8%AF%B4%E5%90%88%E9%9B%86VOL.3%5B2009-11%5D%5Blightkingdom.lightnovel.collection.vol3%5D.7z|2824935|bf6f16910e9f11945d84cf155dd5aaf9|h=45iw2wmhyognkkxpwwc67fzoxdeu46dc|/

相关的站点的话自己能想到的还有
http://bbs.levelup.im/forum-38-1.html
book.sky-fire.com
comic.92wy.com
www.ffsky.com
www.hgamecn.com
www.imdb.com
类似站点去找一下也能发现些，这里名字有些杂乱了，况且ACG内容还是好找的。
此外呢，有些考古性质的企划文对于搜索而言是有辅助作用的，例如维基百科。

这年头有dangdang在，还是纸质顺眼来着，也觉得存放起来踏实一点。
曾有的版权问题的正在发展出适合的解决途径，目前不必要无视已有的关注度。

静态类型函数式语言Objective Caml/ML的简要介绍【程序语言介绍】

2011-07-07T12:07:00.007+08:00

下面拿OCaml手册的导论部分的前两章缩译了一下，这里涵盖了核心语言和模块系统两方面的内容。

* Chapter 1 The core language

这部分是OCaml语言的简明教程，需要有某一编程语言的使用基础，但不一定是函数式语言。

** 1.1 Basics

下面将在交互模式中演示，“#”开头的行表示用户输入。输入以“;;”终止，交互系统会随即解析表达式或定义语句并返回执行结果。

#1+2*3;;
- : int = 7

#let pi = 4.0 *. atan 1.0;;
val pi : float = 3.14159265358979312

#let square x = x *. x;;
val square : float -> float = <fun>

#square(sin pi) +. square(cos pi);;
- : float = 1.

值和类型会被执行，函数中未显式声明的参数系统会根据其定义中的语句来推断。要注意整数和浮点数是不同的类型，前者用“+”和“*”而后者用“+.”和“*.”。

#1.0 * 2;;
Error: This expression has type float but an expression was expected of type int

递归函数有“let rec”绑定：

#let rec fib n =
   if n < 2 then n else fib(n-1) + fib(n-2);;
val fib : int -> int = <fun>

#fib 10;;
- : int = 55

** 1.2 Data types

除了整数和浮点数，Caml中还提供了其他的常用基本类型：布尔型、字符型、字符串型。

#(1 < 2) = false;;
- : bool = false

#’a’;;
- : char = ’a’

#"Hello world";;
- : string = "Hello world"

预定义的数据结构包括元组、数组、列表，此外也可创建自定义类型。列表是由“[”和“]”包裹“;”分割，或者由空表“[]”（读作nil）前面用“::”操作符添加元素构成。

#let l = ["is"; "a"; "tale"; "told"; "etc."];;
val l : string list = ["is"; "a"; "tale"; "told"; "etc."]

#"Life" :: l;;
- : string list = ["Life"; "is"; "a"; "tale"; "told"; "etc."]

列表的内存管理将自动进行，不需要显式地分配或回收。指针由Caml编译器负责，也不需要显式的处理。

列表（以及大部分Caml数据结构）的检查和解析通过模式匹配进行。列表的模式与列表的定义形式相同，以标识符表示列表中未定义的部分。以下是用列表进行插入排序的例子：

#let rec sort lst =
   match lst with
     [] -> []
   | head :: tail -> insert head (sort tail)
and insert elt lst =
   match lst with
     [] -> [elt]
   | head :: tail -> if elt <= head then elt :: lst else head :: insert elt tail
;;
val sort : ’a list -> ’a list = <fun>
val insert : ’a -> ’a list -> ’a list = <fun>

#sort l;;
- : string list = ["a"; "etc."; "is"; "tale"; "told"]

这里sort推断得到的类型是“’a list -> ’a list”，表示作用于任意类型的列表并返回相同类型的列表。其中“’a ”是类型变量，代表任意类型。之所以sort可以用于任意类型列表，是因为比较操作（“=”“<=”等等）在Caml中是多态的。

#sort [6;2;5;3];;
- : int list = [2; 3; 5; 6]

#sort [3.14; 2.718];;
- : float list = [2.718; 3.14]

上面的sort函数没有修改它的输入列表，而是创建并返回一个元素个数相同的递增列表。列表创建后是无法在原地修改的，在Caml中列表是不可变的结构。大部分Caml中的数据结构是不可变的，而少部分（如数组）是可变的（可以在任何时候原地修改）。

** 1.3 Functions as values

Caml是一种函数式语言，支持数学意义上的函数并可以和其他数据片段一样被自由地传递。例如这里的deriv函数以浮点函数为参数并返回它的导函数的逼近函数：

#let deriv f dx = function x -> (f(x +. dx) -. f(x)) /. dx;;
val deriv : (float -> float) -> float -> float -> float = <fun>

#let sin’ = deriv sin 1e-6;;
val sin’ : float -> float = <fun>

#sin’ pi;;
- : float = -1.00000000013961143
Even function composition is definable:

#let compose f g = function x -> f(g(x));;
val compose : (’a -> ’b) -> (’c -> ’a) -> ’c -> ’b = <fun>

#let cos2 = compose square cos;;
val cos2 : float -> float = <fun>

以其他函数作为参数的函数称为“泛函數”（functionals）或者“高阶函数”（higher-order functions）。泛函数可用于对数据结构的迭代或类似的操作。例如Caml的标准库中提供“List.map”将给定函数应用于列表中的每个元素并返回结果列表：

#List.map (function n -> n * 2 + 1) [0;1;2;3;4];;
- : int list = [1; 3; 5; 7; 9]

常用的列表和数组相关的函数已经定义好了，或者也可以按照下面的方式自行定义。

#let rec map f l =
   match l with
     [] -> []
   | hd :: tl -> f hd :: map f tl;;
val map : (’a -> ’b) -> ’a list -> ’b list = <fun>

** 1.4 Records and variants

用户定义的数据结构包括记录和变体。它们都通过类型声明来定义。这里我们声明了一个表示有理数的记录类型。

#type ratio = {num: int; denum: int};;
type ratio = { num : int; denum : int; }

#let add_ratio r1 r2 =
   {num = r1.num * r2.denum + r2.num * r1.denum;
    denum = r1.denum * r2.denum};;
val add_ratio : ratio -> ratio -> ratio = <fun>

#add_ratio {num=1; denum=3} {num=2; denum=5};;
- : ratio = {num = 11; denum = 15}

变体类型的声明列出了该类型所有值的形状。每种情况用一个名称作为标识符，称为构造器，既用来在构造那种变体类型的值，也用来在模式匹配中检查它们。构造器的首字母大写，用来和变量名区分（必须以小写字母开头）。例如这里是一个用来进行混合运算（整数和浮点）的变体类型：

#type number = Int of int | Float of float | Error;;
type number = Int of int | Float of float | Error

这个声明表示number类型的值或者是一个整数，或者是一个浮点数，或者是表示无效运算结果的常量Error（比如被零除）。

枚举类型是变体类型的一种特殊情况，是当所有的选择支都是常量的时候：

#type sign = Positive | Negative;;
type sign = Positive | Negative

#let sign_int n = if n >= 0 then Positive else Negative;;
val sign_int : int -> sign = <fun>

要定义number类型的算数运算，我们需要对用到的两个number使用模式匹配：

#let add_num n1 n2 =
   match (n1, n2) with
     (Int i1, Int i2) ->
       (* Check for overflow of integer addition *)
       if sign_int i1 = sign_int i2 && sign_int(i1 + i2) <> sign_int i1
       then Float(float i1 +. float i2)
       else Int(i1 + i2)
   | (Int i1, Float f2) -> Float(float i1 +. f2)
   | (Float f1, Int i2) -> Float(f1 +. float i2)
   | (Float f1, Float f2) -> Float(f1 +. f2)
   | (Error, _) -> Error
   | (_, Error) -> Error;;
val add_num : number -> number -> number = <fun>

#add_num (Int 123) (Float 3.14159);;
- : number = Float 126.14159

变体类型的最常见的用途是描述递归的数据结构。考虑二叉树的例子：

#type ’a btree = Empty | Node of ’a * ’a btree * ’a btree;;
type ’a btree = Empty | Node of ’a * ’a btree * ’a btree

该定义这样来读：一个包含类型'a（任意类型）的值二叉树或者是空的或者是一个节点，节点有一个类型'a的值和两个也包含类型'a的子树（即两个 'a btree）。

二叉树上的操作的操作依照其定义自身很自然的用递归函数表达出来。例如这里的函数用来在有序二叉树（元素又左至右递增）上查找和插入。

#let rec member x btree =
   match btree with
     Empty -> false
   | Node(y, left, right) ->
       if x = y then true else
       if x < y then member x left else member x right;;
val member : ’a -> ’a btree -> bool = <fun>

#let rec insert x btree =
   match btree with
     Empty -> Node(x, Empty, Empty)
   | Node(y, left, right) ->
       if x <= y then Node(y, insert x left, right)
                 else Node(y, left, insert x right);;
val insert : ’a -> ’a btree -> ’a btree = <fun>

** 1.5 Imperative features

尽管目前的例子都写为纯函数的风格，Caml也具有命令式的特性。这包括了常见的while和for循环，以及可变的数据结构比如数组。数组用“[|”“|]”包围的形式来书写，或者通过“Array.create”函数来分配并初始化然后再赋值。例如，下面的函数即求两个向量（实现为浮点数组）的部分的和。

#let add_vect v1 v2 =
   let len = min (Array.length v1) (Array.length v2) in
   let res = Array.create len 0.0 in
   for i = 0 to len - 1 do
     res.(i) <- v1.(i) +. v2.(i)
   done;
   res;;
val add_vect : float array -> float array -> float array = <fun>

#add_vect [| 1.0; 2.0 |] [| 3.0; 4.0 |];;
- : float array = [|4.; 6.|]

通过来定义中声明为可变的，记录的字段也可以通过赋值操作来修改：

#type mutable_point = { mutable x: float; mutable y: float };;
type mutable_point = { mutable x : float; mutable y : float; }

#let translate p dx dy =
   p.x <- p.x +. dx; p.y <- p.y +. dy;;
val translate : mutable_point -> float -> float -> unit = <fun>

#let mypoint = { x = 0.0; y = 0.0 };;
val mypoint : mutable_point = {x = 0.; y = 0.}

#translate mypoint 1.0 2.0;;
- : unit = ()

#mypoint;;
- : mutable_point = {x = 1.; y = 2.}

Caml没有内置变量（可以通过赋值改变当前值的标识）的概念。（let绑定不是赋值，它在新作用域里建立了新的标识。）不过标准库中通过间接地使用可变字段（或者单元素数组）来提供了引用类型，并可通过操作符“!”获取引用的当前内容以及“:=”来赋值。变量可以通过绑定一个引用来模拟。例如，这里是一个数组的原地插入排序的例子：

#let insertion_sort a =
   for i = 1 to Array.length a - 1 do
     let val_i = a.(i) in
     let j = ref i in
     while !j > 0 && val_i < a.(!j - 1) do
       a.(!j) <- a.(!j - 1);
       j := !j - 1
     done;
     a.(!j) <- val_i
   done;;
val insertion_sort : ’a array -> unit = <fun>

函数也可用于书写需要维持两次调用中的当前状态的函数。例如下面的伪随机数生成器通过引用记录了最后返回的数值：

#let current_rand = ref 0;;
val current_rand : int ref = {contents = 0}

#let random () =
   current_rand := !current_rand * 25713 + 1345;
   !current_rand;;
val random : unit -> int = <fun>

再次说明，引用没什么特别的：它们是通过下面这样的一个可变字段的记录来实现的。

#type ’a ref = { mutable contents: ’a };;
type ’a ref = { mutable contents : ’a; }

#let (!) r = r.contents;;
val ( ! ) : ’a ref -> ’a = <fun>

#let (:=) r newval = r.contents <- newval;;
val ( := ) : ’a ref -> ’a -> unit = <fun>

有时会需要在数据结构中存放多态函数并保持多态。除非用户提供类型标记，不然是不允许的，因为多态仅在全局类型中引入。不过你可以给记录的字段给出显式的多态类型。

#type idref = { mutable id: ’a. ’a -> ’a };;
type idref = { mutable id : ’a. ’a -> ’a; }

#let r = {id = fun x -> x};;
val r : idref = {id = <fun>}

#let g s = (s.id 1, s.id true);;
val g : idref -> int * bool = <fun>

#r.id <- (fun x -> print_string "called id\n"; x);;
- : unit = ()

#g r;;
called id
called id
- : int * bool = (1, true)

** 1.6 Exceptions

Caml提供异常机制用来指示和处理例外的状况。异常也可用于通用的非局部控制结构。异常通过异常构造来声明，并用raise操作符来指示。例如，下面这个取列表头的函数使用异常来指示遇到空表的情况。

#exception Empty_list;;
exception Empty_list

#let head l =
   match l with
     [] -> raise Empty_list
   | hd :: tl -> hd;;
val head : ’a list -> ’a = <fun>

#head [1;2];;
- : int = 1

#head [];;
Exception: Empty_list.

在标准库中异常用来指示库函数不能被正常完成的情况。例如，“List.assoc”函数，用来返回一个“(键, 数据)”对的列表中给定键关联的值，在键没有在列表中出现的时候将引起预定义的异常"Not_found":

#List.assoc 1 [(0, "zero"); (1, "one")];;
- : string = "one"

#List.assoc 2 [(0, "zero"); (1, "one")];;
Exception: Not_found.
Exceptions can be trapped with the try…with construct:

#let name_of_binary_digit digit =
   try
     List.assoc digit [0, "zero"; 1, "one"]
   with Not_found ->
     "not a binary digit";;
val name_of_binary_digit : int -> string = <fun>

#name_of_binary_digit 0;;
- : string = "zero"

#name_of_binary_digit (-1);;
- : string = "not a binary digit"

with部分其实是异常值的正则模式匹配。因此，若干异常可以用一个try...with结构来捕获。此外，终止可以通过捕获所有的异常来进行，执行终止操作，然后再次引起该异常：

#let temporarily_set_reference ref newval funct =
   let oldval = !ref in
   try
     ref := newval;
     let res = funct () in
     ref := oldval;
     res
   with x ->
     ref := oldval;
     raise x;;
val temporarily_set_reference : ’a ref -> ’a -> (unit -> ’b) -> ’b = <fun>

** 1.7 Symbolic processing of expressions

我们通过一个较完整的例子来结束这次介绍：使用Caml进行符号处理，形式化的操作包含变量的算术表达式。下列的变体类型描述了我们将操作的表达式：

#type expression =
     Const of float
   | Var of string
   | Sum of expression * expression (* e1 + e2 *)
   | Diff of expression * expression (* e1 - e2 *)
   | Prod of expression * expression (* e1 * e2 *)
   | Quot of expression * expression (* e1 / e2 *)
;;
type expression =
    Const of float
  | Var of string
  | Sum of expression * expression
  | Diff of expression * expression
  | Prod of expression * expression
  | Quot of expression * expression

我们首先定义一个函数在所给变量由名称映射到值的环境下计算表达式的值。为了简化，环境用关联列表表示。

#exception Unbound_variable of string;;
exception Unbound_variable of string

#let rec eval env exp =
   match exp with
     Const c -> c
   | Var v ->
       (try List.assoc v env with Not_found -> raise(Unbound_variable v))
   | Sum(f, g) -> eval env f +. eval env g
   | Diff(f, g) -> eval env f -. eval env g
   | Prod(f, g) -> eval env f *. eval env g
   | Quot(f, g) -> eval env f /. eval env g;;
val eval : (string * float) list -> expression -> float = <fun>

#eval [("x", 1.0); ("y", 3.14)] (Prod(Sum(Var "x", Const 2.0), Var "y"));;
- : float = 9.42

现在为了进行真正的符号处理，我们定义关于变量dv的表达式的导数：

#let rec deriv exp dv =
   match exp with
     Const c -> Const 0.0
   | Var v -> if v = dv then Const 1.0 else Const 0.0
   | Sum(f, g) -> Sum(deriv f dv, deriv g dv)
   | Diff(f, g) -> Diff(deriv f dv, deriv g dv)
   | Prod(f, g) -> Sum(Prod(f, deriv g dv), Prod(deriv f dv, g))
   | Quot(f, g) -> Quot(Diff(Prod(deriv f dv, g), Prod(f, deriv g dv)),
                        Prod(g, g))
;;
val deriv : expression -> string -> expression = <fun>

#deriv (Quot(Const 1.0, Var "x")) "x";;
- : expression =
Quot (Diff (Prod (Const 0., Var "x"), Prod (Const 1., Const 1.)),
Prod (Var "x", Var "x"))

** 1.8 Pretty-printing and parsing

上面的例子显示，表达式的内部结构（通常也称为抽象语法）在表达式变长的时候很快就难以读写。我们需要打印和解析过程在抽象语法和具体语法（这里指表达式用熟悉的代数符号，例如“2*x+1”）之间来回转换。

在打印函数中，我们考虑通常的优先规则（比如*比+绑定地更紧）来避免打印不必要的括号。在实现上，我们记录当前操作符的优先级并只当操作符的优先级低于当前优先级的时候在周围打印出括号。

#let print_expr exp =
   (* Local function definitions *)
   let open_paren prec op_prec =
     if prec > op_prec then print_string "(" in
   let close_paren prec op_prec =
     if prec > op_prec then print_string ")" in
   let rec print prec exp = (* prec is the current precedence *)
     match exp with
       Const c -> print_float c
     | Var v -> print_string v
     | Sum(f, g) ->
         open_paren prec 0;
         print 0 f; print_string " + "; print 0 g;
         close_paren prec 0
     | Diff(f, g) ->
         open_paren prec 0;
         print 0 f; print_string " - "; print 1 g;
         close_paren prec 0
     | Prod(f, g) ->
         open_paren prec 2;
         print 2 f; print_string " * "; print 2 g;
         close_paren prec 2
     | Quot(f, g) ->
         open_paren prec 2;
         print 2 f; print_string " / "; print 3 g;
         close_paren prec 2
   in print 0 exp;;
val print_expr : expression -> unit = <fun>

#let e = Sum(Prod(Const 2.0, Var "x"), Const 1.0);;
val e : expression = Sum (Prod (Const 2., Var "x"), Const 1.)

#print_expr e; print_newline();;
2. * x + 1.
- : unit = ()

#print_expr (deriv e "x"); print_newline();;
2. * 1. + 0. * x + 0.
- : unit = ()

解析（将具体语法转换为抽象语法）通常更精巧些。Caml提供若干工具来帮助编写解析器：一方面，Caml版本的Lex词法生成器和Yacc解析生成器，可以使用下推自动机处理啦LALR(1)语言。另一方面，预定义的（字符或标志）流类型和流的模式匹配，可以为LL(1)语言方便地编写递归下降的解析器。后面的章节中有使用ocamllex和ocamlyacc的例子。这里我们将使用流解析器。流解析器的语法支持由Camlp4预处理器提供，它可以在交互模式中由下面的“#load”指令载入。

##load "camlp4o.cma";;
Characters -1–1:
Error: Reference to undefined global ‘Dynlink’

#open Genlex;;

let lexer = make_lexer ["("; ")"; "+"; "-"; "*"; "/"];;
val lexer : char Stream.t -> Genlex.token Stream.t = <fun>

在词法分析阶段（将输入文本转换为标志流），我们使用标准库中Genlex模块的“通用”的词法解析器。“make_lexer”接受关键词列表并返回“标志化”字符输入流的词法解析函数。标志是标识符、关键词或者是字面义（整数、浮点、字符、字符串）。空白和评论跳过。

#let token_stream = lexer(Stream.of_string "1.0 +x");;
val token_stream : Genlex.token Stream.t = <abstr>

#Stream.next token_stream;;
- : Genlex.token = Float 1.

#Stream.next token_stream;;
- : Genlex.token = Kwd "+"

#Stream.next token_stream;;
- : Genlex.token = Ident "x"

解析器通过在在标志流上执行自身的操作。和常见的递归下降解析器一样，我们使用若干中间解析函数来反映操作符的优先级和结合性。流上的模式匹配比正则的数据结构更为强大，因为它允许在模式里递归的调用解析函数，用以匹配输入流的子部件。更多的细节见Camlp4的文档。

#let rec parse_expr = parser
     [< e1 = parse_mult; e = parse_more_adds e1 >] -> e
and parse_more_adds e1 = parser
     [< ’Kwd "+"; e2 = parse_mult; e = parse_more_adds (Sum(e1, e2)) >] -> e
   | [< ’Kwd "-"; e2 = parse_mult; e = parse_more_adds (Diff(e1, e2)) >] -> e
   | [< >] -> e1
and parse_mult = parser
     [< e1 = parse_simple; e = parse_more_mults e1 >] -> e
and parse_more_mults e1 = parser
     [< ’Kwd "*"; e2 = parse_simple; e = parse_more_mults (Prod(e1, e2)) >] -> e
   | [< ’Kwd "/"; e2 = parse_simple; e = parse_more_mults (Quot(e1, e2)) >] -> e
   | [< >] -> e1
and parse_simple = parser
     [< ’Ident s >] -> Var s
   | [< ’Int i >] -> Const(float i)
   | [< ’Float f >] -> Const f
   | [< ’Kwd "("; e = parse_expr; ’Kwd ")" >] -> e;;
Error: Syntax error

#let parse_expression = parser [< e = parse_expr; _ = Stream.empty >] -> e;;
Error: Syntax error

通过组合来词法和语法解析器，我们最终获得了一个从字符串中读取表达式的函数：

#let read_expression s = parse_expression(lexer(Stream.of_string s));;
Error: Unbound value parse_expression

#read_expression "2*(x+y)";;
Error: Unbound value read_expression

小问题：为什么在下面两个例子中我们得到了不同的结果？

#read_expression "x - 1";;
Error: Unbound value read_expression

#read_expression "x-1";;
Error: Unbound value read_expression

解答：由Genlex提供的通用的词法解析器把负数识别为一个整数标志。因此“x-1”被读取为标志Ident "x" 跟着标志Int(-1)；该序列不匹配任何解析规则。另一方面“x - 1”中的第二个空格导致词法解析器返回三个期望的标志：Ident "x"然后Kwd "-"然后Int(1)。

** 1.9 Standalone Caml programs

目前所有给出的例子是在交互系统下执行的。Caml代码也可以通过编译器“ocamlc”或“ocamlopt”单独地编译并非交互的执行。源代码需要放在以“.ml”为扩展名的文件中。源文件包含一序列的代码，并在运行时按照排列的顺序执行。不同于交互模式，类型和值不会自动打印；程序需要调用打印函数来显式地输出。这里是一个打印斐波纳契数列的独立的示例程序。

(* File fib.ml *)
let rec fib n =
  if n < 2 then 1 else fib(n-1) + fib(n-2);;
let main () =
  let arg = int_of_string Sys.argv.(1) in
  print_int(fib arg);
  print_newline();
  exit 0;;
main ();;

“Sys.argv”是包含命令行参数的字符串数组。“Sys.argv.(1)”因此是命令行的第一个参数。上面这个程序通过下列命令编译并执行：

$ ocamlc -o fib fib.ml
$ ./fib 10
89
$ ./fib 20
10946

* Chapter 2 The module system

这一章介绍Objective Caml的模块系统。

** 2.1 Structures

模块的主要动机是是将相关的定义（比如定义了一种数据类型和那个类型关联的操作符）打包在一起并为这些定义执行一致的命名策略。这样避免的用尽名称或者意外的命名冲突。这样的包称为一个结构通过“struct…end”结构引入，并包含任意定义语句的序列。结构通常给予一个模块绑定的名称。这里的例子是用结构把优先列队的类型和操作打包在一起：

#module PrioQueue =
   struct
     type priority = int
     type ’a queue = Empty | Node of priority * ’a * ’a queue * ’a queue
     let empty = Empty
     let rec insert queue prio elt =
       match queue with
         Empty -> Node(prio, elt, Empty, Empty)
       | Node(p, e, left, right) ->
           if prio <= p
           then Node(prio, elt, insert right p e, left)
           else Node(p, e, insert right prio elt, left)
     exception Queue_is_empty
     let rec remove_top = function
         Empty -> raise Queue_is_empty
       | Node(prio, elt, left, Empty) -> left
       | Node(prio, elt, Empty, right) -> right
       | Node(prio, elt, (Node(lprio, lelt, _, _) as left),
                         (Node(rprio, relt, _, _) as right)) ->
           if lprio <= rprio
           then Node(lprio, lelt, remove_top left, right)
           else Node(rprio, relt, left, remove_top right)
     let extract = function
         Empty -> raise Queue_is_empty
       | Node(prio, elt, _, _) as queue -> (prio, elt, remove_top queue)
   end;;
module PrioQueue :
  sig
    type priority = int
    type ’a queue = Empty | Node of priority * ’a * ’a queue * ’a queue
    val empty : ’a queue
    val insert : ’a queue -> priority -> ’a -> ’a queue
    exception Queue_is_empty
    val remove_top : ’a queue -> ’a queue
    val extract : ’a queue -> priority * ’a * ’a queue
  end

在结构的外面，它的组件可以用“.”点号标记来引用，也就是由结构名限制的标识符。例如“PrioQueue.insert”的在值的上下文中是结构“PrioQueue”中定义的一个函数。类似的，“PrioQueue.queue”在类型的上下文中是“PrioQueue”中定义的列队类型。

#PrioQueue.insert PrioQueue.empty 1 "hello";;
- : string PrioQueue.queue =
PrioQueue.Node (1, "hello", PrioQueue.Empty, PrioQueue.Empty)

** 2.2 Signatures

签名是结构的界面。签名指定了结构的哪些组件可以从外部访问，并通过何种类型。它可以用来隐藏结构中的一些组件（例如局部函数定义）或者由受限的类型导出相关组件。例如下面的签名指定了三个优先列队的操作符“empty”、“insert”和“extract”，但是没有辅助函数“remove_top”。类似的，它使得列队类型抽象化（通过不以具体的类型提供实际的表现形式）。

#module type PRIOQUEUE =
   sig
     type priority = int (* still concrete *)
     type ’a queue (* now abstract *)
     val empty : ’a queue
     val insert : ’a queue -> int -> ’a -> ’a queue
     val extract : ’a queue -> int * ’a * ’a queue
     exception Queue_is_empty
   end;;
module type PRIOQUEUE =
  sig
    type priority = int
    type ’a queue
    val empty : ’a queue
    val insert : ’a queue -> int -> ’a -> ’a queue
    val extract : ’a queue -> int * ’a * ’a queue
    exception Queue_is_empty
  end

通过该签名限制“PrioQueue”结构的结果是“PrioQueue”结构的另一种使用视角，其中“remove_top”函数不可访问同时有限列队的实际表现是隐藏的：

#module AbstractPrioQueue = (PrioQueue : PRIOQUEUE);;
module AbstractPrioQueue : PRIOQUEUE

#AbstractPrioQueue.remove_top;;
Error: Unbound value AbstractPrioQueue.remove_top

#AbstractPrioQueue.insert AbstractPrioQueue.empty 1 "hello";;
- : string AbstractPrioQueue.queue = <abstr>

限制也可以在定义结构的时候执行，就像

module PrioQueue = (struct ... end : PRIOQUEUE);;

上面的另一种可选语法是：

module PrioQueue : PRIOQUEUE = struct ... end;;

** 2.3 Functors

函子使用由结构到结构的”函数“。它们用来表达参数化的结构：以结构B作为参数的结构A，简单地说就是以B为形式参数（依照对B期望的签名）的函子F返回实际的结构A自身。函子F随后可以使用到B的若干实现B1...Bn上面，对应的产生结构A1...An。

例如这里是一个用有序列表作为集合的结构实现，以一个提供集合元素的类型的结构和该类型的排序函数（用来保持集合是有序的）为参数：

#type comparison = Less | Equal | Greater;;
type comparison = Less | Equal | Greater

#module type ORDERED_TYPE =
   sig
     type t
     val compare: t -> t -> comparison
   end;;
module type ORDERED_TYPE = sig type t val compare : t -> t -> comparison end

#module Set =
   functor (Elt: ORDERED_TYPE) ->
     struct
       type element = Elt.t
       type set = element list
       let empty = []
       let rec add x s =
         match s with
           [] -> [x]
         | hd::tl ->
            match Elt.compare x hd with
              Equal -> s (* x is already in s *)
            | Less -> x :: s (* x is smaller than all elements of s *)
            | Greater -> hd :: add x tl
       let rec member x s =
         match s with
           [] -> false
         | hd::tl ->
             match Elt.compare x hd with
               Equal -> true (* x belongs to s *)
             | Less -> false (* x is smaller than all elements of s *)
             | Greater -> member x tl
     end;;
module Set :
  functor (Elt : ORDERED_TYPE) ->
    sig
      type element = Elt.t
      type set = element list
      val empty : ’a list
      val add : Elt.t -> Elt.t list -> Elt.t list
      val member : Elt.t -> Elt.t list -> bool
    end

通过把函子“Set”应用到一个实现有序类型的结构上，我们获得了该类型的集合操作符：

#module OrderedString =
   struct
     type t = string
     let compare x y = if x = y then Equal else if x < y then Less else Greater
   end;;
module OrderedString :
  sig type t = string val compare : ’a -> ’a -> comparison end

#module StringSet = Set(OrderedString);;
module StringSet :
  sig
    type element = OrderedString.t
    type set = element list
    val empty : ’a list
    val add : OrderedString.t -> OrderedString.t list -> OrderedString.t list
    val member : OrderedString.t -> OrderedString.t list -> bool
  end

#StringSet.member "bar" (StringSet.add "foo" StringSet.empty);;
- : bool = false

** 2.4 Functors and type abstraction

在“PrioQueue”例子中，隐藏集合类型的实际实现会是一个良好的习惯，这样该结构的用户就不依赖于集合是一个列表，并我们能够随后切换到其他更高效的集合的表现形式而不破坏它们的代码。这可以通过合适的函子签名限制“Set”来实现：

#module type SETFUNCTOR =
   functor (Elt: ORDERED_TYPE) ->
     sig
       type element = Elt.t (* concrete *)
       type set (* abstract *)
       val empty : set
       val add : element -> set -> set
       val member : element -> set -> bool
     end;;
module type SETFUNCTOR =
  functor (Elt : ORDERED_TYPE) ->
    sig
      type element = Elt.t
      type set
      val empty : set
      val add : element -> set -> set
      val member : element -> set -> bool
    end

#module AbstractSet = (Set : SETFUNCTOR);;
module AbstractSet : SETFUNCTOR

#module AbstractStringSet = AbstractSet(OrderedString);;
module AbstractStringSet :
  sig
    type element = OrderedString.t
    type set = AbstractSet(OrderedString).set
    val empty : set
    val add : element -> set -> set
    val member : element -> set -> bool
  end

#AbstractStringSet.add "gee" AbstractStringSet.empty;;
- : AbstractStringSet.set = <abstr>

试图更优雅的书写类型约束，有人会希望命名函子返回的结构的签名，然后在约束中使用那个签名：

#module type SET =
   sig
     type element
     type set
     val empty : set
     val add : element -> set -> set
     val member : element -> set -> bool
   end;;
module type SET =
  sig
    type element
    type set
    val empty : set
    val add : element -> set -> set
    val member : element -> set -> bool
  end

#module WrongSet = (Set : functor(Elt: ORDERED_TYPE) -> SET);;
module WrongSet : functor (Elt : ORDERED_TYPE) -> SET

#module WrongStringSet = WrongSet(OrderedString);;
module WrongStringSet :
  sig
    type element = WrongSet(OrderedString).element
    type set = WrongSet(OrderedString).set
    val empty : set
    val add : element -> set -> set
    val member : element -> set -> bool
  end

#WrongStringSet.add "gee" WrongStringSet.empty;;
Error: This expression has type string but an expression was expected of type
         WrongStringSet.element = WrongSet(OrderedString).element

这里的问题是“Set”制定的类型元素是抽象的，使得在函子结果的元素和参数的“t”之间类型相等被遗忘了。所以“WrongStringSet.element”和字符串是不同的类型，“WrongStringSet”上的操作不能使用到字符串上。正如上述演示，签名“Set”中的类型元素声明为和“Elt.t”相等是很重要；不幸地，由于“SET”定义在“Elt”不存在的上下文中上面的想法是不可能的。为了克服这个困难，Objective Caml提供了签名上的类型约束来允许使用额外的类型相等来扩充一个签名：

#module AbstractSet =
   (Set : functor(Elt: ORDERED_TYPE) -> (SET with type element = Elt.t));;
module AbstractSet :
  functor (Elt : ORDERED_TYPE) ->
    sig
      type element = Elt.t
      type set
      val empty : set
      val add : element -> set -> set
      val member : element -> set -> bool
    end

和简化结构定义的情况一样，定义函子并约束其结果提供有另一种语法：

module AbstractSet(Elt: ORDERED_TYPE) : (SET with type element = Elt.t) =
  struct ... end;;

抽象函子结果的类型组件是一个强大的技术来提供我们所描述的这样提供了高度的类型安全。考虑一个字符串序不同于在“OrderedString”结构中实现的标准顺序。例如我们忽略大小写来比较字符串。

#module NoCaseString =
   struct
     type t = string
     let compare s1 s2 =
       OrderedString.compare (String.lowercase s1) (String.lowercase s2)
   end;;
module NoCaseString :
  sig type t = string val compare : string -> string -> comparison end

#module NoCaseStringSet = AbstractSet(NoCaseString);;
module NoCaseStringSet :
  sig
    type element = NoCaseString.t
    type set = AbstractSet(NoCaseString).set
    val empty : set
    val add : element -> set -> set
    val member : element -> set -> bool
  end

#NoCaseStringSet.add "FOO" AbstractStringSet.empty;;
Error: This expression has type
         AbstractStringSet.set = AbstractSet(OrderedString).set
       but an expression was expected of type
         NoCaseStringSet.set = AbstractSet(NoCaseString).set

注意“AbstractStringSet.set”和“NoCaseStringSet.set”这两个类型是不兼容的，这两个类型的值不相匹配。这是正确的行为：即使两个集合包含相同类型（字符串），两者构建于该类型的不同的顺序，操作符需要维护不同的不变量（标准顺序的严格递增和忽略大小写的顺序）。把“AbstractStringSet”的操作应用到类型“NoCaseStringSet.set”的值会给出错误的结果，或创建了违背“NoCaseStringSet”的不变量的列表。

** 2.5 Modules and separate compilation

目前所有的模块的例子都是在交互系统的上下文中给出。不过模块对大型的批量编译程序格外有用。对这样的程序，存在实践的必要性把源代码分割到若干文件中，称为编译单元，可以单独的编译，由此最小化修改后的重编译。

在Objective Caml中，编译单元是结构和签名的特例，单元之间的关系可以从模块系统的方面容易地解释。一个编译单元A包含两个文件：

实现文件A.ml，包含一序列定义，相当于在“struct…end”构造之内；
界面文件A.mli，包含一序列规格，相当于在“sig…end”构造之内。

两个文件定义了一个名为A的结构如同下面的定义插入在顶层环境中：

module A: sig (* contents of file A.mli *) end
        = struct (* contents of file A.ml *) end;;

文件定义的编译单元可以用“ocamlc -c”命令（-c选项表示“只编译，不要连接”）单独编译；这样产生了编译的界面文件（以.cmi为扩展名）和编译的目标代码文件（以.cmo为扩展名）。当所有的单元都被编译，它们的“.cmo”文件使用“ocaml"连接在一起。例如下列命令编译并连接一个由两个编译单元“Aux”和“Main”组成的程序：

$ ocamlc -c Aux.mli # produces aux.cmi
$ ocamlc -c Aux.ml # produces aux.cmo
$ ocamlc -c Main.mli # produces main.cmi
$ ocamlc -c Main.ml # produces main.cmo
$ ocamlc -o theprogram Aux.cmo Main.cmo

这个程序的行为正如同下列语句插入到顶层环境：

module Aux: sig (* contents of Aux.mli *) end
          = struct (* contents of Aux.ml *) end;;
module Main: sig (* contents of Main.mli *) end
           = struct (* contents of Main.ml *) end;;

特别地，“Main”可以引用“Aux”：“Main.ml”和“Main.mli”所包含的定义和声明可以引用“Aux.ml”的定义，使用“Aux.ident”标记，如果“Aux.mli”导出了这些定义的话。

在连接阶段给“ocaml”的“.cmo”文件的顺序决定了模块定义发生的顺序。因此在上面的例子中，“Aux”先出现并且“Main”可以引用它，但是“Aux”不能引用“Main”。

注意仅仅顶层的结构可以映射到单独编译的文件，并且不是函子或者模块类型。不过所有的模块类对象可以以结构的组件出现，所以解决方法是把函子和模块类型放在结构内，这样就能映射为文件了。

* 翻译说明

** 什么是OCaml/ML语言

OCaml是ML语言（当初作为可计算理论证明的工具产生的）的主要方言之一Caml语言当前的实现和扩展，是由INRIA开发的多范式语言。相比于ML另一方言SML，Caml语言是由它的实现（目前是OCaml）所描述的一种语言而没有基于某一报告或标准。但是OCaml在ML的基础上作出有用的扩展和尝试，使之在函数式编程语言中较适合做实际的应用。虽然ML系的语言并不广为使用（貌似仅在一些性能有关的金融数据分析的场合），但是这无法掩盖其设计上存在优异之处。并且OCaml目前在众Linux发行版中得到了较重点的支援，也影响到了F#和Scala语言的产生。关于编程语言类型的一书《Types And Programming Languages》中以OCaml作为描述语言。
个人觉得OCaml的代码十分清晰易读，至少从上面出现的例子中可以感知一二。它比Lisp更接近数学表达式，而比Haskell语法糖要少。在编译过程中编译为带类型的Lambda表达式的，这是它和它之前的函数式语言相通的地方。

** 和Standard ML的比较

SML当前是依据97年的修订报告，其功能和OCaml的核心加上模块这两部分是一致的，在语法上有些许差异。例如SML区分地除type外用datatype声明变体类型，用fun代替let绑定函数类型，用case...of而不是match...with进行模式匹配，用访问方法而不是下标的形式取记录的元素，有单独的eqtype表示可以判断相等的类型，在不同的内置类型重载了同样的算数运算符。
SML更关注于语言自身的规范和设计，在ML系语言中SML更加适合在教学场合中使用，并且不像OCaml受到法国文化的影响。

** 关于所翻译内容的说明

这里翻译的是OCaml手册中An introduction to Objective Caml部分的前两章节，这部分的原理是对所有ML系语言都使用，并且涵盖了编写程序时需要使用到的特性。其中核心部分用于编写一般的程序逻辑，而模块系统用于使用标准库和创建自己的库。其他特性如面向对象部分在很多实际应用中并没有用到。如果想通过实际的例子来获得一些感受的话：
简略的参考发卡片可以看
http://www.ocamlpro.com/code/2011-06-03-cheatsheets.html
这次有许多小的算法片段
http://rosettacode.org/wiki/Category:OCaml
一些开源项目的代码也可以拿来阅读，例如
形式语言系统Coq和P2P客户端Mldonkey。

** OCaml中提供的其他特性

其他特性的话，首先要说到面向对象特性，其围绕object,、class和type这三个关键词展开。注意OCaml在运行式已经擦除了类型信息，所以类型转换只能往父类单向进行，不过type仅代表接口上的关系而与class无关。在OCaml中继承表示句法关系而子类型表示语义关系，两者使用了不相干的语法。
至于常用的而上面没有说到的特性，一个是Labels，作为函数的关键词参数使用，另一个是Polymorphic variants，类似于Scheme中的Symbol。
此外还包含了一个标准库，和若干哦你工具如创建解析器的ocamllex和ocamlyacc以及从代码中生成文档的ocamldoc还有调试和性能测试工具。
另外有个语言扩充允许match语句中用when表示以条件来匹配还是一个较有用的特性。

** 有关的参考文档和阅读资料

首先是官网上的文档，包括OCaml和Caml Light的手册。它们侧重于对语言和实现本身的描述，这是书写程序时所必备的参考。
http://caml.inria.fr/resources/
还有oreilly的书名为《Developing Applications With Objective Caml》在官网是也免费的提供，涵盖了语言的教程和若干经验。
http://caml.inria.fr/pub/docs/oreilly-book/

** 可以使用的IDE工具

良好的缩进对代码的可读性相当重要，有编辑器帮助的话会很方便的。
这年头程序语言貌似都有强制缩进格式的倾向，让不同的人写出缩进完全一样的代码。
在Emacs中可以使用Tuareg Mode；在Ecliipse中可以使用OcaIDE，Scite也自带了OCaml的语法高亮。

** 和Haskell语言的区别

语法的外表上有继承关系倒是了，况其也是随着ML系的强类型函数式语言这一范式发展过来的。
区别在于Haskell是non-strict的，求值仅在需要是进行（注意一下此时的内存分配情况）；是核心部分是纯函数语言，命令式借助于函数的continuation约束执行的次序并由强类型机制约束发生的范围；支持函数的重载，通过typeclass使得同样名称的操作符可以用到不同类型的实例上。此外，Haskell的模块机制和类型无关，仅表示标识符的可见性。
现在Haskell的关注度于已经有超越ML系的趋势，并且自身发展和用户群体更为活跃。

** 关于此次翻译的说明

本来是想根据官方文档的内容来简要的表述一下，后来发觉以自身的能力想说清楚是有难度的，所以就演变成了字面的直译了。
这样可能产生了莫名其妙的曲解，在此也只能暂且就这样了。虽然翻译的曲解不会影响到原文的意思，但是给不幸接触到此文的人误导就不好了。

面向Scheme用户的Common Lisp语言的小贴士【程序语言介绍】

2011-06-30T23:06:00.012+08:00

* Scheme
Scheme的主要参考资源是SICP和R5RS，优点是语言设计的相当精巧，便于学习和理解程序的原理。

* Common Lisp
Common Lisp是Lisp最主要的方言之一，是为了标准化众多分支而产生的，在AI领域特别是符号计算方面有所应用。和Lisp的另一方言Scheme相比，更适合写实际可用的程序，而不限于演示的目的。
本文假定读者已经了解了Scheme语言的基本使用，将侧重于CL语言自身中有差异的部分，以减少在使用CL因为困惑而不自在。
Lisp的共同点是在于List，这里尽量把Scm和CL当作不同的语言来看待，避开去具体比较之间的相似和相异之处。
这里假设已经了解了Lisp系语言的基本使用和编程范式，将仅从语言特性角度来看反而能都看到CL的一些特别之处。

* 参考文档
** Common Lisp the Language, 2nd Edition
语言描述文档，对语言特性和提供的库都有详细的说明
** Common Lisp HyperSpec
参考手册，用于查阅，形式类似于按照关键词组织的卡片表格样式
** ANSI Common Lisp
偏向于语言特性的教学，很适合本文的话题，所以这里将按照这本书的结构来写

* 正文
** 缩进对阅读代码来说，相当重要。如下内容如有歧义请以文档为准
** 列表list是Lisp中重要的数据结构，同时Lisp语言的表达式也以list形式书写，表达式可以求值
** 断言predicate命名以p结尾
** t表示true而nil表示false，t是所有类型的supertype，nil是所有类型的subtype
** 为方便表示不同的操作符，下面将Function称为函数，将Special Form称为语句，将Macro称为宏，有时候在用法上之间的差异会模糊
** 用defun定义全局函数，用defparameter定义全局变量并计算初始值（如果仅仅是定义的话，也可用defvar），用defconstant定义全局常量
** 用let/let*绑定局部变量，用flet/labels绑定局部函数
** 宏destructuring-bind可以接受模式pattern形式的绑定
** 语句setf用来改变全局或局部符号或表达式所表示的空间所绑定的值，当符号未绑定时自动绑定全局符号
** 语句setf可以同时接受多组符号和值的绑定，这里的符号可以是符号类型，也可是表达式来指定符号的空间或者表示对对象的修改
** 函数参数从左到右执行，函数定义时允许递归调用
** 格式化函数format的第一个参数表示输出的方式，格式字符串~A表示在该处输出值，~%表示换行
** 格式化函数中的格式字符串有一些复杂但有效的用法
** 语句quote可以在包内获取或创建符号，或者用来创建列表，可缩写为'
** 语句function可以将符号或lambda表达式对应的函数，可缩写为#'
** 以lambda开头的不是函数或者语句，而是一种单独形式表达式，类似于列表
** 函数apply和funcall用来将函数作用到参数上，第一个参数可以是函数也可以是符号，但不建议是lambda表达式
** 判断值的类型可以用类型相关的断言，或者用函数typep进行比较，typecase进行分支，deftype定义类型，coerce进行类型转换
** 判断值的内容是否相同用eql，判断列表及每个元素相同用equal，判断值所在的地址是否相同用eq
** 列表list通过函数list生成或者通过make-list来创建，内部由点对pair构成
** 用copy-list和copy-alist和copy-tree来复制列表和关联列表和嵌套列表
** 函数mapcar用来通过某函数将列表的每个元素映射并新创建一个列表
** 列表可以充当集合Set使用，或者是序列Sequence，或者是堆Stack，或者是关联列表Assoc-list，在CL中提供有相关的函数
** 多维数组由函数make-array创建或者用#na生成，由函数aref引用下标，并可由setf来改变数组内的值
** 向量是一种一维数组，用vector或者#()来生成，通过svref来引用。数组的函数如sort和aref同样可用
** 字符串也是一种一维数组，可以用equal判断相等（区分大小写），同时也有专门用于字符串的函数如函数char来获取下标对应的字符以及不区分大小写的比较（以“string-”为前缀）
** 列表可用nth获取下标，不过由于是递归调用cdr/rest所以性能不佳。和向量及字符串一起，都可以使用序列相关的函数，如elt获取下标对应的元素
** 序列相关的函数常见的关键词是:key :test :from-end :start :end
** 形如(defstruct point x y)定义了两个成员的结构Structure，由(make-point :x 0 :y 0))创建实例，并得到访问函数point-x和point-y，提供有setf形式用于修改，断言名为point-p。
** 字段可有初始值，结构也由:cone-name定义对应函数的前缀，有:print-function定义打印方式
** 哈希表Hash Table由make-hash-table创建（其:test默认为eql），gethash访问（其第二个返回值表示是否存在）
** 控制流程中语句progn依次执行语句并返回最后一个值，语句block的第一个参数表示标签并可用return-from返回语句块的值（标签为nil时可用return，也可在一些语句内使用，函数名可作为标签使用），tagbody可在内部任意位置位置使用并由通过go来跳转
** 分支cond和case的最后一个分支可以是t或者otherwise表示默认的情况
** 循环和迭代过程可以使用do或do*或dolist或dotimes或mapc（不返回值的mapcar）或loop
** 语句可以返回列表也可以由values返回多个值，通常只有第一个值其作用，可由multiple-value-bind或multiple-value-call或multiple-value-list使用多返回值
** 非局部跳转（跨越函数调用）可以用throw（参数为标签加返回值）和catch和unwind-protect ，而错误error会触发error handler
** 函数symbol-function用来获取符号对应的全局函数，也可以用setf的形式使用，它不可以用来访问局部函数
** 用documentation可以获得defun中参数后的描述用字符串，函数之外的类型也可以定义这样的文档
** 参数列表Parameter List指函数定义和调用时的&rest &optional &key，可以有默认值
** 函数定义中可以指定某变量使用动态作用域，形如(declare (special x))，可以在修改全局变量时以免造成副作用的扩散
** 函数compile用来编译符号所对应的函数，有些操作符会在编译期执行的，会影响到性能和一些值的绑定。
** 递归可以用数学归纳法来考虑
** 标准输入输出流Stream所存放的全局变量是*standard-input*和*standard-output*
** 由make-pathname创建路径，函数open（:direction表示读写方式）由路径打开流，函数close关闭流
** 宏with-open-file所定义的语句有一个隐含的unwind-protect的close，其第一个参数的首元素是该语句中绑定到流的变量名
** 函数read-*默认使用以*standard-input*作为字符输入，函数read-from-string从参数的字符串作为输入流，在读取时read-macro会被展开
** 函数prin1可以和read配对使用（会将转义字符显示出来），通常的输出使用princ，函数pprint对应*print-pretty*非nil
** 函数format中的格式化字符串在~后可跟,分割的参数，参数可空，右侧,可省略
** 符号Symbol不区分大小写（对于包含空格等字符的符号名，可以用双"|"包围），会intern到包package中，不同的包里的同名符号是不同的。
** 以冒号为前缀的关键词keyword的值是其本身，与包的作用域无关。有时需要用gensym得到一个唯一的符号。
** 函数intern用于从字符串在包内查找或创建符号，每个符号有它的属性列表
** 包由宏defpackage创建，可以指定:use :nicknames :export，使用in-package切换到某包内
** 通过“包名:符号名”的形式来使用别的包里导出export的符号
** 当符号有绑定全局变量时，可以用symbol-value获得该变量的值（不同的类型可以绑定到同一个符号）。局部变量只在编译或解释存在，不可以混用
** 类型number分为integer float ratio complex，存在自动和手动的类型转换
** 用=可以比较两个数是否相等（“/=表示参数各不相等”），而eql不仅要相等好需要类型一致
** 整数分为fixnum（最大正值为常量most-positive-fixnum）和bignum，会自动转换。浮点数有四种，之间储存和计算的精度不同
** eval以列表作为参数，执行使用全局作用域
** 定义宏defmacro返回一个列表，语法类似于defun，用macroexpand-1可以手动展开，常配合Backquote书写
** 宏将在在使用它的程序执行前替换原表达式，需要区分编译时和运行时执行的部分，以及和调用的上下文的影响（建议配合let使用）
** 用于setf的同名宏通过define-modify-macro定义，setf中的表达式参数作为该宏的第一个参数
** 定义类defclass，其参数为类名，超类列表，槽列表。函数make-instance通过符号创建类，函数slot-value访问实例的槽
** 槽slot可以定义:accessor :initarg :initform，定义“:allcation :class”则槽属于类而非实例，槽还可以定义:documentation :type
** 子类会继承超类superclass的槽，类可以有多个超类，按照从到右深度优先
** 同名的槽，:allocation :initform :documentation取做特殊化的类（子类），:initargs :accessors :readers :writers取并集，:type取交集，同名依据符号相同来判断
** standard-object是standard-class的实例，是t的subtype，是其他所有class的superclass
** 宏defmethod用于定义方法，可以给参数定义class或者type或者eql条件
** 方法必须有相同数量的参数，可选参数也需要个数一致，&rest或&key需要同时存在或不存在。其中只有必须的参数可以特例化，如果类型一致会覆盖先前定义的特例方法
** 由方法定义的函数称为generic function，可以对不同的类定义不同的方法，类型依照参数从左到右的顺序匹配定义了特例且最特例的类型，这有消息转递模型所差异
** 可以在方法的基础上定义辅助auxiliary方法:before(按照特殊往一般的顺序) :after（按照一般往特殊的顺序） :around（只执行最特殊的，可以(if (next-method-p) (call-next-method))）
** 宏defgeneric用于将所有的方法看作一个整体，例如可用:method-combination通过某操作符混合所有的方法
** CLOS可以配合PACKAGE机制来只导出需要暴露的函数
** 列表类型（也包括其他的容器）中会存在节点数据的共享，并可能构成环（打印需要*print-circle*指定为t，使用#n=和#n#来读入）。特别要注意副作用会影响到所有引用它的数据，例如member就会引用原数据，而list会创建一个新的列表（quote就不会）
** 操作列表的参数以形式(setf list1 (** list1))来使用，这里的操作符有的会创建新的列表，有的则是破坏性的destructive
** 破坏性的操作会改变对象的数据，但是不保证会做出如何的修改，而是确保返回值是正确的，这样可以比完全重新创建列表有性能上的好处
** 有无破坏性的函数可能会对应提供，如mapcar和mapcan，remove和delete，append和nconc，subst和nsubst，通常以命名以n为前缀（表示non-consing）
** 可以用declare定义函数的编译参数，以及用declaim定义全局的，包括optimize inline type，用the定义表达式的类型，数组时可定义:element-type，已知类型可以加快对方法的查找。性能的因素可以在不影响语句时再完善
** 可以定义类型，如(vector fixnum 20)，(simple-array fixnum (4 4))，(integer 1 100)，(simple-array fixnum (* *))，(or vector (and list (not (satisfies circular?))))
** 容易可以定义大于:fill-pointer的空间，以便添加元素用。创建pool可以重复使用以创建的对象，减少cons和gc的开销
** 当流是:element-type 'unsigned-byte时可以read-byte/write-byte
** 定义read-macro通过set-macro-character以及set-dispatch-macro-character来通过流返回列表
** 用户默认包是common-lisp-user，可以用make-package创建用in-package进入，用export导出use-package使用
** 宏loop用来书写迭代过程，可以仿照已有的例子来使用
** 函数error ecase check-type assert会抛出错误，可用ignore-errors转化为nil
** 语句or和and是语句，本身不是函数，也不像C++中那样可以overload为函数
** 可以使用trace以及交互模式中的指令对代码进行调试，交互回话可以保存为映像
** 通过函数load载入文件，通过eval-when在设置在装载或编译时执行语句
** 可以根据所使用的类型，有必要知道一下CL已经自带的一些函数或宏或方法

* Wiki
http://www.cliki.net

* 实现
我暂且用的是gcl和clisp，因为比较容易上手，话说自己还没什么CL的使用使用经验。
IDE可以用SLIME，LispIDE或者带tag和高亮和括号匹配的文本编辑器也行，Cusp不知还在维护否。
有一些开源的符号计算软件使用CL实现的，可以作为学习的资源和参考。

* 其他方言或相关语言
** Emacs Lisp
** Visual Lisp
** Clojure
** Dylan

* 接下来...
** 面向Scheme用户的ML语言的小贴士
** 面向Scheme用户的Haskell语言的小贴士

----
用org-mode列了一个提纲，展开缺乏，看着有点别扭。
有些细节可能会有理解误差，这里仅仅是导读的目的了。
此文纯介绍性质，不建议随意地在实际目的中使用。

----
关于另一个很重要的特性，就是程序边运行边修改，自己还没有这方面的经验和习惯，但是CL的一些语言设计确实有为这种用法考虑。
如果是有经验实现可以选择SBCL+SLIME，本文只是一个浅尝辄止的态度的产物，虽然出发点是想说说Scm和CL的差异的说。
恩...有些地方简略地有些不明不白了...

----
貌似说reduce要优于不定长参数。
loop宏和尾递归是两种风格不同的东西，前者算是更进一步的抽象吧。

《现代操作系统》一书中的每章节的小结部分，放在这里的算是此书中比较浅显的概括

2011-06-13T10:45:00.010+08:00

把每章节的SUMMARY翻译了一下，书是ISBN0-13-031358-0，有976页，这不是该书当前的最新版本。

MODERN OPERATING SYSTEMS
SECOND EDITION
by Andrew S. Tanenbaum

* 0 前言
空

* 1 介绍
操作系统可以从两个视角来看待：资源管理器和扩产的机器。从资源管理器的角度说，操作系统的工作是有效的管理系统的不同的部分。从扩充的机器的角度说，操作系统的工作是给用户提供一个比真实机器方便使用的虚拟机器。
操作系统有一个很长的历史，从它们代替一般的操作的时候开始，到现代的多程序的系统。重要的包括早期的批处理系统、多程序系统、以及个人计算机系统。
由于操作系统紧紧地和硬件交互，一些计算机硬件的知识对于理解操作系统的有用的。计算机由处理器、储存器以及I/O设备组成。这些部分由总线连接。
所有的操作系统都依赖的概念是进程、内存管理、I/O管理、文件系统和安全。它们都会在随后的章节里处理。
任何操作系统的核心是一系列可以处理的系统调用。它们表明了操作系统实际能做的事情。利于UNX系统，我们接触了一组系统调用。第一组系统调用和进程的创建和终止有关。第二组用来读取和写入文件。第三组用于目录管理。第四组包括其他杂项调用。
操作系统结构可以有多种方式。最常见的为单片机系统、层状层次、虚拟机系统、集成内核或者使用客户机服务器模型。

* 2 进程和线程
为了隐藏中断的作用，操作系统提供了由一系列进程并行运行组成的概念模型。进程可以被动态的创建和终止。每个进程有它自己的地址空间。
对于某些应用让一个进程里有多个线程控制是很有用的。这些线程相互独立地调度并个人有自己的堆栈，但是进程里的所有进程享用共同的地址空间。线程可以实现在用户空间或者内核当中。
进程和使用进程间的通讯机制相互通信，例如信号、监视、或者消息。这些机制用来确保不会有两个进程同时在它们会引起混乱的关键区域。进程可以正在运行、可运行或者阻塞状态，并且可以在自己或者另一个进程运行一个通讯机制的中断的时候改变状态。线程间的通讯也是类似的。
进程间的通讯机制可以解决一些问题、比如生产消费问题、餐饮的哲学家问题、读取器与写入器的问题、以及睡觉的理发师的问题。即使使用了这些机制，仍然需要避免错误和死锁问题。
许多调度算法为人所知。它们中一些原先是用于批处理系统的，例如最短任务优先。另一些则在批处理系统中和交互系统中通用。包括循环调度、优先级调度、多级列队、保障调度、彩票调度、以及公平共享调度。一些系统在调度机制和调度方针之间有明确的划分，这样就可以允许用户来控制调度算法。

* 3 死锁
死锁是任何操作系统中都潜在的问题。它在发生在一组进程中各被授权独立地访问一些资源，并每个进程也需要已经属于该组中其他进程的资源。这些进程被阻塞并都永远不能再运行。
死锁可以通过跟踪什么状态是安全的以及什么状态是不安全的来避免。安全的状态是才能在的一序列时间可以保证所有的进程可以结束。不安全的状态是没有这样的保证。Banker算法可以通过拒接将系统的置于不安全状态的请求来避免死锁。
死锁可以通过建立一种让它永远不会产生的设计来阻止。例如，通过仅允许进程只能同时持有一个资源，死锁的循环等待条件就被打破了。死锁也可以通过给所有的资源编号、并让进程请求资源严格按照递增的顺序。饥饿可以通过先来先服务的分配方针。

* 4 内存管理
在这章中我们探讨了内存的管理。我们看到最简单的系统不交换或分页。一旦程序被载入内存中，它将持续到结束。一些操作系统仅允许某时刻仅有一个进程在内存中，而另一些支持多程序。
下一步是交换。通过交换的应用，系统可以处理比内存空间更多的程序。没有空间的进程交换出到磁盘。内存和磁盘上的自由空间通过位图或者列表的形式跟踪。
现代的计算机通常有某种形式的虚拟内存。在最简单的形式中，每个进程的机制空间划分为称为页面大小一致的块，可以放置到内存中任意可获得的页面帧里面。有许多页面替换算法：两种较好的算法是Aging和WSClock。
页面系统的模型可以看作程序中抽象的页面引用字符串合计使用同样的字符串的不同算法。这些模型可以用来做出一些对分页行为的预测。
为了使分页系统工作良好，选择算法是不够的；还需要注意到一些问题如工作集的决定、内存分配的方针、以及页面的大小。
分段有助于在在执行中处理改变大小的数据结构并简化了连接和共享。它也促成了不同分段的不同保护方式。有时分段和分页是组合在一起提供了二维的虚拟内存模型。MULTICS和Intel Pentium系统支持分段和分页。

* 5 输入/输出
输入/输出是一个常被忽视，但是重要的话题。任何系统中相当大的部分是和I/O相连的。I/O可以通过三种方式来完成。第一种，是可编程了I/O，其中主CPU输入或输出每个字节或字并保持紧张的循环等待直到它能得到或发送下一个数据。第二种是中断驱动的I/O，其中CPU开始对字符或单词的传输后离开去做别的事情，直到中断到达表示I/O完成的信号。第三种是通过DMA，它是一个单独管理用户传输数据块的芯片，只有在整块数据传输完成的时候给出中断。
I/O可以以四个层次来结构：中断服务程序，设备驱动程序、设备无关的I/O软件、以及用户空间中的I/O库和后台程序。设备驱动处理运行设备的细节以及为余下的系统提供一致的接口。设备无关的I/O软件进行缓冲和错误报告之类的事情。
磁盘有多种类型，包括磁性的磁盘、阵列、和各种光盘。磁头的调度算法通常可以用来提升磁盘性能，不过这关系到所呈现的几何形态的复杂度。通过连接两个磁盘，可以构建特定作用属性的稳固储存。
时钟用于跟踪真实事件，限制进程可以运行时间长度、处理看门狗定时器、以及做报告。
面向字符的终端有一些特殊字符可用户输入和一些转义字符用于输出。输入可以在原始模式或者烹饪模式，这取决于程序想对输入有多少控制。输出中的转义序列控制光标的移动，并用户允许插入和删除屏幕上的文字。
许多个人计算机使用GUI来输出。它们基于WMP范式：窗口、图标、菜单、以及指点设别。基于GUI的设备一盘是事件驱动的，通过键盘鼠标以及其他送往程序的事件被尽快地处理。
网络终端有若干形式。其中一种最流行的是运行复杂地用于构建图形界面的X系统。X窗口的另一中方式是使用低层次的接口通过网络传输简单的原始像素。SLIM终端的实验显示这项技术也可以很好的工作。
最后，电源管理是便携计算机的一个主要的问题，因为电池的寿命是有限的。各种技术可被操作系统采用来降低电源的损耗。程序可以通过牺牲一些性能来帮助延长电池的使用时间。

* 6 文件系统
从外面来看，文件系统是文件和目录的集合，加上对它们的操作。文件可以被读取和写入，目录可以创建和销毁，并且文件可以在目录间移动。大部分现代的文件系统支持层次的目录系统，其中目录可以有子目录，并它们循环地继续有子目录。
当从内部来看，文件看起来有很大的不同。文件的设计者必须考虑储存是如何分配，以及系统是如何跟踪哪个块是属于哪个文件。可以的方式包括连续的文件、链接的列表、文件分配表、以及i-node。不同哦你高的系统有不同的目录结构。文件属性可以放在目录中或者其他地方（例如i-node中）。磁盘空间可以使用自由列表或者位图来管理。文件系统的可靠性通过制造增量的转储来增强以及通过让程序可以出错的文件系统。文件系统的性能是重要的并可以用若干方式来增强，包括转存、预读、以及仔细的方式文件块使之间临近。日志结构文件系统也通过大的单元进行写入来增强性能。
文件系统的例子包括ISO 9660、CP/M、MS-DOS、Windows 98、以及UNIX。它们在许多方面有区别，包括如何跟踪哪个块属于哪个文件、目录的结构、以及自由磁盘空间的管理方式。

* 7 多媒体操作系统
多媒体是新起的计算机的使用。由于多媒体文件的大尺寸和它们严格的实时回放需求，为文本设计的操作系统对多媒体不够理想。多媒体文件有多重的平行的轨道组成，通常是一轨视频和至少一轨音频以及有时也有字幕轨。它们必须在播放时同步。
音频的通过定期的采样来录制，通常是44,100次/秒（CD音质）。压制可用于音频信号定义统一的10x的压制速率。视频的压制同时使用帧内压缩（JPEG）和帧间压缩（MEPG），后者用P帧表示与前一帧不同的地方。B帧则居于前一帧或者下一帧。
多媒体需要实时调度已满足期限。两种算法常被采用。第一种是固定速率调度，它使用静态的优先级算法依照周期给进程赋予固定的优先级。第二种是期限最近优先，它是总选择最接近期限的进程的动态算法。EDF较复杂，但是能实现100%的利用率。RMS那样的则不能。
多媒体文件系统通常使用Push模型而不是Pull模型。一旦数据流开始，从磁盘上读取数据就不再要用户请求。这种途径和传统的操作系统有根本的不同，由于对满足实时请求的需要。
文件可以连续的储存或者不是。在后一种情况下，单元是可以可变程度的（一个块是一帧）或者固定长度的（一块有多帧）。这些途径有不同的取舍。
文件在磁盘上的放置影响到性能。当有多个文件的时候，有时organ-pipe算法可以使用。分割文件到多个磁盘上不论横向或纵向，是常见的。块和文件缓存策略也广泛地用来提升性能。

* 8 多处理器系统
计算机系统可以使用多个CPU来更加快速和可靠。三种多CPU系统的组成方式是多处理器、多计算机、以及分布式系统。其中每一种都有自己的特性和问题。
多处理器由两个或更多享用功能的RAM的CPU组成。CPU可以用总线、交叉开关、或者多级交换网络来互联。多种操作系统的配置是可行的，包括给每个CPU单独的操作系统、有一个主操作系统其他作为从属、或者使用对称的对处理器让一份操作系的拷贝可以让任何CPU运行。在后面一种情况，需要用锁来保持同步。当锁不能获得的时候，CPU可以旋转或者做上下文切换。多种调度是可以的，包括时间分时、空间共享、以及成群调度。
多计算机也有两个或者更多的CPU，但是这些CPU有它们自己的私有内存。它们不分享公用的内存，所以所有的通信使用消息的转递，在一些情况，网络接板有它自己的CPU，在这种情况下主CPU和接板的CPU必须自己组织以避免竞争条件。多计算机中用户层次的通讯通常使用远程过程调用，但是分布共享内存也可以使用。处理器局部的平衡是这里的一个问题，并有用于此的多种算法包括发送者启动的算法，接受方启动的算法、以及投标算法。
分布系统是松散耦合的系统，它的每个节点都是有着完整的外围设备和自己的操作系统的独立的计算机。通常这样的系统分布在较广的地理区域。中间件通常构建在操作系统之上来给应用程序提供一致的交互层。各种的中间件包括基于文档的、基于文件的、基于对象的、以及基于协调的中间件。一些例子如World Wide Web、AFS、CORBA、Globe、Linda、以及Jini。

* 9 安全
操作系统可以在许多方面都到威胁，从内部的攻击到从外界进入的病毒。许多攻击是黑客尝试闯入特定的系统，通常仅仅是猜测密码。这些攻击通常只是使用常用密码的字典并惊人的成功。密码安全可以通过使用Salt、一次性密码、以及挑战响应方案。智能卡和生物指示也可以使用。视网膜扫面已经实用了。
许多不同的对操作系统的攻击是一致的，包括特洛伊木马、登录欺骗、逻辑炸弹、陷阱门、以及缓冲溢出攻击。通用的攻击包括请求内存并对其窥探，使用非法的系统调用来看看发生什么，甚至尝试欺骗内部来透露他们不应该透露的信息。
病毒是许多用于增长的严重问题。病毒存在多种形式，包括内存常驻病毒、引导区感染、以及宏病毒。使用病毒扫面器在查找病毒特征是有用的，不过真正好的病毒能加密它们的大部分代码并在每次复制的时候修改余下的代码，使得检测非常困难。一些杀毒软件不仅仅通过查找病毒的特征码来工作，而是通过发现特定可疑的行为。通过安全的计算机使用习惯来避免病毒要优于尝试处理攻击后的后果。简单的说，不要载入执行来历不明的和可信度有疑问的程序。
移动代码是如今必须要处理的问题。把它放在沙箱内，解释运行、以及仅运行可信赖的供应商签名的代码是可行的途径。
系统可以用一个领域（如用户）垂直或者对象水平的矩阵来保护。矩阵可以切割为行，采用基于能力的系统，或者为列，采用基于ACL的系统。
安全的系统是可以被设计的，但是必须从开始就定位一个目标。可能最重要的设计规则是有一个最小的可信赖的计算机基础不能被任何资源的访问绕开。多层安全可以基于Bell-La Padula模型，为保密而设计，或者Biba模型，用于维护系统的完整性。橙皮书描述了可信系统需要满足的要求。最终，即使系统可证明是安全的，仍必须注意到隐蔽的渠道，它能够轻易的通过创建模型外的通信渠道来推翻系统。

* 10 案例1：UNIX和LINUX
UNIX由作为小型机的分时系统开始的，但是现在使用涵盖从笔记本计算机到超级计算机。存在有三个接口：Shell、C库、以及系统调用本身。Shell允许用于键入执行的命令。可以是简单的命令、管道、或者更复杂的结构。输入和输出可以重定向。C库涵盖了系统调用并也有增强的调用，例如printf用于格式化输出往文件。实际的系统调用接口是精简的，大约100个调用，每个调用仅仅做它需要的事情。
UNIX中的关键概念包括进程、内存模型、I/O、以及文件系统。进程可以分出子进程，产生树状的结构。UNIX中的进程管理使用两个关键的数据结构，进程表和用户结构。前者总在内存中，但是后者可以被交换或者分页出去。进程的创建通过复制进程表以及内存镜像来完成。调度使用基于优先级的算法并请相互进程。
内存模型每个进程由三个片段组成，text、data、stack。内存管理曾是用交换来完成，不过现在多数UNIX系统中通过分页来完成。核心地图跟踪每个页面的状态，页面守护进程使用使用时钟算法来保持大约有足有的自由页面。
I/O设备使用特殊的文件来访问，各自有一个主设备号和一个次设备号。块设备I/O使用缓冲缓存来减少访问磁盘的次数。LRU算法可用来管理缓存。字符I/O可以通过直接或者烹制模式。线路规程或流用于给字符I/O添加功能。
文件系统是由文件和目录组成的层次结构。所有的磁盘被载入有单独的根开始的单独的目录树。单独的文件可以链接如一个目录从文件系统的其他地方。要使用文件，必须先打开，产生一个用于读取或者写入的文件描述符。在内部，文件系统使用了三个主要的表：文件描述符表、打开的文件描述符表、以及i-node表。其中i-node表最为重要，包含了关于文件所有的管理信息以及它的块的位置。
保护是基于根据所用者用户组和其他来控制读写执行操作。对于目录，可执行标记解释为搜索的权限。

* 11 案例2：WINDOWS2000
Windows2000的结构是HAL、内核、执行文件、以及一层薄的用于捕获传入的系统调用的系统服务层。此外，有各种设备驱动，包括文件系统和GDI。HAL从上层中隐藏了一定的差异。内核试图给可执行文件隐藏余下的差异使得执行文件是机器独立的。
执行程序是基于内存对象。用户进程创建它们并取回句柄在随后操纵它们。执行组件也能创建对象。对象管理器维护了什么对象可以插入用于以后查找的命名空间。
Windows支持进程、作业、线程和Fiber（用户空间）。进程有虚拟地址空间和资源的容器。线程是执行的单位并由操作系统调度。作业是一组进程用于分配资源的额度。调度通过通过优先级算法让最高优先级的线程随后执行。
Windows2000支持按需分页的虚拟内存。分页算法是基于工作集的概念。系统维护若干自由页面的列表，这样每当页面错误发生，一般有自由页面可用。自由页面列表使用复杂的规则来调整，试图扔掉长时间里没有使用的页面。
I/O通过遵循Windows设备模型的设备驱动完成。每个驱动由初始设备对象开始，其中包含了系统用于添加设备和执行I/O的调用的过程的地址。驱动可以层叠作为过滤器。
NTFS文件系统是基于主文件表，它为每个文件或目录有一项记录。每个文件有多项属性，它可以在MFT记录中不常驻位于磁盘上。NTFS支持压缩和加密，以及其他的功能。
安全是基于访问控制列表。每个进程有访问控制标记来表明它是谁以及如果有的话，它有什么特别的特权。每个对象有一个和它相关的安全描述符。安全描述符指向一个自由访问控制解表，其中有允许或拒绝个人或组访问的访问控制项。
最后，Windows2000为文件系统维护单独系统范围的缓存。这是一个虚拟缓存而不是物理的。磁盘块的请求首先往缓存。如果它们不能满足，则适当的文件系统被调用以获取所需的块。

* 12 操作系统设计
设计一个操作系统有决定它要做什么开始。接口应该是简单、完整、并且高效的。它应该有清晰的用户接口范式、执行范式和数据范式。
系统应该合理地结构，使用一种已知的技术，例如分层或客户服务模式。内部的组件应该相互正交并清晰的从机制中划分出政策。一些问题应该有多思考，例如静态动态的数据结构、命名、绑定时间、以及实现模型的顺序。
性能是重要的，但是优化需要仔细选择而不会破坏系统的结构。空间时间的权衡、缓存、暗示、地区利用、以及优化常见情况是常常值得做的。
由几个人编写的系统不同于300人生产出的大系统。在后一种情况下，团队的结构和项目的管理在项目的成功与失败中扮演了关键的角色。
最终，操作系统不得不继续改变以遵循新的趋势迎接新的挑战。其中包括64位地址空间、大量的连接、桌面多处理器、多媒体、手持的无线计算机、以及种类繁多的嵌入系统。接下来的年份将会是操作系统设计的激动人心的时刻。

* 13 阅读清单和参考书目
空

*
下面是闲话时间，当前自己对操作系统的了解仅停留在浅浅的层面。关于操作系统方面还缺乏经验和心得，于是这里来说说Java和Scheme语言中多线程的原理和实现吧。这里的侧重是关于用户模式内线程，利用协程以及时间中断来实现多任务的切换。此外要注意到一些系统调用会阻塞整个进程，这也是需要处理的问题。当然，这部分闲话的内容是可以正好来运用一下操作系统方面的知识。
坑

Academy of Interactive Arts & Sciences【介绍文/翻译/施工】

2011-06-10T20:21:00.008+08:00

Academy of Interactive Arts & Sciences From Wikipedia
嘛...暂时还没开工...
不过其实也没什么好翻译的，只是想找个条目来写写个人的想法。
里面好多东西不熟悉，也没办法有什么感想。
说自己熟悉的话，还是对NES和GBA要过一些。
另外那里还没有涉及到1996年之前的东西。
这样的话，就先坑在这里了。
要是说自己口味的话，喜欢参与感和空间感强的。
有时候对手柄和格子和树状结构有意外的好感。

又一个坑了的视觉小说，\n顺便说说Java与Scheme的混合/嵌入使用

2011-06-02T23:03:00.043+08:00

拿Slick2d和Kawa包了一组给Scheme用的API出来，做了一个简单而拙劣的VisualNovel演示。话说第三方库有源代码和JavaDoc外加严格的类型系统和Eclipse的辅助，使用起来还是挺方便的。
下面的东西是个试验用的半成品，不过后来发觉又依赖JRE又依赖平台二进制包感觉挺恐怖的。想分发或者跨平台的话暂且都有问题，也就没动力继续去完善了这个自命名Slickawa的包了。
于是代码什么的在很久很久以前就不继续了，现在拿出来发觉可以用来写篇日志，相当于随手写写遇到的想法吧。

话说Slick的提供的库的API让自己挺欣赏的，至少是打消了再去包装它一层的看法（比如SDL就一定要先包一个主循环出来类出来供派生才觉得舒服）。不过要注意的是Slick是在OpenGL上的一层包装，如果觉得它提供了某个抽象合适的话，就拿来用，或者直接看它的代码。如果不合适的话，大可不必考虑某些类的存在，按照自己的需要直接从更底层的方法往上层建立。达到目的即可，而且目的肯定不是重复一个和Slick一样的抽象层（比如移植其他平台用）吧。
不过SDL1.2和OpenGL用起来还是有个很明显的区别（就像PyGame和PyGlet），它们负责图像混合的设备不同。前者主要靠CPU，后者主要靠GPU，如果不这样顺着它们的原理用的话，性能会大有问题（所以C或者Shader的使用最好是无限制）。如果要在多媒体程序里做一些视觉效果的话，真的还是很容易出现性能瓶颈的。

给Scheme的API分为四组，sk中是基本的过程，skex中是可以用Scm本身来实现的，sklab是试验用方法，sklib是依赖底层的方法。这分别对应四个Java的Class，要暴露的方法实现为静态的，这样在Kawa中就可以直接使用了。
算是语言间类型的自动绑定吧，其实呢Kawa是把Scheme代码编译为Java的字节码，这样在性能上和互操作上都很方便。不过想在Kawa完全使用Java库还是有些不便，所以还是提供为简单的一个个过程较方便。对象仍旧是对象，方法变为以对象为参数的过程。
现在让Scheme代码和Java代码结合的地方可以有两种，一种是用Kawa提供的机制直接在Scm中使用Java的包和对象，一种是在Java中用Kawa中提供的类型映射类创建实例交给自己管理的Scheme运行环境。不过这两种方式都不要指望Kawa能够是Scheme和Java部分能够完全的分离，必然会有一个中间层在Scheme中操作了Java的数组，或者是在Java中操作了Scm的列表。
如果需要添加什么功能的话，要么单独的写为一个包，要么就在那个中间层里放心大胆的写。不必在意是写为纯Java的还是纯Scheme的为好，被中间层所选用的语言所限，不然在使用所依赖的库的时候会遇到麻烦。如果担心会导致所暴露的API会紊乱的话，就放到不同的命名空间里去。也不必在意是否暴露的足够的API，只要要中间层有足够的活性（有废止的方法标记一下就可以了，反正只涉及静态方法和单方法的界面，单一元素的修改仅会带来很有限的影响。），混合语言所带来的将不是负担而是效率了。中间层即使Java和Scheme语言同时用也可，目的都是让纯Scm部分的代码可以用某个函数，所以还是倾向于在Java中写这个中间层同时Scheme也用。至于Java6的那个对脚本语言的框架，造成通常得首先包装为对象传给那个框架，然后在用脚本语言提供适合自身类型的包装。用来两次包装之后，想实现一些功能的话，放在哪个部件里都觉得不是很方便。
相比另一个Scheme的Java实现SISC，本来自己是觉得它更小巧一些，所以一开始的更偏爱一些。后来觉得Kawa做得更成熟一些，于是就从比较省事的角度选择的Kawa。之前在用tinyscheme做过一次绑定，得自己添加垃圾收集用的类型，再添加Unicode编码的支持，再针对类型的转换把提供的API函数一个个写一遍。而且用到的函数得去tinyscheme的头文件里找，然后再去长长的单个源代码里看看是怎么回事后才用，再传递指针的时候很容易就把类型信息丢掉。结果就是TinyScheme的代码也混杂在宿主程序里面一起修改了。Java的好处是可以把单独要改的类拿出来改一下然后用（只要不涉及包的可见性以及开源的许可协议的限定的话），原本引入的jar文件可以丝毫不变的放在那里。不过话说似乎好多Scm实现都是为单独使用设计的，想手工包装到C/C++里面都有点手疼，而更倾向于用FFI在Scm代码中用C库（于是对第三方库就可能是先用C包一层，然后再Scm针对类型转换包一层了。这样总比在C中连类似什么也考虑要手疼的好一些，虽然这里来说说感想也看不出多少可再用的价值）。
有个chibi-scheme时间不如TinyScheme，但是设计得更加完善一些。

Java和Scheme都有Steele的参与，这或许是让两者看起来很协调的一方面吧（只是或许而已）。两者都有各自的变量命名习惯，都喜欢使用长的n的单词组合。虽然一个用大小写来分割单词，一个用横线来分割单词，但是这两者对应起来还是相当直观。都是很少用语法糖，都是写起来手疼，都是值是有类型的对象的语言。所以两者混合用起来还是蛮协调一致的感觉。
Scheme的运行环境有两个地方，一个是让Scm代码自己成为一个Java类，一个是人工的管理一个Runtime对象。如果仅仅是把Scheme作为数据来看待的话，似乎后者会比较方便。Scm的一个优势是自身可以当作一种数据格式来使用，Kawa中提供了解析供的方法。而让Scm代码去实现某个interface然后传回Java也是可以的。此外还可以main中直接eval，提供一些API后控制权给脚本，让Scheme当胶水使用。
如果仅仅是想REPL地试验一下某个Java代码片段，有个BeanShell还是蛮方便用的。

关于下面的实现，还有些额外的说明。这里就列举一下，语句会不大通顺。首先呢，当类型不重要的时候，用Scm中的List来传递值了，这样比从对象里查询要方便一些（如果List是Lazy的话就更方便了，语言的执行就是 Graph Reduction）。其次来说，这里Java的主循环三种事件要调用Scheme提供的函数。Java部分只要只管要时去调用，而场景的切换放在Scm里面做了。至于场景切换要怎么修改提供给Java的过程，以及场景切换中还是否要做一些额外的事情，Java部分是不用管的。所以这里为了方便的在Scm中实现多个场景，做了一个简单的OO。注意逻辑和渲染和必须分割开来的，中间可以用全局（相对两者而言）来传递信息。还有呢，涉及RGBA混合的过程无论写在Scheme中还是写在Java中都是会性能不够的，正确做法是写在OpenGL里面，可惜自己还不会。动画效果这里参考了Qt的状态和变换框架，这里仅仅提供了一个用来进行y=kx线性变化的类。其实利用y=f(kx1)+g(kx2)的组合还是能做出很多效果的，比如以线性变化为时间轴映射到多个变量上，或者串联多个线性变换，这些都是可以发挥想象里的地方。然后作用坐标、透明度、颜色以及其他可以数值表示的地方，看起来还是挺生动的（这方面Flash是榜样，不过Flash性能限制）。

写的时候参照了KRKR2/KAG3和ONScripter和RenPy的部分代码，以及rpgchina.net和gamediy.net上的教程，以及Slick和PyGame和ClanLib的API：

;;;开始
(sk:make "VisualNovelDemo")
(sk:path ".;visualnovel")
(sk:display-mode 800 600 #f)
(sk:fps 60)
(sk:debug #t)
;;;OO
(define (send obj msg . arg)
  (cond ((obj msg)
         =>(lambda (x) (apply x arg)))))
(define (dispatch prototype method-alist)
  (lambda (mth)
    (cond
      ((assoc mth method-alist) => (lambda (x) (cadr x)))
      ((procedure? prototype) (prototype mth) )
      (else #f))))
;;;全局变量
(define *env* (interaction-environment))
(define *background* #f)
;(define *script* (sk:load-data "script.scm"))
(define *script* (skex:load-line-data "script.scm"))
(define *scripts-now* #f)
;;;全局过程
;(define *music* #f)
(define (state-clear)
  (set! *scene*
        (dispatch '()
                  (list
                   (list 'frame (lambda (delta) '()))
                   (list 'button (lambda (b) '()))
                   (list 'render (lambda (g) '()))
                   )))
  )
(define (dialog-jump! label)
  ;(sk:display "try")(sk:display label)
  (let ((s (member (list 'label label) *script*)))
    (sk:display s)
    (when s
      (state-clear)
      (set! *scripts-now* s)
      (script-next!)
      ;(sk:display (state))
      )))
;;;场景
(define *scene*
  (dispatch '()
            (list
             (list 'frame (lambda (delta) '()))
             (list 'button (lambda (b) '()))
             (list 'render (lambda (g) '()))
             )))
;;;对话场景
(define (scene-dialog text)
  (define dialog-font (sk:load-font "Simhei" 32))
  (define *dialog-char-count* (skex:make-linear 0 (sk:string-length text) 1))
  (define (dialog-end?)
    (skex:linear-end? *dialog-char-count*))
  (define (dialog-end!)
    (skex:linear-end! *dialog-char-count*))
  (define (on-frame delta)
    (skex:linear-next! *dialog-char-count* (* 0.03 delta)))
  (define (on-render g)
    (sk:draw-color 30 428 (sk:color 0 0 0 128) (- 800 60) 128 )
    (skex:draw-text
     34 432
     (sk:substring text 0 (skex:linear-now *dialog-char-count*))
     (- 800 64) dialog-font (sk:color 0 0 0 128))
    (skex:draw-text
     32 430
     (sk:substring text 0 (skex:linear-now *dialog-char-count*))
     (- 800 64) dialog-font (sk:color 255 255 255 255))
    (when (dialog-end?)
      (sk:draw-color 740 530 (sk:color 128 255 128 255) 8 8)
      )
    )

  (define (on-button b)
    (if (or (equal? b '(pressed A)) (and (pair? b)(eq? (car b) 'touch)))
        (if (dialog-end?)
            (script-next!)
            (dialog-end!))))
  (dispatch
   '()
   (list
    (list 'frame on-frame )
    (list 'button on-button )
    (list 'render on-render )
    ))
  )
;;;scene-effect 背景切换效果
;;;背景切换场景
;;;(bg "1.png" 0)
(define (scene-bg-change arg)
  (define *bg-future* (sk:load-image (cadr arg)))
  (define *bg-changing* (skex:make-linear 0 1 (/ 1 (caddr arg))))
  (define on-frame
    (lambda (delta)
      (skex:linear-next! *bg-changing* delta)
      (when (skex:linear-end? *bg-changing*)
        (set! *background* *bg-future*)
        (set! *bg-changing* #f)
        (script-next!))))
  (define on-button
    (lambda (b) '()))
  (define (on-render g)
    (sk:draw-image 0 0 *bg-future* (* 255 (skex:linear-now *bg-changing*))))
  (dispatch '()
            (list
             (list 'frame on-frame )
             (list 'button on-button )
             (list 'render on-render ))))
;;;scene-effect 背景遮片效果
;;;effect-mask
;;;(effect mask "1.png" "rule.png" 100)
;;;name = 'mask
;;;arg = '(mask "1.png" "rule.png" 100)
(define (scene-bg-effect arg)
  ;;to extend this lambda class
  (define (make-effect bg-future effect-render-with-p% time-last)
    (dispatch '()
              (list
               (list 'frame (lambda (delta) '()))
               (list 'button (lambda (b) '()))
               (list 'render (lambda (g) '()))
               )))
  (case (cadr arg)
    ((mask) (scene-bg-mask-change (cdr arg)))
    ((bg) (scene-bg-change (cdr arg)))
    (else (error "effect"))))
;;;'(mask "1.png" "rule.png" 100)
(define (scene-bg-mask-change arg)
  (define *bg-future* (sk:load-image (cadr arg)))
  (define *bg-mask* (sk:load-image (caddr arg)))
  (define *time-line* (skex:make-linear 0 1 (/ 1 (cadddr arg))))
  (define on-frame
    (lambda (delta)
      (skex:linear-next! *time-line* delta)
      (when (skex:linear-end? *time-line*)
        (set! *background* *bg-future*)
        (set! *time-line* #f)
        (script-next!))))
  (define on-button
    (lambda (b) '()))
  (define (on-render g)
    (sklib:draw-image-with-mask 0 0 *bg-future* *bg-mask* (* 255 (skex:linear-now *time-line*))))
  (dispatch '()
            (list
             (list 'frame on-frame )
             (list 'button on-button )
             (list 'render on-render ))))
;;;用户界面场景
(define (scene-ui arg)
  ;(ui ((text 116 500 "开始" fnt clr) start) ((text 516 500 "退出" fnt clr) end))
  (define *ui* '())
  (define (ui-draw x)
    (map (lambda (i)
           (apply
            (case (caar i)
              ((text) sk:draw-string)
              ((image) sk:draw-image)
              (else (error i)))
            (map (lambda (j) (eval j *env*)) (cdar i))))
         x))
  (define (ui-area x)
    (map
     (lambda (i)
       (list
        (let ((arg (map (lambda (j) (eval j *env*)) (cdar i))))
          (let ((x (car arg))
                (y (cadr arg))
                (s (case (caar i)
                     ((text) (sk:text-size (caddr arg) (cadddr arg)))
                     ((image) sk:draw-image)
                     (else (error i)))))
            (list x y (car s) (cadr s))))
        (cadr i)))
     x))
  (define *button-area* #f)
  (set!
   *scene*
   (dispatch
    '()
    (list
     (list
      'frame
      (lambda (delta) '()))
     (list
      'button
      (lambda (b)
        ;(sk:display (ui-area *ui*))
        (when (and (pair? b)(eq? (car b) 'touch))
          ;(touched (1 2))
          (let ((x (caadr b))(y (cadadr b)))
            (map (lambda (i)
                   (when (skex:contained? x y (car i))
                     ;(sk:display (cadr i))
                     (when (symbol? (cadr i))
                       (dialog-jump! (cadr i)))))
                 (ui-area *ui*))))
        (when (and (pair? b)(eq? (car b) 'cursor))
          ;(touched (1 2))
          (let ((x (caadr b))(y (cadadr b)))
            (set! *button-area* #f)
            (map (lambda (i)
                   (when (skex:contained? x y (car i))
                     (set! *button-area* (or *button-area* (car i))))
                   (when *button-area*
                     (set!
                      *button-area*
                      (apply
                       (lambda (a b c d) (list a b (+ 2 c) (+ 2 d)))
                       *button-area*))))
                 (ui-area *ui*))))))
     (list
      'render
      (lambda (g)
        (when *button-area*
          (apply sk:fill (append *button-area* (list (sk:color 0 0 0 128)))))
        (ui-draw *ui*)))
     )))
  (sk:display (cdr arg))
  (set! *ui* (cdr arg))
  *scene*)
;;;解析并执行脚本
(define (script-next!)
  (if (not (null? (cdr *scripts-now*)))
      (begin
        (set! *scripts-now* (cdr *scripts-now*))
        (state-clear)
        (cond ((string? (car *scripts-now*))
               ;;显示对话
               ;;"Hello World"
               (set! *scene* (scene-dialog (car *scripts-now*))))
              ((pair? (car *scripts-now*))
               (case (caar *scripts-now*)
                 ((bg)
                  ;;切换背景
                  ;;(bg "05_1_2.jpg" 100)
                  (set! *scene* (scene-bg-change (car *scripts-now*))))
                 ((effect)
                  ;;切换效果
                  ;;(effect mask "sdf.jpg" "rule/12.png" 2000)
                  ;;(effect bg "rule/12.png" 2000)
                  ;;(effect bg:mask "rule/12.png" 2000)
                  (set! *scene* (scene-bg-effect (car *scripts-now*))))
                 ((ui)
                  ;;显示界面
                  ;;(ui ((text 116 500 "开始" fnt clr) start) ((text 516 500 "退出" fnt clr) end))
                  (set! *scene*(scene-ui (car *scripts-now*))))
                 ((music)
                  ;;播放音乐
                  ;;(music "11.ogg" 100)
                  ;(sk:play-music (sk:load-music (cadr (car *scripts-now*))) #t)
(sk:play-music (cadr (car *scripts-now*)) #t)
                  (script-next!))
                 ((eval)
                  ;;(eval (set! fnt (sk:load-font "Simhei" 48)))
                  (eval (cadr (car *scripts-now*)) *env*)
                  (script-next!))
                 ((label)
                  (script-next!))
                 ((jump)
                  (dialog-jump! (cadr (car *scripts-now*))))
                 (else (error "未知指令"))))
              ((null? (car *scripts-now*)) (script-next!))
              (else (error "未知指令"))))
      (sk:exit)
      ))

(sk:on-init
(lambda (e)
   ;;;载入剧本
   (set! *scripts-now* (cons '() *script*))
   ;(set! bgm (sk:load-music "music/bgm03.ogg"))
   (script-next!)))
(sk:on-frame
(lambda (delta)
   (send *scene* 'frame delta)))
(sk:on-button
(lambda (b)
   (send *scene* 'button b)))
(sk:on-render
(lambda (g)
   (when *background*
     (sk:draw-image 0 0 *background* 255))
   (send *scene* 'render g)))
(sk:start)

所用的脚本格式中@开始的行是命令，读取是首尾加括号，不然则加引号。读取后是一个sexp的列表，这样可以在Scheme中直接操作。
话说IEEE标准里没有收eval语句，因为有点细节上的欠缺。虽然R5RS里有，个人还是觉得这里也不必要去用完整的eval过程，不过自己改写出来一个eval还是个重复劳动。
脚本就是纯文本，话说一开始的写法是每个字符串要加引号。虽然有正则这种东西，但是想重新分段什么的还是不方便。与其每次保存是要处理，不如直接扩充Reader部分。
上面的代码在重构的时候消灭了很多全局变量，顺便也抽象出来一些较直观的概念。这些修改不影响跑测试代码，但是这体现Scm代码的进化方式。
以上的OO是基于原型的消息传递，还缺少一个set-this消息，继承时会用到。不过添加这样一个消息的话，对已有代码影响很小，而且暂时没用到，所以还没有添加。

Java部分的代码或许以后传吧，没多少内容

不过还是暂且来简单的写一些说明吧——
首先呢，是最常用到的若干包和类（以及类的方法）：
kawa.standard.Scheme 对应 Scheme的一个运行环境；
gnu.lists.LList 对应 Scheme中的类型，列表；
gnu.mapping.Symbol 对应 Scheme中的类型，符号；
至于整型就是Integer，字符串就是String
想把sexp字符转为Scheme的嵌套Pair的h话：
LispReader reader = new LispReader(new InPort(new StringReader(sexp)));
return ReaderParens.readList(reader, 0, 1, -1);
至于Number的话可能是gnu.math.Numeric也可能是java.lang.Number，
如要用instanceof判断之后再获取值，比如调用.floatValue();。
此外，现在绘制是一堆draw-*的过程，另一种实现方式是：
提供 <? extends Drawable & Posable ...>然后统一的用draw来调用。
这样就转变为考虑怎样在场景里放置物品，而让绘制操作可以自动进行。
这部分暂时还没用到，只是在Java中申明了Interface，还是放到Scm中需要的时候写这部分好了。
话说一般用对象的使用，以及界面的实现好了，类的派生什么的还是少用为好。
比如这里Java给Scheme的API就不包括类的派生，不过Silck2D的习惯本身也没有精灵类。
有时候嘛，精灵类还是需要的，用来管理场景里哪些东西要绘制，若仅仅是OO的话，还是放在Scm中为好。
在Scheme中可以用lambda来做参数传递时转化为实现了所需要的只有一个方法的界面，
此外Kawa提供的一些机制还是可以用虽然目前不够完善所以用着不舒服。
kawa中导入Java的类是使用(define-namespace sk )，
然后可以直接使用静态成员方法，创建和使用对象也有提供了方法的。
想开一个交互的调试窗口的话，可以执行如下的代码（可以绑定到按键上）：
ReplDocument doc = new ReplDocument(scm, scm.getEnvironment(), true);
GuiConsole con = new GuiConsole(doc);
con.setVisible(true);
其中scm是Kawa提供的Scheme类的实例，也就是我们的scm代码编译后运行的环境。
像Gambit-C一类编译类的Scm实现，直接和C混合着用虽然看起来不够美观。
但总比让FFI的部分复杂要好，毕竟C在内存管理和类型转换上比Java的鸿沟大。
另一个编译器Chicken是可以即当编译器也可嵌入当解释器用，不过Chicken的内存管理方式比较异类。
值得庆幸的是，两者都可以定义变量在GC时执行的过程，这样可以省写一些Free（不要和Close混淆哦，open/close是成对等价于with使用的）。
是嵌入使用，还是有FFI调用外部类，不同的实现有不同的方式的。此外，用C库的话，还有字符串编码问题要自行解决一下。
关于语言标准，IEEE出于简化考虑比R5RS少了eval和卫生宏，不过R5RS还没有module和record-type这两个很有用的组织代码的手段。
再如果仅仅是拿sexp当数据格式来使用的话，那就和使用什么实现没有关系了，手工解决即可。

剧本部分是拿以前的日志重写的，现在有点反胃了。
所有@开始的行已删除，现在算是一个纯文本了。
说实话，废话比以前多了，而且人物感觉更加薄弱。

在遥远的被阻隔的异世界
记忆之海
埋藏着记忆力淡去的痕迹
虽然显得遥远而迷茫
可是……

《遥远的记忆之海》

【Chapter 0】
这里是死后的世界，而年轻的我是记忆之海上的渡船人。
每天都会有亡灵抵达这里，来在这片汹涌的波涛下探寻往日的回忆。
虽然只是一些被遗忘的影像，这恐怕是对被阻隔在异世界的亡灵们有效的抚慰。
我将用这片小舟载着他们，驶向掩埋于他们意识的幻境之中，去探寻这份被遗忘的记忆。
不知道自己是如何开始这项职业的，也不知道是否在遥远的未来会有某个终结点。
大概我便会这么一直以这样平淡而幸福的方式生活下去吧——每天都可以期待不同的故事。
而自己就做好一个船夫好了，这点好奇心尚不会为自己的记忆增加多余的烦恼。

【Chapter 1】
【我】坐稳呦～要出发了～
我在船尾向着船头走上来的一位老奶奶说道。
然后熟练而悠闲地划动起身旁的桨，让船缓缓却高速地飞向某个预定的水域。
海水在炫目却冰凉的天空下闪着光芒，一眼望去只能看见浅浅的海面。
目标抵达后，我让船平稳地停下而随意地顺着波浪起伏，然后向着船上老人站立的那一头说到——
【我】你的记忆便保存在这里，在这片浑浊的水面之下。不过还有若干事项要知道——
【我】在波浪起来的时候，要努力地往海底望，凭自己的坚定的意志去努力地望。
【我】让自己的身躯仿佛为回忆包围、洗涤、沉浸，直到某一刻海水骤然变得清晰。
【我】这样你便能看见深深的海底，看见那片保存着你的记忆的地方。
【我】那是只属于你的地方，只有凭自己的力量才能看见，而别人的帮助对此无能为力。
而老人听见了我的话，点了点头，然后将视线远远的望着海平面的尽头。
她用手触摸着船的边沿，却一直没有敢低下头去将视线触及身旁水面的光芒。
虽然犹豫了一会，老人随后还是放弃了努力，也没有去尝试，转身向内在船头坐下。
【我】就真的这样放弃了吗，这可是一个难得的机会，不需要那个世界的记忆了吗。
每个人只有一次机会来这里探寻活着时候的记忆，老人的行为多少让我不解。
【老人】确实呢……
老人轻轻地应了声，然后坦然地点了点头，颤动着的嘴唇似乎有话要说。
我也暂且安下心来，在这水天包裹的空间里躺在船的一角，听着老人传来的言语：
【老人】随着人生漫长的时光，我已经是一个年迈的人了。记忆力在一天天流逝，身体也一天天薄弱。
【老人】变得不再有力气去触摸身边的世界中的幸福，而对周围事物的意识也越渐模糊。
【老人】活着，自己却越来越难以感受到自己是存在着的。于是生命的最终一刻，便在完全不知觉中抵达了。
【老人】过完了一生，纵然有坎坷或遗憾，可终究还是幸福的一生，可以让我安心于死后了。
【老人】可是衰老的记忆力依旧是留下的残缺，对于自己最后的时光，竟然不能在心里珍藏着这份幸福。
【老人】所以我便来到了这片记忆之海，想弥补这份残缺，想为自己寻找一份安慰。
【老人】至少不论生后或生后，我想让自己明白，自己确实是幸福的生活着的。
【老人】不过啊，果然我还是有这份幸福感便足够了呢。
【老人】这种感受纵然已经被遗忘，也肯定在那个世界里曾经存在过吧。
我打量着对面的老者，觉得她是在害怕由记忆去触及内心的真实，不禁叹气感到遗憾。
老人在船头沉默地坐着，渐渐平静了略带激动的言语，我随后起身撑起船驶上回程之路。
伴着海平面上柔和而巨大的夕阳，船的划痕消失在身后的那片先前抵达过的水域，
这也同时告别了那里那些对于老人将永远被掩埋于海底的对往日的记忆与情感。
这过去的，便是一个普通的工作日，随着一天天的过去，我不久也就会把这天淡忘的。
因为这毕竟只是我不断往复着的类似的日子中的一天，一个没有源头也没有终点的记忆所背负的时光。
接下来一天的客户是一位中年男子，身体健壮没有疾病的样子，看上去是个生活中积极的人。
他是意外而死去的吧，真是遗憾呢，我简单地这样判断着。然后撑起船，又一起踏上一个新的旅途。

【Chapter 2】
船平稳地向预定的某地行去，今天的海面的波浪依旧缓和，我在船头悠闲地把着方向。
而他在船的另一头显出好奇，往四周那片行船偶然路过的水天之痕，不断地张望。
【我】这途中附近不知是埋藏着谁的记忆，在无尽的记忆之海上，恐怕连我也可能不再会抵达这里。
我静静地坐在船的末端，以船夫的身份这样解释道，然后视线依旧向着遥远的目光不能触及的何处。
【中年】好了，我是有点兴奋，毕竟是第一次来到记忆之海。如果这样做对航船有影响的话，我会注意的。
我能够感受到他一旁的视线，那似乎是一种寻求着言语上的联系的期待，这恐怕是出于他待人的热情吧。
【我】我想知道，你为什么要用这唯一的机会，到这里探寻自己的记忆呢？你还没有到一个健忘的年纪。
【中年】我来寻找记忆，并不是因为它们被我遗忘，而是因为它们所承载的时光已经离我而远去。
【中年】我是想寻找一丝安慰——即使将来记忆变得淡去，记忆也曾经凭借着自我的存在而存在过。
【中年】这也是那个生者的世界所留给我的痕迹，告诉自己往日的努力的意义所在，没有遗憾也是一种遗憾吧。
【中年】那些记忆纵然不能在物质上于现在现在的我建立起沟通，但是分明就是我在这里可以依旧延续下的一种财富。
【中年】虽然记忆显得飘渺但却是中真实，这也就是我来到记忆之海缘由，想在这里挖掘到的一份心灵中的宝藏。
船速已经变缓，这是即将到达预定的海域了，我向他做着关于探寻记忆的说明，引着他往船外沿的地方走去。
然后留下他一人等待海风的气息掀起记忆之海翻滚的浪花，祝福他的思绪将能够触及到脚下海水的彼端世界。
风与浪下船头的挺拔地站立着，在海天间映出一个厚实的身影，轮廓仿佛是一扇凭空为世界展开的门。
他的声音在海风之间，在倾诉着言语，在一层层的展开着他的过去——
【中年】这是我的出生，这是我的父母，这是我的学校，
【中年】我的成年，我的工作，我的老婆，我的女儿，我的事业，我的生活……
男人在回忆着他活着的经历，眼前海水的蔚蓝色里翻滚着幸福的味道，一丝腥味，又一丝甘甜。
在随后回程的航线上，他一直在向我分享着他在这里获得的满足——
【中年】美好的期待一直在延续着，直到有一天，那天的一场意外的事故，让我只能告别那一切。
【中年】回忆是以痛苦终结的，我想把这最后的时刻忘掉，可是又害怕失去了想守护的东西。
【中年】我便这样犹豫着在这个死后的世界，后来想法开始有些坦然——
【中年】记忆的存在并不是因为它们被记住，而是它们被经历过。
【中年】记忆的痕迹即使随着时光淡去而似乎不曾有过，它们也不会消失依然存在。
【中年】不经意间看到自己身体上留下的微小残缺，知道这便是一种以不可弥补的痕迹来保存着记忆。
【中年】我想我脑海中的记忆也是一样的，是因为我曾今为着他们的存在而做出过什么。
【中年】这便足够了，它们就是我在记忆之海下埋藏的一份财富，将永远为海天守候。
【中年】所以，记忆里的东西无法改变，也不需要改变了，在现在这个世界里依然可以有新的记忆。
他只是说着他想说出来的事情，似乎不在意我是怎样漫不经心地听着，这样能否记住他说出的话。
在傍晚的时候，打量着我们周围海面似乎永恒不变的夕阳景色，我想——
他说出了现在的感受，这样便是让这种感受以与人共同的记忆的形式确认着存在，让自己能够保留下去。
不过即使这样，着对于我，仍只是不知过去与未来的时光里的一天，一个在永恒的时间轴上的一个渺小痕迹。
而接下来一天的客人是位年轻的学生，年龄似乎与我接近而略小，我依然只是职业地将他引上船。
今天的天空似乎有些异样的阴沉，不过不会影响到航行，于是这又将开始一个新的旅程。

【Chapter 3】
我控着方向，让船往预定的地点驶去，在有些阴沉的天空下划过淡淡的线条。
他和来到记忆之海的大多数人一样，在船的前头打量周围，以未知抚慰着未知，显得有些无措。
回忆的味道就是这样的吧，我也顺着他的视线向远方望去，心中划过这样的想法。
其实的船行不需要过多的体力操作，在今天格外低的天空之下，航行显得有些沉闷。
不过如果天空晴朗，这就是个同往日一样的航行了，充满生活的平淡的温馨，平淡便足够了。
我沉浸在自己的思绪中，随后忽然感到船身的一个摇晃，我看见船对面的那个身影站起身子。
他向我走来，我赶忙先稳定下船的航行，然后放松下身子。此时听见他说话的声音——
【青年】您比我大吧，我可以叫你哥哥吗？
【我】我已经是不在意自己的年龄了。
【青年】那我就叫你哥哥吧！
【我】这随便你。
【青年】嗯，哥哥好！
【我】 ……
他在我一旁坐下，没有把刚才打招呼的热情继续下去，而是将视线转向远方，有些顾虑的样子。
【我】来说你为什么要来到这里，是想寻找到怎样的记忆吧。
虽然他的举动让我感到有些奇怪，我还是试图以平静的语气挑起对话。
【青年】不知道。
他把头转向我，带着年轻人的稚气。
【青年】其实我确实不知道，我没有想寻找的东西。
即使这样也不必要有多余的犹豫吧。
【我】这里有记忆的宝藏哦，会有让人感到幸福的东西，不要为让自己可以努力的机会而犹豫。
【青年】可是那些记忆是我主动抛开的，它们让我感到难受，我却矛盾地又为一种缺失感来到这里。
【我】好了，既然来到这里了，即使意外，也会找到些东西吧。
【我】它们都曾今属于你，今后也依然是。想着抛弃，就可能会让自己失去更多的东西。
他看着我的眼睛，像在寻找一种希望。而航行也在这不知觉中驶近了目的地。
【我】去吧，相信自己心中小小的愿望，在海浪之间寻找能够寻找到的东西。
【青年】恩，谢谢哥哥。
他答应了，然后走向船的那头。站立在船的边沿上，在阴沉的海天之间，显得波澜壮阔。
而我一人在船的这头放松下身子，视线漫无目的地望向天空，意识到居然对着客人说出自己的想法。
我这是说给谁听的呢。一个陌生人？一个在这死后世界里再也不会相遇的人？还是说……我自己？
我在怀疑着自己举动的意义，是否就代表着自己已经做出或者将会做出一些多余的事情呢。
可是此刻我异样的感觉到，我的思绪与情感在被他联系着，从未有过的被一个人所联系着。
想着在此刻能为别人的困难添上自己的帮助，这同时也是在敞开心扉地能够去接受别人的帮助。
看到船头转过头来望着我，在脸上露出一个微笑，而我看着也在自己脸上回应着一个微笑。
两个人的微笑，未曾在这里奢望过的微笑，我意识到这是一个第一次在这死后世界里自己希望永远记住的东西。
忽然平静的一切被打破了，一个浪打在了船身上，他刚刚侧转的身子没有站稳，摇晃着向记忆之海里跌落下去。
在这一瞬间里，海风也变得巨大了，天空更加阴沉下去，而且似乎要发展往一个糟糕的方向。
此刻顾不上太多，我想我得救他。赶忙跑向他所在的船头，往波浪翻滚的海水里跳了下去。
我在下沉，身边被黑暗包围着。那是一片无尽的黑暗，我感到瞬间失去了重力，努力划着水却寻找不到方向。
周围也异样的安静，这是一个海面下无声的世界，时间的流淌似乎漫长，甚至凝结。
渐渐地我的心也在水中平静下来，我能感受到自己的呼吸，呼吸在这个海底并无异样。
恐惧之后这我才意识到，这是在一个死后的世界，一个已经不会再死去而离开的世界，
一个欣慰却又孤独的世界，一个没有失去也没有保留的世界，一个让记忆永恒封存的世界。
在这个黑暗无声的世界里，我顺着水流漂浮着，让意识随着身体漂浮着。
在记忆的海洋中以心灵去触摸着曾今，以及那些孕育着现在和未来的往昔时刻。
我能体会到在深海之下闪烁的幽幽光芒，像一个指引者在前方对我轻轻的召唤着。
我凭借着意志向光芒游去，让光点在眼前接近在身边扩散，觉得这样才能够拯救到什么。
这样才能够实现自己对他人的一个守候，一个哪怕在这死后世界已经显得多余的举动。
一种是哪怕只是出于内心原始的善良的淳朴的冲动，也要去带着落海的少年顺利的回来。
光芒弥散于海底，如同思绪飘荡在无尽的水中接受着温柔而永恒的抚慰，包裹在我的周围。
渐渐地，这些光点构成的屏障上清晰出一个影像，在向我讲述着什么。
在向我呈现着一个“生”所在的世界，一个在海底无尽的黑暗里心所体会的“光”所组成的世界。

【Chapter 4】
【青年】真是一个空旷的操场啊。
耳边响起了青年的言语，轻轻地感叹着，然后声音又远去了。我想这是少年的记忆传递给我的信息吧。
在他的视角上，我以第一人称在看到了他的双手，和他眼前的整片操场。
接下来将在这个记忆构建的世界里，以一天天的经历，去体会着他的过去。
可是这只是视觉，他的意识以及他的存在感，却无法通过薄弱的纽带感觉到。
身体开始活动起来，由机械变得自然地走动着，向着教学楼那里去寻找人的踪影。
我的意识仅仅是随着身体漂浮着，在这个世界里不能左右什么，也不会有想去左右什么的愿望。
在阳光下曝露的身体，接触着这里的空气与水分，仿佛在由陌生不断变得亲近着。
与空旷的操场相比，教学楼因为人的踪迹，而显出格外不同的氛围。
身体继续往教室里走去，人的气息的存在让它移动着的脚步学会了自信。
同时身体也是在渴望着阳光之外的什么，让自己来到这人群中去寻找着。
身体在经历着成长，可是这样似乎仍缺少着什么，它所见到的人群都在它面前散开了。
当身体带着疑惑去走进下一个教室，带着或许会有改观的期望，依旧得到的是一个失望的结果。
【青年】果然人们是讨厌我的，这个世界里已经不需要我的存在了。
此刻身体举动正是表达着他的意志，这让我清晰的感受到意识的存在，但是明白这种体验的阻隔。
之后，身体便失去了他本身的驱动，松软下来。重量压在了我的身上，而我只是依然麻木地站在教室中央。
刚才跑去教室外的人群开始渐渐返回，他们仿佛无视了我的存在，又回到了他们的日常。
我就这样站在教室里，近距离的带着身体逝去的愿望。去接触人群的气息，去沉浸于海洋的梦境之中。
可是，梦境最终将迎来黎明。
【同学】刚才真是一个讨厌的人啊，就这么像无视我们的跑近教室来。”
是“讨厌”吗？一句声音之后，周围的声音也纷纷附和起来，成为这个狭小的教室里共通的话题。
我能感受到其中的恐惧，这正是我能从身体中所感受到的。
让我出于内心的害怕，从这个空间里，从这个人群中向外跑去，跑向一个与此隔绝的世界中。
我在遥远的地方大口的喘着气。驻足后望，那个教室，那片学校已经变成渺小的身影。
这已经足够远了，这已经是喊声不能再被传递到的距离了。我的心开始变得空荡荡的。
这是一种安心吗？我看着自己缓慢起落的脚步，在坚硬的水泥地面没有留下任何的痕迹。
我再去望那片远去的世界，一个希望着阻隔开的，一个永远只保留着不起眼的存在的世界。
我漂浮在这个梦境的世界，和一个已经属于我的身体，因为躲避着什么而肆意游荡着。
只到有一天，也是偶然而特别的一天，我似乎是感到孤单，感到厌倦了。
也似乎是出于好奇，决定再去一次那所学校，再次重拾起曾今想寻找的什么。
校门在眼前清晰了，操场在眼前清晰了，教学楼在眼前清晰了，曾今去过的那所教室在眼前清晰了。
自己觉得心中的愿望，去寻找一个未知到重要的东西的心愿，也这路途上变得清晰了。
这或许就是在凭借着海的梦境的经历，来记忆里所未填的空缺吧。
在那间教室的前，我敲了敲门走了进去，心里已经做好了接受各种意外的准备。
这不是躲闪着旁人视线，而是在寻找他人的帮助，寻找着一种重拾遗失的启示。
他站在教室门前，鼓起勇气地努力睁开眼，去接受着人群的目光。
身体在人群中肆意的走动着，人们并没有做出异样的反应。
身体想在人群中挑起话题，人们的意志中已经淡忘了他的痕迹了。
这我才发现，他所做出决定已经无法改变，关于那个让自己消失于此的决定。
他已经不再属于这个世界了，这一个他曾想抛开却一直未割舍的世界。
那我又将飘向何方呢，向着一个新的永恒的世界吗？
在意识在这个身体已经在远离我而去的时候，我又似乎不愿回到那片记忆之海上。
因为在我海的梦境中，在这死后的世界里，我是第一次意识到了我所希望寻找的东西。
我的意识回到的我的身体上，我闭着眼漂浮在黑暗的无尽的记忆之海的深处。
随着水流飘向我一个不知为何方的地方，一个永远将背负着记忆的地方。
在漫长的飘荡中，终于，我决定，睁开我的眼睛，去看看周围的世界。
去看看身边的世界，哪怕看到的依旧只是黑暗，去依旧能在世界里发现着什么。

【Chapter 5】
这是一片天空柔和的色彩，西斜的阳光透过玻璃照射在我面前的床铺上。
双手是棉被的触觉，鼻尖是医药水的味道，身边有机器在运转的声响。
这是一个空荡荡的病房，我孤单的一个人躺在中央。身体不能动，只能望着粉白的屋顶。
在这狭小的容器里，我感到内心的一阵寂寞与痛苦，因为孤单而在对外界恐惧而害怕着。
害怕着我的记忆里所寄托的想象，会成为自己的一种负担，会让自己面对着未知却只会守护着丝丝迷茫。
我闭上眼，想象自己正被水包围着，想象就在海底，在那片无尽的黑暗中。
希望再次抵达那个世界每天航行在记忆之海上，一直地去陪同着别人寻找着别人在寻找的东西。
于是在这样的孤单中，我的意识又变得模糊开始轻浮，再向一个遥远的地方飘去了。
直到忽然间响起清脆的敲门声，这让我回过神来，可是我仍害怕着不敢睁开我的眼睛。
我听出来是同班的同学来了，他们的话语声在翻滚着我的记忆，清晰着我的心跳。
这让我想到，我忽视了一些自己没有察觉的细节——
那片无尽的大海中也有一份属于自己的记忆吗，是否他们一直埋藏在那里而我却没有在意呢。
我是否也有过一丝小小的心愿要实现——在那个异世界中，也去寻找属于自己的那一份记忆呢。
那些记忆是一份仍然需要自己继续延续下去的记忆，它们还尚未到一个应该被海水所掩埋的时刻。
处在这个生者的世界里的我，是否只有那个异世界里才能找到唯一的归宿，而该早早的就去呢。
可是活着不该是一个被轻易淡忘着的概念，而让记忆独自在无尽深海之下，去忍受着永恒的没有终结的孤单。
是啊，刚才心头居然有抛弃“生”的世界的想法，自己觉得可笑。
去寻找活着的的自己的意义所在，才是对那个死后世界无尽时光最好的终结。
况且一直有人在为着我的“生”而努力呢，让我能够再次的活过来，而我竟想拒绝他人的心愿。
它们的努力让我能够有机会去真正地体会到自己内心的希望，这同时也是他人给予我的希望。
不论是给予的关心或者是给予的治疗，都是由这一切的努力才让我又回到了这个世界中。
【同学】真希望你能够早点醒过来哦，和我们一起去看班级篮球赛。
熟悉的声音在面前在病房中弥散开来。
而我的内心出于一种固执，依然让自己的双眼紧紧闭着，用拒绝去回避心头残余的害怕。
【同学】今天我们先走了，明天放学的时候还会来看你的。
然后是一个轻轻的关门声。
病房里恢复了先前的安静，又只剩下我孤单的一个人在这狭小的房间里。
此刻安静得如同深海的气息，我心头的另一种害怕又让自己猛地设法睁开自己的眼睛。
可是我发现自己的眼睛没能睁开，只是忽然有泪水的热度在脸颊上流淌开来。
我努力地张开口，努力地说着——
【我】只是一个旅途，这几天里我去了一个遥远的地方，现在我已经回来了……
破碎的言语没有出声，只化作苦涩与甘甜，混杂着口角泪水的味道。
而所告别的旅途呢，
将依然安静地在一个遥远的地方延续下去，延续往彼世界中所不存在的尽头。

话说这种质量不高的应急式产物果然连自己都讨厌，当然GalGame是不应该用这样东西做剧本的。
还是去看阿加莎克里斯蒂的小说去吧。。。
顺便觉得小野不由美的也不错。。。
我这里质量拙劣，仅此而已。。。

----
后来试了试html5+Biwascheme或Processing+Kawa或Processing+自己解析脚本，just work。

日记帖

2011-05-28T10:30:00.013+08:00

还久没写日记直接的帖子了，总是从各种逻辑上的堆砌文本的话，有点像有意在消灭自身存在感的样子。就像是把时间的流逝只看作了是一种物理运动的规律，而就仅此而已，掩盖时间给予人的意义。不过日记这种东西，写的时候是需要某种闲心呢。比如正好躺在床上等待着什么，而且知道等待的那个时间是直到自己等待得厌倦了也不会到来。于是可以拿出手机之类可以把玩的东西（就是可以按这按那，但是又漫无目的），来记录一些心情引发一些所想，文字什么的只是附带产物。
其实日记的本身的产物其实就是思绪的记录，一是证明了了脑部的某种运动，一是记录了某种运动确实是存在。当从产物而言去谈论其中的意义的话，并没有直接了价值所得，甚至可以说是某种能量的浪费。可是呢，有什么可以纠结就像知道有什么寻找到就可以满足了一样，然后去为了获得什么而做出什么，承载着一天天的时光。
感觉现在没兴致说东西了，觉得时间就是用来做些什么的。哪怕就是不知如何的消失掉，也不会去让自己知道。于是只有闲暇在能产生的文字，就总是显得这么匆忙呢。

----

最近这里没有贴新的小说呀，这么久没有贴的话，就自己都有种怀念的感觉了。总之就是一直没有要去再写出什么的想法过，因为知道这么写啊写啊，除了弥补自己某时间的闲暇之外，并没有明了的意义。所以了，除非像现在这样心血来潮一般，因为又难得的有心情去看了一些小说啊电影啊理论啊什么的，忽然觉得原来就这么写写也或许蛮有趣的。是啊，虽然平时是觉得写来写去是很无趣的，但是有的时候就是觉得也思路的电波就一致了。
在平时的时候，对于文字的感觉是麻木的。就是觉得有时候觉得不写出来什么点不甘心的时候，也只是很牵强的来写出点什么。虽然自己知道这只是在自娱自乐，但是大多数时候是连这般自我的娱乐的兴致也没有了。有些文本就是在构造出氛围，用设定上的种种关联以及很长的时间来说清楚这是一件怎样一会事情。故事什么的相比于这种氛围是一种显得十分淡薄的东西了。
话说今天来开帖堆字，是忽然觉得这样有趣。就仅仅是有趣而已，不然的话在上面给予思绪是一种不甘心的事情。不过通常的时候，是觉得堆文字是一种无趣的行为吧。但是有的时候出于需要，就是得做一些要如何去做的事情。类似于堆文字这样的事情也是不可避免的。可以在那种认为无趣的时候，总觉的始终思维受限的状态。就是那种要逼迫着自己才能说出些什么，甚至是不大想说也要说出些什么的样子。当然，真正有必要说什么的时候，还是得说了。不是像这里这个让自己随意地来堆放点什么的地方就这么平时可以大不在意的就堆放在这里。在动机越来越淡薄的时候，就是偶尔想出来自娱自乐的时候，就来这里堆放一点什么了。

----

上面还说是日记啊，原本想是想记录一些回忆的，或者哪怕是记录一点以前想记录下来的事情也好。虽然说开一个新帖长长的写出一大段说明的性质的文字至少在看起来的样子会有更好一些的质量，但是有些东西就毕竟只是零星的想法，如果不以随意的方式来记录的话，肯定是永远的掩埋下不会再去写了。凭借触动什么的突然有了生活的某种热情显然是不可靠的事情，至少在某种麻木的努力是无意义的假设之下。当然这句话可以从多方面来解释，可是这个似乎就想纠结于“无意义”三个字上呢，越想否定却又发觉不能完全否定掉的存在。觉得周围一下子变成负担，有忽然觉得原来还有许多有趣的东西等待着没有被发觉呢。
否定掉了太多的东西，也就以为不会有什么剩下了，可是世界从时间和空间的角度来说，都是广阔而漫长的。有时就是有点额外的心情才会发觉到世界中的特别之处吧。而不只是在积累着越来越多的无奈什么的。
不过貌似只是仅又来这里堆堆文字的什么的是形式很有限的，但是也确实可以随意的涂上几笔的意思。只是有所记录，而不是从好坏上评价什么，或者就此勉强着什么。

----

这不叫日记，叫虚拟度假吧。

Z's Yard[中文]

那啥简单的Sexp解析

关于AWK的絮絮叨叨

代码小练习三 - 图

代码小练习二 - 优先队列

代码练习 - 容器

Blogger后台截图留恋

一种Scheme语言中基于消息传递的面向对象机制上 -- 语言机制

堆文的恶趣味

本想写篇心情日记的

存活确认

几个感觉不错的应用

简易Roguelike制作流程【转/待译】

算24【备份】

存活确认

【怀旧向】关于ASCII风格Game的简单尝试 Part-I

【挖一挖】关于文化娱乐方面的 Part-A

【挖一挖】关于PE50的存档

【挖一挖】WQX和单文件小游戏

【挖一挖】levelup.cn的论坛ACG小说版的某些内容

静态类型函数式语言Objective Caml/ML的简要介绍【程序语言介绍】

面向Scheme用户的Common Lisp语言的小贴士【程序语言介绍】

《现代操作系统》一书中的每章节的小结部分，放在这里的算是此书中比较浅显的概括

Academy of Interactive Arts & Sciences【介绍文/翻译/施工】

又一个坑了的视觉小说，\n顺便说说Java与Scheme的混合/嵌入使用

日记帖

Z's Yard[中文]

那啥简单的Sexp解析

关于AWK的絮絮叨叨

代码小练习三 - 图

代码小练习二 - 优先队列

代码练习 - 容器

Blogger后台截图留恋

一种Scheme语言中基于消息传递的面向对象机制 上 -- 语言机制

堆文的恶趣味

本想写篇心情日记的

存活确认

几个感觉不错的应用

简易Roguelike制作流程【转/待译】

算24【备份】

存活确认

【怀旧向】关于ASCII风格Game的简单尝试 Part-I

【挖一挖】关于文化娱乐方面的 Part-A

【挖一挖】关于PE50的存档

【挖一挖】WQX和单文件小游戏

【挖一挖】levelup.cn的论坛ACG小说版的某些内容

静态类型函数式语言Objective Caml/ML的简要介绍【程序语言介绍】

面向Scheme用户的Common Lisp语言的小贴士【程序语言介绍】

《现代操作系统》一书中的每章节的小结部分，放在这里的算是此书中比较浅显的概括

Academy of Interactive Arts & Sciences【介绍文/翻译/施工】

又一个坑了的视觉小说，\n顺便说说Java与Scheme的混合/嵌入使用

日记帖

一种Scheme语言中基于消息传递的面向对象机制上 -- 语言机制