Digitalstack/otclient
2
0
Fork 0
mirror of https://github.com/edubart/otclient.git synced 2025-10-20 06:23:26 +02:00
Code Issues Packages Projects Releases Wiki Activity

Started 1050 implementation and fix ups:

Browse Source 
* Dat now loads (new animations aren't yet functional).
* Fixed the way we reference client versions.

TODO: Write new animation functionality & find out protocol changes.
This commit is contained in:
BenDol
2014-08-03 10:02:28 +12:00
parent fe585d27d8
commit d7429c201c
31 changed files with 316 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/framework/core/binarytree.cpp
View File

@@ -132,7 +132,7 @@ uint16 BinaryTree::getU16()
unserialize();
if(m_pos+2 > m_buffer.size())
stdext::throw_exception("BinaryTree: getU16 failed");
uint16 v = stdext::readLE16(&m_buffer[m_pos]);
uint16 v = stdext::readULE16(&m_buffer[m_pos]);
m_pos += 2;
return v;
}
@@ -142,7 +142,7 @@ uint32 BinaryTree::getU32()
unserialize();
if(m_pos+4 > m_buffer.size())
stdext::throw_exception("BinaryTree: getU32 failed");
uint32 v = stdext::readLE32(&m_buffer[m_pos]);
uint32 v = stdext::readULE32(&m_buffer[m_pos]);
m_pos += 4;
return v;
}
@@ -152,7 +152,7 @@ uint64 BinaryTree::getU64()
unserialize();
if(m_pos+8 > m_buffer.size())
stdext::throw_exception("BinaryTree: getU64 failed");
uint64 v = stdext::readLE64(&m_buffer[m_pos]);
uint64 v = stdext::readULE64(&m_buffer[m_pos]);
m_pos += 8;
return v;
}
@@ -193,14 +193,14 @@ void OutputBinaryTree::addU8(uint8 v)
void OutputBinaryTree::addU16(uint16 v)
{
uint8 data[2];
stdext::writeLE16(data, v);
stdext::writeULE16(data, v);
write(data, 2);
}
void OutputBinaryTree::addU32(uint32 v)
{
uint8 data[4];
stdext::writeLE32(data, v);
stdext::writeULE32(data, v);
write(data, 4);
}

122
src/framework/core/filestream.cpp
View File

