IT博客-kenlistian-随笔分类-AI

lua中的upvalues

kenlistian — Mon, 27 Oct 2008 08:56:00 GMT

理解Upvalues

把它理解为一个与C static变量等价的东西即可。

如下函数：

static int counter(lua_State* L);

int newCounter(Lua_State* L){
   lua_pushnumber(L, 0);
   lua_pushcclosure(L, &counter, 1);
   return 1;
}

其中调用lua_pushcclosure 函数，就是创建了一个闭包函数，
即在该counter函数中，可以使用由
lua_pushnumber 压入的初始值0。
其中压入一个upvalues值，则在pushcclosure第三个参数个数则为1.

在函数中
static int counter (lua_State *L)
{
     double val = lua_tonumber(L, lua_upvalueindex(1));
     lua_pushnumber(L, ++val);
     lua_pushvalue(L, -1); /* duplicate it */
     lua_replace(L, lua_upvalueindex(1));
     return 1;
}

lua_upvaluesindex(1) ,就是取出upvalues值，其索引为第一个参数。
由于这个参数并不是堆栈中索引，而是仅仅表示参数序位的索引，即，取出
upvalue的当前值。

kenlistian 2008-10-27 16:56 发表评论

lua 元表概念

kenlistian — Sun, 19 Oct 2008 06:44:00 GMT

这个是lua中需要理解的概念，以前写过关于元表的笔记，好久没摸，又忘了。

元表概念（ Metatable）
元表由键名为事件 (event) 和其中的值叫作元方法 (metamethod)组成。

在lua中每个值都有一个元表。而table和userdata所定义的值允许自定义对应的元表，
其他都是用统一的元表。

我的理解，元表，其实有点类似值的属性的味道。

对元表的操作
getmetable 查询元方法
setmetable 替换元方法。

metatable 包含几个固定的元方法.
其事件名由下划线 '__' 前缀的字符串组成。
有
"add": + 操作。
"sub": - 操作。其行为类似于 "add" 操作。
"mul": * 操作。其行为类似于 "add" 操作。
"div": / 操作。其行为类似于 "add" 操作。
"mod": % 操作。其行为类似于 "add" 操作，它的原生操作是这样的 o1 - floor(o1/o2)*o2
"pow": ^ （幂）操作。其行为类似于 "add" 操作，它的原生操作是调用 pow 函数（通过 C math 库）。
"unm": 一元 - 操作。
"concat": .. （连接）操作，
"len": # 操作。
"eq": == 操作。
a ~= b 等价于 not (a == b) 。
"lt": < 操作。
"le": <= 操作。
a >= b 等价于 b <= a 。注意，如果元方法 "le" 没有提供，Lua 就尝试 "lt" ，它假定 a <= b 等价于 not (b < a)

"index": 取下标操作用于访问 table[key] 。
"newindex": 赋值给指定下标 table[key]= value 。
"call": 当 Lua 调用一个值时调用。

以上事件中，index 和newindex 很关键，常常被自定义的函数所取代。

如：定义一个函数取代环境中的处理
local f = function (t,i)
error("cannot redefine global variable `"..i.."'",2)
end

local g = {}
local G = getfenv()
setmetatable(g,{__index=G,__newindex=f})

--设置g的运行环境
setfenv(1,g)
rawset(g,"x",3)

x=2
y=1 -- cannot redefine 'y'

以上的替换只能在C下改变，在lua中不能中改变其它任何类型的值的 metatable（debug 库例外）；

值得说明的是：
table 和userdata类型拥有独立的 metatable （也可以共享一个相同的表作它们的 metatable）

在lua的扩展库函数中有一个
luaL_newmetatable
这个函数是创建一个表，作为元表提供给userdata使用。
(userdata，可以理解为自定义的一个数据结构。)

kenlistian 2008-10-19 14:44 发表评论

lua 第三方插件索引

kenlistian — Fri, 17 Oct 2008 16:49:00 GMT

