32 files changed, 534 insertions, 729 deletions

diff --git a/source/Authenticator.cpp b/source/Authenticator.cpp
index a45617f93..e09fd0871 100644
--- a/source/Authenticator.cpp
+++ b/source/Authenticator.cpp
@@ -28,7 +28,6 @@ cAuthenticator::cAuthenticator(void) :
 	m_Address(DEFAULT_AUTH_ADDRESS),
 	m_ShouldAuthenticate(true)
 {
-	ReadINI();
 }
 
 
@@ -45,14 +44,8 @@ cAuthenticator::~cAuthenticator()
 
 
 /// Read custom values from INI
-void cAuthenticator::ReadINI(void)
+void cAuthenticator::ReadINI(cIniFile & IniFile)
 {
-	cIniFile IniFile("settings.ini");
-	if (!IniFile.ReadFile())
-	{
-		return;
-	}
-	
 	m_Server  = IniFile.GetValue("Authentication", "Server");
 	m_Address = IniFile.GetValue("Authentication", "Address");
 	m_ShouldAuthenticate = IniFile.GetValueB("Authentication", "Authenticate", true);
@@ -74,7 +67,6 @@ void cAuthenticator::ReadINI(void)
 	if (bSave)
 	{
 		IniFile.SetValueB("Authentication", "Authenticate", m_ShouldAuthenticate);
-		IniFile.WriteFile();
 	}
 }
 
@@ -100,8 +92,9 @@ void cAuthenticator::Authenticate(int a_ClientID, const AString & a_UserName, co
 
 
 
-void cAuthenticator::Start(void)
+void cAuthenticator::Start(cIniFile & IniFile)
 {
+	ReadINI(IniFile);
 	m_ShouldTerminate = false;
 	super::Start();
 }
diff --git a/source/Authenticator.h b/source/Authenticator.h
index 868476d80..02cd6f4c5 100644
--- a/source/Authenticator.h
+++ b/source/Authenticator.h
@@ -37,13 +37,13 @@ public:
 	~cAuthenticator();
 
 	/// (Re-)read server and address from INI:
-	void ReadINI(void);
+	void ReadINI(cIniFile & IniFile);
 
 	/// Queues a request for authenticating a user. If the auth fails, the user is kicked
 	void Authenticate(int a_ClientID, const AString & a_UserName, const AString & a_ServerHash);
 
 	/// Starts the authenticator thread. The thread may be started and stopped repeatedly
-	void Start(void);
+	void Start(cIniFile & IniFile);
 	
 	/// Stops the authenticator thread. The thread may be started and stopped repeatedly
 	void Stop(void);
diff --git a/source/Bindings.cpp b/source/Bindings.cpp
index 54a3e161b..8259eda81 100644
--- a/source/Bindings.cpp
+++ b/source/Bindings.cpp
@@ -1,6 +1,6 @@
 /*
 ** Lua binding: AllToLua
-** Generated automatically by tolua++-1.0.92 on 10/23/13 13:30:23.
+** Generated automatically by tolua++-1.0.92 on 10/28/13 13:11:03.
 */
 
 #ifndef __cplusplus
@@ -230,7 +230,7 @@ static void tolua_reg_types (lua_State* tolua_S)
  tolua_usertype(tolua_S,"cRoot");
  tolua_usertype(tolua_S,"std::vector<cIniFile::key>");
  tolua_usertype(tolua_S,"cPickup");
- tolua_usertype(tolua_S,"cItems");
+ tolua_usertype(tolua_S,"sWebAdminPage");
  tolua_usertype(tolua_S,"cFireChargeEntity");
  tolua_usertype(tolua_S,"cWorld");
  tolua_usertype(tolua_S,"cChunkDesc");
@@ -253,39 +253,39 @@ static void tolua_reg_types (lua_State* tolua_S)
  tolua_usertype(tolua_S,"cLuaWindow");
  tolua_usertype(tolua_S,"cInventory");
  tolua_usertype(tolua_S,"cHopperEntity");
+ tolua_usertype(tolua_S,"std::vector<AString>");
  tolua_usertype(tolua_S,"cBlockEntityWithItems");
  tolua_usertype(tolua_S,"cWindow");
- tolua_usertype(tolua_S,"cGroup");
  tolua_usertype(tolua_S,"HTTPFormData");
- tolua_usertype(tolua_S,"cCraftingGrid");
+ tolua_usertype(tolua_S,"cGroup");
  tolua_usertype(tolua_S,"cArrowEntity");
  tolua_usertype(tolua_S,"cDropSpenserEntity");
+ tolua_usertype(tolua_S,"cCraftingGrid");
+ tolua_usertype(tolua_S,"cPlayer");
  tolua_usertype(tolua_S,"cBlockArea");
  tolua_usertype(tolua_S,"cTracer");
  tolua_usertype(tolua_S,"cStringMap");
- tolua_usertype(tolua_S,"cBoundingBox");
- tolua_usertype(tolua_S,"cServer");
  tolua_usertype(tolua_S,"cBlockEntity");
  tolua_usertype(tolua_S,"cCriticalSection");
  tolua_usertype(tolua_S,"HTTPTemplateRequest");
+ tolua_usertype(tolua_S,"cBoundingBox");
+ tolua_usertype(tolua_S,"cServer");
  tolua_usertype(tolua_S,"Vector3i");
  tolua_usertype(tolua_S,"cFile");
- tolua_usertype(tolua_S,"std::vector<std::string>");
+ tolua_usertype(tolua_S,"cItems");
  tolua_usertype(tolua_S,"cClientHandle");
+ tolua_usertype(tolua_S,"cIniFile");
  tolua_usertype(tolua_S,"cChatColor");
  tolua_usertype(tolua_S,"cWebPlugin");
- tolua_usertype(tolua_S,"cIniFile");
- tolua_usertype(tolua_S,"cWebAdmin");
- tolua_usertype(tolua_S,"sWebAdminPage");
  tolua_usertype(tolua_S,"cPawn");
- tolua_usertype(tolua_S,"cPlayer");
+ tolua_usertype(tolua_S,"cThrownEggEntity");
  tolua_usertype(tolua_S,"cGroupManager");
+ tolua_usertype(tolua_S,"cWebAdmin");
  tolua_usertype(tolua_S,"cItem");
- tolua_usertype(tolua_S,"HTTPRequest");
  tolua_usertype(tolua_S,"cProjectileEntity");
+ tolua_usertype(tolua_S,"HTTPRequest");
  tolua_usertype(tolua_S,"cItemGrid::cListener");
  tolua_usertype(tolua_S,"cDropperEntity");
- tolua_usertype(tolua_S,"cThrownEggEntity");
 }
 
 /* method: new of class  cIniFile */
@@ -345,59 +345,6 @@ static int tolua_AllToLua_cIniFile_new00_local(lua_State* tolua_S)
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: new of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_new01
-static int tolua_AllToLua_cIniFile_new01(lua_State* tolua_S)
-{
- tolua_Error tolua_err;
- if (
-     !tolua_isusertable(tolua_S,1,"cIniFile",0,&tolua_err) ||
-     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,3,&tolua_err)
- )
-  goto tolua_lerror;
- else
- {
-  const std::string a_Path = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
-  {
-   cIniFile* tolua_ret = (cIniFile*)  Mtolua_new((cIniFile)(a_Path));
-    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cIniFile");
-   tolua_pushcppstring(tolua_S,(const char*)a_Path);
-  }
- }
- return 2;
-tolua_lerror:
- return tolua_AllToLua_cIniFile_new00(tolua_S);
-}
-#endif //#ifndef TOLUA_DISABLE
-
-/* method: new_local of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_new01_local
-static int tolua_AllToLua_cIniFile_new01_local(lua_State* tolua_S)
-{
- tolua_Error tolua_err;
- if (
-     !tolua_isusertable(tolua_S,1,"cIniFile",0,&tolua_err) ||
-     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,3,&tolua_err)
- )
-  goto tolua_lerror;
- else
- {
-  const std::string a_Path = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
-  {
-   cIniFile* tolua_ret = (cIniFile*)  Mtolua_new((cIniFile)(a_Path));
-    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cIniFile");
-    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
-   tolua_pushcppstring(tolua_S,(const char*)a_Path);
-  }
- }
- return 2;
-tolua_lerror:
- return tolua_AllToLua_cIniFile_new00_local(tolua_S);
-}
-#endif //#ifndef TOLUA_DISABLE
-
 /* method: CaseSensitive of class  cIniFile */
 #ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_CaseSensitive00
 static int tolua_AllToLua_cIniFile_CaseSensitive00(lua_State* tolua_S)
@@ -460,101 +407,6 @@ static int tolua_AllToLua_cIniFile_CaseInsensitive00(lua_State* tolua_S)
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: Path of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_Path00
-static int tolua_AllToLua_cIniFile_Path00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
-     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,3,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string newPath = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
-#ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Path'", NULL);
-#endif
-  {
-   self->Path(newPath);
-   tolua_pushcppstring(tolua_S,(const char*)newPath);
-  }
- }
- return 1;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'Path'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-
-/* method: Path of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_Path01
-static int tolua_AllToLua_cIniFile_Path01(lua_State* tolua_S)
-{
- tolua_Error tolua_err;
- if (
-     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
- {
-  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
-#ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Path'", NULL);
-#endif
-  {
-   const std::string tolua_ret = (const std::string)  self->Path();
-   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
-  }
- }
- return 1;
-tolua_lerror:
- return tolua_AllToLua_cIniFile_Path00(tolua_S);
-}
-#endif //#ifndef TOLUA_DISABLE
-
-/* method: SetPath of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_SetPath00
-static int tolua_AllToLua_cIniFile_SetPath00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
-     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,3,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string newPath = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
-#ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPath'", NULL);
-#endif
-  {
-   self->SetPath(newPath);
-   tolua_pushcppstring(tolua_S,(const char*)newPath);
-  }
- }
- return 1;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'SetPath'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-
 /* method: ReadFile of class  cIniFile */
 #ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_ReadFile00
 static int tolua_AllToLua_cIniFile_ReadFile00(lua_State* tolua_S)
@@ -563,24 +415,27 @@ static int tolua_AllToLua_cIniFile_ReadFile00(lua_State* tolua_S)
  tolua_Error tolua_err;
  if (
      !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
-     !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,3,&tolua_err)
+     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+     !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
+     !tolua_isnoobj(tolua_S,4,&tolua_err)
  )
   goto tolua_lerror;
  else
 #endif
  {
   cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  bool a_AllowExampleRedirect = ((bool)  tolua_toboolean(tolua_S,2,true));
+  const AString a_FileName = ((const AString)  tolua_tocppstring(tolua_S,2,0));
+  bool a_AllowExampleRedirect = ((bool)  tolua_toboolean(tolua_S,3,true));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ReadFile'", NULL);
 #endif
   {
-   bool tolua_ret = (bool)  self->ReadFile(a_AllowExampleRedirect);
+   bool tolua_ret = (bool)  self->ReadFile(a_FileName,a_AllowExampleRedirect);
    tolua_pushboolean(tolua_S,(bool)tolua_ret);
+   tolua_pushcppstring(tolua_S,(const char*)a_FileName);
   }
  }
- return 1;
+ return 2;
 #ifndef TOLUA_RELEASE
  tolua_lerror:
  tolua_error(tolua_S,"#ferror in function 'ReadFile'.",&tolua_err);
