3324 lines
88 KiB
C++
3324 lines
88 KiB
C++
#pragma once
|
||
|
||
#include "DNFTOOL.hpp"
|
||
|
||
#include "zlib.h"
|
||
#include <ctime>
|
||
#include <sstream>
|
||
#include <chrono>
|
||
#include "json.hpp"
|
||
|
||
using json = nlohmann::json;
|
||
|
||
|
||
|
||
#include "ffi.h"
|
||
#include "ActiveHook.hpp"
|
||
|
||
|
||
//StringBinÎļþ»º´æ
|
||
static std::vector<std::string> StringBin;
|
||
|
||
|
||
|
||
std::map< int, int>ItemColorMap;
|
||
int RegisterItemColor_STL(HSQUIRRELVM v)
|
||
{
|
||
int ItemID, Clolr;
|
||
int ParameterNum = Sq_gettop(v);
|
||
if (ParameterNum == 3)
|
||
{
|
||
Sq_getinteger(v, 2, &ItemID);
|
||
Sq_getinteger(v, 3, &Clolr);
|
||
ItemColorMap[ItemID] = Clolr;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
static SQInteger sq_StringBinById(HSQUIRRELVM v)
|
||
{
|
||
SQInteger Idx;
|
||
Sq_getinteger(v, 2, &Idx);
|
||
|
||
char* uncode = (char*)(StringBin[Idx]).c_str();
|
||
|
||
//char* ss = DNFTOOL::GBKTOUTF8(std::string(uncode));
|
||
wchar_t* cfg = DNFTOOL::charTowchar_t(uncode);
|
||
|
||
Sq_pushstring(v, cfg, -1);
|
||
delete[]cfg;
|
||
|
||
return 1;
|
||
}
|
||
|
||
static SQInteger sq_LongLongOperation(HSQUIRRELVM v)
|
||
{
|
||
const SQChar* valuebuf1;
|
||
Sq_getstring(v, 2, &valuebuf1);
|
||
char* OutPutText = DNFTOOL::SquirrelU2W(valuebuf1);
|
||
LONGLONG value1 = std::atoll(OutPutText);
|
||
delete[]OutPutText;
|
||
|
||
const SQChar* valuebuf2;
|
||
Sq_getstring(v, 3, &valuebuf2);
|
||
char* OutPutText2 = DNFTOOL::SquirrelU2W(valuebuf2);
|
||
LONGLONG value2 = std::atoll(OutPutText2);
|
||
delete[]OutPutText2;
|
||
|
||
const SQChar* TypeBuf;
|
||
Sq_getstring(v, 4, &TypeBuf);
|
||
char* TypecharBuf = DNFTOOL::SquirrelU2W(TypeBuf);
|
||
std::string Type(TypecharBuf);
|
||
delete[]TypecharBuf;
|
||
|
||
std::string RetString = "";
|
||
if (Type == "+") {
|
||
RetString = std::to_string(value1 + value2);
|
||
}
|
||
else if (Type == "-") {
|
||
RetString = std::to_string(value1 - value2);
|
||
}
|
||
else if (Type == "*") {
|
||
RetString = std::to_string((static_cast<double>(value1) * static_cast<double>(value2)));
|
||
}
|
||
else if (Type == "/") {
|
||
RetString = std::to_string((static_cast<double>(value1) / static_cast<double>(value2)));
|
||
}
|
||
else if (Type == "%") {
|
||
RetString = std::to_string(value1 % value2);
|
||
}
|
||
else if (Type == "format") {
|
||
if (value1 < 1000) {
|
||
RetString = std::to_string(value1);
|
||
}
|
||
else if (value1 < 1000000) {
|
||
RetString = std::to_string(value1 / 1000.0) + "k";
|
||
}
|
||
else if (value1 < 1000000000) {
|
||
RetString = std::to_string(value1 / 1000000.0) + "M";
|
||
}
|
||
else if (value1 < 1000000000000LL) {
|
||
RetString = std::to_string(value1 / 1000000000.0) + "G";
|
||
}
|
||
else {
|
||
RetString = std::to_string(value1 / 1000000000000.0) + "T";
|
||
}
|
||
}
|
||
|
||
|
||
wchar_t* ss = DNFTOOL::charTowchar_t((char*)RetString.c_str());
|
||
Sq_pushstring(v, ss, -1);
|
||
delete[]ss;
|
||
|
||
return 1;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
//zlib½âѹ
|
||
std::string gzip_decompress(const std::string& compressed) {
|
||
z_stream zs;
|
||
memset(&zs, 0, sizeof(zs));
|
||
|
||
if (inflateInit2(&zs, 16 + MAX_WBITS) != Z_OK) {
|
||
//throw std::runtime_error("inflateInit failed");
|
||
return "null";
|
||
}
|
||
|
||
zs.next_in = (Bytef*)compressed.data();
|
||
zs.avail_in = compressed.size();
|
||
|
||
int ret;
|
||
char outbuffer[32768];
|
||
std::string outstring;
|
||
|
||
do {
|
||
zs.next_out = reinterpret_cast<Bytef*>(outbuffer);
|
||
zs.avail_out = sizeof(outbuffer);
|
||
|
||
ret = inflate(&zs, 0);
|
||
|
||
if (outstring.size() < zs.total_out) {
|
||
outstring.append(outbuffer, zs.total_out - outstring.size());
|
||
}
|
||
|
||
} while (ret == Z_OK);
|
||
|
||
inflateEnd(&zs);
|
||
|
||
if (ret != Z_STREAM_END) {
|
||
//throw std::runtime_error("Exception during zlib decompression: (" + std::to_string(ret) + ") " + zs.msg);
|
||
return "null";
|
||
}
|
||
|
||
return outstring;
|
||
}
|
||
static SQInteger sq_Dezlib(HSQUIRRELVM v)
|
||
{
|
||
const SQChar* Str;
|
||
Sq_getstring(v, 2, &Str);
|
||
char* OutPutText = DNFTOOL::SquirrelU2W(Str);
|
||
std::string RealStr = OutPutText;
|
||
delete[]OutPutText;
|
||
|
||
LenheartBase::CBASE64 bb;
|
||
std::string StrBuf = bb.decode(RealStr);
|
||
StrBuf = gzip_decompress(StrBuf);
|
||
|
||
wchar_t* ss = DNFTOOL::charTowchar_t((char*)StrBuf.c_str());
|
||
Sq_pushstring(v, ss, -1);
|
||
delete[]ss;
|
||
|
||
//std::cout << StrBuf << std::endl;
|
||
return 1;
|
||
}
|
||
|
||
|
||
|
||
//»æÖÆImg
|
||
typedef int(_fastcall _Load_Npk)(int thisc, void*, int a2, wchar_t* a3);
|
||
typedef int(_fastcall _Get_Img)(int thisc, void*, int a2);
|
||
typedef int(_fastcall _Draw_Img)(int thisc, void*, int X, int Y, int Img);
|
||
typedef int(_fastcall _Ex_Draw_Img)(DWORD thisc, DWORD Seat, int X, int Y, DWORD Img, int a5, int a6, int a7, int a8, float a9, float a10);
|
||
typedef int(_fastcall _Ex_Draw_Num)(DWORD thisc, DWORD Seat, int X, int Y, DWORD Value, DWORD RGBA, int a6);
|
||
typedef int(_fastcall _Ex_Draw_Init)(DWORD thisc, DWORD Seat, DWORD Value, DWORD RGBA, DWORD asadsd, DWORD asads3d);
|
||
typedef int(_cdecl _Get_Draw_This)(DWORD thisc);
|
||
|
||
static _Load_Npk* Load_Npk = (_Load_Npk*)0x11C0410;
|
||
static _Get_Img* Get_Img = (_Get_Img*)0x11AA190;
|
||
static _Draw_Img* Draw_Img = (_Draw_Img*)0x11A8F60;
|
||
static _Ex_Draw_Img* Ex_Draw_Img = (_Ex_Draw_Img*)0x11A97E0;
|
||
static _Ex_Draw_Num* Ex_Draw_Num = (_Ex_Draw_Num*)0x11b2390;
|
||
static _Ex_Draw_Init* Ex_Draw_Init = (_Ex_Draw_Init*)0x11B22C0;
|
||
static _Get_Draw_This* Get_Draw_This = (_Get_Draw_This*)0x11A5990;
|
||
|
||
static SQInteger sq_DrawImg(HSQUIRRELVM v)
|
||
{
|
||
int Top = Sq_gettop(v);
|
||
if (Top == 4) {
|
||
int imgbuf;
|
||
Sq_getinteger(v, 2, &imgbuf);
|
||
int X;
|
||
Sq_getinteger(v, 3, &X);
|
||
int Y;
|
||
Sq_getinteger(v, 4, &Y);
|
||
Draw_Img(*(int*)0x1B45B94, 0, X, Y, imgbuf);
|
||
return 0;
|
||
}
|
||
if (Top == 5)
|
||
{
|
||
const SQChar* File;
|
||
Sq_getstring(v, 2, &File);
|
||
int Idx;
|
||
Sq_getinteger(v, 3, &Idx);
|
||
int X;
|
||
Sq_getinteger(v, 4, &X);
|
||
int Y;
|
||
Sq_getinteger(v, 5, &Y);
|
||
|
||
|
||
int npkbuf = Load_Npk(*(int*)0x1B4684C, 0, 0, (wchar_t*)File);
|
||
int imgbuf = Get_Img(npkbuf, 0, Idx);
|
||
Draw_Img(*(int*)0x1B45B94, 0, X, Y, imgbuf);
|
||
return 0;
|
||
}
|
||
else if (Top == 6) {
|
||
const SQChar* File;
|
||
Sq_getstring(v, 2, &File);
|
||
int Value;
|
||
Sq_getinteger(v, 3, &Value);
|
||
int X;
|
||
Sq_getinteger(v, 4, &X);
|
||
int Y;
|
||
Sq_getinteger(v, 5, &Y);
|
||
int rgba;
|
||
Sq_getinteger(v, 6, &rgba);
|
||
|
||
int thisc = Get_Draw_This(56);
|
||
int npkbuf = Load_Npk(*(int*)0x1B4684C, 0, 0, (wchar_t*)File);
|
||
int intibuf = Ex_Draw_Init(thisc, 0, *(int*)0x1B45B94, npkbuf, X, Y);//Æ«ÒƶàÉÙµÄÊýÖµ -1 == 0 ËùÐèÆ«ÒÆ - 1
|
||
*(int*)0x1A70190 = intibuf;
|
||
Ex_Draw_Num(intibuf, 0, 100, 100, Value, rgba, 0);
|
||
|
||
|
||
}
|
||
else if (Top == 9 || Top == 10) {
|
||
const SQChar* File;
|
||
Sq_getstring(v, 2, &File);
|
||
int Idx;
|
||
Sq_getinteger(v, 3, &Idx);
|
||
int X;
|
||
Sq_getinteger(v, 4, &X);
|
||
int Y;
|
||
Sq_getinteger(v, 5, &Y);
|
||
int Model;
|
||
Sq_getinteger(v, 6, &Model);
|
||
int rgba;
|
||
Sq_getinteger(v, 7, &rgba);
|
||
|
||
int Xf;
|
||
Sq_getfloat(v, 8, (FLOAT*)&Xf);
|
||
int Yf;
|
||
Sq_getfloat(v, 9, (FLOAT*)&Yf);
|
||
|
||
int npkbuf = Load_Npk(*(int*)0x1B4684C, 0, 0, (wchar_t*)File);
|
||
int imgbuf = Get_Img(npkbuf, 0, Idx);
|
||
Ex_Draw_Img(*(int*)0x1B45B94, 0, X, Y, imgbuf, Xf, Yf, Model, rgba, 0, 0);
|
||
return 0;
|
||
}
|
||
return 0;
|
||
}
|
||
//ÉèÖÃäÖȾģʽ
|
||
typedef int(_cdecl _SetDrawImgModel)(int a1, int a2);
|
||
static _SetDrawImgModel* SetDrawImgModel = (_SetDrawImgModel*)0x11A8A50;
|
||
//»¹ÔäÖȾģʽ
|
||
typedef int(_cdecl _ReleaseDrawImgModel)();
|
||
static _ReleaseDrawImgModel* ReleaseDrawImgModel = (_ReleaseDrawImgModel*)0x11A8B60;
|
||
static SQInteger sq_SetDrawImgModel(HSQUIRRELVM v)
|
||
{
|
||
int M1;
|
||
Sq_getinteger(v, 2, &M1);
|
||
int M2;
|
||
Sq_getinteger(v, 3, &M2);
|
||
SetDrawImgModel(M1, M2);
|
||
return 0;
|
||
}
|
||
static SQInteger sq_ReleaseDrawImgModel(HSQUIRRELVM v)
|
||
{
|
||
ReleaseDrawImgModel();
|
||
return 0;
|
||
}
|
||
|
||
//³õʼ»¯Êý×Ö»æÖÆ
|
||
typedef struct DamageFontInfo
|
||
{
|
||
int Type[8][10];
|
||
|
||
} DamageFontInfo;
|
||
static DamageFontInfo MyFont = { 0 };
|
||
static SQInteger sq_IntiNumberDraw(HSQUIRRELVM v)
|
||
{
|
||
const SQChar* File;
|
||
Sq_getstring(v, 2, &File);
|
||
int Idx;
|
||
Sq_getinteger(v, 3, &Idx);
|
||
int Type;
|
||
Sq_getinteger(v, 4, &Type);
|
||
|
||
int npkbuf = Load_Npk(*(int*)0x1B4684C, 0, 0, (wchar_t*)File);
|
||
|
||
for (size_t i = 0; i < 10; i++)
|
||
{
|
||
int imgbuf = Get_Img(npkbuf, 0, Idx + i);
|
||
MyFont.Type[Type][i] = imgbuf;
|
||
}
|
||
return 0;
|
||
}
|
||
//»æÖÆÊý×Ö
|
||
static SQInteger sq_DrawNumber(HSQUIRRELVM v)
|
||
{
|
||
int X;
|
||
Sq_getinteger(v, 2, &X);
|
||
int Y;
|
||
Sq_getinteger(v, 3, &Y);
|
||
int rgba;
|
||
Sq_getinteger(v, 4, &rgba);
|
||
int Xf;
|
||
Sq_getfloat(v, 5, (FLOAT*)&Xf);
|
||
int Yf;
|
||
Sq_getfloat(v, 6, (FLOAT*)&Yf);
|
||
int Type;
|
||
Sq_getinteger(v, 7, &Type);
|
||
int Number;
|
||
Sq_getinteger(v, 8, &Number);
|
||
std::string Value = std::to_string(Number);
|
||
|
||
float fValue;
|
||
// ͨ¹ýÖ¸ÕëÀàÐÍת»»
|
||
reinterpret_cast<unsigned int*>(&fValue)[0] = Xf;
|
||
|
||
|
||
int mathoffset = 0;
|
||
for (size_t i = 0; i < Value.size(); i++)
|
||
{
|
||
int Idx = Value[i] - 48;
|
||
Ex_Draw_Img(*(int*)0x1B45B94, 0, X + mathoffset, Y, MyFont.Type[Type][Idx], Xf, Yf, 0, rgba, 0, 0);
|
||
|
||
mathoffset += (((*(short*)(MyFont.Type[Type][Idx] + 0x1C)) * fValue) - 5);
|
||
}
|
||
return 0;
|
||
}
|
||
//»æÖƾŹ¬¸ñ
|
||
static SQInteger sq_DrawWindow(HSQUIRRELVM v)
|
||
{
|
||
int Top = Sq_gettop(v);
|
||
int X;
|
||
Sq_getinteger(v, 2, &X);
|
||
int Y;
|
||
Sq_getinteger(v, 3, &Y);
|
||
int WindowWidth;
|
||
Sq_getinteger(v, 4, &WindowWidth);
|
||
int WindowHeight;
|
||
Sq_getinteger(v, 5, &WindowHeight);
|
||
|
||
//·¾¶
|
||
wchar_t* File = L"interface/windowcommon.img";
|
||
int StartIdx = 0;
|
||
|
||
int leftWidth = 11;//×î×ó±ßµÄÆ´½ÓµÄ¿í¶È
|
||
int centerWidth = 12;//Öм䲿·ÖÆ´½ÓµÄ¿í¶È
|
||
|
||
int topHeight = 11;//×îÉÏÃæÆ´½ÓµÄ¸ß¶È
|
||
int centerHeight = 13;//Öм䲿·ÖÆ´½ÓµÄ¸ß¶È
|
||
|
||
if (Top == 11) {
|
||
const SQChar* bFile;
|
||
Sq_getstring(v, 6, &bFile);
|
||
int Idx;
|
||
Sq_getinteger(v, 7, &Idx);
|
||
File = (wchar_t*)bFile;
|
||
StartIdx = Idx;
|
||
Sq_getinteger(v, 8, &leftWidth);
|
||
Sq_getinteger(v, 9, ¢erWidth);
|
||
Sq_getinteger(v, 10, &topHeight);
|
||
Sq_getinteger(v, 11, ¢erHeight);
|
||
}
|
||
|
||
int widthCount = round(WindowWidth / centerWidth);
|
||
int heightCount = round(WindowHeight / centerWidth);
|
||
|
||
int npkbuf = Load_Npk(*(int*)0x1B4684C, 0, 0, File);
|
||
int leftTopFrame = Get_Img(npkbuf, 0, 0 + StartIdx);
|
||
int topCenterFrame = Get_Img(npkbuf, 0, 1 + StartIdx);
|
||
int rightTopFrame = Get_Img(npkbuf, 0, 2 + StartIdx);
|
||
int leftCenterFrame = Get_Img(npkbuf, 0, 3 + StartIdx);
|
||
int centerFrame = Get_Img(npkbuf, 0, 4 + StartIdx);
|
||
int rightCenterFrame = Get_Img(npkbuf, 0, 5 + StartIdx);
|
||
int leftBottomFrame = Get_Img(npkbuf, 0, 6 + StartIdx);
|
||
int centerBottomFrame = Get_Img(npkbuf, 0, 7 + StartIdx);
|
||
int rightBottomFrame = Get_Img(npkbuf, 0, 8 + StartIdx);
|
||
|
||
Draw_Img(*(int*)0x1B45B94, 0, X, Y, leftTopFrame);
|
||
|
||
for (int i = 0; i < widthCount; i++) {
|
||
Draw_Img(*(int*)0x1B45B94, 0, X + leftWidth + centerWidth * i, Y, topCenterFrame);
|
||
}
|
||
|
||
Draw_Img(*(int*)0x1B45B94, 0, X + leftWidth + centerWidth * widthCount, Y, rightTopFrame);
|
||
|
||
|
||
//Æ´½ÓÖмäºÍÏÂÃ沿·ÖµÄ
|
||
//jΪÍùÏÂÊýµÄµÚ¼¸ÐÐ
|
||
for (int j = 0; j < heightCount; j++) {
|
||
Draw_Img(*(int*)0x1B45B94, 0, X, Y + topHeight + centerHeight * j, leftCenterFrame);
|
||
//»æÖÆ×î×ó±ßµÄ²¿·Ö
|
||
|
||
if (j == 0)
|
||
Draw_Img(*(int*)0x1B45B94, 0, X, Y + topHeight + centerHeight * heightCount, leftBottomFrame);
|
||
//ÕâÊÇ»æÖÆ×îÏÂ×ó±ßµÄ¹Õ½Ç
|
||
|
||
//»æÖÆÖмäµÄ²¿·Ö
|
||
for (int i = 0; i < widthCount; i++) {
|
||
Draw_Img(*(int*)0x1B45B94, 0, X + leftWidth + centerWidth * i, Y + topHeight + centerHeight * j, centerFrame);
|
||
if (j == 0)
|
||
Draw_Img(*(int*)0x1B45B94, 0, X + leftWidth + centerWidth * i, Y + topHeight + centerHeight * heightCount, centerBottomFrame);
|
||
//»æÖÆÖмä×îÏÂÃæµÄ²¿·Ö
|
||
}
|
||
|
||
Draw_Img(*(int*)0x1B45B94, 0, X + leftWidth + centerWidth * widthCount, Y + topHeight + centerHeight * j, rightCenterFrame);
|
||
//»æÖÆ×îÓұߵIJ¿·Ö
|
||
|
||
if (j == 0)
|
||
Draw_Img(*(int*)0x1B45B94, 0, X + leftWidth + centerWidth * widthCount, Y + topHeight + centerHeight * heightCount, rightBottomFrame);
|
||
//»æÖÆ×îÓÒ±ß×îÏÂÃæ¹Õ½Ç´¦
|
||
|
||
}
|
||
|
||
|
||
if (heightCount == 0) {
|
||
Draw_Img(*(int*)0x1B45B94, 0, X, Y + topHeight + centerHeight * heightCount, leftBottomFrame);
|
||
for (int i = 0; i < widthCount; i++) {
|
||
Draw_Img(*(int*)0x1B45B94, 0, X + leftWidth + centerWidth * i, Y + topHeight + centerHeight * heightCount, centerBottomFrame);
|
||
}
|
||
//»æÖÆÖмä×îÏÂÃæµÄ²¿·Ö
|
||
Draw_Img(*(int*)0x1B45B94, 0, X + leftWidth + centerWidth * widthCount, Y + topHeight + centerHeight * heightCount, rightBottomFrame);
|
||
//»æÖÆ×îÓÒ±ß×îÏÂÃæ¹Õ½Ç´¦
|
||
}
|
||
|
||
|
||
return 0;
|
||
}
|
||
//»æÖÆÈýͼ
|
||
static SQInteger sq_DrawButton(HSQUIRRELVM v)
|
||
{
|
||
int Top = Sq_gettop(v);
|
||
int X;
|
||
Sq_getinteger(v, 2, &X);
|
||
int Y;
|
||
Sq_getinteger(v, 3, &Y);
|
||
int WindowWidth;
|
||
Sq_getinteger(v, 4, &WindowWidth);
|
||
const SQChar* File;
|
||
Sq_getstring(v, 5, &File);
|
||
int StartIdx;
|
||
Sq_getinteger(v, 6, &StartIdx);
|
||
//Ìî³ä¿í¶È
|
||
int FillWidth;
|
||
Sq_getinteger(v, 7, &FillWidth);
|
||
//Ê×½Ú¿í¶È
|
||
int FirstWidth;
|
||
Sq_getinteger(v, 8, &FirstWidth);
|
||
|
||
int widthCount = round(WindowWidth / 2);
|
||
|
||
int npkbuf = Load_Npk(*(int*)0x1B4684C, 0, 0, (wchar_t*)File);
|
||
int leftFrame = Get_Img(npkbuf, 0, 0 + StartIdx);
|
||
int CenterFrame = Get_Img(npkbuf, 0, 1 + StartIdx);
|
||
int rightFrame = Get_Img(npkbuf, 0, 2 + StartIdx);
|
||
|
||
Draw_Img(*(int*)0x1B45B94, 0, X, Y, leftFrame);
|
||
for (int i = 0; i < widthCount; i++) {
|
||
Draw_Img(*(int*)0x1B45B94, 0, X + FirstWidth + FillWidth * i, Y, CenterFrame);
|
||
}
|
||
|
||
Draw_Img(*(int*)0x1B45B94, 0, X + FirstWidth + FillWidth * widthCount, Y, rightFrame);
|
||
return 0;
|
||
}
|
||
//»ñÈ¡ÎÄ×Ö»æÖƳ¤¶È
|
||
static std::map<std::string, int>LenheartCodeWidth;
|
||
static SQInteger Sq_getstringDrawLength(HSQUIRRELVM v) {
|
||
|
||
const SQChar* Str;
|
||
Sq_getstring(v, 2, &Str);
|
||
|
||
char* OutPutText = DNFTOOL::SquirrelU2W(Str);
|
||
std::string RealStr = OutPutText;
|
||
delete[]OutPutText;
|
||
|
||
if (!LenheartCodeWidth.count("0")) {
|
||
LenheartCodeWidth[" "] = 4;
|
||
LenheartCodeWidth["0"] = 7;
|
||
LenheartCodeWidth["1"] = 5;
|
||
LenheartCodeWidth["2"] = 7;
|
||
LenheartCodeWidth["3"] = 7;
|
||
LenheartCodeWidth["4"] = 7;
|
||
LenheartCodeWidth["5"] = 7;
|
||
LenheartCodeWidth["6"] = 7;
|
||
LenheartCodeWidth["7"] = 6;
|
||
LenheartCodeWidth["8"] = 7;
|
||
LenheartCodeWidth["9"] = 7;
|
||
LenheartCodeWidth["z"] = 6;
|
||
LenheartCodeWidth["y"] = 8;
|
||
LenheartCodeWidth["x"] = 7;
|
||
LenheartCodeWidth["w"] = 7;
|
||
LenheartCodeWidth["v"] = 7;
|
||
LenheartCodeWidth["u"] = 8;
|
||
LenheartCodeWidth["t"] = 6;
|
||
LenheartCodeWidth["s"] = 6;
|
||
LenheartCodeWidth["r"] = 7;
|
||
LenheartCodeWidth["q"] = 7;
|
||
LenheartCodeWidth["p"] = 7;
|
||
LenheartCodeWidth["o"] = 6;
|
||
LenheartCodeWidth["n"] = 8;
|
||
LenheartCodeWidth["m"] = 7;
|
||
LenheartCodeWidth["l"] = 7;
|
||
LenheartCodeWidth["k"] = 7;
|
||
LenheartCodeWidth["j"] = 6;
|
||
LenheartCodeWidth["i"] = 5;
|
||
LenheartCodeWidth["h"] = 8;
|
||
LenheartCodeWidth["g"] = 7;
|
||
LenheartCodeWidth["f"] = 7;
|
||
LenheartCodeWidth["e"] = 6;
|
||
LenheartCodeWidth["d"] = 7;
|
||
LenheartCodeWidth["c"] = 6;
|
||
LenheartCodeWidth["b"] = 7;
|
||
LenheartCodeWidth["a"] = 7;
|
||
LenheartCodeWidth["A"] = 8;
|
||
LenheartCodeWidth["B"] = 7;
|
||
LenheartCodeWidth["C"] = 7;
|
||
LenheartCodeWidth["D"] = 7;
|
||
LenheartCodeWidth["E"] = 7;
|
||
LenheartCodeWidth["F"] = 7;
|
||
LenheartCodeWidth["G"] = 8;
|
||
LenheartCodeWidth["H"] = 8;
|
||
LenheartCodeWidth["I"] = 5;
|
||
LenheartCodeWidth["J"] = 8;
|
||
LenheartCodeWidth["K"] = 8;
|
||
LenheartCodeWidth["L"] = 8;
|
||
LenheartCodeWidth["M"] = 8;
|
||
LenheartCodeWidth["N"] = 8;
|
||
LenheartCodeWidth["O"] = 7;
|
||
LenheartCodeWidth["P"] = 7;
|
||
LenheartCodeWidth["Q"] = 7;
|
||
LenheartCodeWidth["R"] = 8;
|
||
LenheartCodeWidth["S"] = 7;
|
||
LenheartCodeWidth["T"] = 7;
|
||
LenheartCodeWidth["U"] = 8;
|
||
LenheartCodeWidth["V"] = 8;
|
||
LenheartCodeWidth["W"] = 7;
|
||
LenheartCodeWidth["X"] = 7;
|
||
LenheartCodeWidth["Y"] = 7;
|
||
LenheartCodeWidth["Z"] = 7;
|
||
LenheartCodeWidth[","] = 4;
|
||
LenheartCodeWidth["£¬"] = 4;
|
||
LenheartCodeWidth["."] = 3;
|
||
LenheartCodeWidth["¡£"] = 6;
|
||
LenheartCodeWidth["!"] = 3;
|
||
LenheartCodeWidth["£¡"] = 4;
|
||
LenheartCodeWidth["?"] = 7;
|
||
LenheartCodeWidth["£¿"] = 8;
|
||
LenheartCodeWidth[";"] = 3;
|
||
LenheartCodeWidth["£»"] = 4;
|
||
LenheartCodeWidth["["] = 5;
|
||
LenheartCodeWidth["]"] = 5;
|
||
LenheartCodeWidth["{"] = 5;
|
||
LenheartCodeWidth["}"] = 5;
|
||
LenheartCodeWidth["("] = 5;
|
||
LenheartCodeWidth[")"] = 5;
|
||
LenheartCodeWidth["\\"] = 6;
|
||
LenheartCodeWidth["¡°"] = 7;
|
||
LenheartCodeWidth["¡±"] = 7;
|
||
LenheartCodeWidth["\""] = 4;
|
||
LenheartCodeWidth["¡¯"] = 4;
|
||
LenheartCodeWidth["+"] = 7;
|
||
LenheartCodeWidth["-"] = 8;
|
||
LenheartCodeWidth["*"] = 7;
|
||
LenheartCodeWidth["/"] = 8;
|
||
LenheartCodeWidth["="] = 8;
|
||
}
|
||
|
||
int L = 0;
|
||
|
||
int StrTextLength = 0;
|
||
for (size_t i = 0; i < RealStr.length();)
|
||
{
|
||
int cplen = 1;
|
||
if (RealStr[i] < 0)cplen = 2;
|
||
std::string c = RealStr.substr(i, cplen);
|
||
if (LenheartCodeWidth.count(c)) {
|
||
L += LenheartCodeWidth[c];
|
||
}
|
||
else {
|
||
L += 13;
|
||
}
|
||
i += cplen;
|
||
StrTextLength++;
|
||
}
|
||
L -= StrTextLength;
|
||
|
||
Sq_pushinteger(v, L);
|
||
return 1;
|
||
}
|
||
//»ñÈ¡ÎÄ×Ö»»Ðзµ»ØÊý×é
|
||
static SQInteger Sq_getstringDrawArray(HSQUIRRELVM v) {
|
||
|
||
const SQChar* Str;
|
||
Sq_getstring(v, 2, &Str);
|
||
|
||
int Len;
|
||
Sq_getinteger(v, 3, &Len);
|
||
|
||
char* OutPutText = DNFTOOL::SquirrelU2W(Str);
|
||
std::string RealStr = OutPutText;
|
||
delete[]OutPutText;
|
||
|
||
if (!LenheartCodeWidth.count("0")) {
|
||
LenheartCodeWidth[" "] = 4;
|
||
LenheartCodeWidth["0"] = 7;
|
||
LenheartCodeWidth["1"] = 5;
|
||
LenheartCodeWidth["2"] = 7;
|
||
LenheartCodeWidth["3"] = 7;
|
||
LenheartCodeWidth["4"] = 7;
|
||
LenheartCodeWidth["5"] = 7;
|
||
LenheartCodeWidth["6"] = 7;
|
||
LenheartCodeWidth["7"] = 6;
|
||
LenheartCodeWidth["8"] = 7;
|
||
LenheartCodeWidth["9"] = 7;
|
||
LenheartCodeWidth["z"] = 6;
|
||
LenheartCodeWidth["y"] = 8;
|
||
LenheartCodeWidth["x"] = 7;
|
||
LenheartCodeWidth["w"] = 7;
|
||
LenheartCodeWidth["v"] = 7;
|
||
LenheartCodeWidth["u"] = 8;
|
||
LenheartCodeWidth["t"] = 6;
|
||
LenheartCodeWidth["s"] = 6;
|
||
LenheartCodeWidth["r"] = 7;
|
||
LenheartCodeWidth["q"] = 7;
|
||
LenheartCodeWidth["p"] = 7;
|
||
LenheartCodeWidth["o"] = 6;
|
||
LenheartCodeWidth["n"] = 8;
|
||
LenheartCodeWidth["m"] = 7;
|
||
LenheartCodeWidth["l"] = 7;
|
||
LenheartCodeWidth["k"] = 7;
|
||
LenheartCodeWidth["j"] = 6;
|
||
LenheartCodeWidth["i"] = 5;
|
||
LenheartCodeWidth["h"] = 8;
|
||
LenheartCodeWidth["g"] = 7;
|
||
LenheartCodeWidth["f"] = 7;
|
||
LenheartCodeWidth["e"] = 6;
|
||
LenheartCodeWidth["d"] = 7;
|
||
LenheartCodeWidth["c"] = 6;
|
||
LenheartCodeWidth["b"] = 7;
|
||
LenheartCodeWidth["a"] = 7;
|
||
LenheartCodeWidth["A"] = 8;
|
||
LenheartCodeWidth["B"] = 7;
|
||
LenheartCodeWidth["C"] = 7;
|
||
LenheartCodeWidth["D"] = 7;
|
||
LenheartCodeWidth["E"] = 7;
|
||
LenheartCodeWidth["F"] = 7;
|
||
LenheartCodeWidth["G"] = 8;
|
||
LenheartCodeWidth["H"] = 8;
|
||
LenheartCodeWidth["I"] = 5;
|
||
LenheartCodeWidth["J"] = 8;
|
||
LenheartCodeWidth["K"] = 8;
|
||
LenheartCodeWidth["L"] = 8;
|
||
LenheartCodeWidth["M"] = 8;
|
||
LenheartCodeWidth["N"] = 8;
|
||
LenheartCodeWidth["O"] = 7;
|
||
LenheartCodeWidth["P"] = 7;
|
||
LenheartCodeWidth["Q"] = 7;
|
||
LenheartCodeWidth["R"] = 8;
|
||
LenheartCodeWidth["S"] = 7;
|
||
LenheartCodeWidth["T"] = 7;
|
||
LenheartCodeWidth["U"] = 8;
|
||
LenheartCodeWidth["V"] = 8;
|
||
LenheartCodeWidth["W"] = 7;
|
||
LenheartCodeWidth["X"] = 7;
|
||
LenheartCodeWidth["Y"] = 7;
|
||
LenheartCodeWidth["Z"] = 7;
|
||
LenheartCodeWidth[","] = 4;
|
||
LenheartCodeWidth["£¬"] = 4;
|
||
LenheartCodeWidth["."] = 3;
|
||
LenheartCodeWidth["¡£"] = 6;
|
||
LenheartCodeWidth["!"] = 3;
|
||
LenheartCodeWidth["£¡"] = 4;
|
||
LenheartCodeWidth["?"] = 7;
|
||
LenheartCodeWidth["£¿"] = 8;
|
||
LenheartCodeWidth[";"] = 3;
|
||
LenheartCodeWidth["£»"] = 4;
|
||
LenheartCodeWidth["["] = 5;
|
||
LenheartCodeWidth["]"] = 5;
|
||
LenheartCodeWidth["{"] = 5;
|
||
LenheartCodeWidth["}"] = 5;
|
||
LenheartCodeWidth["("] = 5;
|
||
LenheartCodeWidth[")"] = 5;
|
||
LenheartCodeWidth["\\"] = 6;
|
||
LenheartCodeWidth["¡°"] = 7;
|
||
LenheartCodeWidth["¡±"] = 7;
|
||
LenheartCodeWidth["\""] = 4;
|
||
LenheartCodeWidth["¡¯"] = 4;
|
||
LenheartCodeWidth["+"] = 7;
|
||
LenheartCodeWidth["-"] = 8;
|
||
LenheartCodeWidth["*"] = 7;
|
||
LenheartCodeWidth["/"] = 8;
|
||
LenheartCodeWidth["="] = 8;
|
||
}
|
||
|
||
std::vector<std::string>StrBuf;
|
||
|
||
int StrTextLength = 0;
|
||
for (size_t i = 0; i < RealStr.length();)
|
||
{
|
||
int cplen = 1;
|
||
if (RealStr[i] < 0)cplen = 2;
|
||
std::string c = RealStr.substr(i, cplen);
|
||
|
||
StrBuf.push_back(c);
|
||
i += cplen;
|
||
}
|
||
|
||
std::vector<std::string>PushStrBuf;
|
||
std::string Ostr = "";
|
||
for (unsigned int i = 0; i < StrBuf.size(); ++i)
|
||
{
|
||
int AddLen = 0;
|
||
if (LenheartCodeWidth.count(StrBuf[i])) {
|
||
AddLen = LenheartCodeWidth[StrBuf[i]];
|
||
}
|
||
else {
|
||
AddLen = 13;
|
||
}
|
||
|
||
//³¬¹ýÁË
|
||
if (AddLen + StrTextLength > Len) {
|
||
PushStrBuf.push_back(Ostr);
|
||
StrTextLength = AddLen;
|
||
Ostr = StrBuf[i];
|
||
}
|
||
else {
|
||
Ostr += StrBuf[i];
|
||
StrTextLength += AddLen;
|
||
//×îºóÒ»¶Î
|
||
if (i == StrBuf.size() - 1) {
|
||
PushStrBuf.push_back(Ostr);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
sq_newarray((HSQUIRRELVM)v, 0);
|
||
|
||
for (unsigned int i = 0; i < PushStrBuf.size(); ++i)
|
||
{
|
||
std::string Buf = PushStrBuf[i];
|
||
char* ss = DNFTOOL::GBKTOUTF8(Buf);
|
||
wchar_t* aa = DNFTOOL::charTowchar_t(ss);
|
||
Sq_pushstring(v, aa, -1);
|
||
sq_arrayappend((HSQUIRRELVM)v, -2);
|
||
delete[]aa;
|
||
}
|
||
return 1;
|
||
}
|
||
//·´ÐòÁл¯Json
|
||
static SQInteger DecondeJson(HSQUIRRELVM v) {
|
||
const SQChar* OutPutBuffer;
|
||
Sq_getstring(v, 2, &OutPutBuffer);
|
||
char* OutPutText = DNFTOOL::wchar_tTochar((wchar_t*)OutPutBuffer);
|
||
std::string str = OutPutText;
|
||
delete[]OutPutText;
|
||
|
||
size_t pos = 0;
|
||
bool Ars = false;
|
||
while ((pos = str.find("\"", pos)) != std::string::npos) {
|
||
// ÅжÏË«ÒýºÅÊÇ·ñÔÚKeyµÄλÖÃ
|
||
if (pos > 0) {
|
||
if (str[pos - 1] == '[') {
|
||
Ars = true;
|
||
}
|
||
if ((str[pos - 1] == '{' || str[pos + 1] == ':' || str[pos - 1] == ',') && !Ars) {
|
||
// ɾ³ýË«ÒýºÅ
|
||
str.erase(pos, 1);
|
||
}
|
||
else {
|
||
pos++;
|
||
}
|
||
if (str[pos] == ']') {
|
||
Ars = false;
|
||
}
|
||
}
|
||
else {
|
||
pos++;
|
||
}
|
||
}
|
||
|
||
str = DNFTOOL::ReplaceAll(str, ":", "=");
|
||
|
||
wchar_t* ss = DNFTOOL::charTowchar_t((char*)str.c_str());
|
||
Sq_pushstring(v, ss, -1);
|
||
delete[]ss;
|
||
return 1;
|
||
}
|
||
//ÐòÁл¯Json
|
||
std::string EncodeARRAY(HSQUIRRELVM v, std::string Jso);
|
||
std::string EncodeTABLE(HSQUIRRELVM v, std::string Jso);
|
||
std::string EncodeARRAY(HSQUIRRELVM v, std::string Jso) {
|
||
Jso += "[";
|
||
|
||
sq_pushnull((HSQUIRRELVM)v); // null iterator
|
||
while (SQ_SUCCEEDED(sq_next((HSQUIRRELVM)v, -2)))
|
||
{
|
||
SQObjectType Type = sq_gettype((HSQUIRRELVM)v, -1);
|
||
switch (Type)
|
||
{
|
||
case OT_INTEGER: {
|
||
static SQInteger value;
|
||
Sq_getinteger(v, -1, &value);
|
||
Jso += std::to_string(value);
|
||
Jso += ",";
|
||
}
|
||
break;
|
||
case OT_FLOAT:
|
||
{
|
||
SQFloat value;
|
||
Sq_getfloat(v, -1, &value);
|
||
Jso += std::to_string(value);
|
||
Jso += ",";
|
||
}
|
||
break;
|
||
case OT_BOOL:
|
||
{
|
||
SQBool value;
|
||
Sq_getbool(v, -1, &value);
|
||
Jso += std::to_string(value);
|
||
Jso += ",";
|
||
}
|
||
break;
|
||
case OT_STRING:
|
||
{
|
||
const SQChar* value;
|
||
Sq_getstring((HSQUIRRELVM)v, -1, &value);
|
||
|
||
char* vOutPutText = DNFTOOL::SquirrelU2W(value);
|
||
std::string vstr = vOutPutText;
|
||
delete[]vOutPutText;
|
||
Jso += "\"";
|
||
Jso += vstr;
|
||
Jso += "\"";
|
||
Jso += ",";
|
||
}
|
||
break;
|
||
case OT_TABLE:
|
||
{
|
||
static SQInteger Top = Sq_gettop(v);
|
||
SQObject obj;
|
||
sq_getstackobj(v, -1, &obj);
|
||
sq_pushobject(v, obj);
|
||
Jso = EncodeTABLE(v, Jso);
|
||
sq_settop(v, Top);
|
||
Jso += ",";
|
||
}
|
||
break;
|
||
case OT_ARRAY:
|
||
{
|
||
static SQInteger Top = Sq_gettop(v);
|
||
SQObject obj;
|
||
sq_getstackobj(v, -1, &obj);
|
||
sq_pushobject(v, obj);
|
||
Jso = EncodeARRAY(v, Jso);
|
||
sq_settop(v, Top);
|
||
Jso += ",";
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
//ÕâÀï-1ÊÇÖµ£¬-2ÊǼü
|
||
sq_pop((HSQUIRRELVM)v, 2); //ÔÚÏÂÒ»´Îµü´ú֮ǰµ¯³ö¼üºÍÖµ
|
||
}
|
||
sq_pop((HSQUIRRELVM)v, 1); //ÔÚÏÂÒ»´Îµü´ú֮ǰµ¯³ö¼üºÍÖµ
|
||
Jso = Jso.substr(0, Jso.length() - 1);
|
||
Jso += "]";
|
||
return Jso;
|
||
}
|
||
std::string EncodeTABLE(HSQUIRRELVM v, std::string Jso) {
|
||
|
||
Jso += "{";
|
||
|
||
sq_pushnull((HSQUIRRELVM)v); // null iterator
|
||
while (SQ_SUCCEEDED(sq_next((HSQUIRRELVM)v, -2)))
|
||
{
|
||
const SQChar* Key;
|
||
Sq_getstring((HSQUIRRELVM)v, -2, &Key);
|
||
|
||
|
||
char* OutPutText = DNFTOOL::SquirrelU2W(Key);
|
||
std::string str = OutPutText;
|
||
delete[]OutPutText;
|
||
|
||
|
||
Jso += "\"";
|
||
Jso += str;
|
||
Jso += "\"";
|
||
Jso += ":";
|
||
|
||
SQObjectType Type = sq_gettype((HSQUIRRELVM)v, -1);
|
||
switch (Type)
|
||
{
|
||
case OT_INTEGER: {
|
||
static SQInteger value;
|
||
Sq_getinteger(v, -1, &value);
|
||
Jso += std::to_string(value);
|
||
Jso += ",";
|
||
}
|
||
break;
|
||
case OT_FLOAT:
|
||
{
|
||
SQFloat value;
|
||
Sq_getfloat(v, -1, &value);
|
||
Jso += std::to_string(value);
|
||
Jso += ",";
|
||
}
|
||
break;
|
||
case OT_BOOL:
|
||
{
|
||
SQBool value;
|
||
Sq_getbool(v, -1, &value);
|
||
Jso += std::to_string(value);
|
||
Jso += ",";
|
||
}
|
||
break;
|
||
case OT_STRING:
|
||
{
|
||
const SQChar* value;
|
||
Sq_getstring((HSQUIRRELVM)v, -1, &value);
|
||
|
||
char* vOutPutText = DNFTOOL::SquirrelU2W(value);
|
||
std::string vstr = vOutPutText;
|
||
delete[]vOutPutText;
|
||
Jso += "\"";
|
||
Jso += vstr;
|
||
Jso += "\"";
|
||
Jso += ",";
|
||
}
|
||
break;
|
||
case OT_TABLE:
|
||
{
|
||
static SQInteger Top = Sq_gettop(v);
|
||
SQObject obj;
|
||
sq_getstackobj(v, -1, &obj);
|
||
sq_pushobject(v, obj);
|
||
Jso = EncodeTABLE(v, Jso);
|
||
sq_settop(v, Top);
|
||
Jso += ",";
|
||
}
|
||
break;
|
||
case OT_ARRAY:
|
||
{
|
||
static SQInteger Top = Sq_gettop(v);
|
||
SQObject obj;
|
||
sq_getstackobj(v, -1, &obj);
|
||
sq_pushobject(v, obj);
|
||
Jso = EncodeARRAY(v, Jso);
|
||
sq_settop(v, Top);
|
||
Jso += ",";
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
//ÕâÀï-1ÊÇÖµ£¬-2ÊǼü
|
||
sq_pop((HSQUIRRELVM)v, 2); //ÔÚÏÂÒ»´Îµü´ú֮ǰµ¯³ö¼üºÍÖµ
|
||
}
|
||
sq_pop((HSQUIRRELVM)v, 1); //ÔÚÏÂÒ»´Îµü´ú֮ǰµ¯³ö¼üºÍÖµ
|
||
Jso = Jso.substr(0, Jso.length() - 1);
|
||
Jso += "}";
|
||
return Jso;
|
||
}
|
||
static SQInteger EncondeJson(HSQUIRRELVM v) {
|
||
|
||
std::string Jso = "";
|
||
std::string RealJso = EncodeTABLE((HSQUIRRELVM)v, Jso);
|
||
char* sbuf = DNFTOOL::GBKTOUTF8(RealJso);
|
||
wchar_t* ss = DNFTOOL::charTowchar_t(sbuf);
|
||
Sq_pushstring(v, ss, -1);
|
||
return 1;
|
||
}
|
||
//°´¼üÊÇ·ñ°´ÏÂ
|
||
static SQInteger sq_IsKeyDown(HSQUIRRELVM v) {
|
||
|
||
int KeyCode;
|
||
Sq_getinteger(v, 2, &KeyCode);
|
||
|
||
if (KEY_DOWN(KeyCode)) {
|
||
Sq_pushbool(v, true);
|
||
}
|
||
else {
|
||
Sq_pushbool(v, false);
|
||
}
|
||
return 1;
|
||
}
|
||
//´ò¿ªÌØÊâ´°¿Ú
|
||
//´°¿ÚCALL
|
||
typedef void(*NNoticeTCall)(DWORD thisc, DWORD Seat, DWORD a1, wchar_t* a2, DWORD a3, DWORD a4, DWORD a5);
|
||
static NNoticeTCall _ANoticeTcall = (NNoticeTCall)0xE6E070;
|
||
typedef void(_fastcall _Open_ExWindow)(int thisc, void*, int a2, char a3, char a4);
|
||
static _Open_ExWindow* Open_ExWindow = (_Open_ExWindow*)0xE718A0;
|
||
static _Open_ExWindow* Open_ExWindow2 = (_Open_ExWindow*)0xE6E070;
|
||
static SQInteger sq_Open_ExWindow(HSQUIRRELVM v) {
|
||
int a1, a2, a3, a4;
|
||
Sq_getinteger(v, 2, &a1);
|
||
Sq_getinteger(v, 3, &a2);
|
||
Sq_getinteger(v, 4, &a3);
|
||
Sq_getinteger(v, 5, &a4);
|
||
Open_ExWindow(a1, 0, a2, a3, a4);
|
||
return 0;
|
||
}
|
||
static SQInteger sq_Open_ExWindow2(HSQUIRRELVM v) {
|
||
int a1, a2, a3, a4;
|
||
Sq_getinteger(v, 2, &a1);
|
||
Sq_getinteger(v, 3, &a2);
|
||
Sq_getinteger(v, 4, &a3);
|
||
Sq_getinteger(v, 5, &a4);
|
||
Open_ExWindow2(a1, 0, a2, a3, a4);
|
||
return 0;
|
||
}
|
||
typedef int(_cdecl _GetWindowByIdx)(int Idx);
|
||
static _GetWindowByIdx* GetWindowByIdx = (_GetWindowByIdx*)0x5A2A00;
|
||
static SQInteger sq_GetWindowById(HSQUIRRELVM v) {
|
||
int Idx;
|
||
Sq_getinteger(v, 2, &Idx);
|
||
int WindowAddress = GetWindowByIdx(Idx);
|
||
Sq_pushinteger(v, WindowAddress);
|
||
|
||
return 1;
|
||
}
|
||
//Ñ¡Ôñ´óµØͼÇøÓò
|
||
static SQInteger sq_Select_MiniMap_Index(HSQUIRRELVM v) {
|
||
int ReIndex;
|
||
Sq_getinteger(v, 2, &ReIndex);
|
||
static int dnf_103E030 = 0x103E030;
|
||
static int dnf_287FA88 = 0x287FA88;
|
||
static int dnf_103DCD0 = 0x103DCD0;
|
||
static int dnf_103B240 = 0x103B240;
|
||
static int dnf_2878D95 = 0x2878D95;
|
||
static int dnf_1194FC0 = 0x1194FC0;
|
||
static int dnf_410230 = 0x410230;
|
||
static int dnf_102F4D0 = 0x102F4D0;
|
||
_asm
|
||
{
|
||
mov ecx, dword ptr ds : [0x1A5FB20]
|
||
mov esi, dword ptr ds : [ecx + 0x42DC]
|
||
push ReIndex
|
||
call dnf_103E030
|
||
mov ecx, eax
|
||
call dnf_287FA88
|
||
push ReIndex
|
||
call dnf_103E030
|
||
mov ecx, eax
|
||
call dnf_103DCD0
|
||
mov ecx, eax
|
||
mov dword ptr ds : [esi + 0x24] , eax
|
||
call dnf_103B240
|
||
mov ecx, dword ptr ds : [esi + 0x24]
|
||
call dnf_2878D95
|
||
push 0x1556138
|
||
call dnf_1194FC0
|
||
mov ecx, eax
|
||
add esp, 4
|
||
lea edi, dword ptr ds : [ecx + 2]
|
||
dnf_1031651 :
|
||
mov dx, word ptr ds : [ecx]
|
||
add ecx, 2
|
||
test dx, dx
|
||
jne dnf_1031651
|
||
sub ecx, edi
|
||
sar ecx, 1
|
||
push ecx
|
||
push eax
|
||
lea ecx, dword ptr ds : [esi + 0x144]
|
||
call dnf_410230
|
||
}
|
||
return 0;
|
||
}
|
||
//»æÖƼ¼ÄÜ
|
||
typedef void(_fastcall _DrawSkill)(int a1, int seat, int a2, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10, int a11);
|
||
static _DrawSkill* DrawSkill = (_DrawSkill*)0x909d70;
|
||
static SQInteger sq_DrawSkill(HSQUIRRELVM v)
|
||
{
|
||
int a1, x, y, a4, a5, a6, a7, a8, a9, a10;
|
||
//a1¼¼ÄܵØÖ·
|
||
Sq_getinteger(v, 2, &a1);
|
||
Sq_getinteger(v, 3, &x);
|
||
Sq_getinteger(v, 4, &y);
|
||
Sq_getinteger(v, 5, &a4);
|
||
Sq_getinteger(v, 6, &a5);
|
||
Sq_getinteger(v, 7, &a6);
|
||
Sq_getinteger(v, 8, &a7);
|
||
Sq_getinteger(v, 9, &a8);
|
||
Sq_getinteger(v, 10, &a9);
|
||
Sq_getinteger(v, 11, &a10);
|
||
DrawSkill(a1, 0, *(int*)0x1AB7CDC, x, y, a4, a5, a6, a7, a8, a9, a10);
|
||
return 1;
|
||
}
|
||
//ʹÓü¼ÄÜ
|
||
static SQInteger sq_UseSkill(HSQUIRRELVM v)
|
||
{
|
||
int Key_Value;
|
||
Sq_getinteger(v, 2, &Key_Value);
|
||
BYTE* thisc = (BYTE*)(*(DWORD*)(0x1B470E0));
|
||
thisc[269 + Key_Value] = 0x80;
|
||
return 0;
|
||
}
|
||
//»ñÈ¡µ±Ç°Ñ¡Ôñ½»»¥½ÇÉ«ÐÕÃû
|
||
static SQInteger sq_GetPlayerEachName(HSQUIRRELVM v)
|
||
{
|
||
int objNameAddress = *(int*)(0x1ade0e0);
|
||
char* str = DNFTOOL::UnicodeToUtf8((wchar_t*)(objNameAddress + 0x20));
|
||
wchar_t* name = DNFTOOL::charTowchar_t(str);
|
||
free(str);
|
||
Sq_pushstring(v, name, -1);
|
||
delete[]name;
|
||
return 1;
|
||
}
|
||
//»ñÈ¡¼¼ÄܵØÖ·
|
||
typedef int __fastcall _Funcsub_GetSkillAddress(int a1, int a2, int a3);
|
||
static _Funcsub_GetSkillAddress* Funcsub_GetSkillAddress = (_Funcsub_GetSkillAddress*)0x8406C0;
|
||
static SQInteger sq_GetSkillAddress(HSQUIRRELVM v)
|
||
{
|
||
int SkillId;
|
||
Sq_getinteger(v, 2, &SkillId);
|
||
DWORD ADDRESS = Funcsub_GetSkillAddress(*(int*)0x1AB7CDC, 0, SkillId);
|
||
Sq_pushinteger(v, ADDRESS);
|
||
return 1;
|
||
}
|
||
//˳ͼ
|
||
static SQInteger sq_MoveMap(HSQUIRRELVM v)
|
||
{
|
||
int dct;
|
||
Sq_getinteger(v, 2, &dct);
|
||
DWORD Address1 = 0x1A5FB18;
|
||
DWORD Address2 = 0x7CE9E0;
|
||
_asm
|
||
{
|
||
mov ecx, [Address1]
|
||
mov ecx, [ecx]
|
||
mov ecx, [ecx + 0x20a050]
|
||
mov ecx, [ecx + 0x4c]
|
||
push 0x1
|
||
push 0x1
|
||
push 0x0
|
||
push 0x0
|
||
push 0x0
|
||
push 0x0
|
||
push 0x0
|
||
push dct
|
||
call Address2
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
//ͨ¹ýItem±àºÅ»ñȡͼ±êImg
|
||
typedef int(_cdecl _sub7AAB60)(int a1);
|
||
static _sub7AAB60* getitemimg = (_sub7AAB60*)0x7aab60;
|
||
static SQInteger sq_GetImg(HSQUIRRELVM v)
|
||
{
|
||
int a1;
|
||
Sq_getinteger(v, 2, &a1);
|
||
int img = getitemimg(a1);
|
||
Sq_pushinteger(v, img);
|
||
return 1;
|
||
}
|
||
//»æÖÆItem
|
||
typedef int(_cdecl _sub7AA800)(int a1, int a2, int a3, int a4, int a5, int a6, char a7);
|
||
static _sub7AA800* drawimg = (_sub7AA800*)0x7aa800;
|
||
static SQInteger sq_DrawItem(HSQUIRRELVM v)
|
||
{
|
||
int a1, a2, a3, a4, a5, a6, a7;
|
||
Sq_getinteger(v, 2, &a1);
|
||
Sq_getinteger(v, 3, &a2);
|
||
Sq_getinteger(v, 4, &a3);
|
||
Sq_getinteger(v, 5, &a4);
|
||
Sq_getinteger(v, 6, &a5);
|
||
Sq_getinteger(v, 7, &a6);
|
||
Sq_getinteger(v, 8, &a7);
|
||
int img = getitemimg(a3);
|
||
drawimg(a1, a2, img, a4, a5, a6, a7);
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
//»ñÈ¡SQRµÄ¶ÔÏóת»»ÎªÔʼ¶ÔÏóµØÖ·
|
||
typedef int(_cdecl __GetSqrObject)(HSQUIRRELVM a1, int a2);
|
||
typedef int(_cdecl __PushDnfobject)(HSQUIRRELVM a1, wchar_t* Type, DWORD ObjectAddress, DWORD S);
|
||
static __PushDnfobject* PushDnfobject = (__PushDnfobject*)0x11809C0;
|
||
static __GetSqrObject* GetSqrObject = (__GetSqrObject*)0x5c1420;
|
||
static __GetSqrObject* GetExeObject = (__GetSqrObject*)0x5c13A0;
|
||
//»ñÈ¡¶ÔÏóµØÖ·
|
||
static SQInteger GetObjectAddress(HSQUIRRELVM v)
|
||
{
|
||
int objAddress = GetSqrObject(v, 2);
|
||
Sq_pushinteger(v, objAddress);
|
||
return 1;
|
||
}
|
||
//¶ÔÏóµØַת»»ÎªSqr¶ÔÏó
|
||
static SQInteger ObjectAddressToSqrObject(HSQUIRRELVM v)
|
||
{
|
||
int objAddress;
|
||
Sq_getinteger(v, 2, &objAddress);
|
||
const SQChar* Type;
|
||
Sq_getstring(v, 3, &Type);
|
||
int Flag;
|
||
Sq_getinteger(v, 4, &Flag);
|
||
PushDnfobject(v, (wchar_t*)Type, objAddress, 0);
|
||
return 1;
|
||
}
|
||
//»ñÈ¡¶ÔÏóÃû³Æ
|
||
static SQInteger GetObjectName(HSQUIRRELVM v)
|
||
{
|
||
int objAddress = GetSqrObject(v, 2);
|
||
int objNameAddress = *(int*)(objAddress + 0x258);
|
||
char* str = DNFTOOL::UnicodeToUtf8((wchar_t*)objNameAddress);
|
||
wchar_t* name = DNFTOOL::charTowchar_t(str);
|
||
free(str);
|
||
Sq_pushstring(v, name, -1);
|
||
delete[]name;
|
||
return 1;
|
||
}
|
||
//ÉèÖöÔÏóÃû³Æ
|
||
static SQInteger DeleteObjectName(HSQUIRRELVM v)
|
||
{
|
||
int objAddress = GetSqrObject(v, 2);
|
||
wchar_t* objNameAddress = *(wchar_t**)(objAddress + 0x258);
|
||
// ±éÀú×Ö·û´®Ö±µ½Óöµ½¿í×Ö·û¿ÕÖÕÖ¹·û
|
||
for (wchar_t* p = objNameAddress; *p != L'\0'; ++p) {
|
||
// ½«Ã¿¸ö×Ö·ûÌ滻Ϊ¿Õ¸ñ
|
||
*p = L' ';
|
||
}
|
||
return 0;
|
||
}
|
||
//»ñÈ¡¶ÔÏóÃû³Æ
|
||
static SQInteger GetObjectNameByAddress(HSQUIRRELVM v)
|
||
{
|
||
int objAddress;
|
||
Sq_getinteger(v, 2, &objAddress);
|
||
int objNameAddress = *(int*)(objAddress + 0x258);
|
||
char* str = DNFTOOL::UnicodeToUtf8((wchar_t*)objNameAddress);
|
||
wchar_t* name = DNFTOOL::charTowchar_t(str);
|
||
free(str);
|
||
Sq_pushstring(v, name, -1);
|
||
delete[]name;
|
||
return 1;
|
||
}
|
||
|
||
//»ñÈ¡¶ÔÏóÊôÐÔ
|
||
static SQInteger GetObjectInfo(HSQUIRRELVM v)
|
||
{
|
||
int objAddress;
|
||
Sq_getinteger(v, 2, &objAddress);
|
||
int ParameterNum = Sq_gettop(v);
|
||
if (ParameterNum == 4)
|
||
{
|
||
int InfoAddress;
|
||
Sq_getinteger(v, 3, &InfoAddress);
|
||
int Value = (objAddress + InfoAddress);
|
||
|
||
SQBool Type;
|
||
Sq_getbool(v, 4, &Type);
|
||
if (Type == TRUE)
|
||
{
|
||
Sq_pushinteger(v, *(int*)Value);
|
||
}
|
||
else if (Type == FALSE)
|
||
{
|
||
Sq_pushfloat(v, *(FLOAT*)Value);
|
||
}
|
||
}
|
||
else if (ParameterNum == 5)
|
||
{
|
||
int EquAddress;
|
||
Sq_getinteger(v, 3, &EquAddress);
|
||
int InfoAddress;
|
||
Sq_getinteger(v, 4, &InfoAddress);
|
||
int Value = (objAddress + EquAddress);
|
||
Value = *(int*)Value;
|
||
|
||
Value = Value + InfoAddress;
|
||
SQBool Type;
|
||
Sq_getbool(v, 5, &Type);
|
||
if (Type == TRUE)
|
||
{
|
||
Sq_pushinteger(v, *(int*)Value);
|
||
}
|
||
else if (Type == FALSE)
|
||
{
|
||
Sq_pushfloat(v, *(FLOAT*)Value);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
sq_throwerror(v, L"Incorrect function argument");
|
||
return 0;
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
//»ñÈ¡Æï³Ë¶ÔÏóµØÖ·
|
||
static SQInteger GetRidingObjectAddress(HSQUIRRELVM v)
|
||
{
|
||
int objAddress = GetSqrObject(v, 2);
|
||
Sq_pushinteger(v, *(int*)(objAddress + 0x54d0));
|
||
return 1;
|
||
}
|
||
//½âÃÜ»ñÈ¡¶ÔÏóÊôÐÔ
|
||
static SQInteger GetObjectDeInfo(HSQUIRRELVM v)
|
||
{
|
||
int objAddress;
|
||
Sq_getinteger(v, 2, &objAddress);
|
||
int ParameterNum = Sq_gettop(v);
|
||
if (ParameterNum == 4)
|
||
{
|
||
int InfoAddress;
|
||
Sq_getinteger(v, 3, &InfoAddress);
|
||
int Value = (objAddress + InfoAddress);
|
||
|
||
SQBool Type;
|
||
Sq_getbool(v, 4, &Type);
|
||
if (Type == TRUE)
|
||
{
|
||
Sq_pushinteger(v, DNFTOOL::DNFDeCode(Value));
|
||
}
|
||
else if (Type == FALSE)
|
||
{
|
||
Sq_pushfloat(v, (FLOAT)DNFTOOL::DNFDeCode(Value));
|
||
}
|
||
}
|
||
else if (ParameterNum == 5)
|
||
{
|
||
int EquAddress;
|
||
Sq_getinteger(v, 3, &EquAddress);
|
||
int InfoAddress;
|
||
Sq_getinteger(v, 4, &InfoAddress);
|
||
int Value = (objAddress + EquAddress);
|
||
Value = *(int*)Value;
|
||
|
||
Value = Value + InfoAddress;
|
||
SQBool Type;
|
||
Sq_getbool(v, 5, &Type);
|
||
if (Type == TRUE)
|
||
{
|
||
Sq_pushinteger(v, DNFTOOL::DNFDeCode(Value));
|
||
}
|
||
else if (Type == FALSE)
|
||
{
|
||
Sq_pushfloat(v, (FLOAT)DNFTOOL::DNFDeCode(Value));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
sq_throwerror(v, L"Incorrect function argument");
|
||
return 0;
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
//ÉèÖöÔÏóÊôÐÔ
|
||
static SQInteger SetObjectInfo(HSQUIRRELVM v)
|
||
{
|
||
int objAddress;
|
||
Sq_getinteger(v, 2, &objAddress);
|
||
int ParameterNum = Sq_gettop(v);
|
||
if (ParameterNum == 5)
|
||
{
|
||
int InfoAddress;
|
||
Sq_getinteger(v, 3, &InfoAddress);
|
||
int Value = (objAddress + InfoAddress);
|
||
|
||
SQBool Type;
|
||
Sq_getbool(v, 4, &Type);
|
||
if (Type == TRUE)
|
||
{
|
||
int W_Value;
|
||
Sq_getinteger(v, 5, &W_Value);
|
||
*(int*)Value = W_Value;
|
||
}
|
||
else if (Type == FALSE)
|
||
{
|
||
FLOAT W_Value;
|
||
Sq_getfloat(v, 5, &W_Value);
|
||
*(FLOAT*)Value = W_Value;
|
||
}
|
||
}
|
||
else if (ParameterNum == 6)
|
||
{
|
||
int EquAddress;
|
||
Sq_getinteger(v, 3, &EquAddress);
|
||
int InfoAddress;
|
||
Sq_getinteger(v, 4, &InfoAddress);
|
||
int Value = (objAddress + EquAddress);
|
||
Value = *(int*)Value;
|
||
|
||
Value = Value + InfoAddress;
|
||
SQBool Type;
|
||
Sq_getbool(v, 5, &Type);
|
||
if (Type == TRUE)
|
||
{
|
||
int W_Value;
|
||
Sq_getinteger(v, 6, &W_Value);
|
||
*(int*)Value = W_Value;
|
||
}
|
||
else if (Type == FALSE)
|
||
{
|
||
FLOAT W_Value;
|
||
Sq_getfloat(v, 6, &W_Value);
|
||
*(FLOAT*)Value = W_Value;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
sq_throwerror(v, L"Incorrect function argument");
|
||
return 0;
|
||
}
|
||
return 1;
|
||
}
|
||
//¼ÓÃÜÉèÖöÔÏóÊôÐÔ
|
||
static SQInteger SetObjectDeInfo(HSQUIRRELVM v)
|
||
{
|
||
int objAddress;
|
||
Sq_getinteger(v, 2, &objAddress);
|
||
int ParameterNum = Sq_gettop(v);
|
||
if (ParameterNum == 5)
|
||
{
|
||
int InfoAddress;
|
||
Sq_getinteger(v, 3, &InfoAddress);
|
||
int Value = (objAddress + InfoAddress);
|
||
|
||
SQBool Type;
|
||
Sq_getbool(v, 4, &Type);
|
||
if (Type == TRUE)
|
||
{
|
||
int W_Value;
|
||
Sq_getinteger(v, 5, &W_Value);
|
||
DNFTOOL::DNFEnCode(Value, W_Value);
|
||
}
|
||
else if (Type == FALSE)
|
||
{
|
||
FLOAT W_Value;
|
||
Sq_getfloat(v, 5, &W_Value);
|
||
DNFTOOL::DNFEnCode(Value, (int)W_Value);
|
||
}
|
||
}
|
||
else if (ParameterNum == 6)
|
||
{
|
||
int EquAddress;
|
||
Sq_getinteger(v, 3, &EquAddress);
|
||
int InfoAddress;
|
||
Sq_getinteger(v, 4, &InfoAddress);
|
||
int Value = (objAddress + EquAddress);
|
||
Value = *(int*)Value;
|
||
|
||
Value = Value + InfoAddress;
|
||
SQBool Type;
|
||
Sq_getbool(v, 5, &Type);
|
||
if (Type == TRUE)
|
||
{
|
||
int W_Value;
|
||
Sq_getinteger(v, 6, &W_Value);
|
||
DNFTOOL::DNFEnCode(Value, W_Value);
|
||
}
|
||
else if (Type == FALSE)
|
||
{
|
||
FLOAT W_Value;
|
||
Sq_getfloat(v, 6, &W_Value);
|
||
DNFTOOL::DNFEnCode(Value, (int)W_Value);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
sq_throwerror(v, L"Incorrect function argument");
|
||
return 0;
|
||
}
|
||
return 1;
|
||
}
|
||
//»ñÈ¡¶ÔÏóµÈ¼¶
|
||
static SQInteger GetObjectLevel(HSQUIRRELVM v)
|
||
{
|
||
int objAddress = GetSqrObject(v, 2);
|
||
int Level = DNFTOOL::DNFDeCode(objAddress + 0x1A4C);
|
||
Sq_pushinteger(v, Level);
|
||
return 1;
|
||
}
|
||
|
||
//»ñÈ¡¶ÔÏóÊÇ·ñÊÇÍæ¼Òº¯ÊýµØÖ·
|
||
typedef DWORD IsCharacter(int Address);
|
||
static IsCharacter* _IsCharacter = (IsCharacter*)0x5A36F0;
|
||
//»ñÈ¡¶ÔÏóÊÇ·ñÊÇÍæ¼Ò
|
||
static SQInteger GetObjectIsCharacter(HSQUIRRELVM v)
|
||
{
|
||
int objAddress;
|
||
Sq_getinteger(v, 2, &objAddress);
|
||
int Ret = _IsCharacter(objAddress);
|
||
Sq_pushinteger(v, Ret);
|
||
return 1;
|
||
}
|
||
|
||
typedef int(__fastcall* _GetObjectAttribute)(DWORD thisc, int Seat, int Type);
|
||
typedef int(__fastcall* _FloatDecode)(int Address);
|
||
static _GetObjectAttribute GetObjectAttributeFunc = (_GetObjectAttribute)0xD07390;
|
||
static _FloatDecode FloatDecode = (_FloatDecode)0x5B0090;
|
||
//»ñÈ¡¶ÔÏóÊôÐÔ
|
||
static SQInteger GetObjectAttribute(HSQUIRRELVM v)
|
||
{
|
||
int objAddress, Type;
|
||
Sq_getinteger(v, 2, &objAddress);
|
||
Sq_getinteger(v, 3, &Type);
|
||
int Ret = GetObjectAttributeFunc(objAddress, 0, Type);
|
||
Ret = FloatDecode(Ret);
|
||
Sq_pushinteger(v, Ret);
|
||
return 1;
|
||
}
|
||
|
||
//¶ÁÈËÎï »ò ×°±¸ÊôÐÔ
|
||
static SQInteger GetCharacterAttribute(HSQUIRRELVM v)
|
||
{
|
||
int n1, n2;
|
||
int num = Sq_gettop(v);
|
||
|
||
int CharAddr = *(int*)(0x1AB7CDC);
|
||
if (num == 3)
|
||
{
|
||
Sq_getinteger(v, 2, &n1);
|
||
Sq_getinteger(v, 3, &n2);
|
||
int TValue = *(int*)(CharAddr + DNFTOOL::GetEquAddr(n2));
|
||
int SValue = (TValue + n1);
|
||
if (SValue < 0x400000)
|
||
Sq_pushinteger(v, 0);
|
||
else if (n1 != 0x8 && n1 != 0x1C && n1 != 0xF4 && n1 != 0x854)
|
||
Sq_pushinteger(v, (DNFTOOL::DNFDeCode(SValue)));
|
||
else
|
||
Sq_pushinteger(v, (*(int*)(SValue)));
|
||
}
|
||
else if (num == 2)
|
||
{
|
||
Sq_getinteger(v, 2, &n1);
|
||
int Value = (CharAddr + n1);
|
||
|
||
Sq_pushinteger(v, (DNFTOOL::DNFDeCode(Value)));
|
||
}
|
||
else
|
||
{
|
||
sq_throwerror(v, L"parameter error");
|
||
}
|
||
return 1;
|
||
}
|
||
//дÈËÎï »ò ×°±¸ÊôÐÔ
|
||
static SQInteger SetCharacterAttribute(HSQUIRRELVM v)
|
||
{
|
||
int n1, n2, n3;
|
||
int num = Sq_gettop(v);
|
||
int CharAddr = *(int*)(0x1AB7CDC);
|
||
if (num == 4)
|
||
{
|
||
Sq_getinteger(v, 2, &n1);
|
||
Sq_getinteger(v, 3, &n2);
|
||
Sq_getinteger(v, 4, &n3);
|
||
|
||
int TValue = *(int*)(CharAddr + DNFTOOL::GetEquAddr(n2));
|
||
int SValue = (TValue + n1);
|
||
if (SValue < 0x400000)
|
||
Sq_pushbool(v, false);
|
||
else if (n1 != 0x8 && n1 != 0x1C && n1 != 0xF4)
|
||
DNFTOOL::DNFEnCode(SValue, n3);
|
||
else
|
||
*(int*)SValue = n3;
|
||
Sq_pushbool(v, true);
|
||
}
|
||
else if (num == 3)
|
||
{
|
||
Sq_getinteger(v, 2, &n1);
|
||
Sq_getinteger(v, 3, &n2);
|
||
|
||
int Value = (CharAddr + n1);
|
||
DNFTOOL::DNFEnCode(Value, n2);
|
||
Sq_pushbool(v, true);
|
||
}
|
||
else
|
||
{
|
||
Sq_pushbool(v, false);
|
||
}
|
||
return 1;
|
||
}
|
||
//»ñÈ¡³ÇÕò±àºÅ
|
||
static SQInteger GetTownIndex(HSQUIRRELVM v)
|
||
{
|
||
Sq_pushinteger(v, DNFTOOL::GetHook(0x1A5E258, "0xAC+0xD4+", 0));
|
||
return 1;
|
||
}
|
||
//»ñÈ¡³ÇÕòÇøÓò±àºÅ
|
||
static SQInteger GetRegionIndex(HSQUIRRELVM v)
|
||
{
|
||
Sq_pushinteger(v, *(int*)(DNFTOOL::GetHook(0x1A5E258, "0xAC+0xD8+", 0)));
|
||
return 1;
|
||
}
|
||
//»ñÈ¡³ÇÕòX×ø±ê
|
||
static SQInteger GetTownXpos(HSQUIRRELVM v)
|
||
{
|
||
Sq_pushinteger(v, DNFTOOL::GetHook(0x1AB7CE0, "0x2BC+", 0));
|
||
return 1;
|
||
}
|
||
//»ñÈ¡³ÇÕòY×ø±ê
|
||
static SQInteger GetTownYpos(HSQUIRRELVM v)
|
||
{
|
||
Sq_pushinteger(v, DNFTOOL::GetHook(0x1AB7CE0, "0x2C0+", 0));
|
||
return 1;
|
||
}
|
||
//»ñÈ¡Æ£ÀÍÖµ
|
||
static SQInteger GetFatigue(HSQUIRRELVM v)
|
||
{
|
||
int Type;
|
||
int num = Sq_gettop(v);
|
||
if (num == 2)
|
||
{
|
||
Sq_getinteger(v, 2, &Type);
|
||
|
||
switch (Type)
|
||
{
|
||
case 0:
|
||
Sq_pushinteger(v, DNFTOOL::DNFDeCode(0x1AB7E1C));
|
||
break;
|
||
case 1:
|
||
Sq_pushinteger(v, DNFTOOL::DNFDeCode(0x1AB7E10));
|
||
break;
|
||
default:
|
||
Sq_pushbool(v, false);
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
sq_throwerror(v, L"parameter error");
|
||
}
|
||
return 1;
|
||
}
|
||
//»ñÈ¡¾ÑéÖµ
|
||
static SQInteger GetExp(HSQUIRRELVM v)
|
||
{
|
||
int Type;
|
||
|
||
int num = Sq_gettop(v);
|
||
if (num == 2)
|
||
{
|
||
Sq_getinteger(v, 2, &Type);
|
||
|
||
switch (Type)
|
||
{
|
||
case 0:
|
||
Sq_pushinteger(v, DNFTOOL::DNFDeCode(DNFTOOL::GetHook(0x1AB7CDC, "0x3C4C+", 1)));
|
||
break;
|
||
case 1:
|
||
Sq_pushinteger(v, DNFTOOL::DNFDeCode(DNFTOOL::GetHook(0x1AB7CDC, "0x3C40+", 1)));
|
||
break;
|
||
default:
|
||
Sq_pushbool(v, false);
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
sq_throwerror(v, L"parameter error");
|
||
}
|
||
return 1;
|
||
}
|
||
//»ñÈ¡spµã
|
||
typedef int(_fastcall _9166B0)(int a1, int seat);
|
||
static _9166B0* GetSp = (_9166B0*)0x9166B0;
|
||
static SQInteger sq_GetSp(HSQUIRRELVM v)
|
||
{
|
||
int num = Sq_gettop(v);
|
||
if (num == 1)
|
||
{
|
||
Sq_pushinteger(v, GetSp(NULL, 0));
|
||
}
|
||
else
|
||
{
|
||
sq_throwerror(v, L"parameter error");
|
||
}
|
||
return 1;
|
||
}
|
||
//»ñȡðÏÕÍŵȼ¶
|
||
typedef int(_61A5F0)();
|
||
static _61A5F0* GetPass = (_61A5F0*)0x61A5F0;
|
||
static SQInteger sq_GetPassLevel(HSQUIRRELVM v)
|
||
{
|
||
int Passobj = GetPass();
|
||
int l = *(int*)Passobj;
|
||
Sq_pushinteger(v, l);
|
||
return 1;
|
||
}
|
||
//ˢлͼ±ê
|
||
typedef int(_fastcall _4DE680)(int a1, int seat);
|
||
static _4DE680* RefreshEventIcon = (_4DE680*)0x4DE680;
|
||
static SQInteger sq_RefreshEventIcon(HSQUIRRELVM v)
|
||
{
|
||
RefreshEventIcon(0x01A39B78, 0);
|
||
return 0;
|
||
}
|
||
//·¢°üÀàÐÍ
|
||
typedef DWORD SendClass;
|
||
static SendClass* _SendClass = (SendClass*)0x1AEB6E4;
|
||
static SQInteger SendPackType(HSQUIRRELVM v)
|
||
{
|
||
int n1;
|
||
int num = Sq_gettop(v);
|
||
if (num == 2)
|
||
{
|
||
Sq_getinteger(v, 2, &n1);
|
||
_SendpacksType(*_SendClass, 0, n1);
|
||
|
||
Sq_pushbool(v, true);
|
||
}
|
||
else
|
||
{
|
||
sq_throwerror(v, L"parameter error");
|
||
}
|
||
return 1;
|
||
}
|
||
//·¢°üByte
|
||
static SQInteger SendPackByte(HSQUIRRELVM v)
|
||
{
|
||
int n1;
|
||
int num = Sq_gettop(v);
|
||
if (num == 2)
|
||
{
|
||
Sq_getinteger(v, 2, &n1);
|
||
_SendPacksByte(*_SendClass, 0, n1);
|
||
Sq_pushbool(v, true);
|
||
}
|
||
else
|
||
{
|
||
sq_throwerror(v, L"parameter error");
|
||
}
|
||
return 1;
|
||
}
|
||
//·¢°üWord
|
||
static SQInteger SendPackWord(HSQUIRRELVM v)
|
||
{
|
||
int n1;
|
||
int num = Sq_gettop(v);
|
||
if (num == 2)
|
||
{
|
||
Sq_getinteger(v, 2, &n1);
|
||
_SendPacksWord(*_SendClass, 0, n1);
|
||
Sq_pushbool(v, true);
|
||
}
|
||
else
|
||
{
|
||
sq_throwerror(v, L"parameter error");
|
||
}
|
||
return 1;
|
||
}
|
||
//·¢°üDWord
|
||
static SQInteger SendPackDWord(HSQUIRRELVM v)
|
||
{
|
||
int n1;
|
||
int num = Sq_gettop(v);
|
||
if (num == 2)
|
||
{
|
||
Sq_getinteger(v, 2, &n1);
|
||
_SendPacksDWord(*_SendClass, 0, n1);
|
||
Sq_pushbool(v, true);
|
||
}
|
||
else
|
||
{
|
||
sq_throwerror(v, L"parameter error");
|
||
}
|
||
return 1;
|
||
}
|
||
//·¢°üwchar_t* (תÁËchar*)
|
||
static SQInteger SendPackWChar(HSQUIRRELVM v)
|
||
{
|
||
const SQChar* n1;
|
||
int num = Sq_gettop(v);
|
||
if (num == 2)
|
||
{
|
||
Sq_getstring(v, 2, &n1);
|
||
//wchar_t* ת char*
|
||
char* fname = DNFTOOL::wchar_tTochar((wchar_t*)n1);
|
||
_SendPacksChar(*_SendClass, 0, fname, strlen(fname));
|
||
delete[]fname;
|
||
Sq_pushbool(v, true);
|
||
}
|
||
else
|
||
{
|
||
sq_throwerror(v, L"parameter error");
|
||
}
|
||
return 1;
|
||
}
|
||
//·¢°ü
|
||
static SQInteger SendPack(HSQUIRRELVM v)
|
||
{
|
||
int num = Sq_gettop(v);
|
||
if (num == 1)
|
||
{
|
||
_SendPacks();
|
||
Sq_pushbool(v, true);
|
||
}
|
||
else
|
||
{
|
||
sq_throwerror(v, L"parameter error");
|
||
}
|
||
return 1;
|
||
}
|
||
//È¥¸±±¾
|
||
static SQInteger GoDungeon(HSQUIRRELVM v)
|
||
{
|
||
int n1 = 0;
|
||
int n2 = 0;
|
||
int n3 = 0;
|
||
int n4 = 0;
|
||
|
||
int num = Sq_gettop(v);
|
||
|
||
if (num == 2)
|
||
{
|
||
Sq_getinteger(v, 2, &n1);
|
||
}
|
||
else if (num == 5)
|
||
{
|
||
Sq_getinteger(v, 2, &n1);
|
||
Sq_getinteger(v, 3, &n2);
|
||
Sq_getinteger(v, 4, &n3);
|
||
Sq_getinteger(v, 5, &n4);
|
||
}
|
||
else
|
||
{
|
||
Sq_pushbool(v, false);
|
||
return 1;
|
||
}
|
||
|
||
_SendpacksType(*_SendClass, 0, 15);
|
||
_SendPacks();
|
||
|
||
_SendpacksType(*_SendClass, 0, 16);
|
||
_SendPacksWord(*_SendClass, 0, n1);
|
||
_SendPacksByte(*_SendClass, 0, n2);
|
||
_SendPacksByte(*_SendClass, 0, n3);
|
||
_SendPacksByte(*_SendClass, 0, n4);
|
||
_SendPacks();
|
||
|
||
Sq_pushbool(v, true);
|
||
return 1;
|
||
}
|
||
//»Ø³Ç
|
||
static SQInteger GoTown(HSQUIRRELVM v)
|
||
{
|
||
int num = Sq_gettop(v);
|
||
if (num == 1)
|
||
{
|
||
_SendpacksType(*_SendClass, 0, 0x2D);
|
||
_SendPacks();
|
||
Sq_pushbool(v, true);
|
||
}
|
||
else
|
||
{
|
||
Sq_pushbool(v, false);
|
||
}
|
||
return 1;
|
||
}
|
||
//Òƶ¯³ÇÕò
|
||
static SQInteger MoveTown(HSQUIRRELVM v)
|
||
{
|
||
int TownIndex;
|
||
int ReIndex;
|
||
int XPos;
|
||
int YPos;
|
||
int num = Sq_gettop(v);
|
||
if (num == 5)
|
||
{
|
||
Sq_getinteger(v, 2, &TownIndex);
|
||
Sq_getinteger(v, 3, &ReIndex);
|
||
Sq_getinteger(v, 4, &XPos);
|
||
Sq_getinteger(v, 5, &YPos);
|
||
|
||
_SendpacksType(*_SendClass, 0, 38);
|
||
_SendPacksByte(*_SendClass, 0, TownIndex);
|
||
_SendPacksByte(*_SendClass, 0, ReIndex);
|
||
_SendPacksWord(*_SendClass, 0, XPos);
|
||
_SendPacksWord(*_SendClass, 0, YPos);
|
||
_SendPacksByte(*_SendClass, 0, 5);
|
||
_SendPacksWord(*_SendClass, 0, 0);
|
||
_SendPacksWord(*_SendClass, 0, 0);
|
||
_SendPacks();
|
||
|
||
Sq_pushbool(v, true);
|
||
}
|
||
else
|
||
{
|
||
Sq_pushbool(v, false);
|
||
}
|
||
return 1;
|
||
}
|
||
//»æÖÆ×Ö·û
|
||
typedef void(__fastcall* DrawCode)(DWORD thisc, int Seat, int a3, int a4, int a5, int a6);
|
||
typedef DWORD(_fastcall _FontInit)(DWORD thisc, DWORD Seat);
|
||
static _FontInit* sub_11BE9A0 = (_FontInit*)0x11BE9A0;
|
||
static _FontInit* sub_11BE980 = (_FontInit*)0x11BE980;
|
||
typedef DWORD(_fastcall _BFontInit)(DWORD thisc, DWORD Seat);
|
||
static _BFontInit* sub_1206570 = (_BFontInit*)0x1206570;
|
||
typedef DWORD(_fastcall _FontC)(DWORD thisc, DWORD Seat, DWORD Font);
|
||
static _FontC* sub_1206550 = (_FontC*)0x1206550;
|
||
static DrawCode NewDrawCodeF = (DrawCode)0x01206BD0;
|
||
|
||
static SQInteger sq_DrawCode(HSQUIRRELVM v)
|
||
{
|
||
const SQChar* Str;
|
||
int XPos;
|
||
int YPos;
|
||
int Color;
|
||
int Type;
|
||
int Stroke;
|
||
|
||
int ParameterNum = Sq_gettop(v);
|
||
|
||
if (ParameterNum == 4)
|
||
{
|
||
Color = (int)0xfffffffff;
|
||
Type = 1;
|
||
Stroke = 0;
|
||
|
||
Sq_pushbool(v, true);
|
||
}
|
||
else if (ParameterNum == 5)
|
||
{
|
||
//»ñÈ¡ÑÕÉ«
|
||
Sq_getinteger(v, 5, &Color);
|
||
Type = 1;
|
||
Stroke = 0;
|
||
|
||
Sq_pushbool(v, true);
|
||
}
|
||
else if (ParameterNum == 6)
|
||
{
|
||
//»ñÈ¡ÑÕÉ«
|
||
Sq_getinteger(v, 5, &Color);
|
||
//»ñÈ¡ÀàÐÍ
|
||
Sq_getinteger(v, 6, &Type);
|
||
Stroke = 0;
|
||
|
||
Sq_pushbool(v, true);
|
||
}
|
||
else if (ParameterNum == 7)
|
||
{
|
||
//»ñÈ¡ÑÕÉ«
|
||
Sq_getinteger(v, 5, &Color);
|
||
//»ñÈ¡ÀàÐÍ
|
||
Sq_getinteger(v, 6, &Type);
|
||
//»ñÈ¡Ãè±ß
|
||
Sq_getinteger(v, 7, &Stroke);
|
||
|
||
Sq_pushbool(v, true);
|
||
}
|
||
else
|
||
{
|
||
Sq_pushbool(v, false);
|
||
return 1;
|
||
}
|
||
|
||
//»ñÈ¡×Ö·û´®ÄÚÈÝ
|
||
Sq_getstring(v, 2, &Str);
|
||
//»ñÈ¡X×ø±ê
|
||
Sq_getinteger(v, 3, &XPos);
|
||
//»ñÈ¡X×ø±ê
|
||
Sq_getinteger(v, 4, &YPos);
|
||
//ËÉÊó Wchar_t ת»»Îª Unicode
|
||
char* OutPutText = DNFTOOL::SquirrelU2W(Str);
|
||
//תΪÕýÈ·µÄUnicode×Ö·û
|
||
wchar_t* str = DNFTOOL::char2wchar(OutPutText);
|
||
|
||
//ÉêÇë±Ê
|
||
unsigned char* font = new unsigned char[1000];
|
||
//³õʼ»¯±Ê
|
||
sub_11BE9A0((DWORD)font, 0);
|
||
sub_11BE980((DWORD)font, 0);
|
||
//ÊÇ·ñÃè±ß
|
||
font[1] = Stroke;
|
||
|
||
int FontObj;
|
||
|
||
switch (Type)
|
||
{
|
||
case 1:
|
||
FontObj = *(int*)0x1B468CC;
|
||
break;
|
||
case 2:
|
||
FontObj = *(int*)0x1B468DC;
|
||
break;
|
||
case 3:
|
||
FontObj = *(int*)0x1B468D4;
|
||
break;
|
||
default:
|
||
FontObj = *(int*)0x1B468CC;
|
||
break;
|
||
}
|
||
|
||
//×ÖÌå
|
||
*(int*)((int)font + 8) = FontObj;
|
||
|
||
//µÃµ½»æÖƾä±ú
|
||
DWORD base = *(int*)0x1B45B94;
|
||
//ÉèÖñÊ
|
||
sub_1206550(base, 0, (DWORD)font);
|
||
//»æÖÆ×ÖÌå
|
||
NewDrawCodeF(base, 0, XPos, YPos, Color, (int)str);
|
||
//È¡Ïû±Ê
|
||
sub_1206570(base, 0);
|
||
|
||
|
||
delete[]OutPutText;
|
||
delete[]str;
|
||
delete[]font;
|
||
return 1;
|
||
}
|
||
//¶ÁÄÚ´æ
|
||
static SQInteger LReadAddress(HSQUIRRELVM v)
|
||
{
|
||
//ÄÚ´æµØÖ· intÐÍ
|
||
int Address;
|
||
|
||
//»ñÈ¡²ÎÊý¸öÊý
|
||
int ParameterNum = Sq_gettop(v);
|
||
|
||
//1¸ö²ÎÊýʱ
|
||
if (ParameterNum == 2)
|
||
{
|
||
//»ñÈ¡ÖµµÄÀàÐÍ
|
||
int ParameterType = sq_gettype(v, 2);
|
||
|
||
switch (ParameterType)
|
||
{
|
||
case OT_INTEGER://intÀàÐÍ
|
||
{
|
||
//»ñÈ¡µØÖ·
|
||
Sq_getinteger(v, 2, &Address);
|
||
if (Address >= 0x400000) {
|
||
int Value = *(int*)Address;
|
||
Sq_pushinteger(v, Value);
|
||
}
|
||
else {
|
||
Sq_pushinteger(v, -1);
|
||
}
|
||
return 1;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
if (ParameterNum == 3)
|
||
{
|
||
//µØÖ·
|
||
int Address;
|
||
//Æ«ÒÆ
|
||
const SQChar* offset;
|
||
|
||
Sq_getinteger(v, 2, &Address);
|
||
Sq_getstring(v, 3, &offset);
|
||
|
||
int Value = DNFTOOL::GetHook(Address, DNFTOOL::wchar_tTochar((wchar_t*)offset), 0);
|
||
Sq_pushinteger(v, Value);
|
||
return 1;
|
||
}
|
||
return 0;
|
||
}
|
||
//¶ÁÄÚ´æ
|
||
static SQInteger LReadAddressB(HSQUIRRELVM v)
|
||
{
|
||
//ÄÚ´æµØÖ· intÐÍ
|
||
int Address;
|
||
|
||
//»ñÈ¡²ÎÊý¸öÊý
|
||
int ParameterNum = Sq_gettop(v);
|
||
//1¸ö²ÎÊýʱ
|
||
if (ParameterNum == 2)
|
||
{
|
||
//»ñÈ¡µØÖ·
|
||
Sq_getinteger(v, 2, &Address);
|
||
int Value = *(BYTE*)Address;
|
||
Sq_pushinteger(v, Value);
|
||
return 1;
|
||
}
|
||
if (ParameterNum == 3)
|
||
{
|
||
////µØÖ·
|
||
//int Address;
|
||
////Æ«ÒÆ
|
||
//wchar_t* offset;
|
||
|
||
//Sq_getinteger(v, 2, &Address);
|
||
//SQGetString(v, 3, &offset);
|
||
|
||
//int Value = DNFTOOL::GetHook(Address, DNFTOOL::wchar_tTochar(offset));
|
||
//SQPushInt(v, Value);
|
||
std::cout << "δÍê³É" << std::endl;
|
||
return 0;
|
||
}
|
||
else
|
||
{
|
||
Sq_pushbool(v, false);
|
||
return 1;
|
||
}
|
||
return 0;
|
||
}
|
||
//¶ÁÄÚ´æ
|
||
static SQInteger LReadAddressFloat(HSQUIRRELVM v)
|
||
{
|
||
//ÄÚ´æµØÖ· intÐÍ
|
||
int Address;
|
||
Sq_getinteger(v, 2, &Address);
|
||
Sq_pushfloat(v, *(float*)Address);
|
||
return 1;
|
||
}
|
||
//дÄÚ´æ
|
||
static SQInteger LWriteAddressB(HSQUIRRELVM v)
|
||
{
|
||
//ÄÚ´æµØÖ· intÐÍ
|
||
int Address;
|
||
|
||
//»ñÈ¡²ÎÊý¸öÊý
|
||
int ParameterNum = Sq_gettop(v);
|
||
//1¸ö²ÎÊýʱ
|
||
if (ParameterNum == 3)
|
||
{
|
||
//»ñÈ¡µØÖ·
|
||
Sq_getinteger(v, 2, &Address);
|
||
//»ñÈ¡Ð޸ĵÄÖµ
|
||
int WriteValue;
|
||
Sq_getinteger(v, 3, &WriteValue);
|
||
*(BYTE*)Address = (BYTE)WriteValue;
|
||
Sq_pushbool(v, true);
|
||
return 1;
|
||
}
|
||
if (ParameterNum == 4)
|
||
{
|
||
//µØÖ·
|
||
int Address;
|
||
//Æ«ÒÆ
|
||
const SQChar* offset;
|
||
//ÐÞ¸ÄÖµ
|
||
int WriteValue;
|
||
|
||
Sq_getinteger(v, 2, &Address);
|
||
Sq_getstring(v, 3, &offset);
|
||
Sq_getinteger(v, 4, &WriteValue);
|
||
int SelectAddress = DNFTOOL::GetHook(Address, DNFTOOL::wchar_tTochar((wchar_t*)offset), 1);
|
||
*(BYTE*)Address = (BYTE)WriteValue;
|
||
}
|
||
else
|
||
{
|
||
Sq_pushbool(v, false);
|
||
return 1;
|
||
}
|
||
return 0;
|
||
}
|
||
//дÄÚ´æ
|
||
static SQInteger LWriteAddress(HSQUIRRELVM v)
|
||
{
|
||
//ÄÚ´æµØÖ· intÐÍ
|
||
int Address;
|
||
|
||
//»ñÈ¡²ÎÊý¸öÊý
|
||
int ParameterNum = Sq_gettop(v);
|
||
//1¸ö²ÎÊýʱ
|
||
if (ParameterNum == 3)
|
||
{
|
||
//»ñÈ¡µØÖ·
|
||
Sq_getinteger(v, 2, &Address);
|
||
//»ñÈ¡Ð޸ĵÄÖµ
|
||
int WriteValue;
|
||
Sq_getinteger(v, 3, &WriteValue);
|
||
|
||
*(int*)Address = WriteValue;
|
||
Sq_pushbool(v, true);
|
||
return 1;
|
||
}
|
||
if (ParameterNum == 4)
|
||
{
|
||
//µØÖ·
|
||
int Address;
|
||
//Æ«ÒÆ
|
||
const SQChar* offset;
|
||
//ÐÞ¸ÄÖµ
|
||
int WriteValue;
|
||
|
||
Sq_getinteger(v, 2, &Address);
|
||
Sq_getstring(v, 3, &offset);
|
||
Sq_getinteger(v, 4, &WriteValue);
|
||
|
||
int SelectAddress = DNFTOOL::GetHook(Address, DNFTOOL::wchar_tTochar((wchar_t*)offset), 1);
|
||
*(int*)SelectAddress = WriteValue;
|
||
}
|
||
else
|
||
{
|
||
Sq_pushbool(v, false);
|
||
return 1;
|
||
}
|
||
return 0;
|
||
}
|
||
//IntתָÕë
|
||
static SQInteger sq_I2P(HSQUIRRELVM v)
|
||
{
|
||
//ÄÚ´æµØÖ· intÐÍ
|
||
int Address;
|
||
Sq_getinteger(v, 2, &Address);
|
||
Sq_pushuserpointer(v, (void*)Address);
|
||
return 1;
|
||
}
|
||
//Ö¸ÕëתInt
|
||
static SQInteger sq_P2I(HSQUIRRELVM v)
|
||
{
|
||
//ÄÚ´æµØÖ· intÐÍ
|
||
SQUserPointer Address;
|
||
Sq_getuserpointer(v, 2, &Address);
|
||
Sq_pushinteger(v, (int)Address);
|
||
return 1;
|
||
}
|
||
//Êä³ö
|
||
static SQInteger Sout(HSQUIRRELVM v)
|
||
{
|
||
const SQChar* Str;
|
||
Sq_getstring(v, 2, &Str);
|
||
|
||
char* OutPutText = DNFTOOL::SquirrelU2WOut(Str);
|
||
|
||
std::cout << OutPutText << std::endl;
|
||
|
||
delete[] OutPutText;
|
||
|
||
|
||
return 0;
|
||
}
|
||
|
||
static SQInteger Clock(HSQUIRRELVM v)
|
||
{
|
||
Sq_pushinteger(v, clock());
|
||
return 1;
|
||
}
|
||
|
||
static SQInteger Getmicroseconds(HSQUIRRELVM v)
|
||
{
|
||
auto now = std::chrono::high_resolution_clock::now();
|
||
auto duration = now.time_since_epoch();
|
||
auto microseconds = std::chrono::duration_cast<std::chrono::microseconds>(duration).count();
|
||
Sq_pushfloat(v, microseconds / 1000);
|
||
return 1;
|
||
}
|
||
static SQInteger SQTime(HSQUIRRELVM v)
|
||
{
|
||
time_t t;
|
||
time(&t);
|
||
sq_pushinteger(v, *((SQInteger*)&t));
|
||
return 1;
|
||
}
|
||
//н¨´°¿Ú
|
||
//´°¿ÚCALL
|
||
typedef void(__fastcall* NoticeTCall)(DWORD thisc, DWORD Seat, DWORD a1, char* a2, DWORD a3);
|
||
static NoticeTCall _NoticeTcall = (NoticeTCall)0xE6E070;
|
||
static void WindowsNotice(char* str, int type, int b)
|
||
{
|
||
DWORD thisc = 0x1A5FB20;
|
||
thisc = *(DWORD*)thisc;
|
||
_NoticeTcall(thisc, 0, type, str, b);
|
||
}
|
||
static SQInteger NewWindows(HSQUIRRELVM v)
|
||
{
|
||
const SQChar* str = NULL;
|
||
int type = NULL;
|
||
int color = NULL;
|
||
int num = Sq_gettop(v);
|
||
|
||
if (num == 2 || num == 3 || num == 4)
|
||
{
|
||
switch (num)
|
||
{
|
||
case 2:
|
||
Sq_getstring(v, 2, &str);
|
||
break;
|
||
case 3:
|
||
Sq_getstring(v, 2, &str);
|
||
Sq_getinteger(v, 3, &type);
|
||
break;
|
||
case 4:
|
||
Sq_getstring(v, 2, &str);
|
||
Sq_getinteger(v, 3, &type);
|
||
Sq_getinteger(v, 4, &color);
|
||
break;
|
||
}
|
||
|
||
char* OutPutText = DNFTOOL::SquirrelU2W(str);
|
||
WindowsNotice(OutPutText, type, color);
|
||
delete[]OutPutText;
|
||
Sq_pushbool(v, true);
|
||
}
|
||
else
|
||
{
|
||
Sq_pushbool(v, false);
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
static SQInteger sq_Cmd(HSQUIRRELVM v)
|
||
{
|
||
const SQChar* OutPutBuffer;
|
||
Sq_getstring(v, 2, &OutPutBuffer);
|
||
char* OutPutText = DNFTOOL::SquirrelU2W(OutPutBuffer);
|
||
|
||
system(OutPutText);
|
||
delete[]OutPutText;
|
||
return 0;
|
||
}
|
||
static SQInteger sq_CmdEx(HSQUIRRELVM v)
|
||
{
|
||
const SQChar* OutPutBuffer;
|
||
Sq_getstring(v, 2, &OutPutBuffer);
|
||
char* OutPutText = DNFTOOL::SquirrelU2W((wchar_t*)OutPutBuffer);
|
||
|
||
STARTUPINFOA si = { sizeof(STARTUPINFO) };
|
||
PROCESS_INFORMATION pi;
|
||
|
||
// ´´½¨Ð½ø³Ì
|
||
BOOL result = CreateProcessA(
|
||
NULL, // Ó¦ÓóÌÐòÃû³Æ
|
||
OutPutText, // ÃüÁîÐвÎÊý
|
||
NULL, // ½ø³Ì°²È«ÊôÐÔ
|
||
NULL, // Ḭ̈߳²È«ÊôÐÔ
|
||
FALSE, // ¼Ì³Ð¾ä±úÑ¡Ïî
|
||
0, // ´´½¨±êÖ¾
|
||
NULL, // »·¾³±äÁ¿
|
||
NULL, // µ±Ç°Ä¿Â¼
|
||
&si, // STARTUPINFO
|
||
&pi // PROCESS_INFORMATION
|
||
);
|
||
|
||
if (result) {
|
||
// ²»µÈ´ýнø³Ì½áÊø£¬Ö±½Ó¹Ø±Õ¾ä±ú
|
||
CloseHandle(pi.hProcess);
|
||
CloseHandle(pi.hThread);
|
||
}
|
||
else {
|
||
}
|
||
|
||
delete[]OutPutText;
|
||
return 0;
|
||
}
|
||
//ÉèÖÃUI²Û×ø±ê
|
||
static SQInteger SetSlot(HSQUIRRELVM v)
|
||
{
|
||
int Type = NULL;
|
||
int Index = NULL;
|
||
int Xpos = NULL;
|
||
int Ypos = NULL;
|
||
|
||
|
||
int OneAddr = NULL;
|
||
int* xpos = NULL;
|
||
int* ypos = NULL;
|
||
|
||
int ParameterNum = Sq_gettop(v);
|
||
|
||
if (ParameterNum == 5)
|
||
{
|
||
Sq_getinteger(v, 2, &Type);
|
||
Sq_getinteger(v, 3, &Index);
|
||
Sq_getinteger(v, 4, &Xpos);
|
||
Sq_getinteger(v, 5, &Ypos);
|
||
|
||
Sq_pop(v, ParameterNum);
|
||
|
||
switch (Type)
|
||
{
|
||
case 0://ÍØÕ¹¼¼ÄÜÀ¸
|
||
OneAddr = *(int*)0x1ADE0CC;
|
||
OneAddr = *(int*)(OneAddr + (0x60 + (4 * Index)));
|
||
xpos = (int*)(OneAddr + (0x14));
|
||
ypos = (int*)(OneAddr + (0x18));
|
||
*xpos = Xpos;
|
||
*ypos = Ypos;
|
||
break;
|
||
case 1://»ù´¡¼¼ÄÜÀ¸
|
||
OneAddr = *(int*)0x1ADE0CC;
|
||
OneAddr = *(int*)(OneAddr + (0x30 + (4 * Index)));
|
||
xpos = (int*)(OneAddr + (0x14));
|
||
ypos = (int*)(OneAddr + (0x18));
|
||
*xpos = Xpos;
|
||
*ypos = Ypos;
|
||
break;
|
||
case 2://Çл»¼¼ÄÜÀ¸
|
||
OneAddr = *(int*)0x1ADE0CC;
|
||
OneAddr = *(int*)(OneAddr + (0x124 + (4 * Index)));
|
||
xpos = (int*)(OneAddr + (0x14));
|
||
ypos = (int*)(OneAddr + (0x18));
|
||
*xpos = Xpos;
|
||
*ypos = Ypos;
|
||
break;
|
||
case 3://¿ì½ÝÎïÆ·À¸
|
||
OneAddr = *(int*)0x1ADE0CC;
|
||
OneAddr = *(int*)(OneAddr + (0x18 + (4 * Index)));
|
||
xpos = (int*)(OneAddr + (0x14));
|
||
ypos = (int*)(OneAddr + (0x18));
|
||
*xpos = Xpos;
|
||
*ypos = Ypos;
|
||
break;
|
||
case 4://ÌØÐÔ¼¼ÄÜÕ¹¿ªÀ¸
|
||
OneAddr = *(int*)0x1ADE0CC;
|
||
OneAddr = *(int*)(OneAddr + 0xC);
|
||
OneAddr = *(int*)(OneAddr + 0x4);
|
||
OneAddr = *(int*)(OneAddr + 0x0);
|
||
OneAddr = *(int*)(OneAddr + 0x34);
|
||
OneAddr = *(int*)(OneAddr + 0x4);
|
||
OneAddr = *(int*)(OneAddr + 0x28);
|
||
OneAddr = *(int*)(OneAddr + 0x4);
|
||
|
||
xpos = (int*)(OneAddr + (0x394));
|
||
ypos = (int*)(OneAddr + (0x398));
|
||
*xpos = Xpos;
|
||
*ypos = Ypos;
|
||
break;
|
||
case 5://ÌØÐÔ¼¼Äܼ¼ÄÜÀ¸
|
||
OneAddr = *(int*)(0x16E95AC + 0x400000);
|
||
OneAddr = *(int*)(OneAddr + 0x68);
|
||
OneAddr = *(int*)(OneAddr + 0x0);
|
||
OneAddr = *(int*)(OneAddr + 0x8);
|
||
OneAddr = *(int*)(OneAddr + 0x64);
|
||
OneAddr = *(int*)(OneAddr + 0x0);
|
||
OneAddr = *(int*)(OneAddr + 0x1C);
|
||
OneAddr = *(int*)(OneAddr + 0x0);
|
||
|
||
xpos = (int*)(OneAddr + (0x1794));
|
||
ypos = (int*)(OneAddr + (0x1798));
|
||
*xpos = Xpos;
|
||
*ypos = Ypos;
|
||
break;
|
||
case 6://²Ëµ¥À¸
|
||
OneAddr = *(int*)0x1ADE0CC;
|
||
OneAddr = *(int*)(OneAddr + (0x84 + (4 * Index)));
|
||
xpos = (int*)(OneAddr + (0x14));
|
||
ypos = (int*)(OneAddr + (0x18));
|
||
*xpos = Xpos;
|
||
*ypos = Ypos;
|
||
break;
|
||
}
|
||
|
||
Sq_pushbool(v, true);
|
||
}
|
||
else
|
||
{
|
||
Sq_pushbool(v, false);
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
|
||
//ÊäÈë¿òÏà¹Ø
|
||
struct InputWindowInfoS {
|
||
int x;
|
||
int y;
|
||
int width;
|
||
int height;
|
||
std::string str;
|
||
};
|
||
LRESULT CALLBACK LenheartCode(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
HDC hdc;
|
||
PAINTSTRUCT ps;
|
||
static int mX, mY;
|
||
static HWND hwndButton;
|
||
static HWND hwndEditbox;
|
||
std::string strXy;
|
||
const int IDcmdButton = 1;
|
||
const int IDeditBox = 2;
|
||
static InputWindowInfoS* WInfo;
|
||
|
||
|
||
switch (message) {
|
||
case WM_CREATE:
|
||
{
|
||
RECT rect;
|
||
GetWindowRect(hwnd, &rect); // »ñÈ¡´°¿ÚµÄ¾ØÐÎÇøÓò
|
||
|
||
// »ñÈ¡´«µÝµÄ²ÎÊý
|
||
CREATESTRUCT* pCreate = (CREATESTRUCT*)lParam;
|
||
WInfo = (InputWindowInfoS*)pCreate->lpCreateParams;
|
||
|
||
hwndEditbox = CreateWindowA("edit", NULL,
|
||
WS_CHILD | WS_VISIBLE | WS_BORDER | ES_MULTILINE,
|
||
0, 0,
|
||
WInfo->width, WInfo->height,
|
||
hwnd, (HMENU)IDeditBox, NULL, NULL);
|
||
|
||
ShowWindow(hwndEditbox, SW_SHOW);
|
||
UpdateWindow(hwndEditbox);
|
||
|
||
|
||
HFONT hFont = CreateFont(13.5, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
|
||
OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_SWISS, TEXT("Fonts\\msjh.ttf"));
|
||
SendMessage(hwndEditbox, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
|
||
SetForegroundWindow(hwndEditbox);
|
||
|
||
//Èç¹ûÓÐ×ÖÏÈд½øÈ¥
|
||
if (WInfo->str.length() > 0)SetWindowTextA(hwndEditbox, WInfo->str.c_str());
|
||
// »ñÈ¡µ±Ç°Îı¾³¤¶È
|
||
int length = GetWindowTextLengthA(hwndEditbox);
|
||
|
||
// ½«¹â±êÒƶ¯µ½Îı¾Ä©Î²
|
||
SendMessage(hwndEditbox, EM_SETSEL, length, length);
|
||
|
||
return 0;
|
||
}
|
||
case WM_CTLCOLOREDIT:
|
||
{
|
||
HDC ahdc = (HDC)wParam;
|
||
SetTextColor(ahdc, RGB(0, 0, 0));
|
||
//SetTextColor(ahdc, RGB(255, 255, 255));
|
||
SetBkMode(ahdc, TRANSPARENT); // ÉèÖñ³¾°Í¸Ã÷
|
||
return (INT_PTR)GetStockObject(NULL_BRUSH); // ·µ»Ø¿Õ»Ë¢
|
||
//return 0; //·µ»Ø¾ä±ú»Ë¢Ê±£¬±³¾°ÑÕÉ«±äΪ¶ÔÓ¦µÄ±³¾°ÑÕÉ«
|
||
}
|
||
case WM_PAINT:
|
||
{
|
||
hdc = BeginPaint(hwnd, &ps);
|
||
EndPaint(hwnd, &ps);
|
||
return 0;
|
||
}
|
||
case WM_SIZE:
|
||
{
|
||
|
||
return 0;
|
||
}
|
||
|
||
case WM_COMMAND:
|
||
switch (LOWORD(wParam)) {
|
||
case 0:
|
||
PostQuitMessage(0);
|
||
break;
|
||
case IDeditBox:
|
||
if (HIWORD(wParam) == EN_CHANGE) {
|
||
char strbuf[256];
|
||
// ±à¼¿òÄÚÈÝ·¢Éú±ä»¯
|
||
GetWindowTextA(hwndEditbox, strbuf, 256);
|
||
//std::cout << strbuf << std::endl;
|
||
WInfo->str = strbuf;
|
||
}
|
||
|
||
if (HIWORD(wParam) == EN_SETFOCUS) {
|
||
}
|
||
else if (HIWORD(wParam) == EN_KILLFOCUS) {
|
||
DestroyWindow(hwnd); //Ïú»Ù´°¿Ú
|
||
WInfo->str = "LenheartNULL";
|
||
//CREATESTRUCT* pCreate = (CREATESTRUCT*)lParam;
|
||
//delete[](InputWindowInfoS*)pCreate->lpCreateParams;
|
||
//pCreate->lpCreateParams = NULL;
|
||
//exit(0);
|
||
}
|
||
break;
|
||
}
|
||
return 0;
|
||
|
||
case WM_MOUSEACTIVATE:
|
||
break;
|
||
|
||
case WM_CLOSE:
|
||
DestroyWindow(hwnd); //Ïú»Ù´°¿Ú
|
||
return 0;
|
||
|
||
case WM_DESTROY:
|
||
PostQuitMessage(0);
|
||
return 0;
|
||
}
|
||
|
||
return DefWindowProc(hwnd, message, wParam, lParam);
|
||
}
|
||
|
||
void LenheartWindows(LPVOID lpParam) {
|
||
|
||
HWND DNFW = FindWindow(L"DNF Taiwan", L"DNF Taiwan"); // Ìæ»»"Window Title"ΪÄãÒª²éÕҵĴ°¿Ú±êÌâ
|
||
RECT rect;
|
||
GetWindowRect(DNFW, &rect); // »ñÈ¡´°¿ÚµÄ¾ØÐÎÇøÓò
|
||
|
||
InputWindowInfoS* WInfo = (InputWindowInfoS*)lpParam;
|
||
|
||
const wchar_t* className = L"myInputBoxClass";
|
||
HINSTANCE hInstance = GetModuleHandle(NULL);
|
||
|
||
WNDCLASS wc = {};
|
||
wc.lpfnWndProc = LenheartCode;
|
||
wc.hInstance = hInstance;
|
||
wc.lpszClassName = className;
|
||
wc.style = CS_HREDRAW | CS_VREDRAW;
|
||
wc.hbrBackground = CreateSolidBrush(RGB(0, 0, 0));
|
||
//wc.hbrBackground = NULL;
|
||
|
||
RegisterClass(&wc);
|
||
|
||
// ´´½¨ÊäÈë¿ò
|
||
HWND hwnd = CreateWindowEx(
|
||
0, className, L"Input Box",
|
||
WS_POPUP | WS_EX_TOOLWINDOW,
|
||
rect.left + WInfo->x, rect.top + WInfo->y, WInfo->width, WInfo->height,
|
||
NULL, NULL, hInstance, lpParam);
|
||
|
||
|
||
SetWindowLong(hwnd, GWL_EXSTYLE, GetWindowLong(hwnd, GWL_EXSTYLE) | WS_EX_LAYERED | WS_EX_TOOLWINDOW);
|
||
SetLayeredWindowAttributes(hwnd, 0, 0, LWA_ALPHA);
|
||
|
||
|
||
ShowWindow(hwnd, SW_SHOW);
|
||
|
||
MSG msg;
|
||
while (GetMessage(&msg, NULL, 0, 0))
|
||
{
|
||
TranslateMessage(&msg);
|
||
DispatchMessage(&msg);
|
||
}
|
||
}
|
||
static SQInteger sq_NewInputBox(HSQUIRRELVM v)
|
||
{
|
||
InputWindowInfoS* WInfo = new InputWindowInfoS();
|
||
Sq_getinteger(v, 2, &WInfo->x);
|
||
Sq_getinteger(v, 3, &WInfo->y);
|
||
Sq_getinteger(v, 4, &WInfo->width);
|
||
Sq_getinteger(v, 5, &WInfo->height);
|
||
const SQChar* Str;
|
||
Sq_getstring(v, 6, &Str);
|
||
char* OutPutText = DNFTOOL::SquirrelU2W(Str);
|
||
std::string RealStr = OutPutText;
|
||
delete[]OutPutText;
|
||
WInfo->str = RealStr;
|
||
|
||
|
||
DWORD threadID3;
|
||
HANDLE Thand3 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)LenheartWindows, WInfo, 0, &threadID3);
|
||
|
||
Sq_pushinteger(v, (int)WInfo);
|
||
return 1;
|
||
}
|
||
|
||
static SQInteger sq_GetInputBoxStr(HSQUIRRELVM v)
|
||
{
|
||
int Addr;
|
||
Sq_getinteger(v, 2, &Addr);
|
||
InputWindowInfoS* WInfo = (InputWindowInfoS*)Addr;
|
||
|
||
std::string str = WInfo->str;
|
||
char* ss = DNFTOOL::GBKTOUTF8(str);
|
||
//wchar_t* name = DNFTOOL::charTowchar_t((char*)Buf.c_str());
|
||
|
||
wchar_t* aa = DNFTOOL::charTowchar_t(ss);
|
||
Sq_pushstring(v, aa, -1);
|
||
return 1;
|
||
|
||
}
|
||
|
||
static SQInteger sq_SetInputBoxStr(HSQUIRRELVM v)
|
||
{
|
||
int Addr;
|
||
Sq_getinteger(v, 2, &Addr);
|
||
const SQChar* Str;
|
||
Sq_getstring(v, 3, &Str);
|
||
char* OutPutText = DNFTOOL::SquirrelU2W(Str);
|
||
std::string RealStr = OutPutText;
|
||
delete[]OutPutText;
|
||
|
||
InputWindowInfoS* WInfo = (InputWindowInfoS*)Addr;
|
||
WInfo->str = RealStr;
|
||
return 0;
|
||
|
||
}
|
||
|
||
static SQInteger sq_MouseClick(HSQUIRRELVM v)
|
||
{
|
||
// Ä£ÄâÊó±ê×ó¼ü°´ÏÂ
|
||
INPUT input = { 0 };
|
||
input.type = INPUT_MOUSE;
|
||
input.mi.dwFlags = MOUSEEVENTF_LEFTDOWN;
|
||
SendInput(1, &input, sizeof(INPUT));
|
||
|
||
// Ä£ÄâÊó±ê×ó¼ü̧Æð
|
||
input.mi.dwFlags = MOUSEEVENTF_LEFTUP;
|
||
SendInput(1, &input, sizeof(INPUT));
|
||
return 0;
|
||
}
|
||
|
||
|
||
int __declspec(naked)Get_Item(int ItemId) {
|
||
__asm {
|
||
push ebp
|
||
mov ebp, esp
|
||
sub esp, 0xD0
|
||
push ebx
|
||
mov eax, ItemId
|
||
mov dword ptr ss : [ebp - 0x04] , eax
|
||
lea ecx, dword ptr ss : [ebp - 0xD0]
|
||
mov eax, 0x65DE50
|
||
call eax
|
||
mov ecx, dword ptr ss : [ebp - 0x04]
|
||
mov ebx, 0x01
|
||
push ebx
|
||
push eax
|
||
push ecx
|
||
mov eax, 0x972220
|
||
call eax
|
||
add esp, 0x0C
|
||
pop ebx
|
||
mov esp, ebp
|
||
pop ebp
|
||
ret 0x4
|
||
}
|
||
}
|
||
static SQInteger sq_GetItem(HSQUIRRELVM v)
|
||
{
|
||
int Idx;
|
||
Sq_getinteger(v, 2, &Idx);
|
||
int A = Get_Item(Idx);
|
||
Sq_pushinteger(v, A);
|
||
return 1;
|
||
}
|
||
|
||
|
||
|
||
typedef int(_fastcall _11A2030)(int thisc, void*, int a2, int a3, int a4, int a5);
|
||
static _11A2030* SUB_11A2030 = (_11A2030*)0x11A2030;
|
||
static SQInteger sq_Test(HSQUIRRELVM v)
|
||
{
|
||
const SQChar* Path;
|
||
sq_getstring(v, 2, &Path);
|
||
char* a = new char[1024];
|
||
//wchar_t* path = L"region/region.lst";
|
||
SUB_11A2030(0x1D17638, 0, (int)Path, (int)a, 0x100000, 0x19DAF4);
|
||
|
||
//std::cout << a << std::endl;
|
||
return 0;
|
||
|
||
}
|
||
|
||
static SQInteger Sq_ActiveCallFunc(HSQUIRRELVM v)
|
||
{
|
||
// µÃµ½²ÎÊý¸öÊý
|
||
SQInteger Count = sq_gettop(v);
|
||
|
||
// µÃµ½º¯ÊýµØÖ·
|
||
SQInteger FuncAddressbuf;
|
||
Sq_getinteger(v, 2, &FuncAddressbuf);
|
||
|
||
void* FuncAddress = (void*)FuncAddressbuf;
|
||
|
||
// µÃµ½·µ»ØÖµÀàÐÍ
|
||
const SQChar* RetTypebuf;
|
||
Sq_getstring(v, 3, &RetTypebuf);
|
||
char* OutPutText2 = DNFTOOL::SquirrelU2W(RetTypebuf);
|
||
std::string RetType(OutPutText2);
|
||
delete[]OutPutText2;
|
||
|
||
// µÃµ½µ÷ÓÃÀàÐÍ
|
||
SQInteger CallType;
|
||
Sq_getinteger(v, 4, &CallType);
|
||
|
||
std::vector<std::string> ParameterType;
|
||
// ±éÀú²ÎÊýÀàÐÍÊý×é
|
||
sq_pushnull(v); // null iterator
|
||
while (SQ_SUCCEEDED(sq_next(v, 5)))
|
||
{
|
||
const SQChar* path;
|
||
Sq_getstring(v, -1, &path);
|
||
char* OutPutText = DNFTOOL::SquirrelU2W(path);
|
||
ParameterType.push_back(OutPutText);
|
||
delete[]OutPutText;
|
||
Sq_pop(v, 2);
|
||
}
|
||
Sq_pop(v, 1);
|
||
|
||
// Í·²¿ÐÅÏ¢¸öÊý
|
||
int HeaderCount = 5;
|
||
|
||
// ¼ÆËãvalistÄÚ´æ
|
||
int AdrSize = 0;
|
||
for (std::string Type : ParameterType)
|
||
{
|
||
if (CONTAINS_STRING(Type, "int"))
|
||
AdrSize += sizeof(int);
|
||
else if (CONTAINS_STRING(Type, "bool"))
|
||
AdrSize += sizeof(bool);
|
||
else if (CONTAINS_STRING(Type, "string"))
|
||
AdrSize += sizeof(char*);
|
||
else if (CONTAINS_STRING(Type, "float"))
|
||
AdrSize += sizeof(float);
|
||
else if (CONTAINS_STRING(Type, "pointer"))
|
||
AdrSize += sizeof(void*);
|
||
else if (CONTAINS_STRING(Type, "short"))
|
||
AdrSize += sizeof(short);
|
||
else if (CONTAINS_STRING(Type, "char"))
|
||
AdrSize += sizeof(char);
|
||
}
|
||
|
||
char* m = (char*)malloc(AdrSize);
|
||
void* bm = m;
|
||
// ¶¨Ò庯ÊýÇ©Ãû
|
||
ffi_cif cif;
|
||
ffi_type** args = (ffi_type**)malloc(ParameterType.size() * sizeof(ffi_type*)); // ¶¯Ì¬·ÖÅä²ÎÊýÀàÐÍÊý×é
|
||
void** values = (void**)malloc(ParameterType.size() * sizeof(void*)); // ¶¯Ì¬·ÖÅä²ÎÊýÖµÊý×é
|
||
ffi_arg result;
|
||
|
||
int CFlag = 0;
|
||
for (int i = (HeaderCount + 1); i < (Count + 1); i++)
|
||
{
|
||
if (CONTAINS_STRING(ParameterType[0], "int"))
|
||
{
|
||
Sq_getinteger(v, i, (SQInteger*)m);
|
||
args[CFlag] = &ffi_type_sint;
|
||
values[CFlag] = m;
|
||
m += sizeof(int);
|
||
}
|
||
else if (CONTAINS_STRING(ParameterType[0], "float"))
|
||
{
|
||
Sq_getfloat(v, i, (SQFloat*)m);
|
||
args[CFlag] = &ffi_type_float;
|
||
values[CFlag] = m;
|
||
m += sizeof(float);
|
||
}
|
||
else if (CONTAINS_STRING(ParameterType[0], "bool"))
|
||
{
|
||
Sq_getbool(v, i, (SQBool*)m);
|
||
args[CFlag] = &ffi_type_sint8;
|
||
values[CFlag] = m;
|
||
m += sizeof(bool);
|
||
}
|
||
else if (CONTAINS_STRING(ParameterType[0], "string"))
|
||
{
|
||
|
||
Sq_getstring(v, i, (const SQChar**)m);
|
||
args[CFlag] = &ffi_type_pointer;
|
||
values[CFlag] = m;
|
||
m += sizeof(void*);
|
||
}
|
||
else if (CONTAINS_STRING(ParameterType[0], "pointer"))
|
||
{
|
||
Sq_getuserpointer(v, i, (SQUserPointer*)m);
|
||
args[CFlag] = &ffi_type_sint;
|
||
values[CFlag] = m;
|
||
m += sizeof(int);
|
||
}
|
||
else if (CONTAINS_STRING(ParameterType[0], "short"))
|
||
{
|
||
Sq_getinteger(v, i, (SQInteger*)m);
|
||
args[CFlag] = &ffi_type_sint16;
|
||
values[CFlag] = m;
|
||
m += sizeof(short);
|
||
}
|
||
else if (CONTAINS_STRING(ParameterType[0], "char"))
|
||
{
|
||
Sq_getinteger(v, i, (SQInteger*)m);
|
||
args[CFlag] = &ffi_type_schar;
|
||
values[CFlag] = m;
|
||
m += sizeof(char);
|
||
}
|
||
|
||
ParameterType.erase(ParameterType.begin());
|
||
CFlag++;
|
||
}
|
||
|
||
ffi_type* RetTypeFlag = &ffi_type_void;
|
||
|
||
std::string RetTypeString = RetType;
|
||
if (CONTAINS_STRING(RetTypeString, "int"))
|
||
RetTypeFlag = &ffi_type_sint;
|
||
else if (CONTAINS_STRING(RetTypeString, "float"))
|
||
RetTypeFlag = &ffi_type_float;
|
||
else if (CONTAINS_STRING(RetTypeString, "bool"))
|
||
RetTypeFlag = &ffi_type_sint8;
|
||
else if (CONTAINS_STRING(RetTypeString, "string"))
|
||
RetTypeFlag = &ffi_type_pointer;
|
||
else if (CONTAINS_STRING(RetTypeString, "pointer"))
|
||
RetTypeFlag = &ffi_type_pointer;
|
||
else if (CONTAINS_STRING(RetTypeString, "short"))
|
||
RetTypeFlag = &ffi_type_sint16;
|
||
else if (CONTAINS_STRING(RetTypeString, "char"))
|
||
RetTypeFlag = &ffi_type_schar;
|
||
|
||
|
||
int RetCore = 999;
|
||
if (RetCore = ffi_prep_cif(&cif, (ffi_abi)CallType, CFlag, RetTypeFlag, args) == FFI_OK)
|
||
{
|
||
// ¶¯Ì¬µ÷Óú¯Êý
|
||
ffi_call(&cif, FFI_FN(FuncAddress), &result, values);
|
||
}
|
||
|
||
free(args);
|
||
free(values);
|
||
free(bm);
|
||
|
||
if (CONTAINS_STRING(RetTypeString, "int"))
|
||
Sq_pushinteger(v, (int)result);
|
||
else if (CONTAINS_STRING(RetTypeString, "float"))
|
||
Sq_pushfloat(v, (float)result);
|
||
else if (CONTAINS_STRING(RetTypeString, "bool"))
|
||
Sq_pushbool(v, (bool)result);
|
||
else if (CONTAINS_STRING(RetTypeString, "string")) {
|
||
wchar_t* ss = DNFTOOL::charTowchar_t((char*)result);
|
||
Sq_pushstring(v, ss, -1);
|
||
delete[]ss;
|
||
}
|
||
else if (CONTAINS_STRING(RetTypeString, "pointer"))
|
||
Sq_pushuserpointer(v, (void*)result);
|
||
else if (CONTAINS_STRING(RetTypeString, "short"))
|
||
Sq_pushinteger(v, (int)result);
|
||
else if (CONTAINS_STRING(RetTypeString, "char"))
|
||
Sq_pushinteger(v, (int)result);
|
||
else
|
||
return 0;
|
||
return 1;
|
||
}
|
||
|
||
|
||
static SQInteger Sq_GetExportByName(HSQUIRRELVM v)
|
||
{
|
||
//»ñÈ¡º¯Êý·ûºÅÃû
|
||
const SQChar* FuncNamebuf;
|
||
Sq_getstring(v, 2, &FuncNamebuf);
|
||
char* OutPutText2 = DNFTOOL::SquirrelU2W(FuncNamebuf);
|
||
std::string FuncName(OutPutText2);
|
||
delete[]OutPutText2;
|
||
|
||
HMODULE hModule = GetModuleHandle(NULL);
|
||
if (!hModule)
|
||
return 0;
|
||
|
||
FARPROC funcPtr = GetProcAddress(hModule, FuncName.c_str());
|
||
if (!funcPtr)
|
||
return 0;
|
||
|
||
Sq_pushinteger(v, (int)funcPtr);
|
||
return 1;
|
||
}
|
||
|
||
void RegisterMyNutApi(wchar_t* funcName, SQFUNCTION funcAddr)
|
||
{
|
||
HSQUIRRELVM v = *(HSQUIRRELVM*)0x1AF3544;
|
||
Sq_pushroottable(v);
|
||
Sq_pushstring(v, funcName, -1);
|
||
RealSqNewClosure(v, funcAddr, 0);
|
||
SQNewSlot(v, -3, SQFalse);
|
||
SQPopTop(v);
|
||
}
|
||
|
||
|
||
static SQInteger L_Str_Ptr(HSQUIRRELVM v)
|
||
{
|
||
const SQChar* str;
|
||
Sq_getstring(v, 2, &str);
|
||
Sq_pushuserpointer(v, (void*)str);
|
||
return 1;
|
||
}
|
||
|
||
static SQInteger New_Point(HSQUIRRELVM v)
|
||
{
|
||
SQInteger Len;
|
||
Sq_getinteger(v, 2, &Len);
|
||
void* P = malloc(Len);
|
||
Sq_pushuserpointer(v, P);
|
||
return 1;
|
||
}
|
||
static SQInteger _file_releasehook(SQUserPointer p, SQInteger a)
|
||
{
|
||
free((void*)p);
|
||
return 0;
|
||
}
|
||
// ×¢²áÎö¹¹º¯Êý
|
||
static SQInteger Register_Destruction(HSQUIRRELVM v)
|
||
{
|
||
// Îö¹¹º¯Êý²âÊÔ
|
||
SQUserPointer P;
|
||
sq_getuserpointer(v, 2, &P);
|
||
|
||
sq_setinstanceup(v, 3, P);
|
||
sq_setreleasehook(v, 3, _file_releasehook);
|
||
return 0;
|
||
}
|
||
// д×Ö½ÚÊý×é
|
||
static SQInteger Memory_WriteByteArr(HSQUIRRELVM v)
|
||
{
|
||
SQUserPointer P;
|
||
Sq_getuserpointer(v, 2, &P);
|
||
char* Address = (char*)P;
|
||
|
||
size_t Idx = 0;
|
||
sq_pushnull(v); // null iterator
|
||
while (SQ_SUCCEEDED(sq_next(v, 3)))
|
||
{
|
||
SQInteger Buf;
|
||
Sq_getinteger(v, -1, &Buf);
|
||
*(BYTE*)(Address + Idx) = (BYTE)Buf;
|
||
// ÕâÀï-1ÊÇÖµ£¬-2ÊǼü
|
||
Sq_pop(v, 2); // ÔÚÏÂÒ»´Îµü´ú֮ǰµ¯³ö¼üºÍÖµ
|
||
Idx++;
|
||
}
|
||
Sq_pop(v, 1);
|
||
|
||
return 0;
|
||
}
|
||
|
||
// ¶ÁÄÚ´æ×Ö·û´®
|
||
static SQInteger Memory_ReadString(HSQUIRRELVM v)
|
||
{
|
||
// ÄÚ´æµØÖ·
|
||
SQUserPointer Address;
|
||
// »ñÈ¡µØÖ·
|
||
Sq_getuserpointer(v, 2, &Address);
|
||
if (Sq_gettop(v) == 3)
|
||
{
|
||
SQInteger Length;
|
||
Sq_getinteger(v, 3, &Length);
|
||
|
||
char* str = DNFTOOL::UnicodeToUtf8((wchar_t*)Address);
|
||
wchar_t* name = DNFTOOL::charTowchar_t(str);
|
||
free(str);
|
||
Sq_pushstring(v, name, Length);
|
||
delete[]name;
|
||
}
|
||
else
|
||
{
|
||
char* str = DNFTOOL::UnicodeToUtf8((wchar_t*)Address);
|
||
wchar_t* name = DNFTOOL::charTowchar_t(str);
|
||
free(str);
|
||
Sq_pushstring(v, name, -1);
|
||
delete[]name;
|
||
}
|
||
return 1;
|
||
}
|
||
// ¶ÁÄÚ´æ×Ö·û´®
|
||
static SQInteger Memory_ReadStringByUtf8(HSQUIRRELVM v)
|
||
{
|
||
// ÄÚ´æµØÖ·
|
||
SQUserPointer Address;
|
||
// »ñÈ¡µØÖ·
|
||
Sq_getuserpointer(v, 2, &Address);
|
||
if (Sq_gettop(v) == 3)
|
||
{
|
||
SQInteger Length;
|
||
Sq_getinteger(v, 3, &Length);
|
||
|
||
wchar_t* name = DNFTOOL::charTowchar_t((char*)Address);
|
||
Sq_pushstring(v, name, Length);
|
||
delete[]name;
|
||
}
|
||
else
|
||
{
|
||
wchar_t* name = DNFTOOL::charTowchar_t((char*)Address);
|
||
Sq_pushstring(v, name, -1);
|
||
delete[]name;
|
||
}
|
||
return 1;
|
||
}
|
||
// ¶ÁÄÚ´æ×Ö·û´®
|
||
static SQInteger Memory_ReadStringByBig5(HSQUIRRELVM v)
|
||
{
|
||
// ÄÚ´æµØÖ·
|
||
SQUserPointer Address;
|
||
// »ñÈ¡µØÖ·
|
||
Sq_getuserpointer(v, 2, &Address);
|
||
if (Sq_gettop(v) == 3)
|
||
{
|
||
SQInteger Length;
|
||
Sq_getinteger(v, 3, &Length);
|
||
|
||
wchar_t* newadd = DNFTOOL::charTowchar_t((char*)Address);
|
||
char* str = DNFTOOL::Big5ToUtf8(newadd);
|
||
wchar_t* name = DNFTOOL::charTowchar_t(str);
|
||
free(str);
|
||
Sq_pushstring(v, name, Length);
|
||
delete[]name;
|
||
}
|
||
else
|
||
{
|
||
wchar_t* newadd = DNFTOOL::charTowchar_t((char*)Address);
|
||
char* str = DNFTOOL::Big5ToUtf8(newadd);
|
||
wchar_t* name = DNFTOOL::charTowchar_t(str);
|
||
free(str);
|
||
Sq_pushstring(v, name, -1);
|
||
delete[]name;
|
||
}
|
||
return 1;
|
||
}
|
||
// ת»»×Ö·û´®
|
||
static SQInteger ConvertWideChar(HSQUIRRELVM v)
|
||
{
|
||
const SQChar* Str;
|
||
Sq_getstring(v, 2, &Str);
|
||
|
||
const SQChar* olgcodepage;
|
||
Sq_getstring(v, 3, &olgcodepage);
|
||
char* OutPutText1 = DNFTOOL::SquirrelU2W(olgcodepage);
|
||
std::string fromEncoding = OutPutText1;
|
||
delete[]OutPutText1;
|
||
|
||
|
||
if (CONTAINS_STRING(fromEncoding, "big5")) {
|
||
|
||
char* csa = DNFTOOL::wchar_tTochar((wchar_t*)Str);
|
||
wchar_t* name = DNFTOOL::BIG5ToUnicode(csa);
|
||
char* str = DNFTOOL::UnicodeToUtf8(name);
|
||
wchar_t* realname = DNFTOOL::charTowchar_t(str);
|
||
free(str);
|
||
|
||
Sq_pushstring(v, realname, -1);
|
||
delete[]csa;
|
||
delete[]name;
|
||
delete[]realname;
|
||
}
|
||
else if (CONTAINS_STRING(fromEncoding, "unicode")) {
|
||
char* str = DNFTOOL::UnicodeToUtf8((wchar_t*)Str);
|
||
wchar_t* name = DNFTOOL::charTowchar_t(str);
|
||
free(str);
|
||
Sq_pushstring(v, name, -1);
|
||
delete[]name;
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
|
||
// Ö¸ÕëתBlob
|
||
static SQInteger L_Point2Blob(HSQUIRRELVM v)
|
||
{
|
||
SQInteger P;
|
||
sq_getinteger(v, 2, &P);
|
||
SQInteger Count;
|
||
sq_getinteger(v, 3, &Count);
|
||
|
||
char* Address = (char*)P;
|
||
SQUserPointer Blobobj = sqstd_createblob(v, Count);
|
||
memcpy(Blobobj, Address, Count);
|
||
|
||
return 1;
|
||
}
|
||
|
||
static SQInteger OutPutTable(HSQUIRRELVM v)
|
||
{
|
||
const SQChar* Str;
|
||
sq_getstring(v, 2, &Str);
|
||
|
||
char* OutPutText = DNFTOOL::wchar_tTochar((wchar_t*)Str);
|
||
std::string str = OutPutText;
|
||
delete[]OutPutText;
|
||
|
||
nlohmann::json ex1 = nlohmann::json::parse(str);
|
||
|
||
std::cout << std::setw(4) << ex1 << std::endl;
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
void R_Register_Nut() {
|
||
|
||
RegisterMyNutApi(L"L_sq_Test", sq_Test);//zlib½âѹ
|
||
|
||
|
||
RegisterMyNutApi(L"Sq_OutPutTable", OutPutTable);
|
||
RegisterMyNutApi(L"Sq_HookFunc", L_HookFunc);
|
||
RegisterMyNutApi(L"Sq_DeHookFunc", L_DeHookFunc);
|
||
RegisterMyNutApi(L"Str_Ptr", L_Str_Ptr);
|
||
RegisterMyNutApi(L"Sq_New_Point", New_Point);
|
||
RegisterMyNutApi(L"Register_Destruction", Register_Destruction);
|
||
RegisterMyNutApi(L"Sq_Memory_WriteByteArr", Memory_WriteByteArr);
|
||
RegisterMyNutApi(L"Sq_Memory_ReadString", Memory_ReadString);
|
||
RegisterMyNutApi(L"Sq_Memory_ReadStringByUtf8", Memory_ReadStringByUtf8);
|
||
RegisterMyNutApi(L"Sq_Memory_ReadStringByBig5", Memory_ReadStringByBig5);
|
||
RegisterMyNutApi(L"Sq_ConvertWideChar", ConvertWideChar);
|
||
RegisterMyNutApi(L"Sq_Point2Blob", L_Point2Blob);
|
||
RegisterMyNutApi(L"L_Sq_CallFunc", Sq_ActiveCallFunc);//¶¯Ì¬Call
|
||
RegisterMyNutApi(L"L_Sq_GetExportByName", Sq_GetExportByName);//¶¯Ì¬Call
|
||
|
||
RegisterMyNutApi(L"L_sq_GetItem", sq_GetItem);//»ñÈ¡Item
|
||
|
||
RegisterMyNutApi(L"L_sq_StringBinById", sq_StringBinById);//»ñÈ¡×Ö·û´®ÔÚStringBinÖÐ
|
||
RegisterMyNutApi(L"L_sq_LongLongOperation", sq_LongLongOperation);//longlongÀàÐÍÔËËã
|
||
RegisterMyNutApi(L"L_sq_Dezlib", sq_Dezlib);//zlib½âѹ
|
||
RegisterMyNutApi(L"L_sq_DrawImg", sq_DrawImg);//»æÖÆImg
|
||
RegisterMyNutApi(L"L_sq_SetDrawImgModel", sq_SetDrawImgModel);//ÉèÖÃImg»æÖÆģʽ
|
||
RegisterMyNutApi(L"L_sq_ReleaseDrawImgModel", sq_ReleaseDrawImgModel);//ÊÍ·ÅImg»æÖÆģʽ
|
||
RegisterMyNutApi(L"L_sq_IntiNumberDraw", sq_IntiNumberDraw);//³õʼ»¯Êý×Ö»æÖÆ
|
||
RegisterMyNutApi(L"L_sq_DrawNumber", sq_DrawNumber);//»æÖÆÊý×Ö
|
||
RegisterMyNutApi(L"L_sq_DrawWindow", sq_DrawWindow);//»æÖƾŹ¬¸ñ
|
||
RegisterMyNutApi(L"L_sq_DrawButton", sq_DrawButton);//»æÖÆÈýÁªÍ¼
|
||
RegisterMyNutApi(L"L_sq_GetStringDrawLength", Sq_getstringDrawLength);//»ñÈ¡ÎÄ×Ö»æÖƳ¤¶È
|
||
RegisterMyNutApi(L"L_sq_GetStringDrawArray", Sq_getstringDrawArray);//»ñÈ¡ÎÄ×Ö»»Ðзµ»ØÊý×é
|
||
RegisterMyNutApi(L"L_sq_DecondeJson", DecondeJson);//·´ÐòÁл¯Json
|
||
RegisterMyNutApi(L"L_sq_EncondeJson", EncondeJson);//ÐòÁл¯Json
|
||
|
||
RegisterMyNutApi(L"L_sq_IsKeyDown", sq_IsKeyDown);//°´¼üÊÇ·ñ°´ÏÂ
|
||
RegisterMyNutApi(L"L_sq_MouseClick", sq_MouseClick);//°´ÏÂÊó±ê×ó¼ü
|
||
|
||
RegisterMyNutApi(L"L_sq_Open_ExWindow", sq_Open_ExWindow);//´´½¨ÌØÊâ´°¿Ú
|
||
RegisterMyNutApi(L"L_sq_Open_ExWindow2", sq_Open_ExWindow2);//´´½¨ÌØÊâ´°¿Ú
|
||
RegisterMyNutApi(L"L_sq_GetWindowById", sq_GetWindowById);//ͨ¹ýID»ñÈ¡´°¿ÚµØÖ·
|
||
RegisterMyNutApi(L"L_sq_Select_MiniMap_Index", sq_Select_MiniMap_Index);//Ñ¡Ôñ´óµØͼÇøÓò
|
||
|
||
RegisterMyNutApi(L"L_Sq_DrawSkill", sq_DrawSkill);//»æÖƼ¼ÄÜ
|
||
RegisterMyNutApi(L"L_sq_UseSkill", sq_UseSkill);//ʹÓü¼ÄÜ
|
||
|
||
RegisterMyNutApi(L"L_Sq_GetPlayerEachName", sq_GetPlayerEachName);//»ñÈ¡µ±Ç°Ñ¡Ôñ½»»¥½ÇÉ«ÐÕÃû
|
||
RegisterMyNutApi(L"L_Sq_GetSkillAddress", sq_GetSkillAddress);//»ñÈ¡¼¼ÄܵØÖ·
|
||
|
||
RegisterMyNutApi(L"L_sq_MoveMap", sq_MoveMap);//˳ͼ
|
||
|
||
RegisterMyNutApi(L"L_Sq_GetImg", sq_GetImg);//ͨ¹ýItem±àºÅ»ñȡͼ±êImg
|
||
RegisterMyNutApi(L"L_Sq_DrawItem", sq_DrawItem);//»æÖÆItem
|
||
|
||
RegisterMyNutApi(L"L_Sq_GetObjectAddress", GetObjectAddress);//»ñÈ¡¶ÔÏóµØÖ·
|
||
RegisterMyNutApi(L"L_Sq_ObjectAddressToSqrObject", ObjectAddressToSqrObject);//¶ÔÏóµØַת»»ÎªSqr¶ÔÏó
|
||
RegisterMyNutApi(L"L_Sq_GetRidingObjectAddress", GetRidingObjectAddress);//»ñÈ¡Æï³Ë¶ÔÏóµØÖ·
|
||
RegisterMyNutApi(L"L_Sq_GetObjectName", GetObjectName);//»ñÈ¡¶ÔÏóÃû×Ö
|
||
RegisterMyNutApi(L"L_Sq_DeleteObjectName", DeleteObjectName);//ÉèÖöÔÏóÃû×Ö
|
||
RegisterMyNutApi(L"L_Sq_GetObjectNameByAddress", GetObjectNameByAddress);//»ñÈ¡¶ÔÏóÃû×Ö
|
||
RegisterMyNutApi(L"L_Sq_GetObjectInfo", GetObjectInfo);//»ñÈ¡¶ÔÏóÐÅÏ¢
|
||
RegisterMyNutApi(L"L_Sq_GetObjectDeInfo", GetObjectDeInfo);//»ñÈ¡¶ÔÏó¼ÓÃÜÐÅÏ¢
|
||
RegisterMyNutApi(L"L_Sq_SetObjectInfo", SetObjectInfo);//ÉèÖöÔÏóÐÅÏ¢
|
||
RegisterMyNutApi(L"L_Sq_SetObjectDeInfo", SetObjectDeInfo);//ÉèÖöÔÏó¼ÓÃÜÐÅÏ¢
|
||
RegisterMyNutApi(L"L_Sq_GetObjectLevel", GetObjectLevel);//»ñÈ¡¶ÔÏóµÈ¼¶
|
||
RegisterMyNutApi(L"L_Sq_GetObjectIsCharacter", GetObjectIsCharacter);//»ñÈ¡¶ÔÏóÊÇ·ñÊÇÍæ¼Ò
|
||
RegisterMyNutApi(L"L_Sq_GetObjectAttribute", GetObjectAttribute);//»ñÈ¡¶ÔÏóÊôÐÔ
|
||
|
||
RegisterMyNutApi(L"L_sq_GetCharacterAttribute", GetCharacterAttribute);//»ñÈ¡ÈËÎï»ò×°±¸ÊôÐÔ
|
||
RegisterMyNutApi(L"L_sq_SetCharacterAttribute", SetCharacterAttribute);//ÉèÖÃÈËÎï»ò×°±¸ÊôÐÔ
|
||
|
||
|
||
RegisterMyNutApi(L"L_sq_GetTownIndex", GetTownIndex);//»ñÈ¡³ÇÕò±àºÅ
|
||
RegisterMyNutApi(L"L_sq_GetRegionIndex", GetRegionIndex);//»ñÈ¡ÇøÓò±àºÅ
|
||
RegisterMyNutApi(L"L_sq_GetTownXpos", GetTownXpos);//»ñÈ¡³ÇÕòX×ø±ê
|
||
RegisterMyNutApi(L"L_sq_GetTownYpos", GetTownYpos);//»ñÈ¡³ÇÕòY×ø±ê
|
||
|
||
RegisterMyNutApi(L"L_sq_GetFatigue", GetFatigue);//»ñÈ¡Æ£ÀÍÖµ
|
||
RegisterMyNutApi(L"L_sq_GetExp", GetExp);//»ñÈ¡¾ÑéÖµ
|
||
RegisterMyNutApi(L"L_sq_GetSp", sq_GetSp);//»ñÈ¡SPµã
|
||
RegisterMyNutApi(L"L_sq_GetPassLevel", sq_GetPassLevel);//»ñȡðÏÕÍŵȼ¶
|
||
RegisterMyNutApi(L"L_sq_RefreshEventIcon", sq_RefreshEventIcon);//ˢлͼ±ê
|
||
|
||
RegisterMyNutApi(L"L_sq_SendPackType", SendPackType);//·¢°üÀàÐÍ
|
||
RegisterMyNutApi(L"L_sq_SendPackByte", SendPackByte);//°üÊý¾ÝByte
|
||
RegisterMyNutApi(L"L_sq_SendPackWord", SendPackWord);//°üÊý¾ÝWord
|
||
RegisterMyNutApi(L"L_sq_SendPackDWord", SendPackDWord);//°üÊý¾ÝDWord
|
||
RegisterMyNutApi(L"L_sq_SendPackWChar", SendPackWChar);//°üÊý¾ÝDWord
|
||
RegisterMyNutApi(L"L_sq_SendPack", SendPack);//·¢°ü
|
||
|
||
RegisterMyNutApi(L"L_sq_GoDungeon", GoDungeon);//È¥¸±±¾
|
||
RegisterMyNutApi(L"L_sq_GoTown", GoTown);//È¥³ÇÕò
|
||
RegisterMyNutApi(L"L_sq_MoveTown", MoveTown);//È¥³ÇÕò
|
||
|
||
RegisterMyNutApi(L"L_sq_DrawCode", sq_DrawCode);//»æÖÆ×Ö·û //TODO
|
||
|
||
RegisterMyNutApi(L"L_sq_RA", LReadAddress);//¶ÁÄÚ´æ
|
||
RegisterMyNutApi(L"L_sq_WA", LWriteAddress);//дÄÚ´æ
|
||
|
||
RegisterMyNutApi(L"L_sq_RAF", LReadAddressFloat);//¶ÁÄÚ´æ
|
||
//RegisterMyNutApi(L"L_sq_WAF", LWriteAddressFloat);//дÄÚ´æ
|
||
|
||
RegisterMyNutApi(L"L_sq_RAB", LReadAddressB);//¶ÁÄÚ´æ
|
||
RegisterMyNutApi(L"L_sq_WAB", LWriteAddressB);//дÄÚ´æ
|
||
|
||
RegisterMyNutApi(L"L_sq_I2P", sq_I2P);//intתָÕë
|
||
RegisterMyNutApi(L"L_sq_P2I", sq_P2I);//Ö¸Õëתint
|
||
|
||
RegisterMyNutApi(L"printf", Sout);//Êä³ö
|
||
//RegisterMyNutApi(L"L_ReplaceInString", ReplaceInString);//Êä³ö
|
||
RegisterMyNutApi(L"Clock", Clock);//Êä³ö
|
||
RegisterMyNutApi(L"L_Getmicroseconds", Getmicroseconds);//»ñȡ΢Ã뼶
|
||
RegisterMyNutApi(L"Sq_Time", SQTime);
|
||
|
||
RegisterMyNutApi(L"L_NewWindows", NewWindows);//´´½¨´°¿Ú
|
||
RegisterMyNutApi(L"L_Cmd", sq_Cmd);//Ö´ÐÐCmdÃüÁî
|
||
RegisterMyNutApi(L"L_CmdEx", sq_CmdEx);//Ö´ÐÐCmdÃüÁîEx
|
||
|
||
RegisterMyNutApi(L"L_SetSlot", SetSlot);//ÉèÖòÛ×ø±ê
|
||
|
||
RegisterMyNutApi(L"L_RegisterItemColor_STL", RegisterItemColor_STL);//×¢²áItemÑÕÉ«
|
||
|
||
//ÊäÈë¿ò
|
||
RegisterMyNutApi(L"L_sq_GetInputBoxStr", sq_GetInputBoxStr);
|
||
RegisterMyNutApi(L"L_sq_SetInputBoxStr", sq_SetInputBoxStr);
|
||
RegisterMyNutApi(L"L_sq_NewInputBox", sq_NewInputBox);
|
||
} |