@@ -206,7 +206,7 @@ uint16 FileStream::getU16()
if(m_pos+2 > m_data.size())
throwError("read failed");
v = stdext::readLE16(&m_data[m_pos]);
v = stdext::readULE16(&m_data[m_pos]);
m_pos += 2;
}
return v;
@@ -222,7 +222,7 @@ uint32 FileStream::getU32()
if(m_pos+4 > m_data.size())
throwError("read failed");
v = stdext::readLE32(&m_data[m_pos]);
v = stdext::readULE32(&m_data[m_pos]);
m_pos += 4;
}
return v;
@@ -237,7 +237,70 @@ uint64 FileStream::getU64()
} else {
if(m_pos+8 > m_data.size())
throwError("read failed");
v = stdext::readLE64(&m_data[m_pos]);
v = stdext::readULE64(&m_data[m_pos]);
m_pos += 8;
}
return v;
}
int8 FileStream::get8()
{
int8 v = 0;
if(!m_caching) {
if(PHYSFS_read(m_fileHandle, &v, 1, 1) != 1)
throwError("read failed", true);
} else {
if(m_pos+1 > m_data.size())
throwError("read failed");
v = m_data[m_pos];
m_pos += 1;
}
return v;
}
int16 FileStream::get16()
{
int16 v = 0;
if(!m_caching) {
if(PHYSFS_readSLE16(m_fileHandle, &v) == 0)
throwError("read failed", true);
} else {
if(m_pos+2 > m_data.size())
throwError("read failed");
v = stdext::readSLE16(&m_data[m_pos]);
m_pos += 2;
}
return v;
}
int32 FileStream::get32()
{
int32 v = 0;
if(!m_caching) {
if(PHYSFS_readSLE32(m_fileHandle, &v) == 0)
throwError("read failed", true);
} else {
if(m_pos+4 > m_data.size())
throwError("read failed");
v = stdext::readSLE32(&m_data[m_pos]);
m_pos += 4;
}
return v;
}
int64 FileStream::get64()
{
int64 v = 0;
if(!m_caching) {
if(PHYSFS_readSLE64(m_fileHandle, (PHYSFS_sint64*)&v) == 0)
throwError("read failed", true);
} else {
if(m_pos+8 > m_data.size())
throwError("read failed");
v = stdext::readSLE64(&m_data[m_pos]);
m_pos += 8;
}
return v;
@@ -306,7 +369,7 @@ void FileStream::addU16(uint16 v)
throwError("write failed", true);
} else {
m_data.grow(m_pos + 2);
stdext::writeLE16(&m_data[m_pos], v);
stdext::writeULE16(&m_data[m_pos], v);
m_pos += 2;
}
}
@@ -318,7 +381,7 @@ void FileStream::addU32(uint32 v)
throwError("write failed", true);
} else {
m_data.grow(m_pos + 4);
stdext::writeLE32(&m_data[m_pos], v);
stdext::writeULE32(&m_data[m_pos], v);
m_pos += 4;
}
}
@@ -330,7 +393,54 @@ void FileStream::addU64(uint64 v)
throwError("write failed", true);
} else {
m_data.grow(m_pos + 8);
stdext::writeLE64(&m_data[m_pos], v);
stdext::writeULE64(&m_data[m_pos], v);
m_pos += 8;
}
}
void FileStream::add8(int8 v)
{
if(!m_caching) {
if(PHYSFS_write(m_fileHandle, &v, 1, 1) != 1)
throwError("write failed", true);
} else {
m_data.add(v);
m_pos++;
}
}
void FileStream::add16(int16 v)
{
if(!m_caching) {
if(PHYSFS_writeSLE16(m_fileHandle, v) == 0)
throwError("write failed", true);
} else {
m_data.grow(m_pos + 2);
stdext::writeSLE16(&m_data[m_pos], v);
m_pos += 2;
}
}
void FileStream::add32(int32 v)
{
if(!m_caching) {
if(PHYSFS_writeSLE32(m_fileHandle, v) == 0)
throwError("write failed", true);
} else {
m_data.grow(m_pos + 4);
stdext::writeSLE32(&m_data[m_pos], v);
m_pos += 4;
}
}
void FileStream::add64(int64 v)
{
if(!m_caching) {
if(PHYSFS_writeSLE64(m_fileHandle, v) == 0)
throwError("write failed", true);
} else {
m_data.grow(m_pos + 8);
stdext::writeSLE64(&m_data[m_pos], v);
m_pos += 8;
}
}

8
src/framework/core/filestream.h
View File

@@ -54,6 +54,10 @@ public:
uint16 getU16();
uint32 getU32();
uint64 getU64();
int8 get8();
int16 get16();
int32 get32();
int64 get64();
std::string getString();
BinaryTreePtr getBinaryTree();
@@ -63,6 +67,10 @@ public:
void addU16(uint16 v);
void addU32(uint32 v);
void addU64(uint64 v);
void add8(int8 v);
void add16(int16 v);
void add32(int32 v);
void add64(int64 v);
void addString(const std::string& v);
void addPos(uint16 x, uint16 y, uint8 z) { addU16(x); addU16(y); addU8(z); }
void addPoint(const Point& p) { addU8(p.x); addU8(p.y); }

1
src/framework/luafunctions.cpp
View File

@@ -195,6 +195,7 @@ void Application::registerLuaFunctions()
g_lua.bindSingletonFunction("g_resources", "getFileTime", &ResourceManager::getFileTime, &g_resources);
g_lua.bindSingletonFunction("g_resources", "makeDir", &ResourceManager::makeDir, &g_resources);
g_lua.bindSingletonFunction("g_resources", "deleteFile", &ResourceManager::deleteFile, &g_resources);
g_lua.bindSingletonFunction("g_resources", "resolvePath", &ResourceManager::resolvePath, &g_resources);
// Config
g_lua.registerClass<Config>();