下面的这些内容不包含在本文中：
官方的Lua包和文档 (参看 http://www.lua.org/),；
涉及到Lua使用但不是被Lua使用者普遍使用的东西 (参看 http://www.lua.org/uses.html), ；
本wiki已经存在的内容(参看 LuaDirectory).

类库和与Lua绑定的资源

LibrariesAndBindings
开发环境

[LuaIDE] (5.0) - Windows平台Lua的整合开发环境(最新发布 2004-01-29).
[wxLua] (5.0) - Lua and wxWidgets的混合体.有自己的带有调试器的IDE。这个IDE使用wxlua开发的。
[LuaEclipse] (5.0) - Eclipse 平台的Lua IDE .
[Vortex LuaIDE] (5.0) - Brazilian Portuguese的一些免费的Lua IDE! (Outra IDE para Lua gratuita, mas em Português!).
[LuaX] (5.x) - 支持多种操作系统下开发Lua应用的开发平台(with GUI, serial port etc. modules)特别适合于工业自动化和嵌入式产品开发。
[VisualWx] (5.x) - Lua & wxLua的IDE (自由软件)
[QDE] (5.x) - Lua的Quotix 开发环境. 他支持工程管理，多文档接口等 (最新发布2005-03-06).
[B:Lua] - 开源项目：具备各种特征的Lua IDE.

代码封装

[CPB] (5.0)(Win32) - C++ 和 Lua连接之桥,实现两种语言的相互通信.
[CaLua] (5.0) - 实现了绑定C函数和结构体到Lua，可以在Lua中使用C指针、数组、函数。(使用x86结构的计算机)
[CppLua] (5.0) - lua API的C++封装。
[lua2c] (5.0) - 将Lua代码转换成C代码的工具.
[luabind] (5.0) - 基于模板的，绑定Lua和C++类以及函数
[tolua] (5.0) - 自动绑定C/C++和Lua的工具.
LuaWrapper 基于模版的封装包，很容易绑定C++代码和Lua。纯头文件。
[tolua++] (5.0) - tolua的高级版本，带有c++面向对象的特征. ( CompilingToluappWithoutScons i.e., Compiling Tolua++ Without SCons )
[luapi] (5.0) - Lua api的C封装.
[PBLua] (5.0.2) - Lua 5.0.2基本库的封装.
[PowerBLua] (5.0) - PowerBASIC include & source for wrapping Lua (work in progress).
[wxScript] (5.0.2) - 一些抽象类，添加到脚本解释器可以使你的wxWidgets支持Lua语言。
[LunaticPython] (0.1) - Lua/Python 的双向桥。可以将Lua解释器嵌入到python中，反过来也可以。

Lua的使用
Lua的使用列表[1].

[Premake] -一个用Lua语言实现的 automake 替代品. 可以为MS VC++, GNU make, 等创建工程文件.
[Lumikki] (5.0) - 使用Lua宏创建web站点，可以使用导航菜单，风格等。

工具

ExpLua (5.0) - 代码文档工具(开发中。。。).
[Hamster (ex SCons/Lua)] (5.x) - Lua front-end to the SCons build engine (or others).
[Kepler Project] (5.0) - 使用 [CGILua 5.0]实现的Lua 5.0的web模板引擎 .
[Mod_Lua (5.0)] - Apache 2的 module，使得web应用与PHP类似。
[ctrace] (5.0) - 跟踪Lua API调用的工具.
[lper] (5.0) - 创建持久Lua 状态的工具, 基于 [GNU mmalloc] (part of GDB).
PlutoLibrary (5.0.2) - 为Lua创建重量级的持久性.
[ChunkSpy] (5.0.2) - a binary chunk disassembler, with interactive mode, reading custom binary chunk formats, etc.
[lua bakefile] (5.0.2) - 创建 LUA 工程的makefile和工程文件。
[tolua bakefile] (5.0.2) - 创建 TOLUA 工程的makefile和工程文件。
[ChunkBake] (5.0.2) - a line-oriented assembler for Lua 5 virtual machine instructions
[LuaSrcDiet] (5.0.2) - 通过删除不必要的空白和注释缩减Lua文件的大小。
[LuaProfiler] (5.0) - 一个用来查找Lua应用瓶颈的工具time profiler 。

lua中字符串匹配笔记

kenlistian — Wed, 15 Oct 2008 14:12:00 GMT

string.gsub 函数有三个参数：目标串，模式串，替换串。
基本作用是用来查找匹配模式的串，并将使用替换串其替换掉：

s = string.gsub("Lua is good", "good", "bad?")
print(s)   --> Lua is bad

string.gsub 的第二个返回值表示进行替换操作的次数。例如，
下面代码计字符串中空格出现的次数：

_, count = string.gsub("test test", " ", " ")
_ 表示哑元变量

模式串
.   任意字符
%a   字母
%c   控制字符
%d   数字
%l   小写字母
%p   标点字符
%s   空白符
%u   大写字母
%w   字母和数字
%x   十六进制数字
%z   代表 0的字符

特殊字符如下：
(). % + - * ? [ ^ $
% 也作为以上特殊字符的转义字符。

[] 该方框作为匹配该范围的集合，。
如[0-9] 则匹配0到9的数字范围

Lua 中的模式修饰符有四个：
+   匹配前一字符 1 次或多次，最长匹配
*   匹配前一字符 0 次或多次，最长匹配
-   匹配前一字符 0 次或多次，最短匹配
?   匹配前一字符 0 次或 1次
'+'，匹配一个或多个字符，总是进行最长的匹配。
如，模式 '%a+' 匹配一个或多个字母或者一个单词：

注意以上的区别：

如：匹配c中的注释串
用 '/%*.*%*/' 和'/%*.-%*/'

str = "int x; /* x */ int y; /* y */"
print(string.gsub(str, "/%*.*%*/", "<注释串>"))
--> int x; <注释串>
采用 '.-' 则为最短匹配，即匹配 "/*" 开始到第一个 "*/" 之前的部分：
str = "int x; /* x */ int y; /* y */"
print(string.gsub(str, "/%*.-%*/", "<注释部分>"))
--> int x; <注释串> int y; <注释串>

以 '^' 开头表示只匹配目标串的开始部分，
以 '$' 结尾表示只匹配目标串的结尾部分。

%b 表示匹配对称字符，注意其只能针对的ansi码单字符。
x = string.gsub("xdddddyxxx", "%bxy", "取代")
print(x)   -->取代xxx

如去除字符串首尾的空格：
function trim (s)
return (string.gsub(s, "^%s*(.-)%s*$", "%1"))
end

---------------------------------

看原文中的gsub注释：相当详细，不过对于模式解释补充在上。

string.gsub (s, pattern, repl [, n])

Returns a copy of s in which all occurrences of the pattern
have been replaced by a replacement string specified by repl,
which may be a string, a table, or a function.
gsub also returns, as its second value, the total number of substitutions made.

repl是字符串，则为替换。如果在参数前有%则表示符合匹配的字符串
If repl is a string, then its value is used for replacement.
The character % works as an escape character:
any sequence in repl of the form %n, with n between 1 and 9, stands for the
value of the n-th captured substring (see below).
The sequence %0 stands for the whole match. The sequence %% stands for a single %.

repl作为表参数
If repl is a table, then the table is queried for every match,
using the first capture as the key; if the pattern specifies
no captures, then the whole match is used as the key.

如果参数为函数，则每次匹配成功则调用该函数
If repl is a function, then this function is called every
time a match occurs, with all captured substrings passed
as arguments, in order;

if the pattern specifies no captures,
then the whole match is passed as a sole argument.

If the value returned by the table query or by the function call is a string or a number,
then it is used as the replacement string; otherwise, if it is false or nil,
then there is no replacement (that is, the original match is kept in the string).

参数n则限制最大
The optional last parameter n limits the maximum number of substitutions to occur.

举例：
   %1 表示符合模式的第一个匹配
   x = string.gsub("hello world", "(%w+)", "%1 %1")
   --> x="hello hello world world"

   第4项
   x = string.gsub("hello world", "%w+", "%0 %0", 1)
   --> x="hello hello world"

   hello 和from作为模式中左匹配为%1，world 和lua为右匹配，为%2
   x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1")
   --> x="world hello Lua from"

   替换以$打头的字符串
   x = string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv)
   --> x="home = /home/roberto, user = roberto"

   参数为函数类型
   x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)
           return loadstring(s)()
         end)
     --> x="4+5 = 9"

    参数为表类型
   local t = {name="lua", version="5.1"}
   x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t)
   --> x="lua-5.1.tar.gz"