@@ -597,22 +452,25 @@ static int tolua_AllToLua_cIniFile_WriteFile00(lua_State* tolua_S)
  tolua_Error tolua_err;
  if (
      !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
+     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+     !tolua_isnoobj(tolua_S,3,&tolua_err)
  )
   goto tolua_lerror;
  else
 #endif
  {
   const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
+  const AString a_FileName = ((const AString)  tolua_tocppstring(tolua_S,2,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'WriteFile'", NULL);
 #endif
   {
-   bool tolua_ret = (bool)  self->WriteFile();
+   bool tolua_ret = (bool)  self->WriteFile(a_FileName);
    tolua_pushboolean(tolua_S,(bool)tolua_ret);
+   tolua_pushcppstring(tolua_S,(const char*)a_FileName);
   }
  }
- return 1;
+ return 2;
 #ifndef TOLUA_RELEASE
  tolua_lerror:
  tolua_error(tolua_S,"#ferror in function 'WriteFile'.",&tolua_err);
@@ -652,68 +510,6 @@ static int tolua_AllToLua_cIniFile_Clear00(lua_State* tolua_S)
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: Reset of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_Reset00
-static int tolua_AllToLua_cIniFile_Reset00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-#ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Reset'", NULL);
-#endif
-  {
-   self->Reset();
-  }
- }
- return 0;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'Reset'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-
-/* method: Erase of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_Erase00
-static int tolua_AllToLua_cIniFile_Erase00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-#ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Erase'", NULL);
-#endif
-  {
-   self->Erase();
-  }
- }
- return 0;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'Erase'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-
 /* method: FindKey of class  cIniFile */
 #ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_FindKey00
 static int tolua_AllToLua_cIniFile_FindKey00(lua_State* tolua_S)
@@ -730,12 +526,12 @@ static int tolua_AllToLua_cIniFile_FindKey00(lua_State* tolua_S)
 #endif
  {
   const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string keyname = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
+  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'FindKey'", NULL);
 #endif
   {
-   long tolua_ret = (long)  self->FindKey(keyname);
+   int tolua_ret = (int)  self->FindKey(keyname);
    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
    tolua_pushcppstring(tolua_S,(const char*)keyname);
   }
@@ -766,13 +562,13 @@ static int tolua_AllToLua_cIniFile_FindValue00(lua_State* tolua_S)
 #endif
  {
   const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const unsigned keyID = ((const unsigned)  tolua_tonumber(tolua_S,2,0));
-  const std::string valuename = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
+  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
+  const AString valuename = ((const AString)  tolua_tocppstring(tolua_S,3,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'FindValue'", NULL);
 #endif
   {
-   long tolua_ret = (long)  self->FindValue(keyID,valuename);
+   int tolua_ret = (int)  self->FindValue(keyID,valuename);
    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
    tolua_pushcppstring(tolua_S,(const char*)valuename);
   }
@@ -786,38 +582,6 @@ static int tolua_AllToLua_cIniFile_FindValue00(lua_State* tolua_S)
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: NumKeys of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_NumKeys00
-static int tolua_AllToLua_cIniFile_NumKeys00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,2,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
-#ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NumKeys'", NULL);
-#endif
-  {
-   unsigned tolua_ret = (unsigned)  self->NumKeys();
-   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
-  }
- }
- return 1;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'NumKeys'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-
 /* method: GetNumKeys of class  cIniFile */
 #ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetNumKeys00
 static int tolua_AllToLua_cIniFile_GetNumKeys00(lua_State* tolua_S)
@@ -837,7 +601,7 @@ static int tolua_AllToLua_cIniFile_GetNumKeys00(lua_State* tolua_S)
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumKeys'", NULL);
 #endif
   {
-   unsigned tolua_ret = (unsigned)  self->GetNumKeys();
+   int tolua_ret = (int)  self->GetNumKeys();
    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
   }
  }
@@ -866,12 +630,12 @@ static int tolua_AllToLua_cIniFile_AddKeyName00(lua_State* tolua_S)
 #endif
  {
   cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string keyname = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
+  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddKeyName'", NULL);
 #endif
   {
-   unsigned tolua_ret = (unsigned)  self->AddKeyName(keyname);
+   int tolua_ret = (int)  self->AddKeyName(keyname);
    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
    tolua_pushcppstring(tolua_S,(const char*)keyname);
   }
@@ -885,40 +649,6 @@ static int tolua_AllToLua_cIniFile_AddKeyName00(lua_State* tolua_S)
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: KeyName of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_KeyName00
-static int tolua_AllToLua_cIniFile_KeyName00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
-     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,3,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const unsigned keyID = ((const unsigned)  tolua_tonumber(tolua_S,2,0));
-#ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'KeyName'", NULL);
-#endif
-  {
-   std::string tolua_ret = (std::string)  self->KeyName(keyID);
-   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
-  }
- }
- return 1;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'KeyName'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-
 /* method: GetKeyName of class  cIniFile */
 #ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetKeyName00
 static int tolua_AllToLua_cIniFile_GetKeyName00(lua_State* tolua_S)
@@ -935,12 +665,12 @@ static int tolua_AllToLua_cIniFile_GetKeyName00(lua_State* tolua_S)
 #endif
  {
   const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const unsigned keyID = ((const unsigned)  tolua_tonumber(tolua_S,2,0));
+  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetKeyName'", NULL);
 #endif
   {
-   std::string tolua_ret = (std::string)  self->GetKeyName(keyID);
+   AString tolua_ret = (AString)  self->GetKeyName(keyID);
    tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
   }
  }
@@ -953,41 +683,6 @@ static int tolua_AllToLua_cIniFile_GetKeyName00(lua_State* tolua_S)
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: NumValues of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_NumValues00
-static int tolua_AllToLua_cIniFile_NumValues00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
-     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,3,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string keyname = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
-#ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NumValues'", NULL);
-#endif
-  {
-   unsigned tolua_ret = (unsigned)  self->NumValues(keyname);
-   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
-   tolua_pushcppstring(tolua_S,(const char*)keyname);
-  }
- }
- return 2;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'NumValues'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-
 /* method: GetNumValues of class  cIniFile */
 #ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetNumValues00
 static int tolua_AllToLua_cIniFile_GetNumValues00(lua_State* tolua_S)
@@ -995,7 +690,7 @@ static int tolua_AllToLua_cIniFile_GetNumValues00(lua_State* tolua_S)
 #ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (
-     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
      !tolua_isnoobj(tolua_S,3,&tolua_err)
  )
@@ -1003,13 +698,13 @@ static int tolua_AllToLua_cIniFile_GetNumValues00(lua_State* tolua_S)
  else
 #endif
  {
-  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string keyname = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
+  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
+  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumValues'", NULL);
 #endif
   {
-   unsigned tolua_ret = (unsigned)  self->GetNumValues(keyname);
+   int tolua_ret = (int)  self->GetNumValues(keyname);
    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
    tolua_pushcppstring(tolua_S,(const char*)keyname);
   }
@@ -1023,55 +718,26 @@ static int tolua_AllToLua_cIniFile_GetNumValues00(lua_State* tolua_S)
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: NumValues of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_NumValues01
-static int tolua_AllToLua_cIniFile_NumValues01(lua_State* tolua_S)
-{
- tolua_Error tolua_err;
- if (
-     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
-     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,3,&tolua_err)
- )
-  goto tolua_lerror;
- else
- {
-  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const unsigned keyID = ((const unsigned)  tolua_tonumber(tolua_S,2,0));
-#ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NumValues'", NULL);
-#endif
-  {
-   unsigned tolua_ret = (unsigned)  self->NumValues(keyID);
-   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
-  }
- }
- return 1;
-tolua_lerror:
- return tolua_AllToLua_cIniFile_NumValues00(tolua_S);
-}
-#endif //#ifndef TOLUA_DISABLE
-
 /* method: GetNumValues of class  cIniFile */
 #ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetNumValues01
 static int tolua_AllToLua_cIniFile_GetNumValues01(lua_State* tolua_S)
 {
  tolua_Error tolua_err;
  if (
-     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
      !tolua_isnoobj(tolua_S,3,&tolua_err)
  )
   goto tolua_lerror;
  else
  {
-  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const unsigned keyID = ((const unsigned)  tolua_tonumber(tolua_S,2,0));
+  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
+  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumValues'", NULL);
 #endif
   {
-   unsigned tolua_ret = (unsigned)  self->GetNumValues(keyID);
+   int tolua_ret = (int)  self->GetNumValues(keyID);
    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
   }
  }
@@ -1081,43 +747,6 @@ tolua_lerror:
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: ValueName of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_ValueName00
-static int tolua_AllToLua_cIniFile_ValueName00(lua_State* tolua_S)
-{
-#ifndef TOLUA_RELEASE
- tolua_Error tolua_err;
- if (
-     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
-     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
-     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,4,&tolua_err)
- )
-  goto tolua_lerror;
- else
-#endif
- {
-  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string keyname = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
-  const unsigned valueID = ((const unsigned)  tolua_tonumber(tolua_S,3,0));
-#ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ValueName'", NULL);
-#endif
-  {
-   std::string tolua_ret = (std::string)  self->ValueName(keyname,valueID);
-   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
-   tolua_pushcppstring(tolua_S,(const char*)keyname);
-  }
- }
- return 2;
-#ifndef TOLUA_RELEASE
- tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'ValueName'.",&tolua_err);
- return 0;
-#endif
-}
-#endif //#ifndef TOLUA_DISABLE
-
 /* method: GetValueName of class  cIniFile */
 #ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValueName00
 static int tolua_AllToLua_cIniFile_GetValueName00(lua_State* tolua_S)
@@ -1135,13 +764,13 @@ static int tolua_AllToLua_cIniFile_GetValueName00(lua_State* tolua_S)
 #endif
  {
   const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string keyname = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
-  const unsigned valueID = ((const unsigned)  tolua_tonumber(tolua_S,3,0));
+  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,0));
+  const int valueID = ((const int)  tolua_tonumber(tolua_S,3,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValueName'", NULL);
 #endif
   {
-   std::string tolua_ret = (std::string)  self->GetValueName(keyname,valueID);
+   AString tolua_ret = (AString)  self->GetValueName(keyname,valueID);
    tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
    tolua_pushcppstring(tolua_S,(const char*)keyname);
   }
@@ -1155,37 +784,6 @@ static int tolua_AllToLua_cIniFile_GetValueName00(lua_State* tolua_S)
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: ValueName of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_ValueName01
-static int tolua_AllToLua_cIniFile_ValueName01(lua_State* tolua_S)
-{
- tolua_Error tolua_err;
- if (
-     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
-     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
-     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,4,&tolua_err)
- )
-  goto tolua_lerror;
- else
- {
-  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const unsigned keyID = ((const unsigned)  tolua_tonumber(tolua_S,2,0));
-  const unsigned valueID = ((const unsigned)  tolua_tonumber(tolua_S,3,0));
-#ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ValueName'", NULL);
-#endif
-  {
-   std::string tolua_ret = (std::string)  self->ValueName(keyID,valueID);
-   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
-  }
- }
- return 1;
-tolua_lerror:
- return tolua_AllToLua_cIniFile_ValueName00(tolua_S);
-}
-#endif //#ifndef TOLUA_DISABLE
-
 /* method: GetValueName of class  cIniFile */
 #ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValueName01
 static int tolua_AllToLua_cIniFile_GetValueName01(lua_State* tolua_S)
@@ -1201,13 +799,13 @@ static int tolua_AllToLua_cIniFile_GetValueName01(lua_State* tolua_S)
  else
  {
   const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const unsigned keyID = ((const unsigned)  tolua_tonumber(tolua_S,2,0));
-  const unsigned valueID = ((const unsigned)  tolua_tonumber(tolua_S,3,0));
+  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
+  const int valueID = ((const int)  tolua_tonumber(tolua_S,3,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValueName'", NULL);
 #endif
   {
-   std::string tolua_ret = (std::string)  self->GetValueName(keyID,valueID);
+   AString tolua_ret = (AString)  self->GetValueName(keyID,valueID);
    tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
   }
  }
@@ -1306,8 +904,8 @@ static int tolua_AllToLua_cIniFile_GetValue02(lua_State* tolua_S)
  else
  {
   const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const unsigned keyID = ((const unsigned)  tolua_tonumber(tolua_S,2,0));
-  const unsigned valueID = ((const unsigned)  tolua_tonumber(tolua_S,3,0));
+  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
+  const int valueID = ((const int)  tolua_tonumber(tolua_S,3,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValue'", NULL);
 #endif
@@ -1338,8 +936,8 @@ static int tolua_AllToLua_cIniFile_GetValue03(lua_State* tolua_S)
  else
  {
   const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const unsigned keyID = ((const unsigned)  tolua_tonumber(tolua_S,2,0));
-  const unsigned valueID = ((const unsigned)  tolua_tonumber(tolua_S,3,0));
+  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
+  const int valueID = ((const int)  tolua_tonumber(tolua_S,3,0));
   const AString defValue = ((const AString)  tolua_tocppstring(tolua_S,4,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValue'", NULL);
@@ -1688,9 +1286,9 @@ static int tolua_AllToLua_cIniFile_SetValue00(lua_State* tolua_S)
 #endif
  {
   cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const unsigned keyID = ((const unsigned)  tolua_tonumber(tolua_S,2,0));
-  const unsigned valueID = ((const unsigned)  tolua_tonumber(tolua_S,3,0));
-  const std::string value = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
+  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
+  const int valueID = ((const int)  tolua_tonumber(tolua_S,3,0));
+  const AString value = ((const AString)  tolua_tocppstring(tolua_S,4,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetValue'", NULL);
 #endif
@@ -1726,9 +1324,9 @@ static int tolua_AllToLua_cIniFile_SetValue01(lua_State* tolua_S)
  else
  {
   cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string keyname = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
-  const std::string valuename = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
-  const std::string value = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
+  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,0));
+  const AString valuename = ((const AString)  tolua_tocppstring(tolua_S,3,0));
+  const AString value = ((const AString)  tolua_tocppstring(tolua_S,4,0));
   const bool create = ((const bool)  tolua_toboolean(tolua_S,5,true));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetValue'", NULL);
@@ -1766,8 +1364,8 @@ static int tolua_AllToLua_cIniFile_SetValueI00(lua_State* tolua_S)
 #endif
  {
   cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string keyname = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
-  const std::string valuename = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
+  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,0));
+  const AString valuename = ((const AString)  tolua_tocppstring(tolua_S,3,0));
   const int value = ((const int)  tolua_tonumber(tolua_S,4,0));
   const bool create = ((const bool)  tolua_toboolean(tolua_S,5,true));
 #ifndef TOLUA_RELEASE
@@ -1808,8 +1406,8 @@ static int tolua_AllToLua_cIniFile_SetValueB00(lua_State* tolua_S)
 #endif
  {
   cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string keyname = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
-  const std::string valuename = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
+  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,0));
+  const AString valuename = ((const AString)  tolua_tocppstring(tolua_S,3,0));
   const bool value = ((const bool)  tolua_toboolean(tolua_S,4,0));
   const bool create = ((const bool)  tolua_toboolean(tolua_S,5,true));
 #ifndef TOLUA_RELEASE
@@ -1850,8 +1448,8 @@ static int tolua_AllToLua_cIniFile_SetValueF00(lua_State* tolua_S)
 #endif
  {
   cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string keyname = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
-  const std::string valuename = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
+  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,0));
+  const AString valuename = ((const AString)  tolua_tocppstring(tolua_S,3,0));
   const double value = ((const double)  tolua_tonumber(tolua_S,4,0));
   const bool create = ((const bool)  tolua_toboolean(tolua_S,5,true));
 #ifndef TOLUA_RELEASE
@@ -1890,8 +1488,8 @@ static int tolua_AllToLua_cIniFile_DeleteValueByID00(lua_State* tolua_S)
 #endif
  {
   cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const unsigned keyID = ((const unsigned)  tolua_tonumber(tolua_S,2,0));
-  const unsigned valueID = ((const unsigned)  tolua_tonumber(tolua_S,3,0));
+  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
+  const int valueID = ((const int)  tolua_tonumber(tolua_S,3,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteValueByID'", NULL);
 #endif
@@ -1926,8 +1524,8 @@ static int tolua_AllToLua_cIniFile_DeleteValue00(lua_State* tolua_S)
 #endif
  {
   cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string keyname = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
-  const std::string valuename = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
+  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,0));
+  const AString valuename = ((const AString)  tolua_tocppstring(tolua_S,3,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteValue'", NULL);
 #endif
@@ -1963,7 +1561,7 @@ static int tolua_AllToLua_cIniFile_DeleteKey00(lua_State* tolua_S)
 #endif
  {
   cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string keyname = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
+  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteKey'", NULL);
 #endif
@@ -1982,9 +1580,9 @@ static int tolua_AllToLua_cIniFile_DeleteKey00(lua_State* tolua_S)
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: NumHeaderComments of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_NumHeaderComments00
-static int tolua_AllToLua_cIniFile_NumHeaderComments00(lua_State* tolua_S)
+/* method: GetNumHeaderComments of class  cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetNumHeaderComments00
+static int tolua_AllToLua_cIniFile_GetNumHeaderComments00(lua_State* tolua_S)
 {
 #ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
@@ -1998,25 +1596,25 @@ static int tolua_AllToLua_cIniFile_NumHeaderComments00(lua_State* tolua_S)
  {
   cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
 #ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NumHeaderComments'", NULL);
+  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumHeaderComments'", NULL);
 #endif
   {
-   unsigned tolua_ret = (unsigned)  self->NumHeaderComments();
+   int tolua_ret = (int)  self->GetNumHeaderComments();
    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
   }
  }
  return 1;
 #ifndef TOLUA_RELEASE
  tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'NumHeaderComments'.",&tolua_err);
+ tolua_error(tolua_S,"#ferror in function 'GetNumHeaderComments'.",&tolua_err);
  return 0;
 #endif
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: HeaderComment of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_HeaderComment00
-static int tolua_AllToLua_cIniFile_HeaderComment00(lua_State* tolua_S)
+/* method: AddHeaderComment of class  cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_AddHeaderComment00
+static int tolua_AllToLua_cIniFile_AddHeaderComment00(lua_State* tolua_S)
 {
 #ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
@@ -2030,28 +1628,29 @@ static int tolua_AllToLua_cIniFile_HeaderComment00(lua_State* tolua_S)
 #endif
  {
   cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string comment = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
+  const AString comment = ((const AString)  tolua_tocppstring(tolua_S,2,0));
 #ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HeaderComment'", NULL);
+  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddHeaderComment'", NULL);
 #endif
   {
-   self->HeaderComment(comment);
+   self->AddHeaderComment(comment);
    tolua_pushcppstring(tolua_S,(const char*)comment);
   }
  }
  return 1;
 #ifndef TOLUA_RELEASE
  tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'HeaderComment'.",&tolua_err);
+ tolua_error(tolua_S,"#ferror in function 'AddHeaderComment'.",&tolua_err);
  return 0;
 #endif
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: HeaderComment of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_HeaderComment01
-static int tolua_AllToLua_cIniFile_HeaderComment01(lua_State* tolua_S)
+/* method: GetHeaderComment of class  cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetHeaderComment00
+static int tolua_AllToLua_cIniFile_GetHeaderComment00(lua_State* tolua_S)
 {
+#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (
      !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
@@ -2060,20 +1659,24 @@ static int tolua_AllToLua_cIniFile_HeaderComment01(lua_State* tolua_S)
  )
   goto tolua_lerror;
  else
+#endif
  {
   const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const unsigned commentID = ((const unsigned)  tolua_tonumber(tolua_S,2,0));
+  const int commentID = ((const int)  tolua_tonumber(tolua_S,2,0));
 #ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HeaderComment'", NULL);
+  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetHeaderComment'", NULL);
 #endif
   {
-   std::string tolua_ret = (std::string)  self->HeaderComment(commentID);
+   AString tolua_ret = (AString)  self->GetHeaderComment(commentID);
    tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
   }
  }
  return 1;
-tolua_lerror:
- return tolua_AllToLua_cIniFile_HeaderComment00(tolua_S);
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetHeaderComment'.",&tolua_err);
+ return 0;
+#endif
 }
 #endif //#ifndef TOLUA_DISABLE
 
@@ -2093,7 +1696,7 @@ static int tolua_AllToLua_cIniFile_DeleteHeaderComment00(lua_State* tolua_S)
 #endif
  {
   cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  unsigned commentID = ((unsigned)  tolua_tonumber(tolua_S,2,0));
+  int commentID = ((int)  tolua_tonumber(tolua_S,2,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteHeaderComment'", NULL);
 #endif
@@ -2142,9 +1745,9 @@ static int tolua_AllToLua_cIniFile_DeleteHeaderComments00(lua_State* tolua_S)
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: NumKeyComments of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_NumKeyComments00
-static int tolua_AllToLua_cIniFile_NumKeyComments00(lua_State* tolua_S)
+/* method: GetNumKeyComments of class  cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetNumKeyComments00
+static int tolua_AllToLua_cIniFile_GetNumKeyComments00(lua_State* tolua_S)
 {
 #ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
@@ -2158,27 +1761,27 @@ static int tolua_AllToLua_cIniFile_NumKeyComments00(lua_State* tolua_S)
 #endif
  {
   const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const unsigned keyID = ((const unsigned)  tolua_tonumber(tolua_S,2,0));
+  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
 #ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NumKeyComments'", NULL);
+  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumKeyComments'", NULL);
 #endif
   {
-   unsigned tolua_ret = (unsigned)  self->NumKeyComments(keyID);
+   int tolua_ret = (int)  self->GetNumKeyComments(keyID);
    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
   }
  }
  return 1;
 #ifndef TOLUA_RELEASE
  tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'NumKeyComments'.",&tolua_err);
+ tolua_error(tolua_S,"#ferror in function 'GetNumKeyComments'.",&tolua_err);
  return 0;
 #endif
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: NumKeyComments of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_NumKeyComments01
-static int tolua_AllToLua_cIniFile_NumKeyComments01(lua_State* tolua_S)
+/* method: GetNumKeyComments of class  cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetNumKeyComments01
+static int tolua_AllToLua_cIniFile_GetNumKeyComments01(lua_State* tolua_S)
 {
  tolua_Error tolua_err;
  if (
@@ -2190,25 +1793,25 @@ static int tolua_AllToLua_cIniFile_NumKeyComments01(lua_State* tolua_S)
  else
  {
   const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string keyname = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
+  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,0));
 #ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NumKeyComments'", NULL);
+  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumKeyComments'", NULL);
 #endif
   {
-   unsigned tolua_ret = (unsigned)  self->NumKeyComments(keyname);
+   int tolua_ret = (int)  self->GetNumKeyComments(keyname);
    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
    tolua_pushcppstring(tolua_S,(const char*)keyname);
   }
  }
  return 2;
 tolua_lerror:
- return tolua_AllToLua_cIniFile_NumKeyComments00(tolua_S);
+ return tolua_AllToLua_cIniFile_GetNumKeyComments00(tolua_S);
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: KeyComment of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_KeyComment00
-static int tolua_AllToLua_cIniFile_KeyComment00(lua_State* tolua_S)
+/* method: AddKeyComment of class  cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_AddKeyComment00
+static int tolua_AllToLua_cIniFile_AddKeyComment00(lua_State* tolua_S)
 {
 #ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
@@ -2223,13 +1826,13 @@ static int tolua_AllToLua_cIniFile_KeyComment00(lua_State* tolua_S)
 #endif
  {
   cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const unsigned keyID = ((const unsigned)  tolua_tonumber(tolua_S,2,0));
-  const std::string comment = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
+  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
+  const AString comment = ((const AString)  tolua_tocppstring(tolua_S,3,0));
 #ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'KeyComment'", NULL);
+  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddKeyComment'", NULL);
 #endif
   {
-   bool tolua_ret = (bool)  self->KeyComment(keyID,comment);
+   bool tolua_ret = (bool)  self->AddKeyComment(keyID,comment);
    tolua_pushboolean(tolua_S,(bool)tolua_ret);
    tolua_pushcppstring(tolua_S,(const char*)comment);
   }
@@ -2237,15 +1840,15 @@ static int tolua_AllToLua_cIniFile_KeyComment00(lua_State* tolua_S)
  return 2;
 #ifndef TOLUA_RELEASE
  tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'KeyComment'.",&tolua_err);
+ tolua_error(tolua_S,"#ferror in function 'AddKeyComment'.",&tolua_err);
  return 0;
 #endif
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: KeyComment of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_KeyComment01
-static int tolua_AllToLua_cIniFile_KeyComment01(lua_State* tolua_S)
+/* method: AddKeyComment of class  cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_AddKeyComment01
+static int tolua_AllToLua_cIniFile_AddKeyComment01(lua_State* tolua_S)
 {
  tolua_Error tolua_err;
  if (
@@ -2258,13 +1861,13 @@ static int tolua_AllToLua_cIniFile_KeyComment01(lua_State* tolua_S)
  else
  {
   cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string keyname = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
-  const std::string comment = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
+  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,0));
+  const AString comment = ((const AString)  tolua_tocppstring(tolua_S,3,0));
 #ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'KeyComment'", NULL);
+  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddKeyComment'", NULL);
 #endif
   {
-   bool tolua_ret = (bool)  self->KeyComment(keyname,comment);
+   bool tolua_ret = (bool)  self->AddKeyComment(keyname,comment);
    tolua_pushboolean(tolua_S,(bool)tolua_ret);
    tolua_pushcppstring(tolua_S,(const char*)keyname);
    tolua_pushcppstring(tolua_S,(const char*)comment);
@@ -2272,14 +1875,15 @@ static int tolua_AllToLua_cIniFile_KeyComment01(lua_State* tolua_S)
  }
  return 3;
 tolua_lerror:
- return tolua_AllToLua_cIniFile_KeyComment00(tolua_S);
+ return tolua_AllToLua_cIniFile_AddKeyComment00(tolua_S);
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: KeyComment of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_KeyComment02
-static int tolua_AllToLua_cIniFile_KeyComment02(lua_State* tolua_S)
+/* method: GetKeyComment of class  cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetKeyComment00
+static int tolua_AllToLua_cIniFile_GetKeyComment00(lua_State* tolua_S)
 {
+#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (
      !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
@@ -2289,27 +1893,31 @@ static int tolua_AllToLua_cIniFile_KeyComment02(lua_State* tolua_S)
  )
   goto tolua_lerror;
  else
+#endif
  {
   const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const unsigned keyID = ((const unsigned)  tolua_tonumber(tolua_S,2,0));
-  const unsigned commentID = ((const unsigned)  tolua_tonumber(tolua_S,3,0));
+  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
+  const int commentID = ((const int)  tolua_tonumber(tolua_S,3,0));
 #ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'KeyComment'", NULL);
+  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetKeyComment'", NULL);
 #endif
   {
-   std::string tolua_ret = (std::string)  self->KeyComment(keyID,commentID);
+   AString tolua_ret = (AString)  self->GetKeyComment(keyID,commentID);
    tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
   }
  }
  return 1;
-tolua_lerror:
- return tolua_AllToLua_cIniFile_KeyComment01(tolua_S);
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetKeyComment'.",&tolua_err);
+ return 0;
+#endif
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: KeyComment of class  cIniFile */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_KeyComment03
-static int tolua_AllToLua_cIniFile_KeyComment03(lua_State* tolua_S)
+/* method: GetKeyComment of class  cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetKeyComment01
+static int tolua_AllToLua_cIniFile_GetKeyComment01(lua_State* tolua_S)
 {
  tolua_Error tolua_err;
  if (
@@ -2322,20 +1930,20 @@ static int tolua_AllToLua_cIniFile_KeyComment03(lua_State* tolua_S)
  else
  {
   const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string keyname = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
-  const unsigned commentID = ((const unsigned)  tolua_tonumber(tolua_S,3,0));
+  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,0));
+  const int commentID = ((const int)  tolua_tonumber(tolua_S,3,0));
 #ifndef TOLUA_RELEASE
-  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'KeyComment'", NULL);
+  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetKeyComment'", NULL);
 #endif
   {
-   std::string tolua_ret = (std::string)  self->KeyComment(keyname,commentID);
+   AString tolua_ret = (AString)  self->GetKeyComment(keyname,commentID);
    tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
    tolua_pushcppstring(tolua_S,(const char*)keyname);
   }
  }
  return 2;
 tolua_lerror:
- return tolua_AllToLua_cIniFile_KeyComment02(tolua_S);
+ return tolua_AllToLua_cIniFile_GetKeyComment00(tolua_S);
 }
 #endif //#ifndef TOLUA_DISABLE
 
@@ -2356,8 +1964,8 @@ static int tolua_AllToLua_cIniFile_DeleteKeyComment00(lua_State* tolua_S)
 #endif
  {
   cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const unsigned keyID = ((const unsigned)  tolua_tonumber(tolua_S,2,0));
-  const unsigned commentID = ((const unsigned)  tolua_tonumber(tolua_S,3,0));
+  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
+  const int commentID = ((const int)  tolua_tonumber(tolua_S,3,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteKeyComment'", NULL);
 #endif
@@ -2390,8 +1998,8 @@ static int tolua_AllToLua_cIniFile_DeleteKeyComment01(lua_State* tolua_S)
  else
  {
   cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string keyname = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
-  const unsigned commentID = ((const unsigned)  tolua_tonumber(tolua_S,3,0));
+  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,0));
+  const int commentID = ((const int)  tolua_tonumber(tolua_S,3,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteKeyComment'", NULL);
 #endif
@@ -2423,7 +2031,7 @@ static int tolua_AllToLua_cIniFile_DeleteKeyComments00(lua_State* tolua_S)
 #endif
  {
   cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const unsigned keyID = ((const unsigned)  tolua_tonumber(tolua_S,2,0));
+  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteKeyComments'", NULL);
 #endif
@@ -2455,7 +2063,7 @@ static int tolua_AllToLua_cIniFile_DeleteKeyComments01(lua_State* tolua_S)
  else
  {
   cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,0);
-  const std::string keyname = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
+  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,0));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteKeyComments'", NULL);
 #endif
@@ -10073,24 +9681,26 @@ static int tolua_AllToLua_cPickup_new00(lua_State* tolua_S)
      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
      (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const cItem",0,&tolua_err)) ||
-     !tolua_isnumber(tolua_S,6,1,&tolua_err) ||
+     !tolua_isboolean(tolua_S,6,0,&tolua_err) ||
      !tolua_isnumber(tolua_S,7,1,&tolua_err) ||
      !tolua_isnumber(tolua_S,8,1,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,9,&tolua_err)
+     !tolua_isnumber(tolua_S,9,1,&tolua_err) ||
+     !tolua_isnoobj(tolua_S,10,&tolua_err)
  )
   goto tolua_lerror;
  else
 #endif
  {
-  double a_X = ((double)  tolua_tonumber(tolua_S,2,0));
-  double a_Y = ((double)  tolua_tonumber(tolua_S,3,0));
-  double a_Z = ((double)  tolua_tonumber(tolua_S,4,0));
+  double a_PosX = ((double)  tolua_tonumber(tolua_S,2,0));
+  double a_PosY = ((double)  tolua_tonumber(tolua_S,3,0));
+  double a_PosZ = ((double)  tolua_tonumber(tolua_S,4,0));
   const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,5,0));
-  float a_SpeedX = ((float)  tolua_tonumber(tolua_S,6,0.f));
-  float a_SpeedY = ((float)  tolua_tonumber(tolua_S,7,0.f));
-  float a_SpeedZ = ((float)  tolua_tonumber(tolua_S,8,0.f));
+  bool IsPlayerCreated = ((bool)  tolua_toboolean(tolua_S,6,0));
+  float a_SpeedX = ((float)  tolua_tonumber(tolua_S,7,0.f));
+  float a_SpeedY = ((float)  tolua_tonumber(tolua_S,8,0.f));
+  float a_SpeedZ = ((float)  tolua_tonumber(tolua_S,9,0.f));
   {
-   cPickup* tolua_ret = (cPickup*)  Mtolua_new((cPickup)(a_X,a_Y,a_Z,*a_Item,a_SpeedX,a_SpeedY,a_SpeedZ));
+   cPickup* tolua_ret = (cPickup*)  Mtolua_new((cPickup)(a_PosX,a_PosY,a_PosZ,*a_Item,IsPlayerCreated,a_SpeedX,a_SpeedY,a_SpeedZ));
     tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPickup");
   }
  }
@@ -10115,24 +9725,26 @@ static int tolua_AllToLua_cPickup_new00_local(lua_State* tolua_S)
      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
      (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const cItem",0,&tolua_err)) ||
-     !tolua_isnumber(tolua_S,6,1,&tolua_err) ||
+     !tolua_isboolean(tolua_S,6,0,&tolua_err) ||
      !tolua_isnumber(tolua_S,7,1,&tolua_err) ||
      !tolua_isnumber(tolua_S,8,1,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,9,&tolua_err)
+     !tolua_isnumber(tolua_S,9,1,&tolua_err) ||
+     !tolua_isnoobj(tolua_S,10,&tolua_err)
  )
   goto tolua_lerror;
  else
 #endif
  {
-  double a_X = ((double)  tolua_tonumber(tolua_S,2,0));
-  double a_Y = ((double)  tolua_tonumber(tolua_S,3,0));
-  double a_Z = ((double)  tolua_tonumber(tolua_S,4,0));
+  double a_PosX = ((double)  tolua_tonumber(tolua_S,2,0));
+  double a_PosY = ((double)  tolua_tonumber(tolua_S,3,0));
+  double a_PosZ = ((double)  tolua_tonumber(tolua_S,4,0));
   const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,5,0));
-  float a_SpeedX = ((float)  tolua_tonumber(tolua_S,6,0.f));
-  float a_SpeedY = ((float)  tolua_tonumber(tolua_S,7,0.f));
-  float a_SpeedZ = ((float)  tolua_tonumber(tolua_S,8,0.f));
+  bool IsPlayerCreated = ((bool)  tolua_toboolean(tolua_S,6,0));
+  float a_SpeedX = ((float)  tolua_tonumber(tolua_S,7,0.f));
+  float a_SpeedY = ((float)  tolua_tonumber(tolua_S,8,0.f));
+  float a_SpeedZ = ((float)  tolua_tonumber(tolua_S,9,0.f));
   {
-   cPickup* tolua_ret = (cPickup*)  Mtolua_new((cPickup)(a_X,a_Y,a_Z,*a_Item,a_SpeedX,a_SpeedY,a_SpeedZ));
+   cPickup* tolua_ret = (cPickup*)  Mtolua_new((cPickup)(a_PosX,a_PosY,a_PosZ,*a_Item,IsPlayerCreated,a_SpeedX,a_SpeedY,a_SpeedZ));
     tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPickup");
     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
   }
@@ -10276,6 +9888,38 @@ static int tolua_AllToLua_cPickup_IsCollected00(lua_State* tolua_S)
 }
 #endif //#ifndef TOLUA_DISABLE
 
+/* method: IsPlayerCreated of class  cPickup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_IsPlayerCreated00
+static int tolua_AllToLua_cPickup_IsPlayerCreated00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+     !tolua_isusertype(tolua_S,1,"const cPickup",0,&tolua_err) ||
+     !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+  goto tolua_lerror;
+ else
+#endif
+ {
+  const cPickup* self = (const cPickup*)  tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsPlayerCreated'", NULL);
+#endif
+  {
+   bool tolua_ret = (bool)  self->IsPlayerCreated();
+   tolua_pushboolean(tolua_S,(bool)tolua_ret);
+  }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'IsPlayerCreated'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
 /* method: GetProjectileKind of class  cProjectileEntity */
 #ifndef TOLUA_DISABLE_tolua_AllToLua_cProjectileEntity_GetProjectileKind00
 static int tolua_AllToLua_cProjectileEntity_GetProjectileKind00(lua_State* tolua_S)
@@ -12541,7 +12185,8 @@ static int tolua_AllToLua_cWorld_SpawnItemPickups00(lua_State* tolua_S)
      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
      !tolua_isnumber(tolua_S,6,1,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,7,&tolua_err)
+     !tolua_isboolean(tolua_S,7,1,&tolua_err) ||
+     !tolua_isnoobj(tolua_S,8,&tolua_err)
  )
   goto tolua_lerror;
  else
@@ -12553,11 +12198,12 @@ static int tolua_AllToLua_cWorld_SpawnItemPickups00(lua_State* tolua_S)
   double a_BlockY = ((double)  tolua_tonumber(tolua_S,4,0));
   double a_BlockZ = ((double)  tolua_tonumber(tolua_S,5,0));
   double a_FlyAwaySpeed = ((double)  tolua_tonumber(tolua_S,6,1.0));
+  bool IsPlayerCreated = ((bool)  tolua_toboolean(tolua_S,7,false));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnItemPickups'", NULL);
 #endif
   {
-   self->SpawnItemPickups(*a_Pickups,a_BlockX,a_BlockY,a_BlockZ,a_FlyAwaySpeed);
+   self->SpawnItemPickups(*a_Pickups,a_BlockX,a_BlockY,a_BlockZ,a_FlyAwaySpeed,IsPlayerCreated);
   }
  }
  return 0;
@@ -12583,7 +12229,8 @@ static int tolua_AllToLua_cWorld_SpawnItemPickups01(lua_State* tolua_S)
      !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
      !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
      !tolua_isnumber(tolua_S,8,0,&tolua_err) ||
-     !tolua_isnoobj(tolua_S,9,&tolua_err)
+     !tolua_isboolean(tolua_S,9,1,&tolua_err) ||
+     !tolua_isnoobj(tolua_S,10,&tolua_err)
  )
   goto tolua_lerror;
  else
@@ -12596,11 +12243,12 @@ static int tolua_AllToLua_cWorld_SpawnItemPickups01(lua_State* tolua_S)
   double a_SpeedX = ((double)  tolua_tonumber(tolua_S,6,0));
   double a_SpeedY = ((double)  tolua_tonumber(tolua_S,7,0));
   double a_SpeedZ = ((double)  tolua_tonumber(tolua_S,8,0));
+  bool IsPlayerCreated = ((bool)  tolua_toboolean(tolua_S,9,false));
 #ifndef TOLUA_RELEASE
   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnItemPickups'", NULL);
 #endif
   {
-   self->SpawnItemPickups(*a_Pickups,a_BlockX,a_BlockY,a_BlockZ,a_SpeedX,a_SpeedY,a_SpeedZ);
+   self->SpawnItemPickups(*a_Pickups,a_BlockX,a_BlockY,a_BlockZ,a_SpeedX,a_SpeedY,a_SpeedZ,IsPlayerCreated);
   }
  }
  return 0;
@@ -29333,9 +28981,9 @@ static int tolua_AllToLua_cMonster_FamilyFromType00(lua_State* tolua_S)
 }
 #endif //#ifndef TOLUA_DISABLE
 
-/* method: GetSpawnRate of class  cMonster */
-#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_GetSpawnRate00
-static int tolua_AllToLua_cMonster_GetSpawnRate00(lua_State* tolua_S)
+/* method: GetSpawnDelay of class  cMonster */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_GetSpawnDelay00
+static int tolua_AllToLua_cMonster_GetSpawnDelay00(lua_State* tolua_S)
 {
 #ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
@@ -29350,14 +28998,14 @@ static int tolua_AllToLua_cMonster_GetSpawnRate00(lua_State* tolua_S)
  {
   cMonster::eFamily a_MobFamily = ((cMonster::eFamily) (int)  tolua_tonumber(tolua_S,2,0));
   {
-   int tolua_ret = (int)  cMonster::GetSpawnRate(a_MobFamily);
+   int tolua_ret = (int)  cMonster::GetSpawnDelay(a_MobFamily);
    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
   }
  }
  return 1;
 #ifndef TOLUA_RELEASE
  tolua_lerror:
- tolua_error(tolua_S,"#ferror in function 'GetSpawnRate'.",&tolua_err);
+ tolua_error(tolua_S,"#ferror in function 'GetSpawnDelay'.",&tolua_err);
  return 0;
 #endif
 }
@@ -29447,33 +29095,19 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
    tolua_function(tolua_S,"new",tolua_AllToLua_cIniFile_new00);
    tolua_function(tolua_S,"new_local",tolua_AllToLua_cIniFile_new00_local);
    tolua_function(tolua_S,".call",tolua_AllToLua_cIniFile_new00_local);
-   tolua_function(tolua_S,"new",tolua_AllToLua_cIniFile_new01);
-   tolua_function(tolua_S,"new_local",tolua_AllToLua_cIniFile_new01_local);
-   tolua_function(tolua_S,".call",tolua_AllToLua_cIniFile_new01_local);
    tolua_function(tolua_S,"CaseSensitive",tolua_AllToLua_cIniFile_CaseSensitive00);
    tolua_function(tolua_S,"CaseInsensitive",tolua_AllToLua_cIniFile_CaseInsensitive00);
-   tolua_function(tolua_S,"Path",tolua_AllToLua_cIniFile_Path00);
-   tolua_function(tolua_S,"Path",tolua_AllToLua_cIniFile_Path01);
-   tolua_function(tolua_S,"SetPath",tolua_AllToLua_cIniFile_SetPath00);
    tolua_function(tolua_S,"ReadFile",tolua_AllToLua_cIniFile_ReadFile00);
    tolua_function(tolua_S,"WriteFile",tolua_AllToLua_cIniFile_WriteFile00);
    tolua_function(tolua_S,"Clear",tolua_AllToLua_cIniFile_Clear00);
-   tolua_function(tolua_S,"Reset",tolua_AllToLua_cIniFile_Reset00);
-   tolua_function(tolua_S,"Erase",tolua_AllToLua_cIniFile_Erase00);
    tolua_function(tolua_S,"FindKey",tolua_AllToLua_cIniFile_FindKey00);
    tolua_function(tolua_S,"FindValue",tolua_AllToLua_cIniFile_FindValue00);
-   tolua_function(tolua_S,"NumKeys",tolua_AllToLua_cIniFile_NumKeys00);
    tolua_function(tolua_S,"GetNumKeys",tolua_AllToLua_cIniFile_GetNumKeys00);
    tolua_function(tolua_S,"AddKeyName",tolua_AllToLua_cIniFile_AddKeyName00);
-   tolua_function(tolua_S,"KeyName",tolua_AllToLua_cIniFile_KeyName00);
    tolua_function(tolua_S,"GetKeyName",tolua_AllToLua_cIniFile_GetKeyName00);
-   tolua_function(tolua_S,"NumValues",tolua_AllToLua_cIniFile_NumValues00);
    tolua_function(tolua_S,"GetNumValues",tolua_AllToLua_cIniFile_GetNumValues00);
-   tolua_function(tolua_S,"NumValues",tolua_AllToLua_cIniFile_NumValues01);
    tolua_function(tolua_S,"GetNumValues",tolua_AllToLua_cIniFile_GetNumValues01);
-   tolua_function(tolua_S,"ValueName",tolua_AllToLua_cIniFile_ValueName00);
    tolua_function(tolua_S,"GetValueName",tolua_AllToLua_cIniFile_GetValueName00);
-   tolua_function(tolua_S,"ValueName",tolua_AllToLua_cIniFile_ValueName01);
    tolua_function(tolua_S,"GetValueName",tolua_AllToLua_cIniFile_GetValueName01);
    tolua_function(tolua_S,"GetValue",tolua_AllToLua_cIniFile_GetValue00);
    tolua_function(tolua_S,"GetValue",tolua_AllToLua_cIniFile_GetValue01);
@@ -29495,17 +29129,17 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
    tolua_function(tolua_S,"DeleteValueByID",tolua_AllToLua_cIniFile_DeleteValueByID00);
    tolua_function(tolua_S,"DeleteValue",tolua_AllToLua_cIniFile_DeleteValue00);
    tolua_function(tolua_S,"DeleteKey",tolua_AllToLua_cIniFile_DeleteKey00);
-   tolua_function(tolua_S,"NumHeaderComments",tolua_AllToLua_cIniFile_NumHeaderComments00);
-   tolua_function(tolua_S,"HeaderComment",tolua_AllToLua_cIniFile_HeaderComment00);
-   tolua_function(tolua_S,"HeaderComment",tolua_AllToLua_cIniFile_HeaderComment01);
+   tolua_function(tolua_S,"GetNumHeaderComments",tolua_AllToLua_cIniFile_GetNumHeaderComments00);
+   tolua_function(tolua_S,"AddHeaderComment",tolua_AllToLua_cIniFile_AddHeaderComment00);
+   tolua_function(tolua_S,"GetHeaderComment",tolua_AllToLua_cIniFile_GetHeaderComment00);
    tolua_function(tolua_S,"DeleteHeaderComment",tolua_AllToLua_cIniFile_DeleteHeaderComment00);
    tolua_function(tolua_S,"DeleteHeaderComments",tolua_AllToLua_cIniFile_DeleteHeaderComments00);
-   tolua_function(tolua_S,"NumKeyComments",tolua_AllToLua_cIniFile_NumKeyComments00);
-   tolua_function(tolua_S,"NumKeyComments",tolua_AllToLua_cIniFile_NumKeyComments01);
-   tolua_function(tolua_S,"KeyComment",tolua_AllToLua_cIniFile_KeyComment00);
-   tolua_function(tolua_S,"KeyComment",tolua_AllToLua_cIniFile_KeyComment01);
-   tolua_function(tolua_S,"KeyComment",tolua_AllToLua_cIniFile_KeyComment02);
-   tolua_function(tolua_S,"KeyComment",tolua_AllToLua_cIniFile_KeyComment03);
+   tolua_function(tolua_S,"GetNumKeyComments",tolua_AllToLua_cIniFile_GetNumKeyComments00);
+   tolua_function(tolua_S,"GetNumKeyComments",tolua_AllToLua_cIniFile_GetNumKeyComments01);
+   tolua_function(tolua_S,"AddKeyComment",tolua_AllToLua_cIniFile_AddKeyComment00);
+   tolua_function(tolua_S,"AddKeyComment",tolua_AllToLua_cIniFile_AddKeyComment01);
+   tolua_function(tolua_S,"GetKeyComment",tolua_AllToLua_cIniFile_GetKeyComment00);
+   tolua_function(tolua_S,"GetKeyComment",tolua_AllToLua_cIniFile_GetKeyComment01);
    tolua_function(tolua_S,"DeleteKeyComment",tolua_AllToLua_cIniFile_DeleteKeyComment00);
    tolua_function(tolua_S,"DeleteKeyComment",tolua_AllToLua_cIniFile_DeleteKeyComment01);
    tolua_function(tolua_S,"DeleteKeyComments",tolua_AllToLua_cIniFile_DeleteKeyComments00);
@@ -30489,6 +30123,7 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
    tolua_function(tolua_S,"CollectedBy",tolua_AllToLua_cPickup_CollectedBy00);
    tolua_function(tolua_S,"GetAge",tolua_AllToLua_cPickup_GetAge00);
    tolua_function(tolua_S,"IsCollected",tolua_AllToLua_cPickup_IsCollected00);
+   tolua_function(tolua_S,"IsPlayerCreated",tolua_AllToLua_cPickup_IsPlayerCreated00);
   tolua_endmodule(tolua_S);
   tolua_cclass(tolua_S,"cProjectileEntity","cProjectileEntity","cEntity",NULL);
   tolua_beginmodule(tolua_S,"cProjectileEntity");
@@ -31390,17 +31025,17 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
   tolua_endmodule(tolua_S);
   tolua_cclass(tolua_S,"cWindow","cWindow","",NULL);
   tolua_beginmodule(tolua_S,"cWindow");
-   tolua_constant(tolua_S,"Inventory",cWindow::Inventory);
-   tolua_constant(tolua_S,"Chest",cWindow::Chest);
-   tolua_constant(tolua_S,"Workbench",cWindow::Workbench);
-   tolua_constant(tolua_S,"Furnace",cWindow::Furnace);
-   tolua_constant(tolua_S,"DropSpenser",cWindow::DropSpenser);
-   tolua_constant(tolua_S,"Enchantment",cWindow::Enchantment);
-   tolua_constant(tolua_S,"Brewery",cWindow::Brewery);
-   tolua_constant(tolua_S,"NPCTrade",cWindow::NPCTrade);
-   tolua_constant(tolua_S,"Beacon",cWindow::Beacon);
-   tolua_constant(tolua_S,"Anvil",cWindow::Anvil);
-   tolua_constant(tolua_S,"Hopper",cWindow::Hopper);
+   tolua_constant(tolua_S,"wtInventory",cWindow::wtInventory);
+   tolua_constant(tolua_S,"wtChest",cWindow::wtChest);
+   tolua_constant(tolua_S,"wtWorkbench",cWindow::wtWorkbench);
+   tolua_constant(tolua_S,"wtFurnace",cWindow::wtFurnace);
+   tolua_constant(tolua_S,"wtDropSpenser",cWindow::wtDropSpenser);
+   tolua_constant(tolua_S,"wtEnchantment",cWindow::wtEnchantment);
+   tolua_constant(tolua_S,"wtBrewery",cWindow::wtBrewery);
+   tolua_constant(tolua_S,"wtNPCTrade",cWindow::wtNPCTrade);
+   tolua_constant(tolua_S,"wtBeacon",cWindow::wtBeacon);
+   tolua_constant(tolua_S,"wtAnvil",cWindow::wtAnvil);
+   tolua_constant(tolua_S,"wtHopper",cWindow::wtHopper);
    tolua_function(tolua_S,"GetWindowID",tolua_AllToLua_cWindow_GetWindowID00);
    tolua_function(tolua_S,"GetWindowType",tolua_AllToLua_cWindow_GetWindowType00);
    tolua_function(tolua_S,"GetSlot",tolua_AllToLua_cWindow_GetSlot00);
@@ -31467,7 +31102,7 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
    tolua_function(tolua_S,"MobTypeToString",tolua_AllToLua_cMonster_MobTypeToString00);
    tolua_function(tolua_S,"StringToMobType",tolua_AllToLua_cMonster_StringToMobType00);
    tolua_function(tolua_S,"FamilyFromType",tolua_AllToLua_cMonster_FamilyFromType00);
-   tolua_function(tolua_S,"GetSpawnRate",tolua_AllToLua_cMonster_GetSpawnRate00);
+   tolua_function(tolua_S,"GetSpawnDelay",tolua_AllToLua_cMonster_GetSpawnDelay00);
   tolua_endmodule(tolua_S);
   tolua_cclass(tolua_S,"cLineBlockTracer","cLineBlockTracer","",NULL);
   tolua_beginmodule(tolua_S,"cLineBlockTracer");
diff --git a/source/Bindings.h b/source/Bindings.h
index 620dbea84..411e608d9 100644
--- a/source/Bindings.h
+++ b/source/Bindings.h
@@ -1,6 +1,6 @@
 /*

 ** Lua binding: AllToLua

-** Generated automatically by tolua++-1.0.92 on 10/23/13 13:30:24.

+** Generated automatically by tolua++-1.0.92 on 10/28/13 13:11:04.

 */

 

 /* Exported function */

diff --git a/source/BlockID.cpp b/source/BlockID.cpp
index 95e1a63bf..7193094d8 100644
--- a/source/BlockID.cpp
+++ b/source/BlockID.cpp
@@ -42,20 +42,20 @@ class cBlockIDMap
 public:
 	cBlockIDMap(void)
 	{
-		cIniFile Ini("items.ini");
-		if (!Ini.ReadFile())
+		cIniFile Ini;
+		if (!Ini.ReadFile("items.ini"))
 		{
 			return;
 		}
-		long KeyID = Ini.FindKey("Items");
+		int KeyID = Ini.FindKey("Items");
 		if (KeyID == cIniFile::noID)
 		{
 			return;
 		}
-		unsigned NumValues = Ini.GetNumValues(KeyID);
-		for (unsigned i = 0; i < NumValues; i++)
+		int NumValues = Ini.GetNumValues(KeyID);
+		for (int i = 0; i < NumValues; i++)
 		{
-			AString Name = Ini.ValueName(KeyID, i);
+			AString Name = Ini.GetValueName(KeyID, i);
 			if (Name.empty())
 			{
 				continue;
diff --git a/source/ByteBuffer.cpp b/source/ByteBuffer.cpp
index c82951271..6659b4dd4 100644
--- a/source/ByteBuffer.cpp
+++ b/source/ByteBuffer.cpp
@@ -13,8 +13,54 @@
 
 
 
-#define NEEDBYTES(Num) if (!CanReadBytes(Num))  return false;
-#define PUTBYTES(Num)  if (!CanWriteBytes(Num)) return false;
+// If a string sent over the protocol is larger than this, a warning is emitted to the console
+#define MAX_STRING_SIZE (512 KiB)
+
+#define NEEDBYTES(Num) if (!CanReadBytes(Num))  return false;  // Check if at least Num bytes can be read from  the buffer, return false if not
+#define PUTBYTES(Num)  if (!CanWriteBytes(Num)) return false;  // Check if at least Num bytes can be written to the buffer, return false if not
+
+
+
+
+
+#if 0
+
+/// Self-test of the VarInt-reading and writing code
+class cByteBufferSelfTest
+{
+public:
+	cByteBufferSelfTest(void)
+	{
+		TestRead();
+		TestWrite();
+	}
+	
+	void TestRead(void)
+	{
+		cByteBuffer buf(50);
+		buf.Write("\x05\xac\x02\x00", 4);
+		UInt32 v1;
+		ASSERT(buf.ReadVarInt(v1) && (v1 == 5));
+		UInt32 v2;
+		ASSERT(buf.ReadVarInt(v2) && (v2 == 300));
+		UInt32 v3;
+		ASSERT(buf.ReadVarInt(v3) && (v3 == 0));
+	}
+	
+	void TestWrite(void)
+	{
+		cByteBuffer buf(50);
+		buf.WriteVarInt(5);
+		buf.WriteVarInt(300);
+		buf.WriteVarInt(0);
+		AString All;
+		buf.ReadAll(All);
+		ASSERT(All.size() == 4);
+		ASSERT(memcmp(All.data(), "\x05\xac\x02\x00", All.size()) == 0);
+	}
+} g_ByteBufferTest;
+
+#endif
 
 
 
@@ -328,6 +374,48 @@ bool cByteBuffer::ReadBEUTF16String16(AString & a_Value)
 
 
 
+bool cByteBuffer::ReadVarInt(UInt32 & a_Value)
+{
+	CHECK_THREAD;
+	CheckValid();
+	UInt32 Value = 0;
+	int Shift = 0;
+	unsigned char b = 0;
+	do
+	{
+		NEEDBYTES(1);
+		ReadBuf(&b, 1);
+		Value = Value | (((Int64)(b & 0x7f)) << Shift);
+		Shift += 7;
+	} while ((b & 0x80) != 0);
+	a_Value = Value;
+	return true;
+}
+
+
+
+
+
+bool cByteBuffer::ReadVarUTF8String(AString & a_Value)
+{
+	CHECK_THREAD;
+	CheckValid();
+	UInt32 Size = 0;
+	if (!ReadVarInt(Size))
+	{
+		return false;
+	}
+	if (Size > MAX_STRING_SIZE)
+	{
+		LOGWARNING("%s: String too large: %llu (%llu KiB)", __FUNCTION__, Size, Size / 1024);
+	}
+	return ReadString(a_Value, (int)Size);
+}
+
+
+
+
+
 bool cByteBuffer::WriteChar(char a_Value)
 {
 	CHECK_THREAD;
@@ -446,6 +534,44 @@ bool cByteBuffer::WriteBEUTF16String16(const AString & a_Value)
 
 
 
+bool cByteBuffer::WriteVarInt(UInt32 a_Value)
+{
+	CHECK_THREAD;
+	CheckValid();
+	
+	// A 32-bit integer can be encoded by at most 5 bytes:
+	unsigned char b[5];
+	int idx = 0;
+	do
+	{
+		b[idx] = (a_Value & 0x7f) | ((a_Value > 0x7f) ? 0x80 : 0x00);
+		a_Value = a_Value >> 7;
+		idx++;
+	} while (a_Value > 0);
+
+	return WriteBuf(b, idx);
+}
+
+
+
+
+bool cByteBuffer::WriteVarUTF8String(AString & a_Value)
+{
+	CHECK_THREAD;
+	CheckValid();
+	PUTBYTES(a_Value.size() + 1);  // This is a lower-bound on the bytes that will be actually written. Fail early.
+	bool res = WriteVarInt(a_Value.size());
+	if (!res)
+	{
+		return false;
+	}
+	return WriteBuf(a_Value.data(), a_Value.size());
+}
+
+
+
+
+
 bool cByteBuffer::ReadBuf(void * a_Buffer, int a_Count)
 {
 	CHECK_THREAD;
diff --git a/source/ByteBuffer.h b/source/ByteBuffer.h
index 650eda5b0..71ee4764e 100644
--- a/source/ByteBuffer.h
+++ b/source/ByteBuffer.h
@@ -57,8 +57,22 @@ public:
 	bool ReadBEFloat        (float & a_Value);
 	bool ReadBEDouble       (double & a_Value);
 	bool ReadBool           (bool & a_Value);
-	bool ReadBEUTF16String16(AString & a_Value);
-	
+	bool ReadBEUTF16String16(AString & a_Value);  // string length as BE short, then string as UTF-16BE
+	bool ReadVarInt         (UInt32 & a_Value);
+	bool ReadVarUTF8String  (AString & a_Value);  // string length as VarInt, then string as UTF-8
+
+	/// Reads VarInt, assigns it to anything that can be assigned from an UInt32 (unsigned short, char, Byte, double, ...)
+	template <typename T> bool ReadVarUInt(T & a_Value)
+	{
+		UInt32 v;
+		bool res = ReadVarInt(v);
+		if (res)
+		{
+			a_Value = v;
+		}
+		return res;
+	}
+
 	// Write the specified datatype; return true if successfully written
 	bool WriteChar           (char a_Value);
 	bool WriteByte           (unsigned char a_Value);
@@ -68,7 +82,9 @@ public:
 	bool WriteBEFloat        (float  a_Value);
 	bool WriteBEDouble       (double a_Value);
 	bool WriteBool           (bool   a_Value);
-	bool WriteBEUTF16String16(const AString & a_Value);
+	bool WriteBEUTF16String16(const AString & a_Value);  // string length as BE short, then string as UTF-16BE
+	bool WriteVarInt         (UInt32 a_Value);
+	bool WriteVarUTF8String  (AString & a_Value);  // string length as VarInt, then string as UTF-8
 	
 	/// Reads a_Count bytes into a_Buffer; returns true if successful
 	bool ReadBuf(void * a_Buffer, int a_Count);
diff --git a/source/Chunk.cpp b/source/Chunk.cpp
index 038831896..c419cf7f2 100644
--- a/source/Chunk.cpp
+++ b/source/Chunk.cpp
@@ -1152,6 +1152,29 @@ bool cChunk::UnboundedRelGetBlockSkyLight(int a_RelX, int a_RelY, int a_RelZ, NI
 
 
 
+bool cChunk::UnboundedRelGetBlockLights(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE & a_BlockLight, NIBBLETYPE & a_SkyLight) const
+{
+	if ((a_RelY < 0) || (a_RelY >= cChunkDef::Height))
+	{
+		LOGWARNING("%s: requesting a block with a_RelY out of range: %d", __FUNCTION__, a_RelY);
+		return false;
+	}
+	cChunk * Chunk = GetRelNeighborChunkAdjustCoords(a_RelX, a_RelZ);
+	if ((Chunk == NULL) || !Chunk->IsValid())
+	{
+		// The chunk is not available, bail out
+		return false;
+	}
+	int idx = Chunk->MakeIndex(a_RelX, a_RelY, a_RelZ);
+	a_BlockLight = Chunk->GetBlockLight(idx);
+	a_SkyLight = Chunk->GetSkyLight(idx);
+	return true;
+}
+
+
+
+
+
 bool cChunk::UnboundedRelSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta)
 {
 	if ((a_RelY < 0) || (a_RelY > cChunkDef::Height))
diff --git a/source/Chunk.h b/source/Chunk.h
index 2aac78354..591e29ad9 100644
--- a/source/Chunk.h
+++ b/source/Chunk.h
@@ -299,6 +299,8 @@ public:
 
 	inline NIBBLETYPE GetBlockLight(int a_RelX, int a_RelY, int a_RelZ) const {return cChunkDef::GetNibble(m_BlockLight, a_RelX, a_RelY, a_RelZ); }
 	inline NIBBLETYPE GetSkyLight  (int a_RelX, int a_RelY, int a_RelZ) const {return cChunkDef::GetNibble(m_BlockSkyLight, a_RelX, a_RelY, a_RelZ); }
+	inline NIBBLETYPE GetBlockLight(int a_Idx) const {return cChunkDef::GetNibble(m_BlockLight, a_Idx); }
+	inline NIBBLETYPE GetSkyLight  (int a_Idx) const {return cChunkDef::GetNibble(m_BlockSkyLight, a_Idx); }
 	
 	/// Same as GetBlock(), but relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success
 	bool UnboundedRelGetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const;
@@ -315,6 +317,9 @@ public:
 	/// Same as GetBlockSkyLight(), but relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success
 	bool UnboundedRelGetBlockSkyLight(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE & a_SkyLight) const;
 
+	/// Queries both BlockLight and SkyLight, relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success
+	bool UnboundedRelGetBlockLights(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE & a_BlockLight, NIBBLETYPE & a_SkyLight) const;
+
 	/// Same as SetBlock(), but relative coords needn't be in this chunk (uses m_Neighbor-s or m_ChunkMap in such a case); returns true on success
 	bool UnboundedRelSetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 
diff --git a/source/ClientHandle.cpp b/source/ClientHandle.cpp
index f67a546fd..90802aa71 100644
--- a/source/ClientHandle.cpp
+++ b/source/ClientHandle.cpp
@@ -469,12 +469,12 @@ bool cClientHandle::HandleLogin(int a_ProtocolVersion, const AString & a_Usernam
 void cClientHandle::HandleCreativeInventory(short a_SlotNum, const cItem & a_HeldItem)
 {
 	// This is for creative Inventory changes
-	if (m_Player->GetGameMode() != eGameMode_Creative)
+	if (m_Player->IsGameModeCreative())
 	{
 		LOGWARNING("Got a CreativeInventoryAction packet from user \"%s\" while not in creative mode. Ignoring.", m_Username.c_str());
 		return;
 	}
-	if (m_Player->GetWindow()->GetWindowType() != cWindow::Inventory)
+	if (m_Player->GetWindow()->GetWindowType() != cWindow::wtInventory)
 	{
 		LOGWARNING("Got a CreativeInventoryAction packet from user \"%s\" while not in the inventory window. Ignoring.", m_Username.c_str());
 		return;
diff --git a/source/Entities/Pickup.cpp b/source/Entities/Pickup.cpp
index 075f93449..bc8abd204 100644
--- a/source/Entities/Pickup.cpp
+++ b/source/Entities/Pickup.cpp
@@ -24,11 +24,12 @@
 
 
 
-cPickup::cPickup(double a_X, double a_Y, double a_Z, const cItem & a_Item, float a_SpeedX /* = 0.f */, float a_SpeedY /* = 0.f */, float a_SpeedZ /* = 0.f */)
-	:	cEntity(etPickup, a_X, a_Y, a_Z, 0.2, 0.2)
+cPickup::cPickup(double a_PosX, double a_PosY, double a_PosZ, const cItem & a_Item, bool IsPlayerCreated, float a_SpeedX /* = 0.f */, float a_SpeedY /* = 0.f */, float a_SpeedZ /* = 0.f */)
+	:	cEntity(etPickup, a_PosX, a_PosY, a_PosZ, 0.2, 0.2)
 	, m_Timer( 0.f )
 	, m_Item(a_Item)
 	, m_bCollected( false )
+	, m_bIsPlayerCreated( IsPlayerCreated )
 {
 	m_MaxHealth = 5;
 	m_Health = 5;
@@ -126,8 +127,8 @@ bool cPickup::CollectedBy(cPlayer * a_Dest)
 		return false; // It's already collected!
 	}
 	
-	// 800 is to long
-	if (m_Timer < 500.f)
+	// Two seconds if player created the pickup (vomiting), half a second if anything else
+	if (m_Timer < (m_bIsPlayerCreated ? 2000.f : 500.f))
 	{
 		// LOG("Pickup %d cannot be collected by \"%s\", because it is not old enough.", m_UniqueID, a_Dest->GetName().c_str());
 		return false; // Not old enough
diff --git a/source/Entities/Pickup.h b/source/Entities/Pickup.h
index 488f91fb2..d39eda298 100644
--- a/source/Entities/Pickup.h
+++ b/source/Entities/Pickup.h
@@ -24,14 +24,14 @@ class cPickup :
 public:
 	CLASS_PROTODEF(cPickup);
 
-	cPickup(double a_X, double a_Y, double a_Z, const cItem & a_Item, float a_SpeedX = 0.f, float a_SpeedY = 0.f, float a_SpeedZ = 0.f);	// tolua_export
+	cPickup(double a_PosX, double a_PosY, double a_PosZ, const cItem & a_Item, bool IsPlayerCreated, float a_SpeedX = 0.f, float a_SpeedY = 0.f, float a_SpeedZ = 0.f);	// tolua_export
 	
 	cItem &       GetItem(void)       {return m_Item; }								// tolua_export
 	const cItem & GetItem(void) const {return m_Item; }
 
 	virtual void SpawnOn(cClientHandle & a_ClientHandle) override;
 	
-	virtual bool CollectedBy(cPlayer * a_Dest);					// tolua_export
+	bool CollectedBy(cPlayer * a_Dest);					// tolua_export
 
 	virtual void Tick(float a_Dt, cChunk & a_Chunk) override;
 	
@@ -40,6 +40,9 @@ public:
 	
 	/// Returns true if the pickup has already been collected
 	bool IsCollected(void) const { return m_bCollected; }  // tolua_export
+
+	/// Returns true if created by player (i.e. vomiting), used for determining picking-up delay time
+	bool IsPlayerCreated(void) const { return m_bIsPlayerCreated; } // tolua_export
 	
 private:
 	Vector3d   m_ResultingSpeed;	 //Can be used to modify the resulting speed for the current tick ;)
@@ -52,6 +55,8 @@ private:
 	cItem m_Item;
 
 	bool m_bCollected;
+
+	bool m_bIsPlayerCreated;
 };  // tolua_export
 
 
diff --git a/source/Entities/Player.cpp b/source/Entities/Player.cpp
index d93b45614..d94bc944c 100644
--- a/source/Entities/Player.cpp
+++ b/source/Entities/Player.cpp
@@ -349,11 +349,8 @@ void cPlayer::SetTouchGround(bool a_bTouchGround)
 
 void cPlayer::Heal(int a_Health)
 {
-	if (m_Health < GetMaxHealth())
-	{
-		m_Health = (short)std::min((int)a_Health + m_Health, (int)GetMaxHealth());
-		SendHealth();
-	}
+	super::Heal(a_Health);
+	SendHealth();
 }
 
 
@@ -1183,7 +1180,7 @@ void cPlayer::TossItem(
 	double vX = 0, vY = 0, vZ = 0;
 	EulerToVector(-GetRotation(), GetPitch(), vZ, vX, vY);
 	vY = -vY * 2 + 1.f;
-	m_World->SpawnItemPickups(Drops, GetPosX(), GetPosY() + 1.6f, GetPosZ(), vX * 3, vY * 3, vZ * 3);
+	m_World->SpawnItemPickups(Drops, GetPosX(), GetPosY() + 1.6f, GetPosZ(), vX * 3, vY * 3, vZ * 3, true); // 'true' because created by player
 }
 
 
@@ -1227,11 +1224,11 @@ void cPlayer::LoadPermissionsFromDisk()
 	m_Groups.clear();
 	m_Permissions.clear();
 
-	cIniFile IniFile("users.ini");
-	if( IniFile.ReadFile() )
+	cIniFile IniFile;
+	if (IniFile.ReadFile("users.ini"))
 	{
 		std::string Groups = IniFile.GetValue(m_PlayerName, "Groups", "");
-		if( Groups.size() > 0 )
+		if (!Groups.empty())
 		{
 			AStringVector Split = StringSplit( Groups, "," );
 			for( unsigned int i = 0; i < Split.size(); i++ )
@@ -1248,7 +1245,7 @@ void cPlayer::LoadPermissionsFromDisk()
 	}
 	else
 	{
-		LOGWARN("WARNING: Failed to read ini file users.ini");
+		LOGWARN("Failed to read the users.ini file. The player will be added only to the Default group.");
 		AddToGroup("Default");
 	}
 	ResolvePermissions();
diff --git a/source/Entities/Player.h b/source/Entities/Player.h
index 82ff48954..449a63231 100644
--- a/source/Entities/Player.h
+++ b/source/Entities/Player.h
@@ -128,8 +128,8 @@ public:
 	// Sets the current gamemode, doesn't check validity, doesn't send update packets to client
 	void LoginSetGameMode(eGameMode a_GameMode);
 
-	/// Tries to move to a new position, with collision checks and stuff
-	virtual void MoveTo( const Vector3d & a_NewPos );  // tolua_export
+	/// Tries to move to a new position, with attachment-related checks (y == -999)
+	void MoveTo(const Vector3d & a_NewPos);  // tolua_export
 
 	cWindow * GetWindow(void) { return m_CurrentWindow; }  // tolua_export
 	const cWindow * GetWindow(void) const { return m_CurrentWindow; }
@@ -159,21 +159,25 @@ public:
 
 	/// Adds a player to existing group or creates a new group when it doesn't exist
 	void AddToGroup( const AString & a_GroupName );							// tolua_export
+	
 	/// Removes a player from the group, resolves permissions and group inheritance (case sensitive)
 	void RemoveFromGroup( const AString & a_GroupName );					// tolua_export
+	
 	bool CanUseCommand( const AString & a_Command );						// tolua_export
 	bool HasPermission( const AString & a_Permission );						// tolua_export
 	const GroupList & GetGroups() { return m_Groups; }						// >> EXPORTED IN MANUALBINDINGS <<
 	StringList GetResolvedPermissions();									// >> EXPORTED IN MANUALBINDINGS <<
 	bool IsInGroup( const AString & a_Group );								// tolua_export
 
-	AString GetColor(void) const;											// tolua_export
+	// tolua_begin
+	
+	/// Returns the full color code to use for this player, based on their primary group or set in m_Color
+	AString GetColor(void) const;
 
-	void TossItem(bool a_bDraggingItem, char a_Amount = 1, short a_CreateType = 0, short a_CreateHealth = 0);				// tolua_export
+	void TossItem(bool a_bDraggingItem, char a_Amount = 1, short a_CreateType = 0, short a_CreateHealth = 0);
 
-	void Heal( int a_Health );												// tolua_export
-	
-	// tolua_begin
+	/// Heals the player by the specified amount of HPs (positive only); sends health update
+	void Heal(int a_Health);
 	
 	int    GetFoodLevel                 (void) const { return m_FoodLevel; }
 	double GetFoodSaturationLevel       (void) const { return m_FoodSaturationLevel; }
@@ -181,7 +185,7 @@ public:
 	double GetFoodExhaustionLevel       (void) const { return m_FoodExhaustionLevel; }
 	int    GetFoodPoisonedTicksRemaining(void) const { return m_FoodPoisonedTicksRemaining; }
 
-        int GetAirLevel                     (void) const { return m_AirLevel; }
+	int GetAirLevel                     (void) const { return m_AirLevel; }
 	
 	/// Returns true if the player is satiated, i. e. their foodlevel is at the max and they cannot eat anymore
 	bool IsSatiated(void) const { return (m_FoodLevel >= MAX_FOOD_LEVEL); }
@@ -302,6 +306,7 @@ protected:
 
 	/// Player's air level (for swimming)
 	int m_AirLevel;
+
 	/// used to time ticks between damage taken via drowning/suffocation
 	int m_AirTickTimer;
 
diff --git a/source/Generating/ChunkGenerator.cpp b/source/Generating/ChunkGenerator.cpp
index d35b30460..59a00b540 100644
--- a/source/Generating/ChunkGenerator.cpp
+++ b/source/Generating/ChunkGenerator.cpp
@@ -75,8 +75,6 @@ bool cChunkGenerator::Start(cWorld * a_World, cIniFile & a_IniFile)
 	
 	m_Generator->Initialize(a_World, a_IniFile);
 	
-	a_IniFile.WriteFile();
-	
 	return super::Start();
 }
 
diff --git a/source/GroupManager.cpp b/source/GroupManager.cpp
index b79fde9dc..d7332fd0a 100644
--- a/source/GroupManager.cpp
+++ b/source/GroupManager.cpp
@@ -44,8 +44,8 @@ cGroupManager::cGroupManager()
 	: m_pState( new sGroupManagerState )
 {
 	LOGD("-- Loading Groups --");
-	cIniFile IniFile("groups.ini");
-	if (!IniFile.ReadFile())
+	cIniFile IniFile;
+	if (!IniFile.ReadFile("groups.ini"))
 	{
 		LOGWARNING("groups.ini inaccessible, no groups are defined");
 		return;
diff --git a/source/LuaWindow.cpp b/source/LuaWindow.cpp
index a0609f746..9011d668c 100644
--- a/source/LuaWindow.cpp
+++ b/source/LuaWindow.cpp
@@ -31,8 +31,8 @@ cLuaWindow::cLuaWindow(cWindow::WindowType a_WindowType, int a_SlotsX, int a_Slo
 	// If appropriate, add an Armor slot area:
 	switch (a_WindowType)
 	{
-		case cWindow::Inventory:
-		case cWindow::Workbench:
+		case cWindow::wtInventory:
+		case cWindow::wtWorkbench:
 		{
 			m_SlotAreas.push_back(new cSlotAreaArmor(*this));
 			break;
diff --git a/source/Mobs/Monster.cpp b/source/Mobs/Monster.cpp
index 7e35b97f1..9b1f2fc4c 100644
--- a/source/Mobs/Monster.cpp
+++ b/source/Mobs/Monster.cpp
@@ -605,7 +605,7 @@ cMonster::eFamily cMonster::FamilyFromType(eType a_Type)
 
 
 
-int cMonster::GetSpawnRate(cMonster::eFamily a_MobFamily)
+int cMonster::GetSpawnDelay(cMonster::eFamily a_MobFamily)
 {
 	switch (a_MobFamily)
 	{
diff --git a/source/Mobs/Monster.h b/source/Mobs/Monster.h
index 14c72ed73..a0002bf4f 100644
--- a/source/Mobs/Monster.h
+++ b/source/Mobs/Monster.h
@@ -137,17 +137,17 @@ public:
 	
 	// tolua_begin
 	
-	/// Translates MobType enum to a string
+	/// Translates MobType enum to a string, empty string if unknown
 	static AString MobTypeToString(eType a_MobType);
 	
-	/// Translates MobType string to the enum
+	/// Translates MobType string to the enum, mtInvalidType if not recognized
 	static eType StringToMobType(const AString & a_MobTypeName);
 	
 	/// Returns the mob family based on the type
 	static eFamily FamilyFromType(eType a_MobType);
 
-	/// Returns the spawn rate (number of game ticks between spawn attempts) for the given mob family
-	static int GetSpawnRate(cMonster::eFamily a_MobFamily);
+	/// Returns the spawn delay (number of game ticks between spawn attempts) for the given mob family
+	static int GetSpawnDelay(cMonster::eFamily a_MobFamily);
 
 	// tolua_end
 	
diff --git a/source/Mobs/Sheep.cpp b/source/Mobs/Sheep.cpp
index 0d7d43e27..703482ddb 100644
--- a/source/Mobs/Sheep.cpp
+++ b/source/Mobs/Sheep.cpp
@@ -33,6 +33,7 @@ void cSheep::GetDrops(cItems & a_Drops, cEntity * a_Killer)
 
 
 
+
 void cSheep::OnRightClicked(cPlayer & a_Player)
 {
 	if ((a_Player.GetEquippedItem().m_ItemType == E_ITEM_SHEARS) && (!m_IsSheared))
@@ -46,7 +47,8 @@ void cSheep::OnRightClicked(cPlayer & a_Player)
 		}
 
 		cItems Drops;
-		Drops.push_back(cItem(E_BLOCK_WOOL, 4, m_WoolColor));
+		int NumDrops = m_World->GetTickRandomNumber(2) + 1;
+		Drops.push_back(cItem(E_BLOCK_WOOL, NumDrops, m_WoolColor));
 		m_World->SpawnItemPickups(Drops, GetPosX(), GetPosY(), GetPosZ(), 10);
 	}
 }
@@ -54,3 +56,4 @@ void cSheep::OnRightClicked(cPlayer & a_Player)
 
 
 
+
diff --git a/source/MonsterConfig.cpp b/source/MonsterConfig.cpp
index 37c7431b0..a5a1ebd49 100644
--- a/source/MonsterConfig.cpp
+++ b/source/MonsterConfig.cpp
@@ -55,18 +55,18 @@ cMonsterConfig::~cMonsterConfig()
 
 void cMonsterConfig::Initialize()
 {
-	cIniFile MonstersIniFile("monsters.ini");
+	cIniFile MonstersIniFile;
 	
-	if (!MonstersIniFile.ReadFile())
+	if (!MonstersIniFile.ReadFile("monsters.ini"))
 	{
 		LOGWARNING("%s: Cannot read monsters.ini file, monster attributes not available", __FUNCTION__);
 		return;
 	}
 	
-	for (int i = (int)MonstersIniFile.NumKeys(); i >= 0; i--)
+	for (int i = (int)MonstersIniFile.GetNumKeys(); i >= 0; i--)
 	{
 		sAttributesStruct Attributes;
-		AString Name = MonstersIniFile.KeyName(i);
+		AString Name = MonstersIniFile.GetKeyName(i);
 		Attributes.m_Name = Name;
 		Attributes.m_AttackDamage  = MonstersIniFile.GetValueF(Name, "AttackDamage",  0);
 		Attributes.m_AttackRange   = MonstersIniFile.GetValueF(Name, "AttackRange",   0);
diff --git a/source/PluginManager.cpp b/source/PluginManager.cpp
index a557bdc03..5ae70d48d 100644
--- a/source/PluginManager.cpp
+++ b/source/PluginManager.cpp
@@ -103,8 +103,8 @@ void cPluginManager::ReloadPluginsNow(void)
 
 	cServer::BindBuiltInConsoleCommands();
 
-	cIniFile IniFile("settings.ini");
-	if (!IniFile.ReadFile())
+	cIniFile IniFile;
+	if (!IniFile.ReadFile("settings.ini"))
 	{
 		LOGWARNING("cPluginManager: Can't find settings.ini, so can't load any plugins.");
 	}
diff --git a/source/Protocol/Protocol125.cpp b/source/Protocol/Protocol125.cpp
index fb7315468..ef40f265a 100644
--- a/source/Protocol/Protocol125.cpp
+++ b/source/Protocol/Protocol125.cpp
@@ -963,7 +963,7 @@ void cProtocol125::SendWholeInventory(const cWindow & a_Window)
 
 void cProtocol125::SendWindowClose(const cWindow & a_Window)
 {
-	if (a_Window.GetWindowType() == cWindow::Inventory)
+	if (a_Window.GetWindowType() == cWindow::wtInventory)
 	{
 		// Do not send inventory-window-close
 		return;
diff --git a/source/Root.cpp b/source/Root.cpp
index 1f6437784..e992ff614 100644
--- a/source/Root.cpp
+++ b/source/Root.cpp
@@ -116,8 +116,8 @@ void cRoot::Start(void)
 		m_Server = new cServer();
 
 		LOG("Reading server config...");
-		cIniFile IniFile("settings.ini");
-		if (!IniFile.ReadFile())
+		cIniFile IniFile;
+		if (!IniFile.ReadFile("settings.ini"))
 		{
 			LOGWARNING("settings.ini inaccessible, all settings are reset to default values");
 		}
@@ -138,7 +138,6 @@ void cRoot::Start(void)
 			LOGERROR("Failure starting server, aborting...");
 			return;
 		}
-		IniFile.WriteFile();
 
 		m_WebAdmin = new cWebAdmin();
 		m_WebAdmin->Init();
@@ -149,7 +148,7 @@ void cRoot::Start(void)
 		m_FurnaceRecipe   = new cFurnaceRecipe();
 		
 		LOGD("Loading worlds...");
-		LoadWorlds();
+		LoadWorlds(IniFile);
 
 		LOGD("Loading plugin manager...");
 		m_PluginManager = new cPluginManager();
@@ -160,8 +159,10 @@ void cRoot::Start(void)
 
 		// This sets stuff in motion
 		LOGD("Starting Authenticator...");
-		m_Authenticator.Start();
+		m_Authenticator.Start(IniFile);
 		
+		IniFile.WriteFile("settings.ini");
+
 		LOGD("Starting worlds...");
 		StartWorlds();
 		
@@ -245,10 +246,8 @@ void cRoot::LoadGlobalSettings()
 
 
 
-void cRoot::LoadWorlds(void)
+void cRoot::LoadWorlds(cIniFile & IniFile)
 {
-	cIniFile IniFile("settings.ini"); IniFile.ReadFile();
-
 	// First get the default world
 	AString DefaultWorldName = IniFile.GetValueSet("Worlds", "DefaultWorld", "world");
 	m_pDefaultWorld = new cWorld( DefaultWorldName.c_str() );
diff --git a/source/Root.h b/source/Root.h
index c05b29d14..175084c53 100644
--- a/source/Root.h
+++ b/source/Root.h
@@ -162,7 +162,7 @@ private:
 	void LoadGlobalSettings();
 
 	/// Loads the worlds from settings.ini, creates the worldmap
-	void LoadWorlds(void);
+	void LoadWorlds(cIniFile & IniFile);
 	
 	/// Starts each world's life
 	void StartWorlds(void);
diff --git a/source/UI/SlotArea.cpp b/source/UI/SlotArea.cpp
index 0a37e82b0..82e87e126 100644
--- a/source/UI/SlotArea.cpp
+++ b/source/UI/SlotArea.cpp
@@ -559,7 +559,7 @@ cSlotAreaInventoryBase::cSlotAreaInventoryBase(int a_NumSlots, int a_SlotOffset,
 
 void cSlotAreaInventoryBase::Clicked(cPlayer & a_Player, int a_SlotNum, eClickAction a_ClickAction, const cItem & a_ClickedItem)
 {
-	if ((a_Player.GetGameMode() == eGameMode_Creative) && (m_ParentWindow.GetWindowType() == cWindow::Inventory))
+	if (a_Player.IsGameModeCreative() && (m_ParentWindow.GetWindowType() == cWindow::wtInventory))
 	{
 		// Creative inventory must treat a_ClickedItem as a DraggedItem instead, replacing the inventory slot with it
 		SetSlot(a_SlotNum, a_Player, a_ClickedItem);
@@ -793,7 +793,7 @@ void cSlotAreaTemporary::TossItems(cPlayer & a_Player, int a_Begin, int a_End)
 	double vX = 0, vY = 0, vZ = 0;
 	EulerToVector(-a_Player.GetRotation(), a_Player.GetPitch(), vZ, vX, vY);
 	vY = -vY * 2 + 1.f;
-	a_Player.GetWorld()->SpawnItemPickups(Drops, a_Player.GetPosX(), a_Player.GetPosY() + 1.6f, a_Player.GetPosZ(), vX * 3, vY * 3, vZ * 3);
+	a_Player.GetWorld()->SpawnItemPickups(Drops, a_Player.GetPosX(), a_Player.GetPosY() + 1.6f, a_Player.GetPosZ(), vX * 3, vY * 3, vZ * 3, true); // 'true' because player created
 }
 
 
diff --git a/source/UI/Window.cpp b/source/UI/Window.cpp
index 2794abe22..1318cbca8 100644
--- a/source/UI/Window.cpp
+++ b/source/UI/Window.cpp
@@ -23,7 +23,7 @@ char cWindow::m_WindowIDCounter = 1;
 
 
 
-cWindow::cWindow(cWindow::WindowType a_WindowType, const AString & a_WindowTitle) :
+cWindow::cWindow(WindowType a_WindowType, const AString & a_WindowTitle) :
 	m_WindowID((++m_WindowIDCounter) % 127),
 	m_WindowType(a_WindowType),
 	m_WindowTitle(a_WindowTitle),
@@ -31,7 +31,7 @@ cWindow::cWindow(cWindow::WindowType a_WindowType, const AString & a_WindowTitle
 	m_IsDestroyed(false),
 	m_ShouldDistributeToHotbarFirst(true)
 {
-	if (a_WindowType == Inventory)
+	if (a_WindowType == wtInventory)
 	{
 		m_WindowID = 0;
 	}
@@ -277,7 +277,7 @@ bool cWindow::ClosedByPlayer(cPlayer & a_Player, bool a_CanRefuse)
 
 		m_OpenedBy.remove(&a_Player);
 		
-		if ((m_WindowType != Inventory) && m_OpenedBy.empty())
+		if ((m_WindowType != wtInventory) && m_OpenedBy.empty())
 		{
 			Destroy();
 		}
@@ -703,7 +703,7 @@ void cWindow::SetProperty(int a_Property, int a_Value, cPlayer & a_Player)
 // cInventoryWindow:
 
 cInventoryWindow::cInventoryWindow(cPlayer & a_Player) :
-	cWindow(cWindow::Inventory, "Inventory"),
+	cWindow(wtInventory, "Inventory"),
 	m_Player(a_Player)
 {
 	m_SlotAreas.push_back(new cSlotAreaCrafting(2, *this));  // The creative inventory doesn't display it, but it's still counted into slot numbers
@@ -720,7 +720,7 @@ cInventoryWindow::cInventoryWindow(cPlayer & a_Player) :
 // cCraftingWindow:
 
 cCraftingWindow::cCraftingWindow(int a_BlockX, int a_BlockY, int a_BlockZ) :
-	cWindow(cWindow::Workbench, "Crafting Table")
+	cWindow(wtWorkbench, "Crafting Table")
 {
 	m_SlotAreas.push_back(new cSlotAreaCrafting(3, *this));
 	m_SlotAreas.push_back(new cSlotAreaInventory(*this));
@@ -735,7 +735,7 @@ cCraftingWindow::cCraftingWindow(int a_BlockX, int a_BlockY, int a_BlockZ) :
 // cChestWindow:
 
 cChestWindow::cChestWindow(cChestEntity * a_Chest) :
-	cWindow(cWindow::Chest, "Chest"),
+	cWindow(wtChest, "Chest"),
 	m_World(a_Chest->GetWorld()),
 	m_BlockX(a_Chest->GetPosX()),
 	m_BlockY(a_Chest->GetPosY()),
@@ -757,7 +757,7 @@ cChestWindow::cChestWindow(cChestEntity * a_Chest) :
 
 
 cChestWindow::cChestWindow(cChestEntity * a_PrimaryChest, cChestEntity * a_SecondaryChest) :
-	cWindow(cWindow::Chest, "Double Chest"),
+	cWindow(wtChest, "Double Chest"),
 	m_World(a_PrimaryChest->GetWorld()),
 	m_BlockX(a_PrimaryChest->GetPosX()),
 	m_BlockY(a_PrimaryChest->GetPosY()),
@@ -796,7 +796,7 @@ cChestWindow::~cChestWindow()
 // cDropSpenserWindow:
 
 cDropSpenserWindow::cDropSpenserWindow(int a_BlockX, int a_BlockY, int a_BlockZ, cDropSpenserEntity * a_DropSpenser) :
-	cWindow(cWindow::DropSpenser, "Dropspenser")
+	cWindow(wtDropSpenser, "Dropspenser")
 {
 	m_ShouldDistributeToHotbarFirst = false;
 	m_SlotAreas.push_back(new cSlotAreaItemGrid(a_DropSpenser->GetContents(), *this));
@@ -812,7 +812,7 @@ cDropSpenserWindow::cDropSpenserWindow(int a_BlockX, int a_BlockY, int a_BlockZ,
 // cHopperWindow:
 
 cHopperWindow::cHopperWindow(int a_BlockX, int a_BlockY, int a_BlockZ, cHopperEntity * a_Hopper) :
-	super(cWindow::Hopper, "Hopper")
+	super(wtHopper, "Hopper")
 {
 	m_ShouldDistributeToHotbarFirst = false;
 	m_SlotAreas.push_back(new cSlotAreaItemGrid(a_Hopper->GetContents(), *this));
@@ -828,7 +828,7 @@ cHopperWindow::cHopperWindow(int a_BlockX, int a_BlockY, int a_BlockZ, cHopperEn
 // cFurnaceWindow:
 
 cFurnaceWindow::cFurnaceWindow(int a_BlockX, int a_BlockY, int a_BlockZ, cFurnaceEntity * a_Furnace) :
-	cWindow(cWindow::Furnace, "Furnace")
+	cWindow(wtFurnace, "Furnace")
 {
 	m_ShouldDistributeToHotbarFirst = false;
 	m_SlotAreas.push_back(new cSlotAreaFurnace(a_Furnace, *this));
diff --git a/source/UI/Window.h b/source/UI/Window.h
index aa7e9d0d0..2d5e81e9e 100644
--- a/source/UI/Window.h
+++ b/source/UI/Window.h
@@ -49,17 +49,17 @@ class cWindow
 public:
 	enum WindowType
 	{
-		Inventory   = -1,  // This value is never actually sent to a client
-		Chest       = 0,
-		Workbench   = 1,
-		Furnace     = 2,
-		DropSpenser = 3,  // Dropper or Dispenser
-		Enchantment = 4,
-		Brewery     = 5,
-		NPCTrade    = 6,
-		Beacon      = 7,
-		Anvil       = 8,
-		Hopper      = 9,
+		wtInventory   = -1,  // This value is never actually sent to a client
+		wtChest       = 0,
+		wtWorkbench   = 1,
+		wtFurnace     = 2,
+		wtDropSpenser = 3,  // Dropper or Dispenser
+		wtEnchantment = 4,
+		wtBrewery     = 5,
+		wtNPCTrade    = 6,
+		wtBeacon      = 7,
+		wtAnvil       = 8,
+		wtHopper      = 9,
 	};
 	
 	// tolua_end
diff --git a/source/WebAdmin.cpp b/source/WebAdmin.cpp
index 882969746..8c95e4e21 100644
--- a/source/WebAdmin.cpp
+++ b/source/WebAdmin.cpp
@@ -44,8 +44,7 @@ public:
 
 cWebAdmin::cWebAdmin(void) :
 	m_IsInitialized(false),
-	m_TemplateScript("<webadmin_template>"),
-	m_IniFile("webadmin.ini")
+	m_TemplateScript("<webadmin_template>")
 {
 }
 
@@ -86,19 +85,19 @@ void cWebAdmin::RemovePlugin( cWebPlugin * a_Plugin )
 
 bool cWebAdmin::Init(void)
 {
-	if (!m_IniFile.ReadFile())
+	if (!m_IniFile.ReadFile("webadmin.ini"))
 	{
 		return false;
 	}
 
-	LOG("Initialising WebAdmin...");
-
 	if (!m_IniFile.GetValueSetB("WebAdmin", "Enabled", true))
 	{
 		// WebAdmin is disabled, bail out faking a success
 		return true;
 	}
 
+	LOG("Initialising WebAdmin...");
+
 	AString PortsIPv4 = m_IniFile.GetValueSet("WebAdmin", "Port", "8080");
 	AString PortsIPv6 = m_IniFile.GetValueSet("WebAdmin", "PortsIPv6", "");
 
diff --git a/source/World.cpp b/source/World.cpp
index a61c19d63..786d97a4d 100644
--- a/source/World.cpp
+++ b/source/World.cpp
@@ -444,8 +444,8 @@ void cWorld::Start(void)
 	m_SpawnZ = (double)((m_TickRand.randInt() % 1000) - 500);
 	m_GameMode = eGameMode_Creative;
 
-	cIniFile IniFile(m_IniFileName);
-	if (!IniFile.ReadFile())
+	cIniFile IniFile;
+	if (!IniFile.ReadFile(m_IniFileName))
 	{
 		LOGWARNING("Cannot read world settings from \"%s\", defaults will be used.", m_IniFileName.c_str());
 	}
@@ -555,7 +555,7 @@ void cWorld::Start(void)
 
 
 	// Save any changes that the defaults may have done to the ini file:
-	if (!IniFile.WriteFile())
+	if (!IniFile.WriteFile(m_IniFileName))
 	{
 		LOGWARNING("Could not write world config to %s", m_IniFileName.c_str());
 	}
@@ -755,9 +755,9 @@ void cWorld::TickMobs(float a_Dt)
 		for (int i = 0; i < ARRAYCOUNT(AllFamilies); i++)
 		{
 			cMonster::eFamily Family = AllFamilies[i];
-			int spawnrate = cMonster::GetSpawnRate(Family);
+			int SpawnDelay = cMonster::GetSpawnDelay(Family);
 			if (
-				(m_LastSpawnMonster[Family] > m_WorldAge - spawnrate) ||  // Not reached the needed tiks before the next round
+				(m_LastSpawnMonster[Family] > m_WorldAge - SpawnDelay) ||  // Not reached the needed ticks before the next round
 				MobCensus.IsCapped(Family)
 			)
 			{
@@ -1470,7 +1470,7 @@ bool cWorld::WriteBlockArea(cBlockArea & a_Area, int a_MinBlockX, int a_MinBlock
 
 
 
-void cWorld::SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_FlyAwaySpeed)
+void cWorld::SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_FlyAwaySpeed, bool IsPlayerCreated)
 {
 	MTRand r1;
 	a_FlyAwaySpeed /= 1000;  // Pre-divide, so that we don't have to divide each time inside the loop
@@ -1482,7 +1482,7 @@ void cWorld::SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double
 		
 		cPickup * Pickup = new cPickup(
 			a_BlockX, a_BlockY, a_BlockZ,
-			*itr, SpeedX, SpeedY, SpeedZ
+			*itr, IsPlayerCreated, SpeedX, SpeedY, SpeedZ
 		);
 		Pickup->Initialize(this);
 	}
@@ -1492,13 +1492,13 @@ void cWorld::SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double
 
 
 
-void cWorld::SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_SpeedX, double a_SpeedY, double a_SpeedZ)
+void cWorld::SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_SpeedX, double a_SpeedY, double a_SpeedZ, bool IsPlayerCreated)
 {
 	for (cItems::const_iterator itr = a_Pickups.begin(); itr != a_Pickups.end(); ++itr)
 	{
 		cPickup * Pickup = new cPickup(
 			a_BlockX, a_BlockY, a_BlockZ,
-			*itr, (float)a_SpeedX, (float)a_SpeedY, (float)a_SpeedZ
+			*itr, IsPlayerCreated, (float)a_SpeedX, (float)a_SpeedY, (float)a_SpeedZ
 		);
 		Pickup->Initialize(this);
 	}
diff --git a/source/World.h b/source/World.h
index a91007b17..f174a1c2c 100644
--- a/source/World.h
+++ b/source/World.h
@@ -348,10 +348,10 @@ public:
 	// tolua_begin

 

 	/// Spawns item pickups for each item in the list. May compress pickups if too many entities:

-	void SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_FlyAwaySpeed = 1.0);

+	void SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_FlyAwaySpeed = 1.0, bool IsPlayerCreated = false);

 	

 	/// Spawns item pickups for each item in the list. May compress pickups if too many entities. All pickups get the speed specified:

-	void SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_SpeedX, double a_SpeedY, double a_SpeedZ);

+	void SpawnItemPickups(const cItems & a_Pickups, double a_BlockX, double a_BlockY, double a_BlockZ, double a_SpeedX, double a_SpeedY, double a_SpeedZ, bool IsPlayerCreated = false);

 	

 	/// Spawns a new primed TNT entity at the specified block coords and specified fuse duration. Initial velocity is given based on the relative coefficient provided

 	void SpawnPrimedTNT(double a_X, double a_Y, double a_Z, double a_FuseTimeInSec, double a_InitialVelocityCoeff = 1);

diff --git a/source/WorldStorage/WSSAnvil.cpp b/source/WorldStorage/WSSAnvil.cpp
index 537e2f723..b2e104a78 100644
--- a/source/WorldStorage/WSSAnvil.cpp
+++ b/source/WorldStorage/WSSAnvil.cpp
@@ -1123,7 +1123,7 @@ void cWSSAnvil::LoadPickupFromNBT(cEntityList & a_Entities, const cParsedNBT & a
 	{
 		return;
 	}
-	std::auto_ptr<cPickup> Pickup(new cPickup(0, 0, 0, Item));
+	std::auto_ptr<cPickup> Pickup(new cPickup(0, 0, 0, Item, false)); // Pickup delay doesn't matter, just say false
 	if (!LoadEntityBaseFromNBT(*Pickup.get(), a_NBT, a_TagIdx))
 	{
 		return;