Lua OOP函数没有被调用

Question

我将Lua和LuaBridge与Allegro 5一起使用。我决定将所有图形对象移植到Lua，但我遇到了一些问题：

一次调用的字符类

Character = {sprite; AI}
function Character:new()
o = o or {} -- works!
setmetatable(o, self) -- works!
self.__index = self  -- works!
return o -- works!
end
function Character:LoadSprite(filename)
self.sprite = self.sprite or Bitmap() -- works!
self.sprite:LoadFile(filename) -- works!
self.sprite.x = 0 -- works!
self.sprite.y = 0 --works!
end
function Character:SetX(xx)
self.sprite.x = xx -- maybe? cannot tell if it works or not.
end
function Character:AddBehavior(fname, cname)
self.AI = self.AI or Pattern()
self.AI:AddBehavior(fname, cname)
end
function Character:Draw()
self.sprite:Draw() -- works!
end
Foo = Character:new()

Lua脚本，其函数从主程序调用：

function CoreInit() --called at initialization
Foo:LoadSprite("Image.png") -- works!
end
function CoreLogic() --called during logic cycle
Foo:SetX(50)  -- does NOT work!
end
function CoreDraw() --called during drawing/rendering cycle
Foo:Draw()  --works perfectly!
end

因此，基本上，脚本用适当的坐标和图像初始化字符，并绘制它，但要么没有调用逻辑(它在逻辑循环中)，要么改变X坐标的函数出了问题。

此外，任务管理器建议每个周期都有大约30 KB的内存泄漏，当我在C++中使用图像对象时，这种情况并没有发生。

以下是位图结构的一个片段，它通过LuaBridge导出到Lua，以备需要：

void Bitmap::Register(lua_State*lua) {
luabridge::getGlobalNamespace(lua)
.beginClass<Bitmap>("Bitmap")
.addConstructor <void (*) (void)> ()
.addStaticData("scale", &Bitmap::scale)
.addFunction("LoadFile", &Bitmap::LoadFile)
.addFunction("Draw", &Bitmap::Draw)
.addData("x", &Bitmap::x)
.addData("y", &Bitmap::y)
.addData("w", &Bitmap::w)
.addData("h", &Bitmap::h)
.endClass();
}

void Bitmap::LoadFile(string file) {
name = file;
bitmap = al_load_bitmap(file.c_str());
w = al_get_bitmap_width(bitmap);
h = al_get_bitmap_height(bitmap);
}
void Bitmap::Draw() {
if (scale > 1)
al_draw_scaled_bitmap(bitmap, 0, 0, w, h, x * scale , y * scale, w * scale, h * scale, 0);
else
al_draw_bitmap(bitmap, x, y, 0);
}
Bitmap::Bitmap() :  velocity(1) {
bitmap = NULL; 
}
Bitmap::~Bitmap() {
name = "";
if (!bitmap) 
al_destroy_bitmap(bitmap);
}

UPDATE：有一件事我已经弄清楚了，内存泄漏来自CoreLogic；我在C++中注释掉了对它的调用，内存泄漏消失了，但当我保持调用不变，但注释掉了CoreLogic的内容时，泄漏仍然存在。嗯…

第二次更新：内存泄漏已经缩小到AI的问题，我没有发布：

Pattern = {complete; timer; command; Files; Commands; itr; num}
function Pattern:new()
o = o or {}
o.Files = {}
o.Commands = {}
o.complete = false
o.timer = 0
o.itr = 1
o.num = 1
setmetatable(o, self)
self.__index = self
return o
end
function Pattern:AddBehavior(filename, commandname)
self.Files[self.num] = filename
self.Commands[self.num] = commandname
self.num = self.num + 1
end
function Pattern:DoBehavior()
self.command = self.Commands[self.itr]
dofile(self.Files[self.itr])
end
function Pattern:CheckBehavior()
if self.complete == true then
self.itr = self.itr + 1
self.timer = 0
self.complete = false
end
if itr >= num then
self.itr   = 1
self.timer = 0
self.complete = false
end
end
function Pattern:Initialize()
self.itr = 1; self.timer = 0
self.complete = false
self.command = self.Commands[self.itr]
end

在CoreLogic函数中，它将调用Foo。AI：DoBehavior()，它什么都没做，导致了内存泄漏。

Answer 1

Foo.AI:DoBehavior()从文件中读取块，为其内容、字节码转换形式、函数环境以及在该文件的顶层创建的任何可能的临时值保留内存。预计这里会丢失内存，而且不是泄漏。Lua不会立即释放内存。事实上，它甚至根本不会将其返回到系统。

偶尔垃圾收集器会运行并查找不再使用的字符串/表/函数/其他任何东西。Lua在自己的内部索引中将此内存标记为空闲，并将在下次需要空闲内存时使用它，但从系统来看，Lua内存消耗永远不会减少。

如果您怀疑程序的某些部分可能会在自动GC调用之间生成太多不必要的垃圾，则可能需要通过collectgarbage或C API强制执行GC步骤。

Answer 2

经过更多的肘部润滑脂，我能够解决问题；本质上，它回到了Pattern表的构造函数，以及AI对象是如何在Character中初始化的。我不得不将构造函数从更改为

Pattern = {complete; timer; command; Files; Commands; itr; num}
function Pattern:new()
o = o or {}
o.Files = {}
o.Commands = {}
o.complete = false
o.timer = 0
o.itr = 1
o.num = 1
setmetatable(o, self)
self.__index = self
return o
end

至：

Pattern = {}
function Pattern:new()
local o = {complete = false; timer = 0; command = ""; Files = {}; Commands = {}; itr = 1; num = 1}
setmetatable(o, self)
self.__index = self
return o
end

这个：

Character = {sprite; AI}
function Character:new()
o = o or {} 
setmetatable(o, self) 
self.__index = self 
return o 
end

至：

Character = {}
function Character:new()
local o = {sprite; AI = Pattern:new()}
setmetatable(o, self)
self.__index = self
return o
end

现在调用Foo。AI：DoBehavior()在不使用额外内存的情况下按预期操作。这段代码是我第一次尝试在Lua中实现OOP，这可能是我今后要做的事情