==============================
gmatch 的用法：
在模式符合匹配多次时
Returns an iterator function that, each time it is called,
returns the next captures from pattern over string s.
If pattern specifies no captures, then the whole match
is produced in each call.

看例子：
   s = "hello world from Lua"
   for w in string.gmatch(s, "%a+") do
      print(w)
   end

采用gmatch来解析到表类型
     t = {}
     s = "from=world, to=Lua"
     for k, v in string.gmatch(s, "(%w+)=(%w+)") do
       t[k] = v
     end

一个http传送参数的应用
URL 编码,
这种编码将一些特殊字符（比 '=' '&' '+'）转换为"%XX"形式的编码，
XX是字符的16进制表示，空白为'+'。
如，将"a+b = c" 编码为 "a%2Bb+%3D+c"
一个典型的参数串：
name=al&query=a%2Bb+%3D+c&q=yes+or+no

1先把空格和16进制编码转换为ansi码
function convet1(s)
s = string.gsub(s, "+", " ")
s = string.gsub(s, "%%(%x%x)", function (h)
   return string.char(tonumber(h, 16))
end)
return s
end

2.解析参数串
p = {}
function decode (s)
for name, value in string.gmatch(s, "([^&=]+)=([^&=]+)") do
name = unescape(name)
value = unescape(value)
p[name] = value
end
end

kenlistian 2008-10-15 22:12 发表评论

lua 协同基本

kenlistian — Wed, 15 Oct 2008 04:43:00 GMT

Lua 通过 table 提供了所有的协同函数，
create 函数创建一个新的协同程序，
create只有一个参数：
协同程序将要运行的代码封装而成的函数，返回值为thread类型的值。

通常情况下 create 的参数是一个匿名
co = coroutine.create(function ()
       print("hello")
     end)

print(co)   --> thread: 0x8071d98

协同有三个状态：挂起态，运行态，停止态。

当创建协同程序时开始状态为挂起态，即创建后不会自动运行，
用status 函数检查协同的状态：

如：
print(coroutine.status(co))   --> suspended

挂起状态变为运行态：coroutine.resume

coroutine.resume(co)     --> hello

这个例子中，协同体打印出"hello"之后便进入终止状态：
print(coroutine.status(co))   --> dead

挂起函数yield 。将正在运行的代码挂起，

如下代码：
co = coroutine.create(function ()
    for i=1,10 do
      print("co", i)
      coroutine.yield()
    end
end)

运行如下，将在第一个 yield 处被挂起：
coroutine.resume(co)     --> co   1
print(coroutine.status(co))   --> suspended
从协同的观点看：使用函数 yield 可以使程序挂起,当激活被挂起的程序时，
yield返回并继续程序的执行直到再次遇到 yield 或者程序结束
coroutine.resume(co)   --> co   2
coroutine.resume(co)   --> co   3
...
coroutine.resume(co)   --> co   10
coroutine.resume(co)   -- prints nothing

kenlistian 2008-10-15 12:43 发表评论

lua交互为何用堆栈？

kenlistian — Mon, 29 Sep 2008 03:25:00 GMT

为何起用lua堆栈

当在Lua和C之间交换数据时我们面临着两个问题：
动态与静态类型系统的不匹配和自动与手动内存管理的不一致。

在Lua中，我们写下a[k]=v时，k和v可以有几种不同的类型（由于metatables的存在，a也可能有不同的类型）。

