diff --git a/game/modules/tome/data/talents/techniques/dualweapon.lua b/game/modules/tome/data/talents/techniques/dualweapon.lua
index 64d7a63d8152a19c807e257a28277ab3fe739feb..a21b9c176e2d290bfb5bef2993a42e6e5477c0e4 100644
--- a/game/modules/tome/data/talents/techniques/dualweapon.lua
+++ b/game/modules/tome/data/talents/techniques/dualweapon.lua
@@ -131,7 +131,7 @@ newTalent{
if math.floor(core.fov.distance(self.x, self.y, x, y)) > 1 then return nil end
-- First attack with offhand
- local speed, hit = self:attackTargetWith(target, offweapon.combat, nil, self:combatTalentWeaponDamage(t, 0.7, 1.7))
+ local speed, hit = self:attackTargetWith(target, offweapon.combat, nil, self:combatTalentWeaponDamage(t, 0.7, 1.5))
-- Second attack with mainhand
if hit then
@@ -142,7 +142,7 @@ newTalent{
end
-- Attack after the stun, to benefit from backstabs
- self:attackTargetWith(target, weapon.combat, nil, self:combatTalentWeaponDamage(t, 0.7, 1.7))
+ self:attackTargetWith(target, weapon.combat, nil, self:combatTalentWeaponDamage(t, 0.7, 1.5))
end
return true
@@ -150,9 +150,9 @@ newTalent{
info = function(self, t)
return ([[Hit with your offhand weapon for %d%% damage. If the attack hits, the target is stunned for %d turns and you hit it with your mainhand weapon doing %d%% damage.
Stun chance increase with your Dexterity stat.]])
- :format(100 * self:combatTalentWeaponDamage(t, 0.7, 1.7),
+ :format(100 * self:combatTalentWeaponDamage(t, 0.7, 1.5),
2 + self:getTalentLevel(t),
- 100 * self:combatTalentWeaponDamage(t, 0.7, 1.7))
+ 100 * self:combatTalentWeaponDamage(t, 0.7, 1.5))
end,
}
@@ -178,14 +178,14 @@ newTalent{
local x, y, target = self:getTarget(tg)
if not x or not y or not target then return nil end
if math.floor(core.fov.distance(self.x, self.y, x, y)) > 1 then return nil end
- self:attackTarget(target, nil, self:combatTalentWeaponDamage(t, 0.5, 1.4), true)
- self:attackTarget(target, nil, self:combatTalentWeaponDamage(t, 0.5, 1.4), true)
- self:attackTarget(target, nil, self:combatTalentWeaponDamage(t, 0.5, 1.4), true)
+ self:attackTarget(target, nil, self:combatTalentWeaponDamage(t, 0.4, 1.0), true)
+ self:attackTarget(target, nil, self:combatTalentWeaponDamage(t, 0.4, 1.0), true)
+ self:attackTarget(target, nil, self:combatTalentWeaponDamage(t, 0.4, 1.0), true)
return true
end,
info = function(self, t)
- return ([[Lashes out with a flurry of blows, hitting your target three times with each weapon for %d%% damage.]]):format(100 * self:combatTalentWeaponDamage(t, 0.5, 1.4))
+ return ([[Lashes out with a flurry of blows, hitting your target three times with each weapon for %d%% damage.]]):format(100 * self:combatTalentWeaponDamage(t, 0.4, 1.0))
end,
}
diff --git a/premake4.lua b/premake4.lua
index 3dc58c4e47d419c1777d1719c813875593425dac..16181fc9cac7c1d75d938213ea567ccb50752725 100644
--- a/premake4.lua
+++ b/premake4.lua
@@ -18,6 +18,11 @@ newoption {
value = "VM_Type",
description = "Links libraries relative to the application path for redistribution",
}
+newoption {
+ trigger = "luaassert",
+ value = "VM_Type",
+ description = "Enable lua asserts to debug lua C code",
+}
_OPTIONS.lua = _OPTIONS.lua or "default"
@@ -69,6 +74,7 @@ configuration "Debug"
flags { "Symbols" }
buildoptions { "-ggdb" }
targetdir "bin/Debug"
+ if _OPTIONS.luaassert then defines {"LUA_USE_APICHECK"} end
configuration "Release"
defines { "NDEBUG=1" }
diff --git a/src/core_lua.c b/src/core_lua.c
index db7324aeefbdb9326ad6fbaf2a33bfe103f3346e..955824fdf96be7f3c715deab646c0a5abb236f15 100644
--- a/src/core_lua.c
+++ b/src/core_lua.c
@@ -2371,5 +2371,7 @@ int luaopen_core(lua_State *L)
luaL_openlib(L, "rng", rnglib, 0);
luaL_openlib(L, "line", linelib, 0);
luaL_openlib(L, "fs", fslib, 0);
+
+ lua_pop(L, 8);
return 1;
}
diff --git a/src/fov.c b/src/fov.c
index 86acf5744fbe1cd1a8e18f2b2da19626fd941ca0..31138744c9fb028f6987f878916dd69e12aa8c10 100644
--- a/src/fov.c
+++ b/src/fov.c
@@ -450,5 +450,6 @@ int luaopen_fov(lua_State *L)
{
auxiliar_newclass(L, "fov{cache}", fovcache_reg);
luaL_openlib(L, "core.fov", fovlib, 0);
+ lua_pop(L, 1);
return 1;
}
diff --git a/src/lpeg/lpeg.c b/src/lpeg/lpeg.c
index 6596037a14c896dc2d75db00f4e12df03a9e681f..aac499e9039798345cc8ef957722dbfbda60f582 100644
--- a/src/lpeg/lpeg.c
+++ b/src/lpeg/lpeg.c
@@ -2253,6 +2253,7 @@ int luaopen_lpeg (lua_State *L) {
lua_pushliteral(L, "__index");
lua_pushvalue(L, -2);
lua_settable(L, -4);
+ lua_pop(L, 2);
return 1;
}
diff --git a/src/luamd5/md5lib.c b/src/luamd5/md5lib.c
index 35a5db8d1dad19a20013e3910b7da871099aa4dc..c10be6280c6704eaecad2fdbd298476335047ef3 100644
--- a/src/luamd5/md5lib.c
+++ b/src/luamd5/md5lib.c
@@ -198,6 +198,7 @@ static struct luaL_reg md5lib[] = {
int luaopen_md5_core (lua_State *L) {
luaL_openlib(L, "md5.core", md5lib, 0);
set_info (L);
+ lua_pop(L, 1);
return 1;
}
diff --git a/src/luaprofiler/lua50_profiler.c b/src/luaprofiler/lua50_profiler.c
index 0a0a3dde17b33a23e0f8cf7fac54484df9b44df3..2fe49e3064e411d8ae08673a3617e7888c8056e5 100644
--- a/src/luaprofiler/lua50_profiler.c
+++ b/src/luaprofiler/lua50_profiler.c
@@ -226,5 +226,6 @@ int luaopen_profiler(lua_State *L) {
lua_pushliteral (L, "_VERSION");
lua_pushliteral (L, "2.0.1");
lua_settable (L, -3);
+ lua_pop(L, 1);
return 1;
}
diff --git a/src/luasocket/luasocket.c b/src/luasocket/luasocket.c
index 2991a653a211f1387e21901aa66d6faad590a61e..6600731855150cab4635ff0d7a4ef4a0c3a4f66b 100644
--- a/src/luasocket/luasocket.c
+++ b/src/luasocket/luasocket.c
@@ -117,5 +117,6 @@ LUASOCKET_API int luaopen_socket_core(lua_State *L) {
int i;
base_open(L);
for (i = 0; mod[i].name; i++) mod[i].func(L);
+ lua_pop(L, 2);
return 1;
}
diff --git a/src/luasocket/mime.c b/src/luasocket/mime.c
index 700fa05e9304f4ccc3be8630891078e06ddf077e..930473f5463dc0cedc614ea1731f714b05720bcf 100644
--- a/src/luasocket/mime.c
+++ b/src/luasocket/mime.c
@@ -43,7 +43,7 @@ static size_t b64decode(UC c, UC *input, size_t size, luaL_Buffer *buffer);
static void qpsetup(UC *qpclass, UC *qpunbase);
static void qpquote(UC c, luaL_Buffer *buffer);
static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer);
-static size_t qpencode(UC c, UC *input, size_t size,
+static size_t qpencode(UC c, UC *input, size_t size,
const char *marker, luaL_Buffer *buffer);
static size_t qppad(UC *input, size_t size, luaL_Buffer *buffer);
@@ -91,6 +91,7 @@ MIME_API int luaopen_mime_core(lua_State *L)
/* initialize lookup tables */
qpsetup(qpclass, qpunbase);
b64setup(b64unbase);
+ lua_pop(L, 1);
return 1;
}
@@ -100,9 +101,9 @@ MIME_API int luaopen_mime_core(lua_State *L)
/*-------------------------------------------------------------------------*\
* Incrementaly breaks a string into lines. The string can have CRLF breaks.
* A, n = wrp(l, B, length)
-* A is a copy of B, broken into lines of at most 'length' bytes.
-* 'l' is how many bytes are left for the first line of B.
-* 'n' is the number of bytes left in the last line of A.
+* A is a copy of B, broken into lines of at most 'length' bytes.
+* 'l' is how many bytes are left for the first line of B.
+* 'n' is the number of bytes left in the last line of A.
\*-------------------------------------------------------------------------*/
static int mime_global_wrp(lua_State *L)
{
@@ -120,7 +121,7 @@ static int mime_global_wrp(lua_State *L)
else lua_pushnil(L);
lua_pushnumber(L, length);
return 2;
- }
+ }
luaL_buffinit(L, &buffer);
while (input < last) {
switch (*input) {
@@ -147,9 +148,9 @@ static int mime_global_wrp(lua_State *L)
}
/*-------------------------------------------------------------------------*\
-* Fill base64 decode map.
+* Fill base64 decode map.
\*-------------------------------------------------------------------------*/
-static void b64setup(UC *b64unbase)
+static void b64setup(UC *b64unbase)
{
int i;
for (i = 0; i <= 255; i++) b64unbase[i] = (UC) 255;
@@ -158,11 +159,11 @@ static void b64setup(UC *b64unbase)
}
/*-------------------------------------------------------------------------*\
-* Acumulates bytes in input buffer until 3 bytes are available.
+* Acumulates bytes in input buffer until 3 bytes are available.
* Translate the 3 bytes into Base64 form and append to buffer.
* Returns new number of bytes in buffer.
\*-------------------------------------------------------------------------*/
-static size_t b64encode(UC c, UC *input, size_t size,
+static size_t b64encode(UC c, UC *input, size_t size,
luaL_Buffer *buffer)
{
input[size++] = c;
@@ -171,7 +172,7 @@ static size_t b64encode(UC c, UC *input, size_t size,
unsigned long value = 0;
value += input[0]; value <<= 8;
value += input[1]; value <<= 8;
- value += input[2];
+ value += input[2];
code[3] = b64base[value & 0x3f]; value >>= 6;
code[2] = b64base[value & 0x3f]; value >>= 6;
code[1] = b64base[value & 0x3f]; value >>= 6;
@@ -183,11 +184,11 @@ static size_t b64encode(UC c, UC *input, size_t size,
}
/*-------------------------------------------------------------------------*\
-* Encodes the Base64 last 1 or 2 bytes and adds padding '='
+* Encodes the Base64 last 1 or 2 bytes and adds padding '='
* Result, if any, is appended to buffer.
* Returns 0.
\*-------------------------------------------------------------------------*/
-static size_t b64pad(const UC *input, size_t size,
+static size_t b64pad(const UC *input, size_t size,
luaL_Buffer *buffer)
{
unsigned long value = 0;
@@ -200,7 +201,7 @@ static size_t b64pad(const UC *input, size_t size,
luaL_addlstring(buffer, (char *) code, 4);
break;
case 2:
- value = input[0]; value <<= 8;
+ value = input[0]; value <<= 8;
value |= input[1]; value <<= 2;
code[2] = b64base[value & 0x3f]; value >>= 6;
code[1] = b64base[value & 0x3f]; value >>= 6;
@@ -214,11 +215,11 @@ static size_t b64pad(const UC *input, size_t size,
}
/*-------------------------------------------------------------------------*\
-* Acumulates bytes in input buffer until 4 bytes are available.
+* Acumulates bytes in input buffer until 4 bytes are available.
* Translate the 4 bytes from Base64 form and append to buffer.
* Returns new number of bytes in buffer.
\*-------------------------------------------------------------------------*/
-static size_t b64decode(UC c, UC *input, size_t size,
+static size_t b64decode(UC c, UC *input, size_t size,
luaL_Buffer *buffer)
{
/* ignore invalid characters */
@@ -236,7 +237,7 @@ static size_t b64decode(UC c, UC *input, size_t size,
decoded[1] = (UC) (value & 0xff); value >>= 8;
decoded[0] = (UC) value;
/* take care of paddding */
- valid = (input[2] == '=') ? 1 : (input[3] == '=') ? 2 : 3;
+ valid = (input[2] == '=') ? 1 : (input[3] == '=') ? 2 : 3;
luaL_addlstring(buffer, (char *) decoded, valid);
return 0;
/* need more data */
@@ -248,7 +249,7 @@ static size_t b64decode(UC c, UC *input, size_t size,
* A, B = b64(C, D)
* A is the encoded version of the largest prefix of C .. D that is
* divisible by 3. B has the remaining bytes of C .. D, *without* encoding.
-* The easiest thing would be to concatenate the two strings and
+* The easiest thing would be to concatenate the two strings and
* encode the result, but we can't afford that or Lua would dupplicate
* every chunk we received.
\*-------------------------------------------------------------------------*/
@@ -267,7 +268,7 @@ static int mime_global_b64(lua_State *L)
}
/* process first part of the input */
luaL_buffinit(L, &buffer);
- while (input < last)
+ while (input < last)
asize = b64encode(*input++, atom, asize, &buffer);
input = (UC *) luaL_optlstring(L, 2, NULL, &isize);
/* if second part is nil, we are done */
@@ -280,7 +281,7 @@ static int mime_global_b64(lua_State *L)
}
/* otherwise process the second part */
last = input + isize;
- while (input < last)
+ while (input < last)
asize = b64encode(*input++, atom, asize, &buffer);
luaL_pushresult(&buffer);
lua_pushlstring(L, (char *) atom, asize);
@@ -308,7 +309,7 @@ static int mime_global_unb64(lua_State *L)
}
/* process first part of the input */
luaL_buffinit(L, &buffer);
- while (input < last)
+ while (input < last)
asize = b64decode(*input++, atom, asize, &buffer);
input = (UC *) luaL_optlstring(L, 2, NULL, &isize);
/* if second is nil, we are done */
@@ -320,7 +321,7 @@ static int mime_global_unb64(lua_State *L)
}
/* otherwise, process the rest of the input */
last = input + isize;
- while (input < last)
+ while (input < last)
asize = b64decode(*input++, atom, asize, &buffer);
luaL_pushresult(&buffer);
lua_pushlstring(L, (char *) atom, asize);
@@ -336,7 +337,7 @@ static int mime_global_unb64(lua_State *L)
* 9 and 32 can be plain, unless in the end of a line, where must be =XX
* encoded lines must be no longer than 76 not counting CRLF
* soft line-break are =CRLF
-* To encode one byte, we need to see the next two.
+* To encode one byte, we need to see the next two.
* Worst case is when we see a space, and wonder if a CRLF is comming
\*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*\
@@ -349,7 +350,7 @@ static void qpsetup(UC *qpclass, UC *qpunbase)
for (i = 0; i < 256; i++) qpclass[i] = QP_QUOTED;
for (i = 33; i <= 60; i++) qpclass[i] = QP_PLAIN;
for (i = 62; i <= 126; i++) qpclass[i] = QP_PLAIN;
- qpclass['\t'] = QP_IF_LAST;
+ qpclass['\t'] = QP_IF_LAST;
qpclass[' '] = QP_IF_LAST;
qpclass['\r'] = QP_CR;
for (i = 0; i < 256; i++) qpunbase[i] = 255;
@@ -375,9 +376,9 @@ static void qpquote(UC c, luaL_Buffer *buffer)
/*-------------------------------------------------------------------------*\
* Accumulate characters until we are sure about how to deal with them.
-* Once we are sure, output to the buffer, in the correct form.
+* Once we are sure, output to the buffer, in the correct form.
\*-------------------------------------------------------------------------*/
-static size_t qpencode(UC c, UC *input, size_t size,
+static size_t qpencode(UC c, UC *input, size_t size,
const char *marker, luaL_Buffer *buffer)
{
input[size++] = c;
@@ -418,7 +419,7 @@ static size_t qpencode(UC c, UC *input, size_t size,
}
/*-------------------------------------------------------------------------*\
-* Deal with the final characters
+* Deal with the final characters
\*-------------------------------------------------------------------------*/
static size_t qppad(UC *input, size_t size, luaL_Buffer *buffer)
{
@@ -435,8 +436,8 @@ static size_t qppad(UC *input, size_t size, luaL_Buffer *buffer)
* Incrementally converts a string to quoted-printable
* A, B = qp(C, D, marker)
* Marker is the text to be used to replace CRLF sequences found in A.
-* A is the encoded version of the largest prefix of C .. D that
-* can be encoded without doubts.
+* A is the encoded version of the largest prefix of C .. D that
+* can be encoded without doubts.
* B has the remaining bytes of C .. D, *without* encoding.
\*-------------------------------------------------------------------------*/
static int mime_global_qp(lua_State *L)
@@ -478,7 +479,7 @@ static int mime_global_qp(lua_State *L)
/*-------------------------------------------------------------------------*\
* Accumulate characters until we are sure about how to deal with them.
-* Once we are sure, output the to the buffer, in the correct form.
+* Once we are sure, output the to the buffer, in the correct form.
\*-------------------------------------------------------------------------*/
static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer) {
int d;
@@ -486,8 +487,8 @@ static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer) {
/* deal with all characters we can deal */
switch (input[0]) {
/* if we have an escape character */
- case '=':
- if (size < 3) return size;
+ case '=':
+ if (size < 3) return size;
/* eliminate soft line break */
if (input[1] == '\r' && input[2] == '\n') return 0;
/* decode quoted representation */
@@ -497,7 +498,7 @@ static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer) {
else luaL_putchar(buffer, (c << 4) + d);
return 0;
case '\r':
- if (size < 2) return size;
+ if (size < 2) return size;
if (input[1] == '\n') luaL_addlstring(buffer, (char *)input, 2);
return 0;
default:
@@ -510,8 +511,8 @@ static size_t qpdecode(UC c, UC *input, size_t size, luaL_Buffer *buffer) {
/*-------------------------------------------------------------------------*\
* Incrementally decodes a string in quoted-printable
* A, B = qp(C, D)
-* A is the decoded version of the largest prefix of C .. D that
-* can be decoded without doubts.
+* A is the decoded version of the largest prefix of C .. D that
+* can be decoded without doubts.
* B has the remaining bytes of C .. D, *without* decoding.
\*-------------------------------------------------------------------------*/
static int mime_global_unqp(lua_State *L)
@@ -538,7 +539,7 @@ static int mime_global_unqp(lua_State *L)
if (!(*lua_tostring(L, -1))) lua_pushnil(L);
lua_pushnil(L);
return 2;
- }
+ }
/* otherwise process rest of input */
last = input + isize;
while (input < last)
@@ -551,9 +552,9 @@ static int mime_global_unqp(lua_State *L)
/*-------------------------------------------------------------------------*\
* Incrementally breaks a quoted-printed string into lines
* A, n = qpwrp(l, B, length)
-* A is a copy of B, broken into lines of at most 'length' bytes.
-* 'l' is how many bytes are left for the first line of B.
-* 'n' is the number of bytes left in the last line of A.
+* A is a copy of B, broken into lines of at most 'length' bytes.
+* 'l' is how many bytes are left for the first line of B.
+* 'n' is the number of bytes left in the last line of A.
* There are two complications: lines can't be broken in the middle
* of an encoded =XX, and there might be line breaks already
\*-------------------------------------------------------------------------*/
@@ -586,11 +587,11 @@ static int mime_global_qpwrp(lua_State *L)
if (left <= 3) {
left = length;
luaL_addstring(&buffer, EQCRLF);
- }
+ }
luaL_putchar(&buffer, *input);
left--;
break;
- default:
+ default:
if (left <= 1) {
left = length;
luaL_addstring(&buffer, EQCRLF);
@@ -618,7 +619,7 @@ static int mime_global_qpwrp(lua_State *L)
* last is the previous character
\*-------------------------------------------------------------------------*/
#define eolcandidate(c) (c == '\r' || c == '\n')
-static int eolprocess(int c, int last, const char *marker,
+static int eolprocess(int c, int last, const char *marker,
luaL_Buffer *buffer)
{
if (eolcandidate(c)) {
@@ -636,10 +637,10 @@ static int eolprocess(int c, int last, const char *marker,
}
/*-------------------------------------------------------------------------*\
-* Converts a string to uniform EOL convention.
+* Converts a string to uniform EOL convention.
* A, n = eol(o, B, marker)
* A is the converted version of the largest prefix of B that can be
-* converted unambiguously. 'o' is the context returned by the previous
+* converted unambiguously. 'o' is the context returned by the previous
* call. 'n' is the new context.
\*-------------------------------------------------------------------------*/
static int mime_global_eol(lua_State *L)
@@ -666,18 +667,18 @@ static int mime_global_eol(lua_State *L)
}
/*-------------------------------------------------------------------------*\
-* Takes one byte and stuff it if needed.
+* Takes one byte and stuff it if needed.
\*-------------------------------------------------------------------------*/
static size_t dot(int c, size_t state, luaL_Buffer *buffer)
{
luaL_putchar(buffer, c);
switch (c) {
- case '\r':
+ case '\r':
return 1;
- case '\n':
- return (state == 1)? 2: 0;
- case '.':
- if (state == 2)
+ case '\n':
+ return (state == 1)? 2: 0;
+ case '.':
+ if (state == 2)
luaL_putchar(buffer, '.');
default:
return 0;
@@ -702,7 +703,7 @@ static int mime_global_dot(lua_State *L)
}
/* process all input */
luaL_buffinit(L, &buffer);
- while (input < last)
+ while (input < last)
state = dot(*input++, state, &buffer);
luaL_pushresult(&buffer);
lua_pushnumber(L, state);
diff --git a/src/lxp/lxplib.c b/src/lxp/lxplib.c
index 46a9d88d581a1a78f09151da15ae87743f9246ef..5508665ea6fb9998ede60111e2f9f79976b6f0d9 100644
--- a/src/lxp/lxplib.c
+++ b/src/lxp/lxplib.c
@@ -535,6 +535,7 @@ int luaopen_lxp (lua_State *L) {
luaL_openlib (L, NULL, lxp_meths, 0);
luaL_openlib (L, "lxp", lxp_funcs, 0);
set_info (L);
+ lua_pop(L, 2);
return 1;
}
diff --git a/src/main.c b/src/main.c
index 7a725da39e06f5708249709f4530d364316f664b..56424101dbdf253e41529be2a09a9911aa22a3f9 100644
--- a/src/main.c
+++ b/src/main.c
@@ -84,6 +84,7 @@ static int traceback (lua_State *L) {
int docall (lua_State *L, int narg, int nret)
{
+// printf("<===%d\n", lua_gettop(L));
int status;
int base = lua_gettop(L) - narg; /* function index */
lua_pushcfunction(L, traceback); /* push traceback function */
@@ -92,6 +93,7 @@ int docall (lua_State *L, int narg, int nret)
lua_remove(L, base); /* remove traceback function */
/* force a complete garbage collection in case of errors */
if (status != 0) lua_gc(L, LUA_GCCOLLECT, 0);
+// printf(">===%d\n", lua_gettop(L));
return status;
}
@@ -260,7 +262,7 @@ void on_tick()
lua_rawgeti(L, LUA_REGISTRYINDEX, current_game);
docall(L, 1, 1);
tickPaused = lua_toboolean(L, -1);
-// lua_pop(L, 1);
+ lua_pop(L, 1);
}
/* Gather our frames per second */
diff --git a/src/map.c b/src/map.c
index f729136dffc9bf91a622b0d488935bff75c81a5d..d9eb6e724b80b2c83ed3e8e1a4e4d17fe9f91b2e 100644
--- a/src/map.c
+++ b/src/map.c
@@ -1128,5 +1128,6 @@ int luaopen_map(lua_State *L)
auxiliar_newclass(L, "core{map}", map_reg);
auxiliar_newclass(L, "core{mapobj}", map_object_reg);
luaL_openlib(L, "core.map", maplib, 0);
+ lua_pop(L, 1);
return 1;
}
diff --git a/src/music.c b/src/music.c
index 9b504890fb91884f1104109d563741fd7052c922..cc33c88369d9e023bf7fdef37bbf2b7790192e96 100644
--- a/src/music.c
+++ b/src/music.c
@@ -228,5 +228,6 @@ int luaopen_sound(lua_State *L)
auxiliar_newclass(L, "core{music}", music_reg);
auxiliar_newclass(L, "core{sound}", sound_reg);
luaL_openlib(L, "core.sound", soundlib, 0);
+ lua_pop(L, 1);
return 1;
}
diff --git a/src/noise.c b/src/noise.c
index 626240ec2807d01870e2b37fb1cf2cb9b48eac04..c2c7c039086011331d0d37ce415fe10d367de3ab 100644
--- a/src/noise.c
+++ b/src/noise.c
@@ -392,5 +392,6 @@ int luaopen_noise(lua_State *L)
{
auxiliar_newclass(L, "noise{core}", noise_reg);
luaL_openlib(L, "core.noise", noiselib, 0);
+ lua_pop(L, 1);
return 1;
}
diff --git a/src/particles.c b/src/particles.c
index a4963865e17f325ddc4ee2c0e91295c156f371e6..62a233c2b37ffb4213751a35f25f253b169fc77b 100644
--- a/src/particles.c
+++ b/src/particles.c
@@ -263,6 +263,7 @@ static int particles_emit(lua_State *L)
getparticulefield(L, "av", &(p->av));
getparticulefield(L, "aa", &(p->aa));
}
+ lua_pop(L, 1);
}
p->ox = p->x;
p->oy = p->y;
@@ -385,8 +386,6 @@ static int particles_update(lua_State *L)
int i, j;
bool alive = FALSE;
- glBindTexture(GL_TEXTURE_2D, ps->texture);
-
for (w = 0; w < ps->nb; w++)
{
particle_type *p = &ps->particles[w];
@@ -456,5 +455,6 @@ int luaopen_particles(lua_State *L)
lua_pushstring(L, "ETERNAL");
lua_pushnumber(L, PARTICLE_ETERNAL);
lua_settable(L, -3);
+ lua_pop(L, 1);
return 1;
}
diff --git a/src/particles_gas.c b/src/particles_gas.c
index c010bf7cb9ec46cc6275471bb4e69a1151efd73f..0480195bfd618b4d92b885615c8c713cc91ad7a5 100644
--- a/src/particles_gas.c
+++ b/src/particles_gas.c
@@ -450,5 +450,6 @@ int luaopen_gas(lua_State *L)
{
auxiliar_newclass(L, "core{gas}", gas_reg);
luaL_openlib(L, "core.gas", gaslib, 0);
+ lua_pop(L, 1);
return 1;
}
diff --git a/src/serial.c b/src/serial.c
index b7fef6435390e97db219f69f12f3a6422aff90b6..1820442ead92dd141007fd601b0371374fdb3274 100644
--- a/src/serial.c
+++ b/src/serial.c
@@ -433,5 +433,6 @@ int luaopen_serial(lua_State *L)
{
auxiliar_newclass(L, "core{serial}", serial_reg);
luaL_openlib(L, "core.serial", seriallib, 0);
+ lua_pop(L, 1);
return 1;
}
diff --git a/src/shaders.c b/src/shaders.c
index a3ca09a6ce20b47bc9e191a29d06c7d86d20dec0..dbd1004d7ef4f8f824b5e94299fa9affc69fadcc 100644
--- a/src/shaders.c
+++ b/src/shaders.c
@@ -306,5 +306,6 @@ int luaopen_shaders(lua_State *L)
auxiliar_newclass(L, "gl{program}", program_reg);
luaL_openlib(L, "core.shader", shaderlib, 0);
+ lua_pop(L, 1);
return 1;
}
diff --git a/src/struct.c b/src/struct.c
index cb4150a09c38f972a61a184384504aae6712fc23..4973e297a8edd1c82d1379666336da15a59e3f50 100644
--- a/src/struct.c
+++ b/src/struct.c
@@ -324,6 +324,7 @@ static const struct luaL_reg thislib[] = {
LUALIB_API int luaopen_struct (lua_State *L) {
luaL_register(L, "struct", thislib);
+ lua_pop(L, 1);
return 1;
}