flewkey/cuberite-2a
1
0
Fork 0
Code Releases Activity

Merge branch 'master' into BlockTracing

Browse Source
This commit is contained in:
madmaxoft 2013-08-05 16:02:41 +02:00
commit c0066e7260
14 changed files with 1199 additions and 719 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
VC2008/MCServer.vcproj
View File

@ -1852,6 +1852,10 @@
RelativePath="..\source\blocks\BlockCactus.h"
>
</File>
<File
RelativePath="..\source\Blocks\BlockCarpet.h"
>
</File>
<File
RelativePath="..\source\Blocks\BlockCauldron.h"
>

89
VC2008/MCServer.vcproj.user Normal file
View File

@ -0,0 +1,89 @@
<?xml version="1.0" encoding="UTF-8"?>
<VisualStudioUserFile
ProjectType="Visual C++"
Version="9,00"
ShowAllFiles="false"
>
<Configurations>
<Configuration
Name="Debug|Win32"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory="..\MCServer"
CommandArguments=""
Attach="false"
DebuggerType="3"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor="0"
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Release|Win32"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory="..\MCServer"
CommandArguments=""
Attach="false"
DebuggerType="3"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor="0"
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
<Configuration
Name="Release profiled|Win32"
>
<DebugSettings
Command="$(TargetPath)"
WorkingDirectory="..\MCServer"
CommandArguments=""
Attach="false"
DebuggerType="3"
Remote="1"
RemoteMachine="ASAGA"
RemoteCommand=""
HttpUrl=""
PDBPath=""
SQLDebugging=""
Environment=""
EnvironmentMerge="true"
DebuggerFlavor="0"
MPIRunCommand=""
MPIRunArguments=""
MPIRunWorkingDirectory=""
ApplicationCommand=""
ApplicationArguments=""
ShimCommand=""
MPIAcceptMode=""
MPIAcceptFilter=""
/>
</Configuration>
</Configurations>
</VisualStudioUserFile>

521
iniFile/iniFile.cpp
View File