如果我们想在C中提供类似的操作，无论怎样，操作表的函数(settable)必定有一个固定的类型。
我们将需要几十个不同的函数来完成这一个的操作（三个参数的类型的每一种组合都需要一个函数）。

在C中声明一些union类型来解决这个问题，称之为lua_Value，它能够描述所有类型的Lua值。
，就可以这样声明settable
void lua_settable (lua_Value a, lua_Value k, lua_Value v);
这个解决方案有两个缺点。
1。要将如此复杂的类型映射到其它语言可能很困难；Lua不仅被设计为与C/C++易于交互，
Java,Fortran以及类似的语言也一样。
2。Lua负责垃圾回收：如果将Lua值保存在C变量中，Lua引擎没有办法了解这种用法；
   它可能错误地认为某个值为垃圾并收集他。

Lua API没有定义任何类似lua_Value的类型。替代的方案，
它用一个抽象的栈在Lua与C之间交换值。
栈中的每一条记录都可以保存任何Lua值。

无论你何时想要从Lua请求一个值（比如一个全局变量的值），
1.将这个值压入栈，
2。调用Lua（这个值将被弹出）。

仍然需要一个不同的函数将每种C类型压入栈和一个不同函数从栈上取值（译注：只是取出不是弹出），
但是我们避免了组合式的爆炸（combinatorial explosion）。另外，因为栈是由Lua来管理的，
垃圾回收器知道那个值正在被C使用。几乎所有的API函数都用到了栈。

lua_pcall从栈上获取要被调用的函数并把任何临时的错误信息放在这里。
Lua以一个严格的LIFO规则（后进先出；也就是，始终存取栈顶）来操作栈。

当你调用Lua时，它只会改变栈顶部分。你的Ｃ代码却有更多的自由；更明确的来讲，
你可以查询栈上的任何元素，甚至是在任何一个位置插入和删除元素。

API有一系列压栈的函数，它将每种可以用C来描述的Lua类型压栈：
空值（nil）                                   用lua_pushnil，
数值型（doubele）                             用lua_pushnumber，
布尔型（在C中用整数表示）                     用lua_pushboolean，
任意的字符串（char*类型，允许包含'\0'字符）   用lua_pushlstring，
C语言风格（以'\0'结束）的字符串（const char*）用lua_pushstring：

void lua_pushnil (lua_State *L);
void lua_pushboolean (lua_State *L, int bool);
void lua_pushnumber (lua_State *L, double n);
void lua_pushlstring (lua_State *L, const char *s,size_t length);
void lua_pushstring (lua_State *L, const char *s);

同样也有将C函数和userdata值压入栈的函数，稍后会讨论到它们。
Lua中的字符串不是以零为结束符的；它们依赖于一个明确的长度，
因此可以包含任意的二进制数据。

将字符串压入串的正式函数是lua_pushlstring，它要求一个明确的长度作为参数。
对于以零结束的字符串，你可以用lua_pushstring（它用strlen来计算字符串长度）。

Lua是拷贝字符串而不是保持指向外部字符串（或任何其它对象，除了C函数——它总是静态指针）的指针。
对于它保持的所有字符串，Lua要么做一份内部的拷贝要么重新利用已经存在的字符串。

检测栈上是否有足够你需要的空间
int lua_checkstack (lua_State *L, int sz);

查询元素
API用索引来访问栈中的元素。

在栈中的第一个元素（也就是第一个被压入栈的）有索引1，下一个有索引2，以此类推。
我们也可以用栈顶作为参照来存取元素，利用负索引。
在这种情况下，-1指出栈顶元素（也就是最后被压入的），-2指出它的前一个元素，以此类推。

如，调用lua_tostring(L, -1)以字符串的形式返回栈顶的值。

在某些场合使用正索引访问栈较方便，另外一些情况下，使用负索引访问栈更方便。

API提供了一套lua_is*函数来检查一个元素是否是一个指定的类型，*可以是任何Lua类型。
因此有lua_isnumber,lua_isstring,lua_istable以及类似的函数。所有这些函数都有同样
的原型：

int lua_is... (lua_State *L, int index);
lua_isnumber和lua_isstring函数不检查这个值是否是指定的类型，而是看它是否能被转
换成指定的那种类型。例如，任何数字类型都满足lua_isstring。
还有一个lua_type函数，它返回栈中元素的类型。
（lua_is*中的有些函数实际上是用了这个函数定义的宏）

为了从栈中获得值，这里有lua_to*函数：
int lua_toboolean (lua_State *L, int index);
double lua_tonumber (lua_State *L, int index);
const char * lua_tostring (lua_State *L, int index);
size_t lua_strlen (lua_State *L, int index);
即使给定的元素的类型不正确，调用上面这些函数也没有什么问题。在这种情况下，
lua_toboolean、lua_tonumber和lua_strlen返回0，其他函数返回NULL。

由于ANSI C没有提供有效的可以用来判断错误发生数字值，所以返回的0是没有什么用处的。
对于其他函数而言，我们一般不需要使用对应的lua_is*函数：我们只需要调用lua_is*，
测试返回结果是否为NULL即可。

//返回的是一个指针，则需要另外找个地址拷贝值。。。。。
Lua_tostring函数返回一个指向字符串的内部拷贝的指针。你不能修改它（使你想起那里有一个const）。
只要这个指针对应的值还在栈内，Lua会保证这个指针一直有效。