6
src/framework/net/inputmessage.cpp
View File

@@ -56,7 +56,7 @@ uint8 InputMessage::getU8()
uint16 InputMessage::getU16()
{
checkRead(2);
uint16 v = stdext::readLE16(m_buffer + m_readPos);
uint16 v = stdext::readULE16(m_buffer + m_readPos);
m_readPos += 2;
return v;
}
@@ -64,7 +64,7 @@ uint16 InputMessage::getU16()
uint32 InputMessage::getU32()
{
checkRead(4);
uint32 v = stdext::readLE32(m_buffer + m_readPos);
uint32 v = stdext::readULE32(m_buffer + m_readPos);
m_readPos += 4;
return v;
}
@@ -72,7 +72,7 @@ uint32 InputMessage::getU32()
uint64 InputMessage::getU64()
{
checkRead(8);
uint64 v = stdext::readLE64(m_buffer + m_readPos);
uint64 v = stdext::readULE64(m_buffer + m_readPos);
m_readPos += 8;
return v;
}

10
src/framework/net/outputmessage.cpp
View File

@@ -46,7 +46,7 @@ void OutputMessage::addU8(uint8 value)
void OutputMessage::addU16(uint16 value)
{
checkWrite(2);
stdext::writeLE16(m_buffer + m_writePos, value);
stdext::writeULE16(m_buffer + m_writePos, value);
m_writePos += 2;
m_messageSize += 2;
}
@@ -54,7 +54,7 @@ void OutputMessage::addU16(uint16 value)
void OutputMessage::addU32(uint32 value)
{
checkWrite(4);
stdext::writeLE32(m_buffer + m_writePos, value);
stdext::writeULE32(m_buffer + m_writePos, value);
m_writePos += 4;
m_messageSize += 4;
}
@@ -62,7 +62,7 @@ void OutputMessage::addU32(uint32 value)
void OutputMessage::addU64(uint64 value)
{
checkWrite(8);
stdext::writeLE64(m_buffer + m_writePos, value);
stdext::writeULE64(m_buffer + m_writePos, value);
m_writePos += 8;
m_messageSize += 8;
}
@@ -104,7 +104,7 @@ void OutputMessage::writeChecksum()
uint32 checksum = stdext::adler32(m_buffer + m_headerPos, m_messageSize);
assert(m_headerPos - 4 >= 0);
m_headerPos -= 4;
stdext::writeLE32(m_buffer + m_headerPos, checksum);
stdext::writeULE32(m_buffer + m_headerPos, checksum);
m_messageSize += 4;
}
@@ -112,7 +112,7 @@ void OutputMessage::writeMessageSize()
{
assert(m_headerPos - 2 >= 0);
m_headerPos -= 2;
stdext::writeLE16(m_buffer + m_headerPos, m_messageSize);
stdext::writeULE16(m_buffer + m_headerPos, m_messageSize);
m_messageSize += 2;
}

2
src/framework/platform/win32window.cpp
View File