@ -12,17 +12,13 @@
//////////////////////////////////////////////////////////////////////
/*
!! MODIFIED BY FAKETRUTH !!
!! MODIFIED BY FAKETRUTH and xoft !!
*/
#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules
// C++ Includes
#include <iostream>
#include <fstream>
#include <sstream>
using namespace std;
// C Includes
#include <ctype.h>
@ -31,26 +27,32 @@ using namespace std;
#include "iniFile.h"
#if defined(WIN32)
#define iniEOL endl
#define iniEOL endl
#else
#define iniEOL '\r' << endl
#define iniEOL '\r' << endl
#endif
#ifndef _WIN32
#define sscanf_s(buffer, stringbuffer, ...) (sscanf(buffer, stringbuffer, __VA_ARGS__))
#define sscanf_s(buffer, stringbuffer, ...) (sscanf(buffer, stringbuffer, __VA_ARGS__))
#endif
using namespace std;
cIniFile::cIniFile( const string iniPath)
cIniFile::cIniFile(const string & a_Path) :
m_IsCaseInsensitive(true)
{
Path( iniPath);
caseInsensitive = true;
Path(a_Path);
}
bool cIniFile::ReadFile()
bool cIniFile::ReadFile(bool a_AllowExampleRedirect)
{
// Normally you would use ifstream, but the SGI CC compiler has
// a few bugs with ifstream. So ... fstream used.
@ -58,12 +60,31 @@ bool cIniFile::ReadFile()
string line;
string keyname, valuename, value;
string::size_type pLeft, pRight;
bool IsFromExampleRedirect = false;
f.open( (FILE_IO_PREFIX + path).c_str(), ios::in);
if ( f.fail())
f.open((FILE_IO_PREFIX + m_Path).c_str(), ios::in);
if (f.fail())
{
f.clear();
if (a_AllowExampleRedirect)
{
// Retry with the .example.ini file instead of .ini:
string ExPath(m_Path.substr(0, m_Path.length() - 4));
ExPath.append(".example.ini");
f.open((FILE_IO_PREFIX + ExPath).c_str(), ios::in);
if (f.fail())
{
return false;
}
IsFromExampleRedirect = true;
}
else
{
return false;
}
}
while (getline( f, line))
while (getline(f, line))
{
// To be compatible with Win32, check for existence of '\r'.
// Win32 files have the '\r' and Unix files don't at the end of a line.
@ -75,9 +96,9 @@ bool cIniFile::ReadFile()
{
continue;
}
if ( line[lineLength - 1] == '\r')
if (line[lineLength - 1] == '\r')
{
line = line.substr( 0, lineLength - 1);
line = line.substr(0, lineLength - 1);
}
if (line.length() == 0)
@ -87,18 +108,18 @@ bool cIniFile::ReadFile()
// Check that the user hasn't opened a binary file by checking the first
// character of each line!
if ( !isprint( line[0]))
if (!isprint(line[0]))
{
printf( "Failing on char %d\n", line[0]);
printf("%s: Binary-check failed on char %d\n", __FUNCTION__, line[0]);
f.close();
return false;
}
if (( pLeft = line.find_first_of(";#[=")) == string::npos)
if ((pLeft = line.find_first_of(";#[=")) == string::npos)
{
continue;
}
switch ( line[pLeft])
switch (line[pLeft])
{
case '[':
{
@ -107,17 +128,17 @@ bool cIniFile::ReadFile()
(pRight > pLeft)
)
{
keyname = line.substr( pLeft + 1, pRight - pLeft - 1);
AddKeyName( keyname);
keyname = line.substr(pLeft + 1, pRight - pLeft - 1);
AddKeyName(keyname);
}
break;
}
case '=':
{
valuename = line.substr( 0, pLeft);
value = line.substr( pLeft + 1);
SetValue( keyname, valuename, value);
valuename = line.substr(0, pLeft);
value = line.substr(pLeft + 1);
SetValue(keyname, valuename, value);
break;
}
@ -126,11 +147,11 @@ bool cIniFile::ReadFile()
{
if (names.size() == 0)
{
HeaderComment( line.substr( pLeft + 1));
HeaderComment(line.substr(pLeft + 1));
}
else
{
KeyComment( keyname, line.substr( pLeft + 1));
KeyComment(keyname, line.substr(pLeft + 1));
}
break;
}
@ -138,43 +159,61 @@ bool cIniFile::ReadFile()
} // while (getline())
f.close();
if (names.size() > 0)
if (names.size() == 0)
{
return true;
}
return false;
}
if (IsFromExampleRedirect)
{
WriteFile();
}
return true;
}
bool cIniFile::WriteFile()
bool cIniFile::WriteFile(void) const
{
unsigned commentID, keyID, valueID;
// Normally you would use ofstream, but the SGI CC compiler has
// a few bugs with ofstream. So ... fstream used.
fstream f;
f.open( (FILE_IO_PREFIX + path).c_str(), ios::out);
if ( f.fail())
f.open((FILE_IO_PREFIX + m_Path).c_str(), ios::out);
if (f.fail())
{
return false;
}
// Write header comments.
for ( commentID = 0; commentID < comments.size(); ++commentID)
for (commentID = 0; commentID < comments.size(); ++commentID)
{
f << ';' << comments[commentID] << iniEOL;
if ( comments.size())
}
if (comments.size())
{
f << iniEOL;
}
// Write keys and values.
for ( keyID = 0; keyID < keys.size(); ++keyID) {
for (keyID = 0; keyID < keys.size(); ++keyID)
{
f << '[' << names[keyID] << ']' << iniEOL;
// Comments.
for ( commentID = 0; commentID < keys[keyID].comments.size(); ++commentID)
for (commentID = 0; commentID < keys[keyID].comments.size(); ++commentID)
{
f << ';' << keys[keyID].comments[commentID] << iniEOL;
}
// Values.
for ( valueID = 0; valueID < keys[keyID].names.size(); ++valueID)
for (valueID = 0; valueID < keys[keyID].names.size(); ++valueID)
{
f << keys[keyID].names[valueID] << '=' << keys[keyID].values[valueID] << iniEOL;
}
f << iniEOL;
}
f.close();
@ -186,11 +225,16 @@ bool cIniFile::WriteFile()
long cIniFile::FindKey( const string & keyname) const
long cIniFile::FindKey(const string & a_KeyName) const
{
for ( unsigned keyID = 0; keyID < names.size(); ++keyID)
if ( CheckCase( names[keyID]) == CheckCase( keyname))
string CaseKeyName = CheckCase(a_KeyName);
for (unsigned keyID = 0; keyID < names.size(); ++keyID)
{
if (CheckCase(names[keyID]) == CaseKeyName)
{
return long(keyID);
}
}
return noID;
}
@ -198,14 +242,21 @@ long cIniFile::FindKey( const string & keyname) const
long cIniFile::FindValue( unsigned const keyID, const string & valuename) const
long cIniFile::FindValue(unsigned const keyID, const string & a_ValueName) const
{
if ( !keys.size() || keyID >= keys.size())
if (!keys.size() || (keyID >= keys.size()))
{
return noID;
}
for ( unsigned valueID = 0; valueID < keys[keyID].names.size(); ++valueID)
if ( CheckCase( keys[keyID].names[valueID]) == CheckCase( valuename))
string CaseValueName = CheckCase(a_ValueName);
for (unsigned valueID = 0; valueID < keys[keyID].names.size(); ++valueID)
{
if (CheckCase(keys[keyID].names[valueID]) == CaseValueName)
{
return long(valueID);
}
}
return noID;
}
@ -213,10 +264,10 @@ long cIniFile::FindValue( unsigned const keyID, const string & valuename) const
unsigned cIniFile::AddKeyName( const string & keyname)
unsigned cIniFile::AddKeyName(const string & keyname)
{
names.resize( names.size() + 1, keyname);
keys.resize( keys.size() + 1);
names.resize(names.size() + 1, keyname);
keys.resize(keys.size() + 1);
return names.size() - 1;
}
@ -224,22 +275,28 @@ unsigned cIniFile::AddKeyName( const string & keyname)
string cIniFile::KeyName( unsigned const keyID) const
string cIniFile::KeyName(unsigned const keyID) const
{
if ( keyID < names.size())
if (keyID < names.size())
{
return names[keyID];
}
else
{
return "";
}
}
unsigned cIniFile::NumValues( unsigned const keyID)
unsigned cIniFile::NumValues(unsigned const keyID)
{
if ( keyID < keys.size())
if (keyID < keys.size())
{
return keys[keyID].names.size();
}
return 0;
}
@ -247,11 +304,13 @@ unsigned cIniFile::NumValues( unsigned const keyID)
unsigned cIniFile::NumValues( const string & keyname)
unsigned cIniFile::NumValues(const string & keyname)
{
long keyID = FindKey( keyname);
if ( keyID == noID)
long keyID = FindKey(keyname);
if (keyID == noID)
{
return 0;
}
return keys[keyID].names.size();
}
@ -259,10 +318,12 @@ unsigned cIniFile::NumValues( const string & keyname)
string cIniFile::ValueName( unsigned const keyID, unsigned const valueID) const
string cIniFile::ValueName(unsigned const keyID, unsigned const valueID) const
{
if ( keyID < keys.size() && valueID < keys[keyID].names.size())
if (keyID < keys.size() && valueID < keys[keyID].names.size())
{
return keys[keyID].names[valueID];
}
return "";
}
@ -270,23 +331,26 @@ string cIniFile::ValueName( unsigned const keyID, unsigned const valueID) const
string cIniFile::ValueName( const string & keyname, unsigned const valueID) const
string cIniFile::ValueName(const string & keyname, unsigned const valueID) const
{
long keyID = FindKey( keyname);
if ( keyID == noID)
long keyID = FindKey(keyname);
if (keyID == noID)
{
return "";
return ValueName( keyID, valueID);
}
return ValueName(keyID, valueID);
}
bool cIniFile::SetValue( unsigned const keyID, unsigned const valueID, const string & value)
bool cIniFile::SetValue(unsigned const keyID, unsigned const valueID, const string & value)
{
if ( keyID < keys.size() && valueID < keys[keyID].names.size())
if ((keyID < keys.size()) && (valueID < keys[keyID].names.size()))
{
keys[keyID].values[valueID] = value;
}
return false;
}
@ -294,30 +358,41 @@ bool cIniFile::SetValue( unsigned const keyID, unsigned const valueID, const str
bool cIniFile::SetValue( const string & keyname, const string & valuename, const string & value, bool const create)
bool cIniFile::SetValue(const string & keyname, const string & valuename, const string & value, bool const create)
{
long keyID = FindKey( keyname);
if ( keyID == noID) {
if ( create)
keyID = long( AddKeyName( keyname));
long keyID = FindKey(keyname);
if (keyID == noID)
{
if (create)
{
keyID = long(AddKeyName(keyname));
}
else
{
return false;
}
}
long valueID = FindValue( unsigned(keyID), valuename);
if ( valueID == noID) {
if ( !create)
return false;
keys[keyID].names.resize( keys[keyID].names.size() + 1, valuename);
keys[keyID].values.resize( keys[keyID].values.size() + 1, value);
} else
long valueID = FindValue(unsigned(keyID), valuename);
if (valueID == noID)
{
if(!create)
keys[keyID].values[valueID] = value;
if (!create)
{
return false;
}
keys[keyID].names.resize(keys[keyID].names.size() + 1, valuename);
keys[keyID].values.resize(keys[keyID].values.size() + 1, value);
}
else
{
keys[keyID].names.resize( keys[keyID].names.size() + 1, valuename);
keys[keyID].values.resize( keys[keyID].values.size() + 1, value);
if (!create)
{
keys[keyID].values[valueID] = value;
}
else
{
keys[keyID].names.resize(keys[keyID].names.size() + 1, valuename);
keys[keyID].values.resize(keys[keyID].values.size() + 1, value);
}
}
@ -328,48 +403,49 @@ bool cIniFile::SetValue( const string & keyname, const string & valuename, const
bool cIniFile::SetValueI( const string & keyname, const string & valuename, int const value, bool const create)
bool cIniFile::SetValueI(const string & keyname, const string & valuename, int const value, bool const create)
{
AString Data;
Printf(Data, "%d", value);
return SetValue( keyname, valuename, Data, create);
return SetValue(keyname, valuename, Data, create);
}
bool cIniFile::SetValueF( const string & keyname, const string & valuename, double const value, bool const create)
bool cIniFile::SetValueF(const string & keyname, const string & valuename, double const value, bool const create)
{
AString Data;
Printf(Data, "%f", value);
return SetValue( keyname, valuename, Data, create);
return SetValue(keyname, valuename, Data, create);
}
bool cIniFile::SetValueV( const string & keyname, const string & valuename, char *format, ...)
bool cIniFile::SetValueV(const string & keyname, const string & valuename, char * format, ...)
{
va_list args;
va_start( args, format);
va_start(args, format);
AString Data;
AppendVPrintf(Data, format, args);
va_end( args);
return SetValue( keyname, valuename, Data);
va_end(args);
return SetValue(keyname, valuename, Data);
}
string cIniFile::GetValue( unsigned const keyID, unsigned const valueID, const string & defValue) const
string cIniFile::GetValue(unsigned const keyID, unsigned const valueID, const string & defValue) const
{
if ( keyID < keys.size() && valueID < keys[keyID].names.size())
if ((keyID < keys.size()) && (valueID < keys[keyID].names.size()))
{
return keys[keyID].values[valueID];
}
return defValue;
}
@ -377,15 +453,19 @@ string cIniFile::GetValue( unsigned const keyID, unsigned const valueID, const s
string cIniFile::GetValue( const string & keyname, const string & valuename, const string & defValue) const
string cIniFile::GetValue(const string & keyname, const string & valuename, const string & defValue) const
{
long keyID = FindKey( keyname);
if ( keyID == noID)
long keyID = FindKey(keyname);
if (keyID == noID)
{
return defValue;
}
long valueID = FindValue( unsigned(keyID), valuename);
if ( valueID == noID)
long valueID = FindValue(unsigned(keyID), valuename);
if (valueID == noID)
{
return defValue;
}
return keys[keyID].values[valueID];
}
@ -398,7 +478,7 @@ int cIniFile::GetValueI(const string & keyname, const string & valuename, int co
{
AString Data;
Printf(Data, "%d", defValue);
return atoi( GetValue( keyname, valuename, Data).c_str());
return atoi(GetValue(keyname, valuename, Data).c_str());
}
@ -409,7 +489,7 @@ double cIniFile::GetValueF(const string & keyname, const string & valuename, dou
{
AString Data;
Printf(Data, "%f", defValue);
return atof( GetValue( keyname, valuename, Data).c_str());
return atof(GetValue(keyname, valuename, Data).c_str());
}
@ -418,15 +498,15 @@ double cIniFile::GetValueF(const string & keyname, const string & valuename, dou
AString cIniFile::GetValueSet(const AString & keyname, const AString & valuename, const AString & defValue)
{
long keyID = FindKey( keyname);
if ( keyID == noID)
long keyID = FindKey(keyname);
if (keyID == noID)
{
SetValue(keyname, valuename, defValue);
return defValue;
}
long valueID = FindValue( unsigned(keyID), valuename);
if ( valueID == noID)
long valueID = FindValue(unsigned(keyID), valuename);
if (valueID == noID)
{
SetValue(keyname, valuename, defValue);
return defValue;
@ -461,175 +541,266 @@ int cIniFile::GetValueSetI(const AString & keyname, const AString & valuename, c
bool cIniFile::DeleteValueByID( const unsigned keyID, const unsigned valueID )
bool cIniFile::DeleteValueByID(const unsigned keyID, const unsigned valueID)
{
if ( keyID < keys.size() && valueID < keys[keyID].names.size())
if (keyID < keys.size() && valueID < keys[keyID].names.size())
{
// This looks strange, but is neccessary.
vector<string>::iterator npos = keys[keyID].names.begin() + valueID;
vector<string>::iterator vpos = keys[keyID].values.begin() + valueID;
keys[keyID].names.erase( npos, npos + 1);
keys[keyID].values.erase( vpos, vpos + 1);
keys[keyID].names.erase(npos, npos + 1);
keys[keyID].values.erase(vpos, vpos + 1);
return true;
}
return false;
}
bool cIniFile::DeleteValue( const string & keyname, const string & valuename)
bool cIniFile::DeleteValue(const string & keyname, const string & valuename)
{
long keyID = FindKey( keyname);
if ( keyID == noID)
long keyID = FindKey(keyname);
if (keyID == noID)
{
return false;
}
long valueID = FindValue( unsigned(keyID), valuename);
if ( valueID == noID)
long valueID = FindValue(unsigned(keyID), valuename);
if (valueID == noID)
{
return false;
}
return DeleteValueByID( keyID, valueID );
return DeleteValueByID(keyID, valueID);
}
bool cIniFile::DeleteKey( const string & keyname)
{
long keyID = FindKey( keyname);
if ( keyID == noID)
return false;
// Now hopefully this destroys the vector lists within keys.
// Looking at <vector> source, this should be the case using the destructor.
// If not, I may have to do it explicitly. Memory leak check should tell.
// memleak_test.cpp shows that the following not required.
//keys[keyID].names.clear();
//keys[keyID].values.clear();
bool cIniFile::DeleteKey(const string & keyname)
{
long keyID = FindKey(keyname);
if (keyID == noID)
{
return false;
}
vector<string>::iterator npos = names.begin() + keyID;
vector<key>::iterator kpos = keys.begin() + keyID;
names.erase( npos, npos + 1);
keys.erase( kpos, kpos + 1);
names.erase(npos, npos + 1);
keys.erase(kpos, kpos + 1);
return true;
}
void cIniFile::Erase()
void cIniFile::Clear(void)
{
// This loop not needed. The vector<> destructor seems to do
// all the work itself. memleak_test.cpp shows this.
//for ( unsigned i = 0; i < keys.size(); ++i) {
// keys[i].names.clear();
// keys[i].values.clear();
//}
names.clear();
keys.clear();
comments.clear();
}
void cIniFile::HeaderComment( const string & comment)
void cIniFile::HeaderComment(const string & comment)
{
comments.resize( comments.size() + 1, comment);
comments.push_back(comment);
// comments.resize(comments.size() + 1, comment);
}
string cIniFile::HeaderComment( unsigned const commentID) const
string cIniFile::HeaderComment(unsigned const commentID) const
{
if ( commentID < comments.size())
if (commentID < comments.size())
{
return comments[commentID];
}
return "";
}
bool cIniFile::DeleteHeaderComment( unsigned commentID)
bool cIniFile::DeleteHeaderComment(unsigned commentID)
{
if ( commentID < comments.size()) {
if (commentID < comments.size())
{
vector<string>::iterator cpos = comments.begin() + commentID;
comments.erase( cpos, cpos + 1);
comments.erase(cpos, cpos + 1);
return true;
}
return false;
}
unsigned cIniFile::NumKeyComments( unsigned const keyID) const
unsigned cIniFile::NumKeyComments(unsigned const keyID) const
{
if ( keyID < keys.size())
if (keyID < keys.size())
{
return keys[keyID].comments.size();
}
return 0;
}
unsigned cIniFile::NumKeyComments( const string & keyname) const
unsigned cIniFile::NumKeyComments(const string & keyname) const
{
long keyID = FindKey( keyname);
if ( keyID == noID)
long keyID = FindKey(keyname);
if (keyID == noID)
return 0;
return keys[keyID].comments.size();
}
bool cIniFile::KeyComment( unsigned const keyID, const string & comment)
bool cIniFile::KeyComment(unsigned const keyID, const string & comment)
{
if ( keyID < keys.size()) {
keys[keyID].comments.resize( keys[keyID].comments.size() + 1, comment);
if (keyID < keys.size())
{
keys[keyID].comments.resize(keys[keyID].comments.size() + 1, comment);
return true;
}
return false;
}
bool cIniFile::KeyComment( const string & keyname, const string & comment)
bool cIniFile::KeyComment(const string & keyname, const string & comment)
{
long keyID = FindKey( keyname);
if ( keyID == noID)
long keyID = FindKey(keyname);
if (keyID == noID)
{
return false;
return KeyComment( unsigned(keyID), comment);
}
return KeyComment(unsigned(keyID), comment);
}
string cIniFile::KeyComment( unsigned const keyID, unsigned const commentID) const
string cIniFile::KeyComment(unsigned const keyID, unsigned const commentID) const
{
if ( keyID < keys.size() && commentID < keys[keyID].comments.size())
if ((keyID < keys.size()) && (commentID < keys[keyID].comments.size()))
{
return keys[keyID].comments[commentID];
}
return "";
}
string cIniFile::KeyComment( const string & keyname, unsigned const commentID) const
string cIniFile::KeyComment(const string & keyname, unsigned const commentID) const
{
long keyID = FindKey( keyname);
if ( keyID == noID)
long keyID = FindKey(keyname);
if (keyID == noID)
{
return "";
return KeyComment( unsigned(keyID), commentID);
}
return KeyComment(unsigned(keyID), commentID);
}
bool cIniFile::DeleteKeyComment( unsigned const keyID, unsigned const commentID)
bool cIniFile::DeleteKeyComment(unsigned const keyID, unsigned const commentID)
{
if ( keyID < keys.size() && commentID < keys[keyID].comments.size()) {
if ((keyID < keys.size()) && (commentID < keys[keyID].comments.size()))
{
vector<string>::iterator cpos = keys[keyID].comments.begin() + commentID;
keys[keyID].comments.erase( cpos, cpos + 1);
keys[keyID].comments.erase(cpos, cpos + 1);
return true;
}
return false;
}
bool cIniFile::DeleteKeyComment( const string & keyname, unsigned const commentID)
bool cIniFile::DeleteKeyComment(const string & keyname, unsigned const commentID)
{
long keyID = FindKey( keyname);
if ( keyID == noID)
long keyID = FindKey(keyname);
if (keyID == noID)
{
return false;
return DeleteKeyComment( unsigned(keyID), commentID);
}
return DeleteKeyComment(unsigned(keyID), commentID);
}
bool cIniFile::DeleteKeyComments( unsigned const keyID)
bool cIniFile::DeleteKeyComments(unsigned const keyID)
{
if ( keyID < keys.size()) {
if (keyID < keys.size())
{
keys[keyID].comments.clear();
return true;
}
return false;
}
bool cIniFile::DeleteKeyComments( const string & keyname)
bool cIniFile::DeleteKeyComments(const string & keyname)
{
long keyID = FindKey( keyname);
if ( keyID == noID)
long keyID = FindKey(keyname);
if (keyID == noID)
{
return false;
return DeleteKeyComments( unsigned(keyID));
}
return DeleteKeyComments(unsigned(keyID));
}
string cIniFile::CheckCase( string s) const
string cIniFile::CheckCase(const string & s) const
{
if ( caseInsensitive)
for ( string::size_type i = 0; i < s.length(); ++i)
s[i] = (char)tolower(s[i]);
if (!m_IsCaseInsensitive)
{
return s;
}
string res(s);
size_t len = res.length();
for (size_t i = 0; i < len; i++)
{
res[i] = tolower(res[i]);
}
return res;
}

194
iniFile/iniFile.h
View File

@ -30,135 +30,155 @@
class cIniFile // tolua_export
{ // tolua_export
// tolua_begin
class cIniFile
{
private:
bool caseInsensitive;
std::string path;
struct key {
bool m_IsCaseInsensitive;
std::string m_Path;
struct key
{
std::vector<std::string> names;
std::vector<std::string> values;
std::vector<std::string> comments;
};
} ;
std::vector<key> keys;
std::vector<std::string> names;
std::vector<std::string> comments;
std::string CheckCase( std::string s) const;
/// If the object is case-insensitive, returns s as lowercase; otherwise returns s as-is
std::string CheckCase(const std::string & s) const;
public:
enum errors{ noID = -1}; // tolua_export
cIniFile( const std::string iniPath = ""); // tolua_export
virtual ~cIniFile() {}
enum errors
{
noID = -1,
};
/// Creates a new instance; sets m_Path to a_Path, but doesn't read the file
cIniFile(const std::string & a_Path = "");
// Sets whether or not keynames and valuenames should be case sensitive.
// The default is case insensitive.
void CaseSensitive() {caseInsensitive = false;} // tolua_export
void CaseInsensitive() {caseInsensitive = true;} // tolua_export
void CaseSensitive (void) { m_IsCaseInsensitive = false; }
void CaseInsensitive(void) { m_IsCaseInsensitive = true; }
// Sets path of ini file to read and write from.
void Path(const std::string & newPath) {path = newPath;} // tolua_export
std::string Path() const {return path;} // tolua_export
void SetPath(const std::string & newPath) {Path( newPath);} // tolua_export
void Path(const std::string & newPath) {m_Path = newPath;}
const std::string & Path(void) const {return m_Path;}
void SetPath(const std::string & newPath) {Path(newPath);}
// Reads ini file specified using path.
// Returns true if successful, false otherwise.
bool ReadFile(); // tolua_export
/** Reads the ini file specified in m_Path
If the file doesn't exist and a_AllowExampleRedirect is true, tries to read <basename>.example.ini, and
writes its contents as <basename>.ini, if successful.
Returns true if successful, false otherwise.
*/
bool ReadFile(bool a_AllowExampleRedirect = true);
// Writes data stored in class to ini file.
bool WriteFile(); // tolua_export
/// Writes data stored in class to ini file specified in m_Path
bool WriteFile(void) const;
// Deletes all stored ini data.
void Erase(); // tolua_export
void Clear() {Erase();} // tolua_export
void Reset() {Erase();} // tolua_export
/// Deletes all stored ini data (but doesn't touch the file)
void Clear(void);
void Reset(void) { Clear(); }
void Erase(void) { Clear(); } // OBSOLETE, this name is misguiding and will be removed from the interface
// Returns index of specified key, or noID if not found.
long FindKey( const std::string & keyname) const; // tolua_export
/// Returns index of specified key, or noID if not found
long FindKey(const std::string & keyname) const;
// Returns index of specified value, in the specified key, or noID if not found.
long FindValue( const unsigned keyID, const std::string & valuename) const; // tolua_export
/// Returns index of specified value, in the specified key, or noID if not found
long FindValue(const unsigned keyID, const std::string & valuename) const;
// Returns number of keys currently in the ini.
unsigned NumKeys() const {return names.size();} // tolua_export
unsigned GetNumKeys() const {return NumKeys();} // tolua_export
/// Returns number of keys currently in the ini
unsigned NumKeys (void) const {return names.size();}
unsigned GetNumKeys(void) const {return NumKeys();}
// Add a key name.
unsigned AddKeyName( const std::string & keyname); // tolua_export
/// Add a key name
unsigned AddKeyName(const std::string & keyname);
// Returns key names by index.
std::string KeyName( const unsigned keyID) const; // tolua_export
std::string GetKeyName( const unsigned keyID) const {return KeyName(keyID);} // tolua_export
std::string KeyName(const unsigned keyID) const;
std::string GetKeyName(const unsigned keyID) const {return KeyName(keyID);}
// Returns number of values stored for specified key.
unsigned NumValues( const std::string & keyname); // tolua_export
unsigned GetNumValues( const std::string & keyname) {return NumValues( keyname);} // tolua_export
unsigned NumValues( const unsigned keyID); // tolua_export
unsigned GetNumValues( const unsigned keyID) {return NumValues( keyID);} // tolua_export
unsigned NumValues (const std::string & keyname);
unsigned GetNumValues(const std::string & keyname) {return NumValues(keyname);}
unsigned NumValues (const unsigned keyID);
unsigned GetNumValues(const unsigned keyID) {return NumValues(keyID);}
// Returns value name by index for a given keyname or keyID.
std::string ValueName( const std::string & keyname, const unsigned valueID) const; // tolua_export
std::string GetValueName( const std::string & keyname, const unsigned valueID) const { // tolua_export
return ValueName( keyname, valueID);
} // tolua_export
std::string ValueName( const unsigned keyID, const unsigned valueID) const; // tolua_export
std::string GetValueName( const unsigned keyID, const unsigned valueID) const { // tolua_export
return ValueName( keyID, valueID);
} // tolua_export
std::string ValueName( const std::string & keyname, const unsigned valueID) const;
std::string GetValueName( const std::string & keyname, const unsigned valueID) const
{
return ValueName(keyname, valueID);
}
std::string ValueName (const unsigned keyID, const unsigned valueID) const;
std::string GetValueName(const unsigned keyID, const unsigned valueID) const
{
return ValueName(keyID, valueID);
}
// Gets value of [keyname] valuename =.
// Overloaded to return string, int, and double.
// Returns defValue if key/value not found.
AString GetValue (const AString & keyname, const AString & valuename, const AString & defValue = "") const; // tolua_export
AString GetValue (const unsigned keyID, const unsigned valueID, const AString & defValue = "") const; // tolua_export
double GetValueF(const AString & keyname, const AString & valuename, const double defValue = 0) const; // tolua_export
int GetValueI(const AString & keyname, const AString & valuename, const int defValue = 0) const; // tolua_export
bool GetValueB(const AString & keyname, const AString & valuename, const bool defValue = false) const { // tolua_export
return ( GetValueI( keyname, valuename, int( defValue)) > 0);
} // tolua_export
AString GetValue (const AString & keyname, const AString & valuename, const AString & defValue = "") const;
AString GetValue (const unsigned keyID, const unsigned valueID, const AString & defValue = "") const;
double GetValueF(const AString & keyname, const AString & valuename, const double defValue = 0) const;
int GetValueI(const AString & keyname, const AString & valuename, const int defValue = 0) const;
bool GetValueB(const AString & keyname, const AString & valuename, const bool defValue = false) const
{
return (GetValueI(keyname, valuename, int(defValue)) > 0);
}
// Gets the value; if not found, write the default to the INI file
AString GetValueSet (const AString & keyname, const AString & valuename, const AString & defValue = ""); // tolua_export
double GetValueSetF(const AString & keyname, const AString & valuename, const double defValue = 0.0); // tolua_export
int GetValueSetI(const AString & keyname, const AString & valuename, const int defValue = 0); // tolua_export
bool GetValueSetB(const AString & keyname, const AString & valuename, const bool defValue = false) { // tolua_export
AString GetValueSet (const AString & keyname, const AString & valuename, const AString & defValue = "");
double GetValueSetF(const AString & keyname, const AString & valuename, const double defValue = 0.0);
int GetValueSetI(const AString & keyname, const AString & valuename, const int defValue = 0);
bool GetValueSetB(const AString & keyname, const AString & valuename, const bool defValue = false)
{
return (GetValueSetI(keyname, valuename, defValue ? 1 : 0) > 0);
} // tolua_export
}
// Sets value of [keyname] valuename =.
// Specify the optional paramter as false (0) if you do not want it to create
// the key if it doesn't exist. Returns true if data entered, false otherwise.
// Overloaded to accept string, int, and double.
bool SetValue( const unsigned keyID, const unsigned valueID, const std::string & value); // tolua_export
bool SetValue( const std::string & keyname, const std::string & valuename, const std::string & value, const bool create = true); // tolua_export
bool SetValueI( const std::string & keyname, const std::string & valuename, const int value, const bool create = true); // tolua_export
bool SetValueB( const std::string & keyname, const std::string & valuename, const bool value, const bool create = true) { // tolua_export
bool SetValue( const unsigned keyID, const unsigned valueID, const std::string & value);
bool SetValue( const std::string & keyname, const std::string & valuename, const std::string & value, const bool create = true);
bool SetValueI( const std::string & keyname, const std::string & valuename, const int value, const bool create = true);
bool SetValueB( const std::string & keyname, const std::string & valuename, const bool value, const bool create = true)
{
return SetValueI( keyname, valuename, int(value), create);
} // tolua_export
bool SetValueF( const std::string & keyname, const std::string & valuename, const double value, const bool create = true); // tolua_export
}
bool SetValueF( const std::string & keyname, const std::string & valuename, const double value, const bool create = true);
bool SetValueV( const std::string & keyname, const std::string & valuename, char *format, ...);
// Deletes specified value.
// Returns true if value existed and deleted, false otherwise.
bool DeleteValueByID( const unsigned keyID, const unsigned valueID ); // tolua_export
bool DeleteValue( const std::string & keyname, const std::string & valuename); // tolua_export
bool DeleteValueByID( const unsigned keyID, const unsigned valueID );
bool DeleteValue( const std::string & keyname, const std::string & valuename);
// Deletes specified key and all values contained within.
// Returns true if key existed and deleted, false otherwise.
bool DeleteKey(const std::string & keyname); // tolua_export
bool DeleteKey(const std::string & keyname);
// Header comment functions.
// Header comments are those comments before the first key.
//
// Number of header comments.
unsigned NumHeaderComments() {return comments.size();} // tolua_export
unsigned NumHeaderComments(void) {return comments.size();}
// Add a header comment.
void HeaderComment( const std::string & comment); // tolua_export
void HeaderComment(const std::string & comment);
// Return a header comment.
std::string HeaderComment( const unsigned commentID) const; // tolua_export
std::string HeaderComment(const unsigned commentID) const;
// Delete a header comment.
bool DeleteHeaderComment( unsigned commentID); // tolua_export
bool DeleteHeaderComment(unsigned commentID);
// Delete all header comments.
void DeleteHeaderComments() {comments.clear();} // tolua_export
void DeleteHeaderComments(void) {comments.clear();}
// Key comment functions.
// Key comments are those comments within a key. Any comments
@ -167,20 +187,26 @@ public:
// the CIniFile::WriteFile() is called.
//
// Number of key comments.
unsigned NumKeyComments( const unsigned keyID) const; // tolua_export
unsigned NumKeyComments( const std::string & keyname) const; // tolua_export
unsigned NumKeyComments( const unsigned keyID) const;
unsigned NumKeyComments( const std::string & keyname) const;
// Add a key comment.
bool KeyComment( const unsigned keyID, const std::string & comment); // tolua_export
bool KeyComment( const std::string & keyname, const std::string & comment); // tolua_export
bool KeyComment(const unsigned keyID, const std::string & comment);
bool KeyComment(const std::string & keyname, const std::string & comment);
// Return a key comment.
std::string KeyComment( const unsigned keyID, const unsigned commentID) const; // tolua_export
std::string KeyComment( const std::string & keyname, const unsigned commentID) const; // tolua_export
std::string KeyComment(const unsigned keyID, const unsigned commentID) const;
std::string KeyComment(const std::string & keyname, const unsigned commentID) const;
// Delete a key comment.
bool DeleteKeyComment( const unsigned keyID, const unsigned commentID); // tolua_export
bool DeleteKeyComment( const std::string & keyname, const unsigned commentID); // tolua_export
bool DeleteKeyComment(const unsigned keyID, const unsigned commentID);
bool DeleteKeyComment(const std::string & keyname, const unsigned commentID);
// Delete all comments for a key.
bool DeleteKeyComments( const unsigned keyID); // tolua_export
bool DeleteKeyComments( const std::string & keyname); // tolua_export
}; // tolua_export
bool DeleteKeyComments(const unsigned keyID);
bool DeleteKeyComments(const std::string & keyname);
};
// tolua_end
#endif

2
source/BlockID.h
View File

@ -169,6 +169,8 @@ enum ENUM_BLOCK_ID
E_BLOCK_DROPPER = 158,
E_BLOCK_CARPET = 171,
// Keep these two as the last values, without a number - they will get their correct number assigned automagically by C++
// IsValidBlock() depends on this
E_BLOCK_NUMBER_OF_TYPES, ///< Number of individual (different) blocktypes

54
source/Blocks/BlockCarpet.h Normal file
View File

@ -0,0 +1,54 @@
// BlockCarpet.h
// Declares the cBlockCarpetHandler class representing the handler for the carpet block
#pragma once
class cBlockCarpetHandler :
public cBlockHandler
{
public:
cBlockCarpetHandler(BLOCKTYPE a_BlockType);
virtual const char * GetStepSound(void) override
{
return "step.cloth";
}
virtual bool GetPlacementBlockTypeMeta(
cWorld * a_World, cPlayer * a_Player,
int a_BlockX, int a_BlockY, int a_BlockZ, char a_BlockFace,
int a_CursorX, int a_CursorY, int a_CursorZ,
BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta
) override
{
a_BlockType = m_BlockType;
a_BlockMeta = a_Player->GetEquippedItem().m_ItemDamage & 0x0f;
return true;
}
virtual void ConvertToPickups(cItems & a_Pickups, NIBBLETYPE a_BlockMeta) override
{
a_Pickups.push_back(cItem(E_BLOCK_CARPET, a_BlockMeta));
}
virtual bool CanBeAt(int a_RelX, int a_RelY, int a_RelZ, const cChunk & a_Chunk) override
{
return ((a_RelY > 0) && (a_Chunk.GetBlock(a_RelX, a_RelY - 1, a_RelZ) != E_BLOCK_AIR));
}
} ;

1
source/Blocks/BlockChest.h
View File

@ -3,6 +3,7 @@
#include "BlockEntity.h"
#include "../World.h"
#include "../BlockArea.h"
#include "../Player.h"

2
source/Blocks/BlockDropSpenser.h
View File

@ -5,6 +5,8 @@
#pragma once
#include "../Piston.h"

97
source/Blocks/BlockHandler.cpp
View File

@ -5,59 +5,60 @@
#include "../World.h"
#include "../Root.h"
#include "../PluginManager.h"
#include "BlockSand.h"
#include "BlockGravel.h"
#include "BlockDoor.h"
#include "BlockFire.h"
#include "BlockRedstone.h"
#include "BlockRedstoneTorch.h"
#include "BlockRedstoneRepeater.h"
#include "BlockPiston.h"
#include "BlockWorkbench.h"
#include "BlockEntity.h"
#include "BlockVine.h"
#include "BlockTallGrass.h"
#include "BlockSnow.h"
#include "BlockCloth.h"
#include "BlockSlab.h"
#include "BlockDirt.h"
#include "BlockTorch.h"
#include "BlockWood.h"
#include "BlockLeaves.h"
#include "BlockSapling.h"
#include "BlockFluid.h"
#include "BlockChest.h"
#include "BlockFurnace.h"
#include "BlockDropSpenser.h"
#include "BlockStairs.h"
#include "BlockLadder.h"
#include "BlockLever.h"
#include "BlockSign.h"
#include "BlockCrops.h"
#include "BlockSugarcane.h"
#include "BlockFlower.h"
#include "BlockMushroom.h"
#include "BlockCactus.h"
#include "BlockStems.h"
#include "BlockGlowstone.h"
#include "BlockStone.h"
#include "BlockMelon.h"
#include "BlockIce.h"
#include "BlockOre.h"
#include "BlockNote.h"
#include "BlockBed.h"
#include "BlockFarmland.h"
#include "BlockMycelium.h"
#include "BlockRail.h"
#include "BlockGlass.h"
#include "BlockEnderchest.h"
#include "BlockFenceGate.h"
#include "BlockFlowerPot.h"
#include "BlockCauldron.h"
#include "BlockBrewingStand.h"
#include "BlockCactus.h"
#include "BlockCarpet.h"
#include "BlockCauldron.h"
#include "BlockChest.h"
#include "BlockCloth.h"
#include "BlockCobWeb.h"
#include "BlockCrops.h"
#include "BlockDeadBush.h"
#include "BlockDirt.h"
#include "BlockDoor.h"
#include "BlockDropSpenser.h"
#include "BlockEnderchest.h"
#include "BlockEntity.h"
#include "BlockFarmland.h"
#include "BlockFenceGate.h"
#include "BlockFire.h"
#include "BlockFlower.h"
#include "BlockFlowerPot.h"
#include "BlockFluid.h"
#include "BlockFurnace.h"
#include "BlockGlass.h"
#include "BlockGlowstone.h"
#include "BlockGravel.h"
#include "BlockHopper.h"
#include "BlockIce.h"
#include "BlockLadder.h"
#include "BlockLeaves.h"
#include "BlockLever.h"
#include "BlockMelon.h"
#include "BlockMushroom.h"
#include "BlockMycelium.h"
#include "BlockNote.h"
#include "BlockOre.h"
#include "BlockPiston.h"
#include "BlockRail.h"
#include "BlockRedstone.h"
#include "BlockRedstoneRepeater.h"
#include "BlockRedstoneTorch.h"
#include "BlockSand.h"
#include "BlockSapling.h"
#include "BlockSign.h"
#include "BlockSlab.h"
#include "BlockSnow.h"
#include "BlockStairs.h"
#include "BlockStems.h"
#include "BlockStone.h"
#include "BlockSugarcane.h"
#include "BlockTallGrass.h"
#include "BlockTorch.h"
#include "BlockVine.h"
#include "BlockWood.h"
#include "BlockWorkbench.h"

7
source/GroupManager.cpp
View File

@ -47,11 +47,8 @@ cGroupManager::cGroupManager()
cIniFile IniFile("groups.ini");
if (!IniFile.ReadFile())
{
LOGINFO("groups.ini inaccessible, using groups.example.ini for defaults!");
IniFile.Path("groups.example.ini");
IniFile.ReadFile();
IniFile.Path("groups.ini");
IniFile.WriteFile();
LOGWARNING("groups.ini inaccessible, no groups are defined");
return;
}
unsigned int NumKeys = IniFile.GetNumKeys();

6
source/MCLogger.cpp
View File

@ -10,6 +10,9 @@
cMCLogger * cMCLogger::s_MCLogger = NULL;
#ifdef _WIN32
HANDLE g_Console = GetStdHandle(STD_OUTPUT_HANDLE);
#endif
@ -145,8 +148,7 @@ void cMCLogger::Error(const char* a_Format, va_list a_ArgList)
void cMCLogger::SetColor( unsigned char a_Color )
{
#ifdef _WIN32
HANDLE hConsole = GetStdHandle( STD_OUTPUT_HANDLE );
SetConsoleTextAttribute( hConsole, a_Color );
SetConsoleTextAttribute(g_Console, a_Color);
#else
(void)a_Color;
#endif

164
source/ManualBindings.cpp
View File

@ -265,6 +265,96 @@ static int tolua_DoWith(lua_State* tolua_S)
template<
class Ty1,
class Ty2,
bool (Ty1::*Func1)(int, cItemCallback<Ty2> &)
>
static int tolua_DoWithID(lua_State* tolua_S)
{
int NumArgs = lua_gettop(tolua_S) - 1; /* This includes 'self' */
if ((NumArgs != 2) && (NumArgs != 3))
{
return lua_do_error(tolua_S, "Error in function call '#funcname#': Requires 2 or 3 arguments, got %i", NumArgs);
}
Ty1 * self = (Ty1 *)tolua_tousertype(tolua_S, 1, 0);
int ItemID = (int)tolua_tonumber(tolua_S, 2, 0);
if (!lua_isfunction(tolua_S, 3))
{
return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a function for parameter #2", NumArgs);
}
/* luaL_ref gets reference to value on top of the stack, the table is the last argument and therefore on the top */
int TableRef = LUA_REFNIL;
if (NumArgs == 3)
{
TableRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX);
if (TableRef == LUA_REFNIL)
{
return lua_do_error(tolua_S, "Error in function call '#funcname#': Could not get value reference of parameter #3", NumArgs);
}
}
/* table value is popped, and now function is on top of the stack */
int FuncRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX);
if (FuncRef == LUA_REFNIL)
{
return lua_do_error(tolua_S, "Error in function call '#funcname#': Could not get function reference of parameter #2", NumArgs);
}
class cLuaCallback : public cItemCallback<Ty2>
{
public:
cLuaCallback(lua_State * a_LuaState, int a_FuncRef, int a_TableRef) :
LuaState(a_LuaState),
FuncRef(a_FuncRef),
TableRef(a_TableRef)
{}
private:
virtual bool Item(Ty2 * a_Item) override
{
lua_rawgeti(LuaState, LUA_REGISTRYINDEX, FuncRef); // Push function to call
tolua_pushusertype(LuaState, a_Item, Ty2::GetClassStatic()); // Push the item
if (TableRef != LUA_REFNIL)
{
lua_rawgeti(LuaState, LUA_REGISTRYINDEX, TableRef); // Push the optional callbackdata param
}
int s = lua_pcall(LuaState, (TableRef == LUA_REFNIL ? 1 : 2), 1, 0);
if (cLuaState::ReportErrors(LuaState, s))
{
return true; // Abort enumeration
}
if (lua_isboolean(LuaState, -1))
{
return (tolua_toboolean(LuaState, -1, 0) > 0);
}
return false; /* Continue enumeration */
}
lua_State * LuaState;
int FuncRef;
int TableRef;
} Callback(tolua_S, FuncRef, TableRef);
bool bRetVal = (self->*Func1)(ItemID, Callback);
/* Unreference the values again, so the LUA_REGISTRYINDEX can make place for other references */
luaL_unref(tolua_S, LUA_REGISTRYINDEX, TableRef);
luaL_unref(tolua_S, LUA_REGISTRYINDEX, FuncRef);
/* Push return value on stack */
tolua_pushboolean(tolua_S, bRetVal );
return 1;
}
template< class Ty1,
class Ty2,
bool (Ty1::*Func1)(int, int, int, cItemCallback<Ty2> &) >
@ -597,6 +687,52 @@ tolua_lerror:
static int tolua_cWorld_TryGetHeight(lua_State * tolua_S)
{
// Exported manually, because tolua would require the out-only param a_Height to be used when calling
// Takes (a_World,) a_BlockX, a_BlockZ
// Returns Height, IsValid
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype (tolua_S, 1, "cWorld", 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
#endif
{
cWorld * self = (cWorld *) tolua_tousertype (tolua_S, 1, 0);
int BlockX = (int) tolua_tonumber (tolua_S, 2, 0);
int BlockZ = (int) tolua_tonumber (tolua_S, 3, 0);
#ifndef TOLUA_RELEASE
if (self == NULL)
{
tolua_error(tolua_S, "Invalid 'self' in function 'TryGetHeight'", NULL);
}
#endif
{
int Height = 0;
bool res = self->TryGetHeight(BlockX, BlockZ, Height);
tolua_pushnumber(tolua_S, Height);
tolua_pushboolean(tolua_S, res ? 1 : 0);
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S, "#ferror in function 'TryGetHeight'.", &tolua_err);
return 0;
#endif
}
static int tolua_cPluginManager_GetAllPlugins(lua_State * tolua_S)
{
cPluginManager* self = (cPluginManager*) tolua_tousertype(tolua_S,1,0);
@ -1373,25 +1509,27 @@ void ManualBindings::Bind(lua_State * tolua_S)
tolua_function(tolua_S, "LOGERROR", tolua_LOGERROR);
tolua_beginmodule(tolua_S, "cRoot");
tolua_function(tolua_S, "ForEachWorld", tolua_ForEach<cRoot, cWorld, &cRoot::ForEachWorld>);
tolua_function(tolua_S, "FindAndDoWithPlayer", tolua_DoWith <cRoot, cPlayer, &cRoot::FindAndDoWithPlayer>);
tolua_function(tolua_S, "ForEachPlayer", tolua_ForEach<cRoot, cPlayer, &cRoot::ForEachPlayer>);
tolua_function(tolua_S, "ForEachWorld", tolua_ForEach<cRoot, cWorld, &cRoot::ForEachWorld>);
tolua_endmodule(tolua_S);
tolua_beginmodule(tolua_S, "cWorld");
tolua_function(tolua_S, "ForEachPlayer", tolua_ForEach<cWorld, cPlayer, &cWorld::ForEachPlayer>);
tolua_function(tolua_S, "ForEachEntity", tolua_ForEach<cWorld, cEntity, &cWorld::ForEachEntity>);
tolua_function(tolua_S, "ForEachEntityInChunk", tolua_ForEachInChunk<cWorld, cEntity, &cWorld::ForEachEntityInChunk>);
tolua_function(tolua_S, "ForEachChestInChunk", tolua_ForEachInChunk<cWorld, cChestEntity, &cWorld::ForEachChestInChunk>);
tolua_function(tolua_S, "ForEachFurnaceInChunk", tolua_ForEachInChunk<cWorld, cFurnaceEntity, &cWorld::ForEachFurnaceInChunk>);
tolua_function(tolua_S, "DoWithPlayer", tolua_DoWith<cWorld, cPlayer, &cWorld::DoWithPlayer>);
tolua_function(tolua_S, "FindAndDoWithPlayer", tolua_DoWith<cWorld, cPlayer, &cWorld::FindAndDoWithPlayer>);
tolua_function(tolua_S, "DoWithChestAt", tolua_DoWithXYZ<cWorld, cChestEntity, &cWorld::DoWithChestAt>);
tolua_function(tolua_S, "DoWithDispenserAt", tolua_DoWithXYZ<cWorld, cDispenserEntity, &cWorld::DoWithDispenserAt>);
tolua_function(tolua_S, "DoWithDropperAt", tolua_DoWithXYZ<cWorld, cDropperEntity, &cWorld::DoWithDropperAt>);
tolua_function(tolua_S, "DoWithDropSpenserAt", tolua_DoWithXYZ<cWorld, cDropSpenserEntity, &cWorld::DoWithDropSpenserAt>);
tolua_function(tolua_S, "DoWithDropperAt", tolua_DoWithXYZ<cWorld, cDropperEntity, &cWorld::DoWithDropperAt>);
tolua_function(tolua_S, "DoWithEntityByID", tolua_DoWithID< cWorld, cEntity, &cWorld::DoWithEntityByID>);
tolua_function(tolua_S, "DoWithFurnaceAt", tolua_DoWithXYZ<cWorld, cFurnaceEntity, &cWorld::DoWithFurnaceAt>);
tolua_function(tolua_S, "DoWithPlayer", tolua_DoWith< cWorld, cPlayer, &cWorld::DoWithPlayer>);
tolua_function(tolua_S, "FindAndDoWithPlayer", tolua_DoWith< cWorld, cPlayer, &cWorld::FindAndDoWithPlayer>);
tolua_function(tolua_S, "ForEachChestInChunk", tolua_ForEachInChunk<cWorld, cChestEntity, &cWorld::ForEachChestInChunk>);
tolua_function(tolua_S, "ForEachEntity", tolua_ForEach< cWorld, cEntity, &cWorld::ForEachEntity>);
tolua_function(tolua_S, "ForEachEntityInChunk", tolua_ForEachInChunk<cWorld, cEntity, &cWorld::ForEachEntityInChunk>);
tolua_function(tolua_S, "ForEachFurnaceInChunk", tolua_ForEachInChunk<cWorld, cFurnaceEntity, &cWorld::ForEachFurnaceInChunk>);
tolua_function(tolua_S, "ForEachPlayer", tolua_ForEach< cWorld, cPlayer, &cWorld::ForEachPlayer>);
tolua_function(tolua_S, "SetSignLines", tolua_cWorld_SetSignLines);
tolua_function(tolua_S, "TryGetHeight", tolua_cWorld_TryGetHeight);
tolua_function(tolua_S, "UpdateSign", tolua_cWorld_SetSignLines);
tolua_endmodule(tolua_S);
@ -1400,11 +1538,11 @@ void ManualBindings::Bind(lua_State * tolua_S)
tolua_endmodule(tolua_S);
tolua_beginmodule(tolua_S, "cPluginManager");
tolua_function(tolua_S, "GetAllPlugins", tolua_cPluginManager_GetAllPlugins);
tolua_function(tolua_S, "BindCommand", tolua_cPluginManager_BindCommand);
tolua_function(tolua_S, "BindConsoleCommand", tolua_cPluginManager_BindConsoleCommand);
tolua_function(tolua_S, "ForEachCommand", tolua_cPluginManager_ForEachCommand);
tolua_function(tolua_S, "ForEachConsoleCommand", tolua_cPluginManager_ForEachConsoleCommand);
tolua_function(tolua_S, "GetAllPlugins", tolua_cPluginManager_GetAllPlugins);
tolua_endmodule(tolua_S);
tolua_beginmodule(tolua_S, "cPlayer");
@ -1419,17 +1557,17 @@ void ManualBindings::Bind(lua_State * tolua_S)
tolua_endmodule(tolua_S);
tolua_beginmodule(tolua_S, "cPlugin_NewLua");
tolua_function(tolua_S, "AddWebTab", tolua_cPlugin_NewLua_AddWebTab);
tolua_function(tolua_S, "AddTab", tolua_cPlugin_NewLua_AddTab);
tolua_function(tolua_S, "AddWebTab", tolua_cPlugin_NewLua_AddWebTab);
tolua_endmodule(tolua_S);
tolua_cclass(tolua_S,"HTTPRequest","HTTPRequest","",NULL);
tolua_beginmodule(tolua_S,"HTTPRequest");
// tolua_variable(tolua_S,"Method",tolua_get_HTTPRequest_Method,tolua_set_HTTPRequest_Method);
// tolua_variable(tolua_S,"Path",tolua_get_HTTPRequest_Path,tolua_set_HTTPRequest_Path);
tolua_variable(tolua_S,"FormData",tolua_get_HTTPRequest_FormData,0);
tolua_variable(tolua_S,"Params",tolua_get_HTTPRequest_Params,0);
tolua_variable(tolua_S,"PostParams",tolua_get_HTTPRequest_PostParams,0);
tolua_variable(tolua_S,"FormData",tolua_get_HTTPRequest_FormData,0);
tolua_endmodule(tolua_S);
tolua_beginmodule(tolua_S, "cWebAdmin");
@ -1441,8 +1579,8 @@ void ManualBindings::Bind(lua_State * tolua_S)
tolua_endmodule(tolua_S);
tolua_beginmodule(tolua_S, "cClientHandle");
tolua_constant(tolua_S, "MIN_VIEW_DISTANCE", cClientHandle::MIN_VIEW_DISTANCE);
tolua_constant(tolua_S, "MAX_VIEW_DISTANCE", cClientHandle::MAX_VIEW_DISTANCE);
tolua_constant(tolua_S, "MIN_VIEW_DISTANCE", cClientHandle::MIN_VIEW_DISTANCE);
tolua_endmodule(tolua_S);
tolua_beginmodule(tolua_S, "cItemGrid");

13
source/Root.cpp
View File

@ -112,10 +112,7 @@ void cRoot::Start(void)
cIniFile IniFile("settings.ini");
if (!IniFile.ReadFile())
{
LOGINFO("settings.ini inaccessible, using settings.example.ini for defaults!");
IniFile.Path("settings.example.ini");
IniFile.ReadFile();
IniFile.Path("settings.ini");
LOGWARNING("settings.ini inaccessible, all settings are reset to default values");
}
m_PrimaryServerVersion = IniFile.GetValueI("Server", "PrimaryServerVersion", 0);
if (m_PrimaryServerVersion == 0)
@ -139,14 +136,10 @@ void cRoot::Start(void)
cIniFile WebIniFile("webadmin.ini");
if (!WebIniFile.ReadFile())
{
LOGINFO("webadmin.ini inaccessible, using webadmin.example.ini for defaults!");
WebIniFile.Path("webadmin.example.ini");
WebIniFile.ReadFile();
WebIniFile.Path("webadmin.ini");
WebIniFile.WriteFile();
LOGWARNING("webadmin.ini inaccessible, wabadmin is disabled");
}
if (WebIniFile.GetValueB("WebAdmin", "Enabled", false ))
if (WebIniFile.GetValueB("WebAdmin", "Enabled", false))
{
LOG("Creating WebAdmin...");
m_WebAdmin = new cWebAdmin(8080);

4
source/World.h
View File

@ -129,7 +129,7 @@ public:
// tolua_end
/// Retrieves the world height at the specified coords; returns false if chunk not loaded / generated
bool TryGetHeight(int a_BlockX, int a_BlockZ, int & a_Height); // TODO: Export in ManualBindings.cpp
bool TryGetHeight(int a_BlockX, int a_BlockZ, int & a_Height); // Exported in ManualBindings.cpp
// Broadcast respective packets to all clients of the chunk where the event is taking place
// (Please keep these alpha-sorted)
@ -245,7 +245,7 @@ public:
bool ForEachEntityInChunk(int a_ChunkX, int a_ChunkZ, cEntityCallback & a_Callback); // Exported in ManualBindings.cpp
/// Calls the callback if the entity with the specified ID is found, with the entity object as the callback param. Returns true if entity found and callback returned false.
bool DoWithEntityByID(int a_UniqueID, cEntityCallback & a_Callback); // TODO: Exported in ManualBindings.cpp
bool DoWithEntityByID(int a_UniqueID, cEntityCallback & a_Callback); // Exported in ManualBindings.cpp
/// Compares clients of two chunks, calls the callback accordingly
void CompareChunkClients(int a_ChunkX1, int a_ChunkZ1, int a_ChunkX2, int a_ChunkZ2, cClientDiffCallback & a_Callback);