当一个C函数返回后，Lua会清理他的栈，所以，有一个原则：永远不要将指向Lua字符串的指针
保存到访问他们的外部函数中。

Lua_string返回的字符串结尾总会有一个字符结束标志0，但是字符串中间也可能包含0，
lua_strlen返回字符串的实际长度。特殊情况下，假定栈顶的值是一个字符串，

下面的断言(assert)总是有效的：

//s是一个指向某个字符串地址的指针
const char *s = lua_tostring(L, -1); // any Lua string
size_t l = lua_strlen(L, -1);        // its length
assert(s[l] == '\0');
assert(strlen(s) <= l);

kenlistian 2008-09-29 11:25 发表评论

兵棋概念

kenlistian — Mon, 19 May 2008 09:38:00 GMT

一、基础知识
战棋游戏现在已经是我们相当常见的一种游戏方式了，在国际上最有知明度的当属SSI的元帅系列，
（《魔幻元帅》、《星际元帅》、《装甲元帅》、《太平洋元帅》、《人民元帅》）其次还有诸如
MICPROSE的《幽浮》系列和最老资格的《鱼叉》系列。（其他与军事无关的所谓战棋游戏这里不讨
论）

而在国内方面，比较之名的战棋游戏就更多了，限于篇幅，不一一列举。

战棋游戏的游戏方式和下陆战棋差不多，同样是双方你一回合我一回合一下走一步，
所不同的是陆战棋所比的是单纯的官大官小，官小的立马出局，而战棋游戏则不同，
你需要考虑各种方面的情况，比如自然、天气（这两项多见于欧美战棋游戏）等级等等，
这项我们在后面的战棋环境在说。我们可以施法，人物也可以成长，这也算是战棋游戏最
大的特色了。

附：战棋游戏的规则：

在一幅地图上，双方各执一方，由甲方先走，甲方可以考虑在可移动范围内移动，移动完毕后
可以考虑是否攻击，完后休息待命，轮到乙方行动，这时候乙方也可以先行走，然后在攻击，
接下来，乙方也待命，轮到甲方走。如此这般。这就形成了战棋游戏的基本规则。

二、什么叫战棋
其实战棋最早不叫战棋，而是叫兵棋，英文名WAR　GAME，就是战争游戏的意思，多年来，
国内一直翻译其为作战模拟，也许是想将其与计算机作战模拟连接起来，但是对理论性、
系统性的刻意追求，却间接的导致了许多我军许多官兵听其高深的名字望而生畏，从而放
弃对其的研究.....

无论是说戚继光当年在马背上默弈，还是陈老总在准海战役的前线下棋，说来说去总是为了说兵，
而并非说棋，这棋似乎总是兵的陪衬，或者是为了说说棋，而拿兵来虚张一下声势，在国人眼里，
兵与棋是有一定的共通之处，但是他毕竟不是一路呀。

然而在地球的那一边，却上演了一出用兵必下棋，下棋再用兵，兵、棋形影不离，二者融为一体
的的活话剧，

三、最早的战棋
现代类型的战棋是由普鲁士的宫庭战争顾问冯.莱斯维茨于1811年年首先发明的，
它由一幅地图，一套代表军队的硬方块，一本详细规则　，一张概率表和一个骰子
组成，用这套战棋，可以逼真地淙当时战场擤的实际作战活动，所以它一问世，就受
到各列强军队的欢迎，被迅速普及和不断加以改进，在第一次和第二次世界大战中，
各发达国家用兵棋模拟的方法来试验和检验作战计划已达到了相当水平，其中，下兵
棋已列为德军各级指挥机关制定作战计划的正规程序。
例如：1939年12月，在德军总部的作战室里，由所有执行进攻法国作战计划的部队指挥
官，对通过阿登森林突破马其诺防线的计划用战棋做了实验，棋盘上的预演证明了该计
划是可行的，于是付诸战场后，果然取得了巨大的胜利。
1940年，尝到了战棋甜头的德军指挥官再次在棋盘上试验了入侵英国的“海狮计划”。
通过战棋，暴出许多问题，结果这个计划没有实施。

同年8月，德军总部又用战棋检验了进攻苏联的巴巴罗萨计划，战棋表明基本可行，
但是仅从北翼包抄第聂伯河以西的苏军是十分困难的，后来在实上，这一方向的德
军陷入了泥沼而导致伤亡惨重。

1944年11月2日，德国A集团军司令莫德尔正在作战室里进行战棋模拟，前线突然传来战报：
一个美军新的危胁出现在赫登－－哥梅特地区，莫德尔将这一情况加入棋局后，棋盘上的推
演预示几小时后德军第116装甲师将处于被动地位，该师师长冯.范登堡当即在棋桌边给他的
下属下达了作战命令，使部队独占先机，避免了损失。
不仅是德国陆军，德国海军也非常重视战棋的作用，1938－－1939年冬天，卡尔.邓尼茨海军
上将通过战棋进行模拟，结果发明了著名的潜艇打击盟军护卫舰队的“狼群战术”。