@@ -798,7 +798,7 @@ int WIN32Window::internalLoadMouseCursor(const ImagePtr& image, const Point& hot
std::vector<uchar> xorMask(numbytes, 0);
for(int i=0;i<numbits;++i) {
uint32 rgba = stdext::readLE32(image->getPixelData() + i*4);
uint32 rgba = stdext::readULE32(image->getPixelData() + i*4);
if(rgba == 0xffffffff) { //white
HSB_BIT_SET(xorMask, i);
} else if(rgba == 0x00000000) { //alpha

20
src/framework/stdext/math.h
View File

@@ -31,13 +31,21 @@ namespace stdext {
inline bool is_power_of_two(size_t v) { return ((v != 0) && !(v & (v - 1))); }
inline size_t to_power_of_two(size_t v) { if(v == 0) return 0; size_t r = 1; while(r < v && r != 0xffffffff) r <<= 1; return r; }
inline uint16_t readLE16(const uchar *addr) { return (uint16_t)addr[1] << 8 | addr[0]; }
inline uint32_t readLE32(const uchar *addr) { return (uint32_t)readLE16(addr + 2) << 16 | readLE16(addr); }
inline uint64_t readLE64(const uchar *addr) { return (uint64_t)readLE32(addr + 4) << 32 | readLE32(addr); }
inline uint16_t readULE16(const uchar *addr) { return (uint16_t)addr[1] << 8 | addr[0]; }
inline uint32_t readULE32(const uchar *addr) { return (uint32_t)readULE16(addr + 2) << 16 | readULE16(addr); }
inline uint64_t readULE64(const uchar *addr) { return (uint64_t)readULE32(addr + 4) << 32 | readULE32(addr); }
inline void writeLE16(uchar *addr, uint16_t value) { addr[1] = value >> 8; addr[0] = (uint8_t)value; }
inline void writeLE32(uchar *addr, uint32_t value) { writeLE16(addr + 2, value >> 16); writeLE16(addr, (uint16_t)value); }
inline void writeLE64(uchar *addr, uint64_t value) { writeLE32(addr + 4, value >> 32); writeLE32(addr, (uint32_t)value); }
inline void writeULE16(uchar *addr, uint16_t value) { addr[1] = value >> 8; addr[0] = (uint8_t)value; }
inline void writeULE32(uchar *addr, uint32_t value) { writeULE16(addr + 2, value >> 16); writeULE16(addr, (uint16_t)value); }
inline void writeULE64(uchar *addr, uint64_t value) { writeULE32(addr + 4, value >> 32); writeULE32(addr, (uint32_t)value); }
inline int16_t readSLE16(const uchar *addr) { return (int16_t)addr[1] << 8 | addr[0]; }
inline int32_t readSLE32(const uchar *addr) { return (int32_t)readSLE16(addr + 2) << 16 | readSLE16(addr); }
inline int64_t readSLE64(const uchar *addr) { return (int64_t)readSLE32(addr + 4) << 32 | readSLE32(addr); }
inline void writeSLE16(uchar *addr, int16_t value) { addr[1] = value >> 8; addr[0] = (int8_t)value; }
inline void writeSLE32(uchar *addr, int32_t value) { writeSLE16(addr + 2, value >> 16); writeSLE16(addr, (int16_t)value); }
inline void writeSLE64(uchar *addr, int64_t value) { writeSLE32(addr + 4, value >> 32); writeSLE32(addr, (int32_t)value); }
uint32_t adler32(const uint8_t *buffer, size_t size);

4
src/framework/util/crypt.cpp
View File

@@ -201,7 +201,7 @@ std::string Crypt::_encrypt(const std::string& decrypted_string, bool useMachine
{
std::string tmp = "0000" + decrypted_string;
uint32 sum = stdext::adler32((const uint8*)decrypted_string.c_str(), decrypted_string.size());
stdext::writeLE32((uint8*)&tmp[0], sum);
stdext::writeULE32((uint8*)&tmp[0], sum);
std::string encrypted = base64Encode(xorCrypt(tmp, getCryptKey(useMachineUUID)));
return encrypted;
}
@@ -211,7 +211,7 @@ std::string Crypt::_decrypt(const std::string& encrypted_string, bool useMachine
std::string decoded = base64Decode(encrypted_string);
std::string tmp = xorCrypt(base64Decode(encrypted_string), getCryptKey(useMachineUUID));
if(tmp.length() >= 4) {
uint32 readsum = stdext::readLE32((const uint8*)tmp.c_str());
uint32 readsum = stdext::readULE32((const uint8*)tmp.c_str());
std::string decrypted_string = tmp.substr(4);
uint32 sum = stdext::adler32((const uint8*)decrypted_string.c_str(), decrypted_string.size());
if(readsum == sum)