而日本也同样重视战棋的发展，1941年9月2日至13日，日本海军军事学院和陆军军事学院的
兵棋预设，分析了偷袭珍珠港的计划，计划表明基本可行，但鱼雷机需要加大打击效力，于
是日本海军立即根据此改变了自己的计划，从而使得美军的太平洋舰队受到了重创。而在随
后的1942年等等几年中，日本又利用战棋模拟，检验了空袭澳大利亚的西南部、攻占约翰森
群岛、夏威夷岛的计划。在一连串的检验中，只有中途岛海战的计划没有成功，当时按照战
棋的预演表明，南云的航空母航将受到美军陆基空军的空袭，被击中九次，赤诚和嘉赫两艘
航母当即沉灭，但是这次指导战棋预演的最高指挥官官宇垣抗议裁决，将击中次数改为三，
航母沉灭数减为一，结果在实战当中，日军四艘航母全部沉灭，日本海军也从此走像了衰亡。

而英国人在二次世界大战的时候也使用了战棋，当时的陆军中将蒙哥马利将军在对付德军非洲
军团的北非战役时，时常将战棋拿出来预设一番，他让参谋以敌人的身份拿起一个标志物向他
发起进攻，模拟出“沙漠之狐”隆美尔的一个又一个可能的行动，从而使英军获得了后来阿拉
曼战役的成功，击败了隆美尔的非洲兵团。

而在1944年3月7日，在伦敦对保罗学校的地板上，蒙哥马利铺开了一幅大的海滩地图，像艾森毫
威尔和邱吉尔讲解他的战棋预演结果，这一战棋结果模拟的不是别的战役，就是日后盟军击败德
军取得决定性胜利的诺曼底登陆。

以上只是最基本的战棋，换句话说，他们或许不能称这之为战棋，只能称之为兵棋，因为他们没
有现代战棋游戏所拥有的一些其他东西，真正将兵棋转换成战棋的还是美军。

那是二次世界大战时期，当时美国海军部成立了一个以著名发明家爱迪生为领导的海军研究实验室，
1942年3月1日，由约翰生领导的运筹小组诞生，珍珠港遭袭击后，美军决定对日军展开水雷战，该组
反复在棋盘上操作进行双方的扫雷布雷战，使战棋布局不断演化出天气、经济、战略、战术等等对战
争的影响，约翰生也因此被美军委派制订作战计划，他在后来的作战报告中写到：“我发现，日军用
来对付强大的水雷攻击的手段，几乎都在每个战棋棋局中出现过。”最后，日军 670艘舰船被水雷击
沉的事例说明了约翰生战略的成功。

4、战棋的规格
是什么使战棋游戏有了未卜先知的能力呢？
答日：数学。马克思说过：“理论　只有在能够使用数学语言加以描述时，它才真正升为科学。

战争理论以及整个军事科学也不例外，数学更深刻的把握住了战争逻辑，将兵棋的整个模拟过程量化了，
从而使战棋模拟与一般性的沙盘作业和图上推演完全区别开来。

尽管战场因素错综复杂，是一个充满偶然性的领域，但它也与世间的一切事物一样，可以被分解成一些
个体和单方面分别加以认识，然后再按照个体和单个方面之间的联系规律，把局部的认识综合起来，就
能够把握整个作战过程的总体规律，现代战棋游戏正是按这一思路设计的。一副模拟现代空地一体战的
战棋，地图为 256＊256，首先规定棋中每走一格代表实地距离200米，每走一步代表作战时间五分钟。
这样，在战棋中机动力最差的步兵单位一步最多走几格就停下来了，而这种移动格数的规定与实战一样，
依地型，道路条件而异。然后在规定的这一步中，依靠胜余机会力的大小，规定这只步兵队能够攻击几次，
依据其命中、摧毁概率来计划成果，然后再加上所处地形的防御、天候、视野、士气、战斗力等等数值，
以及指挥、通信、空袭、后方炮击、空投、侦察等等制约，这样一套战棋游戏就活灵活现的出来了。

5、战棋的AI
在一个外行人眼里看来，战棋游戏不过是让自己的机动单位能走多远走多远，然后迅速的将敌人消灭的
普通游戏，其实是不然的，严格的来讲，战棋游戏（特别是六角格战棋游戏）较之即时战略游戏，是更
能体现现代战争的风貌的，在战棋游戏里，你不能一味味傻傻在往前冲，你要考虑到敌人的机动力，自
己的攻击能力等等，将这些多方面的因素综合的考虑起来，你才可以取得最后的胜利。

6、战棋的地图风格

一般的来讲，一个战棋游戏他的地图是分是以下的规格的，分别有60＊60　80＊80　120＊120　160＊160　256＊256
等等，分别用于表现多种不同的战役模式，比如说如果要表现诺曼底登陆，如果用宏观的表现方法
本着越大越好的原则那肯定是不现实的，而且地图太大，反面会使玩家手忙脚乱，到不如用一幅
160＊160的图表现一下。

战棋游戏的地图风格根据地区的不同也会划分成几个不同的风格，比如说欧美，战棋游戏大多数是
以历史上的真实战役为蓝本，再要不然就是让某一个国家去完成统一的大任，再加上他们是六角格
战棋游戏，用Q版来表现肯定是不现实的，所以在欧美的战棋游戏中，你一般看见的地图风格都是
按照实际地图比例1：X压缩而成的，我们可以在地图上看到城市、乡村、河流、山脉等等。

近年来在欧美，战棋游戏题材越做越敏感，使得几乎世界各国的领土都出现过在战棋游戏中的地图上，
比如《装甲元帅》里有斯大林格勒战役、《西线风云》里有阿登战役、而《人民元帅》里更是因为
意识形态的原因弄出了一些预测未来的荒唐的战役大肆渲染中国威胁论。

据说SSI的游戏《人民元帅》曾被我国禁止（并没有见到相关的公文），这里在讨论涉及该游戏并不
表示赞同游戏中的观点。随着接下来几年世界局势的变幻以及游戏制作组的倾向等等原因，这种战
役设定也许会逐步的多起来，或许预测未来的战役才更符合并棋推演的初衷。

   我国自古以来就有用棋戏的方法研究战争，然而到了进代却由于不重视，却逐渐失传，而如今，
   时代发展了，条件变化了，研究战争的方法也要变化，要在和平环境中不断增加应付下一场战争
   的战争的经验，战棋无疑是一个好的选择，我们需要脚踏实地去迎接已经席卷世界的这一套战棋
   游戏，在地球的另一半世界里，我们将证明无愧于自己的祖先！

本文参考文献：
杨南征先生《兵与棋》
于翔的战棋（SLG）游戏可行性研究报告

kenlistian 2008-05-19 17:38 发表评论

游戏分类

kenlistian — Wed, 07 May 2008 06:03:00 GMT

游戏大的类别：
RTG     (Real-Time Game)                         即时游戏
TBG     (Turn-Based Game)                       回合制游戏
OLG     (Online Game)                              在线游戏(这个缩写好像只有中国才有--b)

种类：
RPG     (Role Playing Game)                     角色扮演游戏，例如《暗黑破坏神》
AVG     (Adventure Game)                       冒险游戏，例如《国王密使》
ACT     (Action Game)                              动作游戏，例如《鬼武者》
STG     (Shooting Game)                          射击游戏，例如《三角洲部队》，三角洲部队有第一人称模式。
FPS     (First Person Shooting)                 第一人称射击游戏，例如《反恐精英》
FTG     (Fighting Game)                           格斗游戏，例如《KOF》

RTS     (Real-Time Strategy Game)               即时战略游戏，例如《星际争霸》
RTM     (Real-Time Military Game)                即时战术游戏，例如《盟军敢死队》
TBS     (Turn-Based Strategy Game)              回合制策略游戏，例如《魔法门之英雄无敌》

RAC (Race Game) 赛车游戏，例如《NFS》
SLG/SIM (Simulation Game) 模拟游戏，例如《模拟城市》

EDU     (Education Game)                        养成游戏，例如《明星志愿》
SPT     (Sport Game)                                体育游戏，例如《FIFA》
PUZ     (Puzzle Game)                              益智游戏，例如《五子棋大师》
TAB     (Table Game)                               桌面游戏，例如《桌面弹球》

扩展种类：
ARPG    (Action RPG)                                 动作角色扮演游戏，例如《刀剑封魔录》
SRPG    (Simulation RPG)                           模拟角色扮演游戏，例如《风色幻想》
AAVG    (Action Adventure Game)            动作冒险游戏，例如《古墓丽影》
SFTG    (Simulation FTG)                           模拟格斗类游戏，找不出典型例子。
MMORPG (Massively Multiplayer Online RPG)      大型多人在线角色扮演游戏，例如《传奇》
MMOARPG (Massively Multiplayer Online ARPG)     大型多人在线动作角色扮演游戏，例如《刀剑Online》
MMOSRPG (Massively Multiplayer Online SRPG)     大型多人在线模拟角色扮演游戏，例如《傲世Online》

其他类：
ETC (etc.) 其他类游戏，无法被归为以上种类的游戏一般都认为是其他类，

随着时间推移，新的游戏种类不断推出，这些“其他类”游戏最终会拥有一个正式的名字。

还是有些乱，不过，我认为游戏分为如下：

1.第一人称类游戏不管是动作类，角色，还是射击类，都是构建在虚拟真实模拟下。

这类游戏一般架构在即时环境下。

2.第三人称类：属于操纵类游戏了，包括即使，回合，动作；如果从技术讲就有2d，3d的实现。

3.益智类这个就是纯粹靠游戏强大的算法来支持了，

kenlistian 2008-05-07 14:03 发表评论

ansi，gb2312，utf-8笔记

kenlistian — Wed, 27 Feb 2008 04:04:00 GMT

ANSI----->------>
Unicode---->utf-8

ASCII：是编码，它映射了127个字符，因此7位(bit)二进制数足够用来表示127个字符。
Unicode：为每个字符提供了唯一的特定数值，它世界上使用的所有字符都列出来，并给每一个字符一个唯一特定数值。
   通常Unicode编码指的是utf-16，如在文本中以unicode存储的话则是指UTF-16。在vc环境中就是wchar，宽字节。
Utf-8 则是unicode的中的一种编码方式。
: 或-80是一个简体中文字符集的中国国家标准，全称为《信息交换用汉字编码字符集--基本集》，由中国国家标准总局发布，1981年5月1日实施。编码通行于大陆，几乎所有的中文系统和国际化的软件都支持。是一种编码字符集。
理解为则是的扩展集。gbk和gb2312不存在转换
BIG5 台湾人用的中文字符集合。

当unicode-> or ->unicode 时，存在着函数。
当utf-8-> or ->utf-8        也存在。
当utf-8->unicode or unicode->utf-8      也存在。
当然也存在
到 unicode 和 unicode 到的

干脆列个表吧：

	unicode	utf-8	gb2312	big5
unicode	-	v	v	v
utf-8	v	-	v	v
gb2312	v	v	-	v
big5	v	v	v	-

其中依据各自的编码原理，当然各种语言也各自的方法，如在vc中，当，一般就是采用的
WideCharToMultiByte or MultiByteToWideChar方式倒来倒去。
而在asp中则一般是utf-8到gb2312or 到utf-8，
下面摘抄一段：
' ->utf-8
Function chinese2unicode(Str)
dim i
dim Str_one
dim Str_unicode
for i=1 to len(Str)
    Str_one=Mid(Str,i,1)
    Str_unicode=Str_unicode&chr(38)
    Str_unicode=Str_unicode&chr(35)
    Str_unicode=Str_unicode&chr(120)
    Str_unicode=Str_unicode& Hex(ascw(Str_one))
    Str_unicode=Str_unicode&chr(59)
next
Response.Write Str_unicode
end function

至于为啥细节，则需要了解它们的编码规则，这里不用讨论了，那些函数，在各个语言中都有人总结出来，拿来直接用即可。
那些编码规范，其实说来，大致了解就可以了。

kenlistian 2008-02-27 12:04 发表评论

lua mark1

kenlistian — Thu, 26 Jul 2007 01:26:00 GMT

mark 标记
http://hi.baidu.com/bitbull/blog/item/bc27581eca1886f61bd5768e.html

kenlistian 2007-07-26 09:26 发表评论

lua的诡异1

kenlistian — Thu, 24 May 2007 07:36:00 GMT

在lua中有几个关键点必须搞清楚，这个都是需要仔细去揣摩的。

一。堆栈调用

lua和其他语言交互是通过堆栈来操作，那么那些明明了了的调用就变成在堆栈上push和pop上做文章了。

比如你要取一个lua文件中的某个数值，不是一个等号就能得到，而是调用lua_getglobal()把lua中数值变量压入堆栈，然后通过lua_tostring或者lua_tonumber来获取它。如果这还可以理解的话，那么把lua文件中表的处理，则需要一系列的压栈和处理索引后才能获取。如果参数很多，还要注意索引值的正确与否。

二表之堆栈调用

看手册时，发现这点非常不易理解。而且手册的帮助也是看得人琢磨不透。以下说明

`lua_settable 表赋值`

void lua_settable (lua_State *L, int index);

等价 t[k] = v 操作，这里 t 理解为table，为index索引所对应的表， v 为值， k 键名。

实际上就是对表操作，再说白些，就是在堆上处理某个表的修改。其完整的操作都是先需要

lua_pushxxx后，对某个表做t[k]=v操作。完事后，该函数弹出-2，-1处值

英文：

`lua_settable`

void lua_settable (lua_State *L, int index);

Does the equivalent to t[k] = v, where t is the value at the given valid index index, v is the value at the top of the stack, and k is the value just below the top.

This function pops both the key and the value from the stack. As in Lua, this function may trigger a metamethod for the "newindex" event

其实画个图，就是这个样

索引号表堆栈堆栈相对位置

index ----> t ------->v（值） -1

k （键名） -2

该操作其实对表t[k]=v

`lua_gettable 取表值`

void lua_gettable (lua_State *L, int index);

把t[k] 值压入堆栈，通过lua_toxxxx取出该值。

index 指向某个表，而 k 则为某个表的键名。调用该函数时，需要先压入一个k，表（索引）键名。

调用该函数，其实就是在堆中把t[k]的值获取处理，完事后弹出k，而返回的表值在堆的顶部（-1处）。

拿个例子来讲最生动：
比如调用一个函数，其中函数是在lua中定义的表中的函数，即：

mytable = {
   Function1 = function (var ) return var.."world，my test" end
}
。。。
lua_pushstring(L, "mytable");           --压表名，将在全局栈中找该表
lua_gettable(L, LUA_GLOBALSINDEX);      --以表名查表在全局表中的位置，结果在堆顶
lua_pushstring(L, "Function1");         --压函数名，“Function1”在堆栈-1处，
                                         mytable的表索引在-2位置（不是字符串）
lua_gettable(L, -2);                    --在mytable表中查找function1的索引值（指针），
                                         该操作完后，栈顶为function1函数指针。

lua_pushstring("hello");               --压参
lua_pcall(L, 1, 1, 0);                   --调用函数，返回一个参数。
lua_String msg = lua_tostring(L, -1);
lua_pop(L, 1);

四垃圾收集

这个概念是这样的：
lua不需要用户干预内存的操作，只是通过垃圾收集器来自动管理内存。所有对象都被自动管理，有： table, userdata、函数、线程、和字符串。
其管理机制是：通过递增的标志来决定是否收集，用2个标记数字来控制垃圾收集周期：
garbage-collector pause 和 garbage-collector step multiplier 。

collector pause 按收集周期决定收集内存，当其数值越大，则收集周期也越长。
step multiplier 按相对内存分配的速度来收集。数值越大收集器则收集更快。

kenlistian 2007-05-24 15:36 发表评论