初版

include/CConnectPool.h

@@ -0,0 +1,90 @@
+#pragma once
+#ifndef CCONNECT_POOL_H_2021
+#define CCONNECT_POOL_H_2021
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <queue>
+#include <set>
+#include <pthread.h>
+#include <unistd.h>
+#include "mysql/mysql.h"
+
+class CConnectPool
+{
+public:
+    struct Connect_Info
+    {
+        int MinConnectCount;
+        int MaxConnectCount;
+        const char *Host;
+        int Port;
+        const char *Account;
+        const char *Passwd;
+        const char* KName;
+    };
+
+    Connect_Info My_Info;
+
+public:
+    /**
+     * @brief 创建连接池 \n
+     * 在主线程中创建连接池，创建后需要调用FreePool予以释放
+     * 创建失败程序会打印错误信息并终止运行
+     */
+    static void
+    CreatePool(int MinConnectCount, int MaxConnectCount, const char *Host, int Port, const char *Account, const char *Passwd);
+
+    /**
+     * @brief 释放连接池 \n
+     * 需要在主线程中调用该接口
+     */
+    static void FreePool();
+
+    /**
+     * @brief 获取连接 \n
+     * 支持多线程，使用完成后需调用PutConnect，归还连接，本函数为阻塞函数，直到有可用连接才调用返回
+     * @return 返回数据库连接
+     *  --NULL表示调用失败
+     */
+    static MYSQL *GetConnect();
+
+    /**
+     * @brief 获取连接 \n
+     * 支持多线程，使用完成后需调用PutConnect，归还连接，本函数调用后立刻返回，若没有空闲连接则返回NULL
+     * @return 返回数据库连接
+     *  --NULL表示调用失败
+     * */
+    static MYSQL *TryGetConnect();
+
+    /**
+     * @brief 向连接池归还连接 \n
+     * 支持多线程
+     * @param[in] pConn    需要归还的数据库连接
+     * */
+    static void PutConnect(MYSQL *pConn);
+
+private:
+    CConnectPool();
+    ~CConnectPool();
+    MYSQL *_GetConnect(bool bTry);
+    void _PutConnect(MYSQL *pConn);
+    // 真正创建连接
+    MYSQL *_CreateConnect();
+
+    static CConnectPool *s_pInstance;
+    std::queue<MYSQL *> m_queueFree; // 空闲队列
+    std::set<MYSQL *> m_setBusy;     // 繁忙队列
+    pthread_mutex_t m_mutex;
+    pthread_cond_t m_cond;
+};
+
+#endif
+
+/*
+使用说明
+CConnectPool::CreatePool();
+MYSQL *sql = CConnectPool::GetConnect();
+CConnectPool::PutConnect(sql);
+CConnectPool::FreePool();
+*/

include/SqrReg_Game.hpp

@@ -0,0 +1,325 @@
+#pragma once
+#include "squirrel.h"
+#include "sqstdaux.h"
+#include "sqstdblob.h"
+#include "sqstdio.h"
+#include "sqstdmath.h"
+#include "sqstdstring.h"
+#include "sqstdsystem.h"
+#include "CConnectPool.h"
+#include <iostream>
+
+template <typename R, typename A, typename... ARG>
+R CallGameT(A call_addr, const ARG... arguments)
+{
+    if (!call_addr)
+    {
+        return R();
+    }
+    const auto control = reinterpret_cast<R (*)(ARG...)>(call_addr);
+    try
+    {
+        return control(arguments...);
+    }
+    catch (...)
+    {
+    }
+    return R();
+}
+
+static char szGamePath[256];
+static int getargs(char ***argv)
+{
+    size_t buflen = 1024, readlen = 0, maxlen = buflen;
+    int fd = open("/proc/self/cmdline", O_RDONLY);
+    if (fd == -1)
+        return 0;
+    char *buf = (char *)malloc(buflen);
+    while (1)
+    {
+        ssize_t n = read(fd, buf + readlen, buflen - readlen);
+        if (n == -1)
+        {
+            free(buf);
+            close(fd);
+            return 0;
+        }
+        readlen += n;
+        if (!n || readlen < buflen)
+            break;
+        maxlen += buflen;
+        buf = (char *)realloc(buf, maxlen);
+    }
+    close(fd);
+    int argc = 0;
+    char *cp = buf;
+    do
+    {
+        while (*cp != '\0')
+            cp++;
+        argc++;
+    } while (++cp < buf + readlen);
+    *argv = (char **)malloc(argc * sizeof(char *));
+    argc = 0;
+    cp = buf;
+    do
+    {
+        (*argv)[argc] = (char *)malloc(strlen(cp) + 1);
+        strcpy((*argv)[argc], cp);
+        argc++;
+        while (*cp != '\0')
+            cp++;
+    } while (++cp < buf + readlen);
+    free(buf);
+    return argc;
+}
+static int getConfigPath(char *pPath, size_t nSize)
+{
+    if (readlink("/proc/self/exe", pPath, nSize) <= 0)
+        return -1;
+    char **argv = NULL;
+    int argc = getargs(&argv);
+    if (!argv || argc < 2)
+    {
+        if (argv)
+        {
+            for (int i = 0; i < argc; i++)
+            {
+                if (argv[i])
+                    free(argv[i]);
+            }
+            free(argv);
+        }
+        return -1;
+    }
+    *strrchr(pPath, '/') = '\0';
+    sprintf(pPath, "%s/cfg/%s.cfg", pPath, argv[1]);
+    for (int i = 0; i < argc; i++)
+    {
+        if (argv[i])
+            free(argv[i]);
+    }
+    free(argv);
+    return 0;
+}
+static SQInteger Game_GetConfig(HSQUIRRELVM v)
+{
+    sq_pushstring(v, szGamePath, -1);
+    return 1;
+}
+
+// 指针转int
+static SQInteger L_Ptr2Int(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    sq_pushinteger(v, (int)P);
+    return 1;
+}
+// int转指针
+static SQInteger L_Int2Ptr(HSQUIRRELVM v)
+{
+    SQInteger Address;
+    sq_getinteger(v, 2, &Address);
+    sq_pushuserpointer(v, (void *)Address);
+    return 1;
+}
+
+// 写内存
+static SQInteger L_WriteAddress(HSQUIRRELVM v)
+{
+    // 内存地址 int型
+    SQUserPointer Address;
+    // 内存偏移 int型
+    SQInteger Offset;
+    // 获取参数个数
+    int ParameterNum = sq_gettop(v);
+    // 2个参数时
+    if (ParameterNum == 4)
+    {
+        // 获取地址
+        sq_getuserpointer(v, 2, &Address);
+        // 获取偏移
+        sq_getinteger(v, 3, &Offset);
+        // 获取修改的值
+        SQInteger WriteValue;
+        sq_getinteger(v, 4, &WriteValue);
+
+        *(int *)((void *)Address + Offset) = WriteValue;
+        sq_pushbool(v, true);
+        return 1;
+    }
+    if (ParameterNum == 5)
+    {
+    }
+    else
+    {
+        sq_pushbool(v, false);
+        return 1;
+    }
+    return 0;
+}
+// 读内存
+static SQInteger L_ReadAddress(HSQUIRRELVM v)
+{
+    // 内存地址 int型
+    SQUserPointer Address;
+    // 获取地址
+    sq_getuserpointer(v, 2, &Address);
+    sq_pushinteger(v, *(int *)Address);
+    return 1;
+}
+
+// 读取字节数组
+static SQInteger L_ReadByteArr(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Count;
+    sq_getinteger(v, 3, &Count);
+
+    char *Address = (char *)P;
+    sq_newarray(v, 0);
+    for (size_t i = 0; i < Count; i++)
+    {
+        sq_pushinteger(v, (int)(Address[i]));
+        sq_arrayappend(v, -2);
+    }
+    return 1;
+}
+// 指针转Blob
+static SQInteger L_Point2Blob(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Count;
+    sq_getinteger(v, 3, &Count);
+
+    char *Address = (char *)P;
+    SQUserPointer Blobobj = sqstd_createblob(v, Count);
+    memcpy(Blobobj, P, Count);
+
+    return 1;
+}
+// 写字节数组
+static SQInteger L_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);
+        Address[Idx] = Buf;
+        // 这里-1是值，-2是键
+        sq_pop(v, 2); // 在下一次迭代之前弹出键和值
+        Idx++;
+    }
+    sq_pop(v, 1);
+
+    return 0;
+}
+// 写Blob到指定地址
+static SQInteger L_WriteBlobToAddress(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQUserPointer Blobobj;
+    // sq_getuserpointer(v, 3, &P);
+    sqstd_getblob(v, 3, &Blobobj);
+    int Size = sqstd_getblobsize(v, 3);
+
+    memcpy(P, Blobobj, Size);
+    return 0;
+}
+// 通过ID从Pvf中查询名称
+static SQInteger L_GetNameByIdFromPvf(HSQUIRRELVM v)
+{
+    SQInteger Idx;
+    sq_getinteger(v, 2, &Idx);
+
+    void *Ret = CallGameT<void *>(0x835FA32, CallGameT<void *>(0x80CC19B), (unsigned int)Idx);
+    if (Ret)
+    {
+        const char *Name = CallGameT<const char *>(0x811ed82, Ret);
+        sq_pushstring(v, Name, -1);
+    }
+    else
+    {
+        sq_pushnull(v);
+    }
+    return 1;
+}
+// 创建数据库连接池
+static SQInteger L_CreatCConnectPool(HSQUIRRELVM v)
+{
+    SQInteger MinConnectCount, MaxConnectCount, Port;
+    const SQChar *Host;
+    const SQChar *Account;
+    const SQChar *Passwd;
+
+    sq_getinteger(v, 2, &MinConnectCount);
+    sq_getinteger(v, 3, &MaxConnectCount);
+    sq_getstring(v, 4, &Host);
+    sq_getinteger(v, 5, &Port);
+    sq_getstring(v, 6, &Account);
+    sq_getstring(v, 7, &Passwd);
+
+    // 初始化数据库
+    CConnectPool::CreatePool(MinConnectCount, MaxConnectCount, Host, Port, Account, Passwd);
+    return 0;
+}
+// 阻塞线程的数据库操作 无返回值
+static SQInteger L_MysqlExecNoRet(HSQUIRRELVM v)
+{
+    const SQChar *Sql;
+    sq_getstring(v, 2, &Sql);
+
+    MYSQL *MysqlObject = CConnectPool::GetConnect();
+    mysql_query(MysqlObject, Sql);
+    CConnectPool::PutConnect(MysqlObject);
+    return 0;
+}
+
+static SQInteger register_Game_func(HSQUIRRELVM v, SQFUNCTION f, const char *fname)
+{
+    sq_pushroottable(v);
+    sq_pushstring(v, fname, -1);
+    sq_newclosure(v, f, 0); // create a new function
+    sq_newslot(v, -3, SQFalse);
+    sq_pop(v, 1); // pops the root table
+}
+
+static void RegisterGame(HSQUIRRELVM v)
+{
+    getConfigPath(szGamePath, sizeof(szGamePath));
+
+    // int 和指针相互转换
+    register_World_func(v, L_Ptr2Int, _SC("Sq_Ptr2Int"));
+    register_World_func(v, L_Int2Ptr, _SC("Sq_Int2Ptr"));
+
+    // 获取频道配置
+    register_World_func(v, Game_GetConfig, _SC("Sq_Game_GetConfig"));
+    // 写地址int
+    register_World_func(v, L_WriteAddress, _SC("Sq_WriteAddress"));
+    // 读地址int
+    register_World_func(v, L_ReadAddress, _SC("Sq_ReadAddress"));
+    // 读取Byte
+    register_World_func(v, L_ReadByteArr, _SC("Sq_ReadByteArr"));
+    // 写入Byte
+    register_World_func(v, L_WriteByteArr, _SC("Sq_WriteByteArr"));
+    // 通过指针转Blob
+    register_World_func(v, L_Point2Blob, _SC("Sq_Point2Blob"));
+    // 写Blob到指定地址
+    register_World_func(v, L_WriteBlobToAddress, _SC("Sq_WriteBlobToAddress"));
+    // 通过ID从Pvf中查询名称
+    register_World_func(v, L_GetNameByIdFromPvf, _SC("Sq_GetNameByIdFromPvf"));
+    // 创建数据库连接池
+    register_World_func(v, L_CreatCConnectPool, _SC("Sq_CreatCConnectPool"));
+    // 阻塞线程的数据库操作 无返回值
+    register_World_func(v, L_MysqlExecNoRet, _SC("Sq_MysqlExecNoRet"));
+}

include/SqrReg_GameManager.hpp

@@ -0,0 +1,46 @@
+#pragma once
+#include "squirrel.h"
+#include "sqstdaux.h"
+#include "sqstdblob.h"
+#include "sqstdio.h"
+#include "sqstdmath.h"
+#include "sqstdstring.h"
+#include "sqstdsystem.h"
+#include <iostream>
+
+typedef void *(*__GetGameManagerVoid)();
+static SQInteger GameManager_GameManager(HSQUIRRELVM v)
+{
+    void *GameManager = ((__GetGameManagerVoid)0x080CC18E)();
+    sq_pushuserpointer(v, GameManager);
+    return 1;
+}
+typedef void *(*__GameManagerByThis)(void *GameManager);
+static SQInteger GameManager_GetParty(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    void *CParty = ((__GameManagerByThis)0x08294E10)(P);
+    if (CParty)
+        sq_pushuserpointer(v, CParty);
+    else
+        sq_pushinteger(v, 0);
+    return 1;
+}
+
+static SQInteger register_GameManager_func(HSQUIRRELVM v, SQFUNCTION f, const char *fname)
+{
+    sq_pushroottable(v);
+    sq_pushstring(v, fname, -1);
+    sq_newclosure(v, f, 0); // create a new function
+    sq_newslot(v, -3, SQFalse);
+    sq_pop(v, 1); // pops the root table
+}
+
+static void RegisterGameManager(HSQUIRRELVM v)
+{
+    // 获得GameManager对象
+    register_GameManager_func(v, GameManager_GameManager, _SC("Sq_GameManager_GameManager"));
+    // 获得队伍对象
+    register_GameManager_func(v, GameManager_GetParty, _SC("Sq_GameManager_GetParty"));
+}

include/SqrReg_Inven.hpp

@@ -0,0 +1,114 @@
+#pragma once
+#include "squirrel.h"
+#include "sqstdaux.h"
+#include "sqstdblob.h"
+#include "sqstdio.h"
+#include "sqstdmath.h"
+#include "sqstdstring.h"
+#include "sqstdsystem.h"
+#include <iostream>
+
+template <typename R, typename A, typename... ARG>
+R CallInven(A call_addr, const ARG... arguments)
+{
+    if (!call_addr)
+    {
+        return R();
+    }
+    const auto control = reinterpret_cast<R (*)(ARG...)>(call_addr);
+    try
+    {
+        return control(arguments...);
+    }
+    catch (...)
+    {
+    }
+    return R();
+}
+
+// 获取背包
+static SQInteger Inven_GetInven(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    void *InvenP = CallInven<void *>(0x80DA28E, P);
+    sq_pushuserpointer(v, InvenP);
+    return 1;
+}
+
+// 获取背包中的项目
+static SQInteger Inven_GetItem(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Type, Slot;
+    sq_getinteger(v, 3, &Type);
+    sq_getinteger(v, 4, &Slot);
+
+    void *ItemP = CallInven<void *>(0x84FC1DE, P, Type, Slot);
+    sq_pushuserpointer(v, ItemP);
+    return 1;
+}
+
+// 删除背包中的项目
+static SQInteger Inven_RemoveItem(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+
+    CallInven<void *>(0x080CB7D8, P);
+    return 0;
+}
+
+// 删除背包中的指定数量的项目
+static SQInteger Inven_RemoveItemFormCount(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Type, Slot, Count, Ps, Log;
+    sq_getinteger(v, 3, &Type);
+    sq_getinteger(v, 4, &Slot);
+    sq_getinteger(v, 5, &Count);
+    sq_getinteger(v, 6, &Ps);
+    sq_getinteger(v, 7, &Log);
+
+    SQInteger Ret = CallInven<int>(0x850400C, P, Type, Slot, Count, Ps, Log);
+    sq_pushinteger(v, Ret);
+    return 1;
+}
+
+// 根据Id获取背包中的物品槽位
+static SQInteger Inven_GetItemById(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Idx;
+    sq_getinteger(v, 3, &Idx);
+
+    SQInteger Slot = CallInven<int>(0x08505172, P, Idx);
+    sq_pushinteger(v, Slot);
+    return 1;
+}
+
+static SQInteger register_Inven_func(HSQUIRRELVM v, SQFUNCTION f, const char *fname)
+{
+    sq_pushroottable(v);
+    sq_pushstring(v, fname, -1);
+    sq_newclosure(v, f, 0); // create a new function
+    sq_newslot(v, -3, SQFalse);
+    sq_pop(v, 1); // pops the root table
+}
+
+static void RegisterInven(HSQUIRRELVM v)
+{
+    // 获取背包
+    register_Inven_func(v, Inven_GetInven, "Sq_Inven_GetInven");
+    // 获取背包中的道具
+    register_Inven_func(v, Inven_GetItem, "Sq_Inven_GetItem");
+    // 删除背包中的项目
+    register_Inven_func(v, Inven_RemoveItem, "Sq_Inven_RemoveItem");
+    // 根据Id获取背包中的物品槽位
+    register_Inven_func(v, Inven_RemoveItemFormCount, "Sq_Inven_RemoveItemFormCount");
+    // 根据Id获取背包中的物品槽位
+    register_Inven_func(v, Inven_GetItemById, "Sq_Inven_GetItemById");
+}

include/SqrReg_Packet.hpp

@@ -0,0 +1,126 @@
+#pragma once
+#include "squirrel.h"
+#include "sqstdaux.h"
+#include "sqstdblob.h"
+#include "sqstdio.h"
+#include "sqstdmath.h"
+#include "sqstdstring.h"
+#include "sqstdsystem.h"
+#include "import.h"
+#include "inline_hook.h"
+#include "Singleton.h"
+#include "./sdk/sdk_class.h"
+#include "utils.h"
+#include "GameDataManager.h"
+#include "PacketBuf.h"
+#include "User.h"
+#include <iostream>
+
+static SQInteger Packet_New(HSQUIRRELVM v)
+{
+    InterfacePacketBuf *Pck = (InterfacePacketBuf *)PacketGuard::NewPacketGuard();
+    sq_pushuserpointer(v, Pck);
+    return 1;
+}
+static SQInteger Packet_Put_header(HSQUIRRELVM v)
+{
+    SQUserPointer Buf;
+    sq_getuserpointer(v, 2, &Buf);
+    InterfacePacketBuf *Pck = (InterfacePacketBuf *)Buf;
+    SQInteger Header1;
+    sq_getinteger(v, 3, &Header1);
+    SQInteger Header2;
+    sq_getinteger(v, 4, &Header2);
+    Pck->put_header(Header1, Header2);
+    return 0;
+}
+static SQInteger Packet_Put_byte(HSQUIRRELVM v)
+{
+    SQUserPointer Buf;
+    sq_getuserpointer(v, 2, &Buf);
+    InterfacePacketBuf *Pck = (InterfacePacketBuf *)Buf;
+    SQInteger Byte;
+    sq_getinteger(v, 3, &Byte);
+    Pck->put_byte(Byte);
+    return 0;
+}
+static SQInteger Packet_Put_short(HSQUIRRELVM v)
+{
+    SQUserPointer Buf;
+    sq_getuserpointer(v, 2, &Buf);
+    InterfacePacketBuf *Pck = (InterfacePacketBuf *)Buf;
+    SQInteger Short;
+    sq_getinteger(v, 3, &Short);
+    Pck->put_short(Short);
+    return 0;
+}
+static SQInteger Packet_Put_int(HSQUIRRELVM v)
+{
+    SQUserPointer Buf;
+    sq_getuserpointer(v, 2, &Buf);
+    InterfacePacketBuf *Pck = (InterfacePacketBuf *)Buf;
+    SQInteger Int;
+    sq_getinteger(v, 3, &Int);
+    Pck->put_int(Int);
+    return 0;
+}
+static SQInteger Packet_Put_binary(HSQUIRRELVM v)
+{
+    SQUserPointer Buf;
+    sq_getuserpointer(v, 2, &Buf);
+    InterfacePacketBuf *Pck = (InterfacePacketBuf *)Buf;
+    const SQChar *Str;
+    sq_getstring(v, 3, &Str);
+    Pck->put_str((char *)Str, strlen(Str));
+    return 0;
+}
+static SQInteger Packet_Finalize(HSQUIRRELVM v)
+{
+    SQUserPointer Buf;
+    sq_getuserpointer(v, 2, &Buf);
+    InterfacePacketBuf *Pck = (InterfacePacketBuf *)Buf;
+    SQBool B;
+    sq_getbool(v, 3, &B);
+    Pck->finalize(B);
+    return 0;
+}
+static SQInteger Packet_Send(HSQUIRRELVM v)
+{
+    SQUserPointer userbuf;
+    sq_getuserpointer(v, 2, &userbuf);
+    CUser *user = (CUser *)userbuf;
+    SQUserPointer Buf;
+    sq_getuserpointer(v, 3, &Buf);
+    user->Send((PacketGuard *)Buf);
+    return 0;
+}
+static SQInteger Packet_Delete(HSQUIRRELVM v)
+{
+    SQUserPointer Buf;
+    sq_getuserpointer(v, 2, &Buf);
+    InterfacePacketBuf *Pck = (InterfacePacketBuf *)Buf;
+    InterfacePacketBuf::DelPacketBuf(Pck);
+    return 0;
+}
+
+static SQInteger register_Packet_func(HSQUIRRELVM v, SQFUNCTION f, const char *fname)
+{
+    sq_pushroottable(v);
+    sq_pushstring(v, fname, -1);
+    sq_newclosure(v, f, 0); // create a new function
+    sq_newslot(v, -3, SQFalse);
+    sq_pop(v, 1); // pops the root table
+}
+
+static void RegisterPacket(HSQUIRRELVM v)
+{
+    register_Packet_func(v, Packet_New, _SC("Sq_Packet_New"));
+    register_Packet_func(v, Packet_Put_header, _SC("Sq_Packet_Put_header"));
+    register_Packet_func(v, Packet_Put_byte, _SC("Sq_Packet_Put_byte"));
+    register_Packet_func(v, Packet_Put_short, _SC("Sq_Packet_Put_short"));
+    register_Packet_func(v, Packet_Put_int, _SC("Sq_Packet_Put_int"));
+    register_Packet_func(v, Packet_Put_binary, _SC("Sq_Packet_Put_binary"));
+    register_Packet_func(v, Packet_Finalize, _SC("Sq_Packet_Finalize"));
+    register_Packet_func(v, Packet_Send, _SC("Sq_Packet_Send"));
+    register_Packet_func(v, Packet_Delete, _SC("Sq_Packet_Delete"));
+}

include/SqrReg_Party.hpp

@@ -0,0 +1,66 @@
+#pragma once
+#include "squirrel.h"
+#include "sqstdaux.h"
+#include "sqstdblob.h"
+#include "sqstdio.h"
+#include "sqstdmath.h"
+#include "sqstdstring.h"
+#include "sqstdsystem.h"
+#include <iostream>
+
+typedef int (*__CreateParty)(void *CParty, void *CUser);
+static SQInteger Party_CreateParty(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQUserPointer User;
+    sq_getuserpointer(v, 3, &User);
+    ((__CreateParty)0x0859B1BE)(P, User);
+    return 0;
+}
+typedef int (*__SetPartyInfoUI)(void *CParty, int code);
+static SQInteger Party_SetPartyInfoUI(HSQUIRRELVM v) // 设置队伍信息UI可以不写 创出来空的  要写的话要搞个指针 写入很多参数
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    ((__SetPartyInfoUI)0x0859B234)(P, 0x44d672e);
+    return 0;
+}
+typedef int (*__JoinParty)(void *CParty, void *CUser);
+static SQInteger Party_JoinParty(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQUserPointer User;
+    sq_getuserpointer(v, 3, &User);
+    ((__JoinParty)0x0859B2B6)(P, User);
+    return 0;
+}
+typedef int (*__SendPartyIpInfo)(void *CParty);
+static SQInteger Party_SendPartyIpInfo(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    ((__SendPartyIpInfo)0x0859CEA2)(P);
+    return 0;
+}
+static SQInteger register_Party_func(HSQUIRRELVM v, SQFUNCTION f, const char *fname)
+{
+    sq_pushroottable(v);
+    sq_pushstring(v, fname, -1);
+    sq_newclosure(v, f, 0); // create a new function
+    sq_newslot(v, -3, SQFalse);
+    sq_pop(v, 1); // pops the root table
+}
+
+static void RegisterParty(HSQUIRRELVM v)
+{
+    // 创建队伍
+    register_Party_func(v, Party_CreateParty, _SC("Sq_Party_CreateParty"));
+    // 设置队伍信息UI
+    register_Party_func(v, Party_SetPartyInfoUI, _SC("Sq_Party_SetPartyInfoUI"));
+    // 让玩家加入队伍
+    register_Party_func(v, Party_JoinParty, _SC("Sq_Party_JoinParty"));
+    // 广播队伍玩家IP
+    register_Party_func(v, Party_SendPartyIpInfo, _SC("Sq_Party_SendPartyIpInfo"));
+}

include/SqrReg_User.hpp

@@ -0,0 +1,500 @@
+#pragma once
+#include "squirrel.h"
+#include "sqstdaux.h"
+#include "sqstdblob.h"
+#include "sqstdio.h"
+#include "sqstdmath.h"
+#include "sqstdstring.h"
+#include "sqstdsystem.h"
+#include <vector>
+#include <cstring>
+#include <iostream>
+
+template <typename R, typename A, typename... ARG>
+R CallUser(A call_addr, const ARG... arguments)
+{
+    if (!call_addr)
+    {
+        return R();
+    }
+    const auto control = reinterpret_cast<R (*)(ARG...)>(call_addr);
+    try
+    {
+        return control(arguments...);
+    }
+    catch (...)
+    {
+    }
+    return R();
+}
+
+typedef int (*__GetUserByThis)(void *CUser);
+typedef int (*__GetUserArea)(void *CUser, bool a);
+typedef int (*__SetUserByInt)(void *CUser, int Value);
+static SQInteger CUser_GetPosX(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger X = int(((__GetUserByThis)0x0813492c)((void *)P));
+    sq_pushinteger(v, X);
+    return 1;
+}
+static SQInteger CUser_GetPosY(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Y = int(((__GetUserByThis)0x0813493c)((void *)P));
+    sq_pushinteger(v, Y);
+    return 1;
+}
+static SQInteger CUser_Direction(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Ret = int(((__GetUserByThis)0x0813494c)((void *)P));
+    sq_pushinteger(v, Ret);
+    return 1;
+}
+static SQInteger CUser_GetVill(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Vill = int(((__GetUserByThis)0x08645564)((void *)P));
+    sq_pushinteger(v, Vill);
+    return 1;
+}
+static SQInteger CUser_GetArea(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    SQInteger Type = 0;
+    sq_getuserpointer(v, 2, &P);
+    if (sq_gettop(v) == 3)
+    {
+        sq_getinteger(v, 3, &Type);
+    }
+    SQInteger Area = int(((__GetUserArea)0x086813BE)((void *)P, Type));
+    sq_pushinteger(v, Area);
+    return 1;
+}
+static SQInteger CUser_GetState(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger State = int(((__GetUserByThis)0x080DA38C)((void *)P));
+    sq_pushinteger(v, State);
+    return 1;
+}
+static SQInteger CUser_GetCharacCount(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Count = int(((__GetUserByThis)0x082300E8)((void *)P));
+    sq_pushinteger(v, Count);
+    return 1;
+}
+static SQInteger CUser_GetUniqueId(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger UID = int(((__GetUserByThis)0x080DA37C)((void *)P));
+    sq_pushinteger(v, UID);
+    return 1;
+}
+static SQInteger CUser_GetAccId(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger UID = int(((__GetUserByThis)0x080DA36E)((void *)P));
+    sq_pushinteger(v, UID);
+    return 1;
+}
+static SQInteger CUser_GetCharacNo(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger CID = int(((__GetUserByThis)0x080CBC4E)((void *)P));
+    sq_pushinteger(v, CID);
+    return 1;
+}
+static SQInteger CUser_GetCharacJob(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Ret = int(((__GetUserByThis)0x080FDF20)((void *)P));
+    sq_pushinteger(v, Ret);
+    return 1;
+}
+static SQInteger CUser_GetCharacName(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Ret = int(((__GetUserByThis)0x08101028)((void *)P));
+    sq_pushstring(v, _SC((char *)Ret), -1);
+    return 1;
+}
+static SQInteger CUser_GetCharacLevel(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Ret = int(((__GetUserByThis)0x080DA2B8)((void *)P));
+    sq_pushinteger(v, Ret);
+    return 1;
+}
+static SQInteger CUser_SetCharacLevel(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Value;
+    sq_getinteger(v, 3, &Value);
+    ((__SetUserByInt)0x0867a95c)((void *)P, Value);
+    return 0;
+}
+static SQInteger CUser_GetCharacGrowType(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Ret = int(((__GetUserByThis)0x0815741C)((void *)P));
+    sq_pushinteger(v, Ret);
+    return 1;
+}
+static SQInteger CUser_GetCharacSecondGrowType(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Ret = int(((__GetUserByThis)0x0822F23C)((void *)P));
+    sq_pushinteger(v, Ret);
+    return 1;
+}
+static SQInteger CUser_GetFatigue(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Ret = int(((__GetUserByThis)0x08657766)((void *)P));
+    sq_pushinteger(v, Ret);
+    return 1;
+}
+static SQInteger CUser_GetMaxFatigue(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Ret = int(((__GetUserByThis)0x08657804)((void *)P));
+    sq_pushinteger(v, Ret);
+    return 1;
+}
+typedef int (*__CUser_DisConnSig)(void *CUser, int type, int is, int err);
+static SQInteger CUser_DisConnSig(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    SQInteger Src;
+    SQInteger P2;
+    SQInteger P3;
+    sq_getuserpointer(v, 2, &P);
+    sq_getinteger(v, 3, &Src);
+    sq_getinteger(v, 4, &P2);
+    sq_getinteger(v, 5, &P3);
+    SQInteger Ret = int(((__CUser_DisConnSig)0x086489F4)((void *)P, Src, P2, P3));
+    sq_pushinteger(v, Ret);
+    return 1;
+}
+typedef void *(*__GetUserParty)(void *CUser);
+static SQInteger CUser_GetParty(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQUserPointer Ret = (((__GetUserParty)0x0865514C)((void *)P));
+    sq_pushuserpointer(v, Ret);
+    return 1;
+}
+static SQInteger CUser_CheckInBossTower(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Ret = int(((__GetUserByThis)0x082a67e2)((void *)P));
+    sq_pushinteger(v, Ret);
+    return 1;
+}
+static SQInteger CUser_CheckInBlueMarble(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Ret = int(((__GetUserByThis)0x080da32a)((void *)P));
+    sq_pushinteger(v, Ret);
+    return 1;
+}
+static SQInteger CUser_IsGmMode(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Ret = int(((__GetUserByThis)0x0814589c)((void *)P));
+    sq_pushinteger(v, Ret);
+    return 1;
+}
+static SQInteger CUser_GetVisibleValues(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Ret = int(((__GetUserByThis)0x0868BDE4)((void *)P));
+    sq_pushinteger(v, Ret);
+    return 1;
+}
+static SQInteger CUser_GetCurCharacLastPlayTick(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Ret = int(((__GetUserByThis)0x082A66AA)((void *)P));
+    sq_pushinteger(v, Ret);
+    return 1;
+}
+typedef int (*__GiveUserItem)(void *CUser, int a2, int a3, int a4, int *a5, int a6);
+typedef int (*__UserSendUpdateItemList)(void *CUser, int a2, int a3, int a4);
+static SQInteger CUser_GiveUserItem(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger ItemId, ItemCount;
+    sq_getinteger(v, 3, &ItemId);
+    sq_getinteger(v, 4, &ItemCount);
+    int *ItemSpace = (int *)malloc(4);
+    int Slot = int(((__GiveUserItem)0x0867B6D4)((void *)P, ItemId, ItemCount, 6, ItemSpace, 0));
+    if (Slot >= 0)
+    {
+        sq_newarray(v, 0);
+        sq_pushinteger(v, *ItemSpace);
+        sq_arrayappend(v, -2);
+        sq_pushinteger(v, Slot);
+        sq_arrayappend(v, -2);
+    }
+    else
+        sq_pushnull(v);
+    return 1;
+}
+// 通知客户端更新道具信息
+static SQInteger CUser_SendUpdateItemList(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Type, ItemSpace, Slot;
+    sq_getinteger(v, 3, &Type);
+    sq_getinteger(v, 4, &ItemSpace);
+    sq_getinteger(v, 5, &Slot);
+
+    CallUser<int>(0x867C65A, P, Type, ItemSpace, Slot);
+    return 0;
+}
+// 通知客户端更新背包栏
+static SQInteger CUser_SendItemSpace(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger itemSpace;
+    sq_getinteger(v, 3, &itemSpace);
+
+    CallUser<int>(0x865DB6C, P, itemSpace);
+    return 0;
+}
+// 发送邮件
+static SQInteger CUser_SendMail(HSQUIRRELVM v)
+{
+    SQInteger Cid;
+    sq_getinteger(v, 2, &Cid);
+
+    std::vector<std::pair<int, int>> List;
+    List.clear();
+
+    int ItemListLen = 0;
+    sq_pushnull(v); // null iterator
+    while (SQ_SUCCEEDED(sq_next(v, 3)))
+    {
+        SQInteger Index, Count;
+        sq_getinteger(v, -1, &Count);
+        sq_getinteger(v, -2, &Index);
+        std::pair<int, int> pair1 = std::make_pair(Index, Count);
+        List.push_back(pair1);
+        // 这里-1是值，-2是键
+        sq_pop(v, 2); // 在下一次迭代之前弹出键和值
+        ItemListLen++;
+    }
+    sq_pop(v, 1);
+
+    void *addition_slots = malloc(1000);
+    for (int i = 0; i < 10; i++)
+    {
+        CallUser<void>(0x80CB854, addition_slots + (i * 61));
+    }
+    CallUser<int>(0x8556A14, List, addition_slots, 10);
+
+    SQInteger Gold;
+    sq_getinteger(v, 4, &Gold);
+    const SQChar *Title;
+    const SQChar *Text;
+    sq_getstring(v, 5, &Title);
+    sq_getstring(v, 6, &Text);
+    int TextLen = strlen(Text);
+
+    CallUser<int>(0x8556B68, Title, addition_slots, ItemListLen, Gold, Cid, Text, TextLen, 0, 99, 1);
+    return 0;
+}
+// 发送邮件
+static SQInteger CUser_ChangeGrowType(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Base, Ex;
+    sq_getinteger(v, 3, &Base);
+    sq_getinteger(v, 4, &Ex);
+
+    CallUser<int>(0x867B048, P, Base, Ex);
+    return 0;
+}
+
+// 发送消息包
+static SQInteger CUser_SendNotiPacket(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Type1, Type2, Type3;
+    sq_getinteger(v, 3, &Type1);
+    sq_getinteger(v, 4, &Type2);
+    sq_getinteger(v, 5, &Type3);
+    CallUser<int>(0x867BA5C, P, Type1, Type2, Type3);
+    return 0;
+}
+// 获取技能树
+static SQInteger CUser_GetSkillW(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    void *S = CallUser<void *>(0x822F140, P);
+    sq_pushuserpointer(v, S);
+    return 1;
+}
+// 重置技能
+static SQInteger CUser_InitSkillW(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger GrowType, IsAwa;
+    sq_getinteger(v, 3, &GrowType);
+    sq_getinteger(v, 4, &IsAwa);
+    CallUser<int>(0x8608120, P, GrowType, IsAwa);
+    return 0;
+}
+// 改变GM完成任务模式
+static SQInteger CUser_ChangeGmQuestFlag(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Type;
+    sq_getinteger(v, 3, &Type);
+
+    CallUser<int>(0x822FC8E, P, Type);
+    return 0;
+}
+// 任务相关操作
+static SQInteger CUser_QuestAction(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Type, QuestId, Reward, Flag;
+    sq_getinteger(v, 3, &Type);
+    sq_getinteger(v, 4, &QuestId);
+    sq_getinteger(v, 5, &Reward);
+    sq_getinteger(v, 6, &Flag);
+
+    CallUser<int>(0x0866DA8A, P, Type, QuestId, Reward, Flag);
+    return 0;
+}
+// 刷新上次任务完成时间
+static SQInteger CUser_RefreshLastQuestTime(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+
+    *(int *)((void *)P + 0x79644) = 0;
+    return 0;
+}
+
+static SQInteger register_User_func(HSQUIRRELVM v, SQFUNCTION f, const char *fname)
+{
+    sq_pushroottable(v);
+    sq_pushstring(v, fname, -1);
+    sq_newclosure(v, f, 0); // create a new function
+    sq_newslot(v, -3, SQFalse);
+    sq_pop(v, 1); // pops the root table
+}
+
+static void RegisterUser(HSQUIRRELVM v)
+{
+    // 获取X坐标
+    register_User_func(v, CUser_GetPosX, "Sq_CUser_GetPosX");
+    // 获取Y坐标
+    register_User_func(v, CUser_GetPosY, "Sq_CUser_GetPosY");
+    // 获取朝向
+    register_User_func(v, CUser_Direction, "Sq_CUser_Direction");
+    // 获取城镇编号
+    register_User_func(v, CUser_GetVill, "Sq_CUser_GetTownIndex");
+    // 获取区域编号
+    register_User_func(v, CUser_GetArea, "Sq_CUser_GetAreaIndex");
+    // 获取账号状态
+    register_User_func(v, CUser_GetState, "Sq_CUser_GetState");
+    // 获取角色数量
+    register_User_func(v, CUser_GetCharacCount, "Sq_CUser_GetCharacCount");
+    // 获取UID
+    register_User_func(v, CUser_GetAccId, "Sq_CUser_GetAccId");
+    // 获取UniqueId
+    register_User_func(v, CUser_GetUniqueId, "Sq_CUser_GetUniqueId");
+    // 获取CID
+    register_User_func(v, CUser_GetCharacNo, "Sq_CUser_GetCharacNo");
+    // 获取角色职业
+    register_User_func(v, CUser_GetCharacJob, "Sq_CUser_GetCharacJob");
+    // 获取角色名称
+    register_User_func(v, CUser_GetCharacName, "Sq_CUser_GetCharacName");
+    // 获取角色等级
+    register_User_func(v, CUser_GetCharacLevel, "Sq_CUser_GetCharacLevel");
+    // 设置角色等级
+    register_User_func(v, CUser_SetCharacLevel, "Sq_CUser_SetCharacLevel");
+    // 获取角色转职职业
+    register_User_func(v, CUser_GetCharacGrowType, "Sq_CUser_GetCharacGrowType");
+    // 获取角色觉醒职业
+    register_User_func(v, CUser_GetCharacSecondGrowType, "Sq_CUser_GetCharacSecondGrowType");
+    // 获取已用疲劳值
+    register_User_func(v, CUser_GetFatigue, "Sq_CUser_GetFatigue");
+    // 获取最大疲劳值
+    register_User_func(v, CUser_GetMaxFatigue, "Sq_CUser_GetMaxFatigue");
+    // 踢人
+    register_User_func(v, CUser_DisConnSig, "Sq_CUser_DisConnSig");
+    // 获取当前小队/副本
+    register_User_func(v, CUser_GetParty, "Sq_CUser_GetParty");
+    // 获是否在领主塔
+    register_User_func(v, CUser_CheckInBossTower, "Sq_CUser_CheckInBossTower");
+    // 获取是否在龙之路
+    register_User_func(v, CUser_CheckInBlueMarble, "Sq_CUser_CheckInBlueMarble");
+    // 是否开启GM权限
+    register_User_func(v, CUser_IsGmMode, "Sq_CUser_IsGmMode");
+    // 获取可见Values
+    register_User_func(v, CUser_GetVisibleValues, "Sq_CUser_GetVisibleValues");
+    // 获取账号上次退出游戏的时间
+    register_User_func(v, CUser_GetCurCharacLastPlayTick, "Sq_CUser_GetCurCharacLastPlayTick");
+    // 发送道具
+    register_User_func(v, CUser_GiveUserItem, "Sq_CUser_GiveUserItem");
+    // 通知客户端更新背包
+    register_User_func(v, CUser_SendItemSpace, "Sq_CUser_SendItemSpace");
+    // 通知客户端道具更新
+    register_User_func(v, CUser_SendUpdateItemList, "Sq_CUser_SendUpdateItemList");
+    // 发送GM邮件
+    register_User_func(v, CUser_SendMail, "Sq_CUser_SendMail");
+    // 更改职业
+    register_User_func(v, CUser_ChangeGrowType, "Sq_CUser_ChangeGrowType");
+    // 发送消息包
+    register_User_func(v, CUser_SendNotiPacket, "Sq_CUser_SendNotiPacket");
+    // 获取技能树
+    register_User_func(v, CUser_GetSkillW, "Sq_CUser_GetSkillW");
+    // 重置技能树
+    register_User_func(v, CUser_InitSkillW, "Sq_CUser_InitSkillW");
+    // 改变GM完成任务模式
+    register_User_func(v, CUser_ChangeGmQuestFlag, "Sq_CUser_ChangeGmQuestFlag");
+    // 任务相关操作
+    register_User_func(v, CUser_QuestAction, "Sq_CUser_QuestAction");
+    // 刷新上次任务完成时间
+    register_User_func(v, CUser_RefreshLastQuestTime, "Sq_CUser_RefreshLastQuestTime");
+}

include/SqrReg_World.hpp

@@ -0,0 +1,177 @@
+#pragma once
+#include "squirrel.h"
+#include "sqstdaux.h"
+#include "sqstdblob.h"
+#include "sqstdio.h"
+#include "sqstdmath.h"
+#include "sqstdstring.h"
+#include "sqstdsystem.h"
+#include <iostream>
+#include <map>
+
+typedef void *(*__G_GameWorld)();
+static SQInteger Get_GameWorld(HSQUIRRELVM v)
+{
+    void *World = ((__G_GameWorld)0x080DA3A7)();
+    sq_pushuserpointer(v, World);
+    return 1;
+}
+typedef int (*__GetSessionByUid)(void *World, int Uid);
+static SQInteger GameWorld_GetSessionByUid(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Uid;
+    sq_getinteger(v, 3, &Uid);
+
+    SQInteger Session = ((__GetSessionByUid)0x086C4C24)((void *)P, Uid);
+    sq_pushinteger(v, Session);
+    return 1;
+}
+typedef void *(*__GetUserBySession)(void *World, int Session);
+static SQInteger GameWorld_GetUserBySession(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Session;
+    sq_getinteger(v, 3, &Session);
+
+    void *User = ((__GetUserBySession)0x086C4B9C)((void *)P, Session);
+    sq_pushuserpointer(v, User);
+    return 1;
+}
+typedef void *(*__GetUserByUid)(void *World, int Uid);
+static SQInteger GameWorld_GetUserByUid(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQInteger Uid;
+    sq_getinteger(v, 3, &Uid);
+
+    void *User = ((__GetUserByUid)0x086C4D40)((void *)P, Uid);
+    sq_pushuserpointer(v, User);
+    return 1;
+}
+typedef void *(*__GetUserByName)(void *World, char *Name);
+static SQInteger GameWorld_GetUserByName(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    const SQChar *Name;
+    sq_getstring(v, 3, &Name);
+
+    void *User = ((__GetUserByName)0x086C9464)((void *)P, (char *)Name);
+    sq_pushuserpointer(v, User);
+    return 1;
+}
+typedef int (*__GetUserCount)(void *World);
+static SQInteger GameWorld_GetUserCount(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+
+    SQInteger Count = ((__GetUserCount)0x086C4550)((void *)P);
+    sq_pushinteger(v, Count);
+    return 1;
+}
+typedef void (*__SendAll)(void *World, void *Pack);
+static SQInteger GameWorld_SendAll(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQUserPointer Pck;
+    sq_getuserpointer(v, 3, &Pck);
+
+    ((__SendAll)0x086C8C14)((void *)P, (void *)Pck);
+    return 0;
+}
+typedef void (*__SendPartyInfoToAll)(void *World, void *CParty, int code);
+static SQInteger GameWorld_SendPartyInfoToAll(HSQUIRRELVM v)
+{
+    SQUserPointer World;
+    sq_getuserpointer(v, 2, &World);
+    SQUserPointer CParty;
+    sq_getuserpointer(v, 3, &CParty);
+
+    ((__SendPartyInfoToAll)0x086C878A)((void *)World, (void *)CParty, 0);
+    return 0;
+}
+// typedef std::map<int, std::string> (*__GetUserIdList)(&std::vector<unsigned short> a1, int a2);
+// static SQInteger GetUserIdList(HSQUIRRELVM v)
+// {
+//     SQInteger a1, a2;
+//     sq_getinteger(v, 2, &a1);
+//     sq_getinteger(v, 3, &a2);
+//     std::vector<unsigned short> Qs;
+//     std::map<int, std::string> Ret = ((__GetUserIdList)0x086C305E)(&Qs, a2);
+
+//     std::cout << Qs.size() << std::endl;
+//     std::cout << Ret.size() << std::endl;
+//     return 0;
+// }
+typedef void *(*__WorldMoveArea)(void *World, void *User, int a3, int a4, int a5, int a6, int a7, int a8, int a9, int a10, int a11);
+static SQInteger GameWorld_MoveArea(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQUserPointer Player;
+    sq_getuserpointer(v, 3, &Player);
+    SQInteger TownIndex, AreaIndex, Xpos, Ypos;
+    sq_getinteger(v, 4, &TownIndex);
+    sq_getinteger(v, 5, &AreaIndex);
+    sq_getinteger(v, 6, &Xpos);
+    sq_getinteger(v, 7, &Ypos);
+
+    ((__WorldMoveArea)0x86C5A84)((void *)P, (void *)Player, TownIndex, AreaIndex, Xpos, Ypos, 0, 0, 0, 0, 0);
+    return 0;
+}
+typedef void *(*__SendDungeonInOut)(void *World, void *User, int a3, bool a4);
+static SQInteger GameWorld_SendDungeonInOut(HSQUIRRELVM v)
+{
+    SQUserPointer P;
+    sq_getuserpointer(v, 2, &P);
+    SQUserPointer Player;
+    sq_getuserpointer(v, 3, &Player);
+    SQInteger Index;
+    SQBool Model;
+    sq_getinteger(v, 4, &Index);
+    sq_getbool(v, 5, &Model);
+
+    ((__SendDungeonInOut)0x86C8FC8)((void *)P, (void *)Player, Index, Model);
+    return 0;
+}
+
+static SQInteger register_World_func(HSQUIRRELVM v, SQFUNCTION f, const char *fname)
+{
+    sq_pushroottable(v);
+    sq_pushstring(v, fname, -1);
+    sq_newclosure(v, f, 0); // create a new function
+    sq_newslot(v, -3, SQFalse);
+    sq_pop(v, 1); // pops the root table
+}
+
+static void RegisterWorld(HSQUIRRELVM v)
+{
+    // 获取游戏世界
+    register_World_func(v, Get_GameWorld, _SC("Sq_Get_GameWorld"));
+    // 根据UID获取Session
+    register_World_func(v, GameWorld_GetSessionByUid, _SC("Sq_GameWorld_GetSessionByUid"));
+    // 根据Session获取玩家
+    register_World_func(v, GameWorld_GetUserBySession, _SC("Sq_GameWorld_GetUserBySession"));
+    // 根据UID获取玩家
+    register_World_func(v, GameWorld_GetUserByUid, _SC("Sq_GameWorld_GetUserByUid"));
+    // 根据名字获取玩家
+    register_World_func(v, GameWorld_GetUserByName, _SC("Sq_GameWorld_GetUserByName"));
+    // 获取玩家数量
+    register_World_func(v, GameWorld_GetUserCount, _SC("Sq_GameWorld_GetUserCount"));
+    // 给所有玩家发包
+    register_World_func(v, GameWorld_SendAll, _SC("Sq_GameWorld_SendAll"));
+    // 指定玩家移动
+    register_World_func(v, GameWorld_MoveArea, _SC("Sq_GameWorld_MoveArea"));
+    // 给所有玩家发送队伍包
+    register_World_func(v, GameWorld_SendPartyInfoToAll, _SC("Sq_GameWorld_SendPartyInfoToAll"));
+    // 副本开启或关闭消息
+    register_World_func(v, GameWorld_SendDungeonInOut, _SC("Sq_GameWorld_SendDungeonInOut"));
+
+    // register_World_func(v, GetUserIdList, _SC("Sq_GetUserIdList"));
+}

include/Tool.h

@@ -0,0 +1,322 @@
+#pragma once
+#include <iostream>
+#include <iconv.h>
+#include <vector>
+#include <dirent.h>
+#include <string.h>
+#include "squirrel.h"
+
+class Tool
+{
+private:
+    /* data */
+public:
+    Tool(/* args */);
+    ~Tool();
+
+    // 将int 转为小端序列
+    static unsigned char *IntToByteLittle(int Count);
+    // 将小端序列 转为int
+    static int ByteLittleToInt(unsigned char *Count);
+    // 将字符串转为 数组
+    static unsigned char *StringToByte(std::string str);
+
+public:
+    // 错误输出
+    static void Error(std::string E);
+    // 警告输出
+    static void Warring(std::string W);
+    // 常规输出
+    static void Logger(std::string L);
+
+    // 获取当前时间戳
+    static long long get_cur_time();
+
+    static int UTF8ToGB2312(char *szSrc, size_t iSrcLen, char *szDst, size_t iDstLen);
+    static int GB2312ToUTF8(char *szSrc, size_t iSrcLen, char *szDst, size_t iDstLen);
+
+    // 输出字节数组
+    static void printUint8Array(uint8_t *array, size_t length)
+    {
+        for (size_t i = 0; i < length; ++i)
+        {
+            std::cout << static_cast<int>(array[i]);
+            if (i != length - 1)
+            {
+                std::cout << ", "; // 添加逗号分隔符
+            }
+        }
+        std::cout << std::endl;
+    }
+
+    // 批量替换字符串中文本
+    static std::string &ReplaceAll(std::string &str, const std::string &src, const std::string &dst)
+    {
+        std::string::size_type pos(0);
+        while (true)
+        {
+            if ((pos = str.find(src)) != std::string::npos)
+            {
+                str.replace(pos, src.length(), dst);
+            }
+            else
+            {
+                break;
+            }
+        }
+        return str;
+    }
+
+    // 遍历指定文件夹下的所有文件，不包括指定文件夹内的文件夹
+    static std::vector<std::string> GetListFiles(const std::string &path, const std::string &exten = "*")
+    {
+        std::vector<std::string> list;
+        list.clear();
+
+        DIR *dp = NULL;
+        struct dirent *dirp = NULL;
+        if ((dp = opendir(path.c_str())) == NULL)
+        {
+            return list;
+        }
+
+        while ((dirp = readdir(dp)) != NULL)
+        {
+            if (dirp->d_type == DT_REG)
+            {
+                if (exten.compare("*") == 0)
+                    list.emplace_back(static_cast<std::string>(dirp->d_name));
+                else if (std::string(dirp->d_name).find(exten) != std::string::npos)
+                    list.emplace_back(static_cast<std::string>(dirp->d_name));
+            }
+        }
+
+        closedir(dp);
+
+        return list;
+    }
+
+    // 遍历指定文件夹下的所有文件夹，不包括指定文件夹下的文件
+    static std::vector<std::string> GetListFolders(const std::string &path, const std::string &exten = "*")
+    {
+        std::vector<std::string> list;
+        list.clear();
+
+        DIR *dp = NULL;
+        struct dirent *dirp = NULL;
+        if ((dp = opendir(path.c_str())) == NULL)
+        {
+            return list;
+        }
+
+        while ((dirp = readdir(dp)) != NULL)
+        {
+            if (dirp->d_type == DT_DIR && strcmp(dirp->d_name, ".") != 0 && strcmp(dirp->d_name, "..") != 0)
+            {
+                if (exten.compare("*") == 0)
+                    list.emplace_back(static_cast<std::string>(dirp->d_name));
+                else if (std::string(dirp->d_name).find(exten) != std::string::npos)
+                    list.emplace_back(static_cast<std::string>(dirp->d_name));
+            }
+        }
+
+        closedir(dp);
+
+        return list;
+    }
+
+    // 遍历指定文件夹下的所有文件，包括指定文件夹内的文件夹
+    static std::vector<std::string> GetListFilesR(const std::string &path, const std::string &exten = "*")
+    {
+        std::vector<std::string> list = Tool::GetListFiles(path, exten);
+
+        std::vector<std::string> dirs = Tool::GetListFolders(path, exten);
+
+        // 遍历目录
+        for (auto it = dirs.cbegin(); it != dirs.cend(); ++it)
+        {
+            // 递归调用扫完
+            std::vector<std::string> dirsvecBuf = Tool::GetListFilesR(path + "/" + *it);
+            if (dirsvecBuf.size() > 0)
+            {
+                for (auto dirsvecBufF = dirsvecBuf.cbegin(); dirsvecBufF != dirsvecBuf.cend(); ++dirsvecBufF)
+                {
+                    list.emplace_back(*it + "/" + *dirsvecBufF);
+                }
+            }
+        }
+
+        return list;
+    }
+
+    // 序列化Array为字符串
+    static std::string EncodeARRAY(HSQUIRRELVM v, std::string Jso)
+    {
+        Jso += "[";
+        sq_pushnull(v);
+        while (SQ_SUCCEEDED(sq_next(v, -2)))
+        {
+            SQObjectType Type = sq_gettype(v, -1);
+            switch (Type)
+            {
+            case OT_INTEGER:
+            {
+                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(v, -1, &value);
+                std::string vstr = value;
+                Jso += "\"";
+                Jso += vstr;
+                Jso += "\"";
+                Jso += ",";
+            }
+            break;
+            case OT_TABLE:
+            {
+                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:
+            {
+                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(v, 2); // 在下一次迭代之前弹出键和值
+        }
+        sq_pop(v, 1); // 在下一次迭代之前弹出键和值
+        Jso = Jso.substr(0, Jso.length() - 1);
+        Jso += "]";
+        return Jso;
+    }
+
+    // 序列化Table为字符串
+    static std::string EncodeTABLE(HSQUIRRELVM v, std::string Jso)
+    {
+        Jso += "{";
+        sq_pushnull(v); // null iterator
+        while (SQ_SUCCEEDED(sq_next(v, -2)))
+        {
+            const SQChar *Key;
+            sq_getstring(v, -2, &Key);
+
+            std::string str = Key;
+
+            Jso += "\"";
+            Jso += str;
+            Jso += "\"";
+            Jso += ":";
+
+            SQObjectType Type = sq_gettype(v, -1);
+            switch (Type)
+            {
+            case OT_INTEGER:
+            {
+                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(v, -1, &value);
+
+                std::string vstr = value;
+                Jso += "\"";
+                Jso += vstr;
+                Jso += "\"";
+                Jso += ",";
+            }
+            break;
+            case OT_TABLE:
+            {
+                SQInteger Top = sq_gettop(v);
+                SQObject obj;
+                sq_getstackobj(v, -1, &obj);
+                sq_pushobject(v, obj);
+                Jso = Tool::EncodeTABLE(v, Jso);
+                sq_settop(v, Top);
+                Jso += ",";
+            }
+            break;
+            case OT_ARRAY:
+            {
+                SQInteger Top = sq_gettop(v);
+                SQObject obj;
+                sq_getstackobj(v, -1, &obj);
+                sq_pushobject(v, obj);
+                Jso = Tool::EncodeARRAY(v, Jso);
+                sq_settop(v, Top);
+                Jso += ",";
+            }
+            break;
+            default:
+                break;
+            }
+
+            // 这里-1是值，-2是键
+            sq_pop(v, 2); // 在下一次迭代之前弹出键和值
+        }
+        sq_pop(v, 1); // 在下一次迭代之前弹出键和值
+        Jso = Jso.substr(0, Jso.length() - 1);
+        Jso += "}";
+        return Jso;
+    }
+};

include/dp2_sdk_c.h

@@ -0,0 +1,18 @@
+#pragma once
+#include <dlfcn.h>
+
+typedef struct lua_State lua_State;
+typedef void (*dp2_game_script_t)(void(*ufptr)(lua_State* L, void*), void* udptr);
+
+// 进入dp的锁, 触发回调, 同时获得lua指针
+static int dp2_game_script(void(*ufptr)(lua_State* L, void*), void* udptr) {
+    void* fn = dlsym(RTLD_DEFAULT, "__dp2_game_script");
+    if (!fn) {
+        return 1;
+    }
+    dp2_game_script_t func = (dp2_game_script_t)fn;
+    printf("\n函数\n");
+    func(ufptr, udptr);
+    printf("\n调用成功\n");
+    return 0;
+}

include/l_socket.h

@@ -0,0 +1,218 @@
+#pragma once
+#include "Singleton.h"
+#include "l_squirrel.h"
+#include <iostream>
+#include <asio.hpp>
+
+extern HSQUIRRELVM v;
+extern std::recursive_mutex SqMtx;
+
+using namespace asio;
+using asio::ip::tcp;
+
+class Client
+{
+private:
+    asio::io_context io_context;
+    tcp::resolver resolver;
+    tcp::socket socket;
+    tcp::resolver::results_type endpoint;
+    std::array<char, 8192> buffer;
+    std::array<char, 8192000> PackData;
+    std::size_t writeDataSize = 0;
+    std::size_t receivedDataSize = 0;
+    std::size_t TestCode = 0;
+    std::string Ip = "192.168.200.27";
+    // std::string Ip = "127.0.0.1";
+    std::string Port = "65109";
+    std::mutex PackMtx;
+
+public:
+    bool ConnectState = false;
+
+public:
+    Client(asio::io_context &io_context)
+        : resolver(io_context),
+          socket(io_context)
+    {
+        endpoint = resolver.resolve(Ip, Port);
+        PackData.fill(0);
+    }
+
+    void start()
+    {
+        async_connect(socket, endpoint, [this](const asio::error_code &error, const tcp::endpoint &endpoint)
+                      {
+        if (!error) {
+            ConnectState = true;
+            read();
+            std::lock_guard<std::recursive_mutex> lock(SqMtx);
+            SQInteger top = sq_gettop(v); // saves the stack size before the call
+            sq_pushroottable(v);          // pushes the global table
+            sq_pushstring(v, _SC("OnGatewaySocketConnect"), -1);
+            if (SQ_SUCCEEDED(sq_get(v, -2)))
+            {                        // gets the field 'foo' from the global table
+                sq_pushroottable(v); // push the 'this' (in this case is the global table)
+                sq_call(v, 1, SQFalse, SQTrue); // calls the function
+            }
+            sq_settop(v, top); // restores the original stack size
+            io_context.poll(); // 处理一次事件循环，避免主线程阻塞
+        } else {
+            std::cerr << "Error connecting to server: " << error.message() << std::endl;
+        } });
+    }
+
+    void read()
+    {
+        socket.async_read_some(asio::buffer(buffer), [this](const asio::error_code &error, std::size_t bytes_transferred)
+                               {
+        if (!error) {
+            PackMtx.lock();
+            for (std::size_t i = 0; i < bytes_transferred; ++i)
+            {
+                PackData[writeDataSize + i] = buffer[i];
+            }
+            writeDataSize += bytes_transferred;
+            PackMtx.unlock();
+            read();
+        } else {
+            std::cerr << "Error reading data: " << error.message() << std::endl;
+            reconnect();
+        } });
+    }
+
+    void reconnect()
+    {
+        ConnectState = false;
+        std::cout << "服务器断开连接,尝试重连." << std::endl;
+        // 执行重连操作
+        // 关闭当前连接
+        socket.close();
+        // 重新解析端点
+        endpoint = resolver.resolve(Ip, Port);
+        // 重新连接
+        async_connect(socket, endpoint, [this](const asio::error_code &error, const tcp::endpoint &endpoint)
+                      {
+            if (!error) {
+                ConnectState = true;
+                std::lock_guard<std::recursive_mutex> lock(SqMtx);
+                SQInteger top = sq_gettop(v); // saves the stack size before the call
+                sq_pushroottable(v);          // pushes the global table
+                sq_pushstring(v, _SC("OnGatewaySocketConnect"), -1);
+                if (SQ_SUCCEEDED(sq_get(v, -2)))
+                {                                   // gets the field 'foo' from the global table
+                    sq_pushroottable(v);            // push the 'this' (in this case is the global table)
+                    sq_call(v, 1, SQFalse, SQTrue); // calls the function
+                }
+                sq_settop(v, top); // restores the original stack size
+
+                read();
+            } else {
+                std::cerr << "Error reconnecting to server: " << error.message() << std::endl;
+                // 可以在此处添加重连失败的处理逻辑
+                reconnect();
+            } });
+    }
+
+    void send(unsigned char *message, int Length)
+    {
+        async_write(socket, asio::buffer(message, Length), [this](const asio::error_code &error, std::size_t bytes_transferred)
+                    {
+        if (!error) {
+            // std::cout << "Message sent" << std::endl;
+        } else {
+            std::cerr << "Error sending message: " << error.message() << std::endl;
+        } });
+    }
+
+    void PackLogic()
+    {
+        // 如果包长度不够直接返回
+        if (PackData.size() < 4)
+            return;
+        // 如果里面已经读了超过一半的大小了
+        if (writeDataSize >= 40960)
+        {
+            PackMtx.lock();
+            // 删除前XX个元素
+            std::copy(PackData.begin() + receivedDataSize, PackData.end(), PackData.begin());
+            // 将最后16个元素设置为0
+            std::fill(PackData.end() - receivedDataSize, PackData.end(), 0);
+            // 写的大小重置
+            writeDataSize -= receivedDataSize;
+            // 读的大小重置
+            receivedDataSize = 0;
+            PackMtx.unlock();
+        }
+
+        unsigned char *Count = new unsigned char[4];
+        std::copy(PackData.begin() + receivedDataSize, PackData.begin() + 4 + receivedDataSize, Count);
+        int PackSize = ByteLittleToInt(Count);
+        delete[] Count;
+        // 如果长度不够直接返回
+        if (PackSize <= 0)
+            return;
+        char *StrBuffer = new char[PackSize + 1];
+        std::copy(PackData.begin() + 4 + receivedDataSize, PackData.begin() + 4 + PackSize + receivedDataSize, StrBuffer);
+        StrBuffer[PackSize] = '\0';
+        // 这次读了多少
+        receivedDataSize += (4 + PackSize);
+
+        std::string Str = StrBuffer;
+        delete[] StrBuffer;
+        // std::cout << "包大小:  " << PackSize << std::endl;
+        // std::cout << "包内容:  " << Str << std::endl;
+        // std::cout << "收到了第:  " << TestCode << "个包" << std::endl;
+
+        std::lock_guard<std::recursive_mutex> lock(SqMtx);
+        SQInteger top = sq_gettop(v); // saves the stack size before the call
+        sq_pushroottable(v);          // pushes the global table
+        sq_pushstring(v, _SC("OnGatewaySocketMsg"), -1);
+        if (SQ_SUCCEEDED(sq_get(v, -2)))
+        {                        // gets the field 'foo' from the global table
+            sq_pushroottable(v); // push the 'this' (in this case is the global table)
+            sq_pushstring(v, Str.c_str(), -1);
+            sq_call(v, 2, SQFalse, SQTrue); // calls the function
+        }
+        sq_settop(v, top); // restores the original stack size
+
+        TestCode++;
+    }
+
+    static int ByteLittleToInt(unsigned char *Count)
+    {
+        int int1 = Count[0] & 0xff;
+        int int2 = (Count[1] & 0xff) << 8;
+        int int3 = (Count[2] & 0xff) << 16;
+        int int4 = (Count[3] & 0xff) << 24;
+
+        return int1 | int2 | int3 | int4;
+    }
+};
+
+class l_socket
+{
+public:
+private:
+    l_socket() {}                                   // private constructor to prevent instantiation
+    l_socket(const l_socket &) = delete;            // disable copy constructor
+    l_socket &operator=(const l_socket &) = delete; // disable assignment operator
+    Client *ClientObj;
+
+public:
+    bool InitState = false;
+    static l_socket &getInstance()
+    {
+        static l_socket instance;
+        return instance;
+    }
+
+    void InitSqr();
+    void InitPackLogic();
+    void Init();
+    void Send(const SQChar *Pck);
+    void Logic();
+    void IntToByteLittle(unsigned char *b, int Count);
+
+public:
+};

include/l_squirrel.h

@@ -0,0 +1,32 @@
+#pragma once
+#ifndef l_squirrel
+#define l_squirrel
+// #define SQUNICODE
+#define NO_COMPILER
+
+#include "squirrel.h"
+#include "sqstdaux.h"
+#include "sqstdblob.h"
+#include "sqstdio.h"
+#include "sqstdmath.h"
+#include "sqstdstring.h"
+#include "sqstdsystem.h"
+#include "l_squirrel_register.hpp"
+#include "Tool.h"
+#include <map>
+#include <fstream>
+#include <sstream>
+#include <iostream>
+#include <stdarg.h>
+#include <mutex>
+
+#ifdef SQUNICODE
+#define scvprintf vfwprintf
+#define scfprintf fwprintf
+#else
+#define scvprintf vfprintf
+#define scfprintf fprintf
+#endif
+
+void InitSquirrel();
+#endif

include/l_squirrel_register.hpp

@@ -0,0 +1,28 @@
+#pragma once
+#include "squirrel.h"
+#include "sqstdaux.h"
+#include "sqstdblob.h"
+#include "sqstdio.h"
+#include "sqstdmath.h"
+#include "sqstdstring.h"
+#include "sqstdsystem.h"
+#include "SqrReg_User.hpp"        //用户类
+#include "SqrReg_Packet.hpp"      //发包类
+#include "SqrReg_World.hpp"       //世界类
+#include "SqrReg_Game.hpp"        //游戏类
+#include "SqrReg_GameManager.hpp" //游戏管理器类
+#include "SqrReg_Party.hpp"       //队伍类
+#include "SqrReg_Inven.hpp"       //背包类
+#include <iostream>
+#include <stdarg.h>
+
+static void GlobaRegisterSquirrel(HSQUIRRELVM v)
+{
+    RegisterInven(v);       // 背包类
+    RegisterGameManager(v); // 游戏管理器类
+    RegisterParty(v);       // 队伍类
+    RegisterGame(v);        // 游戏类
+    RegisterWorld(v);       // 世界类
+    RegisterPacket(v);      // 发包类
+    RegisterUser(v);        // 用户类
+}

include/lauxlib.h

@@ -0,0 +1,264 @@
+/*
+** $Id: lauxlib.h,v 1.131.1.1 2017/04/19 17:20:42 roberto Exp $
+** Auxiliary functions for building Lua libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lauxlib_h
+#define lauxlib_h
+
+
+#include <stddef.h>
+#include <stdio.h>
+
+#include "lua.h"
+
+
+
+/* extra error code for 'luaL_loadfilex' */
+#define LUA_ERRFILE     (LUA_ERRERR+1)
+
+
+/* key, in the registry, for table of loaded modules */
+#define LUA_LOADED_TABLE	"_LOADED"
+
+
+/* key, in the registry, for table of preloaded loaders */
+#define LUA_PRELOAD_TABLE	"_PRELOAD"
+
+
+typedef struct luaL_Reg {
+  const char *name;
+  lua_CFunction func;
+} luaL_Reg;
+
+
+#define LUAL_NUMSIZES	(sizeof(lua_Integer)*16 + sizeof(lua_Number))
+
+LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz);
+#define luaL_checkversion(L)  \
+	  luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES)
+
+LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
+LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
+LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);
+LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg);
+LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg,
+                                                          size_t *l);
+LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg,
+                                          const char *def, size_t *l);
+LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg);
+LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def);
+
+LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg);
+LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg,
+                                          lua_Integer def);
+
+LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
+LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t);
+LUALIB_API void (luaL_checkany) (lua_State *L, int arg);
+
+LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
+LUALIB_API void  (luaL_setmetatable) (lua_State *L, const char *tname);
+LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname);
+LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
+
+LUALIB_API void (luaL_where) (lua_State *L, int lvl);
+LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
+
+LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def,
+                                   const char *const lst[]);
+
+LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);
+LUALIB_API int (luaL_execresult) (lua_State *L, int stat);
+
+/* predefined references */
+#define LUA_NOREF       (-2)
+#define LUA_REFNIL      (-1)
+
+LUALIB_API int (luaL_ref) (lua_State *L, int t);
+LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
+
+LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename,
+                                               const char *mode);
+
+#define luaL_loadfile(L,f)	luaL_loadfilex(L,f,NULL)
+
+LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz,
+                                   const char *name, const char *mode);
+LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
+
+LUALIB_API lua_State *(luaL_newstate) (void);
+
+LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx);
+
+LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
+                                                  const char *r);
+
+LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);
+
+LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname);
+
+LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1,
+                                  const char *msg, int level);
+
+LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,
+                                 lua_CFunction openf, int glb);
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+
+#define luaL_newlibtable(L,l)	\
+  lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)
+
+#define luaL_newlib(L,l)  \
+  (luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
+
+#define luaL_argcheck(L, cond,arg,extramsg)	\
+		((void)((cond) || luaL_argerror(L, (arg), (extramsg))))
+#define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))
+#define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))
+
+#define luaL_typename(L,i)	lua_typename(L, lua_type(L,(i)))
+
+#define luaL_dofile(L, fn) \
+	(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_dostring(L, s) \
+	(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_getmetatable(L,n)	(lua_getfield(L, LUA_REGISTRYINDEX, (n)))
+
+#define luaL_opt(L,f,n,d)	(lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
+
+#define luaL_loadbuffer(L,s,sz,n)	luaL_loadbufferx(L,s,sz,n,NULL)
+
+
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+typedef struct luaL_Buffer {
+  char *b;  /* buffer address */
+  size_t size;  /* buffer size */
+  size_t n;  /* number of characters in buffer */
+  lua_State *L;
+  char initb[LUAL_BUFFERSIZE];  /* initial buffer */
+} luaL_Buffer;
+
+
+#define luaL_addchar(B,c) \
+  ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \
+   ((B)->b[(B)->n++] = (c)))
+
+#define luaL_addsize(B,s)	((B)->n += (s))
+
+LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
+LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);
+LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
+LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
+LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz);
+LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz);
+
+#define luaL_prepbuffer(B)	luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
+
+/* }====================================================== */
+
+
+
+/*
+** {======================================================
+** File handles for IO library
+** =======================================================
+*/
+
+/*
+** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and
+** initial structure 'luaL_Stream' (it may contain other fields
+** after that initial structure).
+*/
+
+#define LUA_FILEHANDLE          "FILE*"
+
+
+typedef struct luaL_Stream {
+  FILE *f;  /* stream (NULL for incompletely created streams) */
+  lua_CFunction closef;  /* to close stream (NULL for closed streams) */
+} luaL_Stream;
+
+/* }====================================================== */
+
+
+
+/* compatibility with old module system */
+#if defined(LUA_COMPAT_MODULE)
+
+LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname,
+                                   int sizehint);
+LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname,
+                                const luaL_Reg *l, int nup);
+
+#define luaL_register(L,n,l)	(luaL_openlib(L,(n),(l),0))
+
+#endif
+
+
+/*
+** {==================================================================
+** "Abstraction Layer" for basic report of messages and errors
+** ===================================================================
+*/
+
+/* print a string */
+#if !defined(lua_writestring)
+#define lua_writestring(s,l)   fwrite((s), sizeof(char), (l), stdout)
+#endif
+
+/* print a newline and flush the output */
+#if !defined(lua_writeline)
+#define lua_writeline()        (lua_writestring("\n", 1), fflush(stdout))
+#endif
+
+/* print an error message */
+#if !defined(lua_writestringerror)
+#define lua_writestringerror(s,p) \
+        (fprintf(stderr, (s), (p)), fflush(stderr))
+#endif
+
+/* }================================================================== */
+
+
+/*
+** {============================================================
+** Compatibility with deprecated conversions
+** =============================================================
+*/
+#if defined(LUA_COMPAT_APIINTCASTS)
+
+#define luaL_checkunsigned(L,a)	((lua_Unsigned)luaL_checkinteger(L,a))
+#define luaL_optunsigned(L,a,d)	\
+	((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d)))
+
+#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
+#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
+
+#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
+#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
+
+#endif
+/* }============================================================ */
+
+
+
+#endif
+
+

include/lua.h

@@ -0,0 +1,485 @@
+/*
+** Lua - A Scripting Language
+** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
+** See Copyright Notice at the end of this file
+*/
+
+
+#ifndef lua_h
+#define lua_h
+
+#include <stdarg.h>
+#include <stddef.h>
+
+
+#include "luaconf.h"
+
+
+#define LUA_VERSION_MAJOR	"5"
+#define LUA_VERSION_MINOR	"3"
+#define LUA_VERSION_NUM		503
+#define LUA_VERSION_RELEASE	"6"
+
+#define LUA_VERSION	"Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
+#define LUA_RELEASE	LUA_VERSION "." LUA_VERSION_RELEASE
+#define LUA_COPYRIGHT	LUA_RELEASE "  Copyright (C) 1994-2020 Lua.org, PUC-Rio"
+#define LUA_AUTHORS	"R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
+
+
+/* mark for precompiled code ('<esc>Lua') */
+#define LUA_SIGNATURE	"\x1bLua"
+
+/* option for multiple returns in 'lua_pcall' and 'lua_call' */
+#define LUA_MULTRET	(-1)
+
+
+/*
+** Pseudo-indices
+** (-LUAI_MAXSTACK is the minimum valid index; we keep some free empty
+** space after that to help overflow detection)
+*/
+#define LUA_REGISTRYINDEX	(-LUAI_MAXSTACK - 1000)
+#define lua_upvalueindex(i)	(LUA_REGISTRYINDEX - (i))
+
+
+/* thread status */
+#define LUA_OK		0
+#define LUA_YIELD	1
+#define LUA_ERRRUN	2
+#define LUA_ERRSYNTAX	3
+#define LUA_ERRMEM	4
+#define LUA_ERRGCMM	5
+#define LUA_ERRERR	6
+
+
+typedef struct lua_State lua_State;
+
+
+/*
+** basic types
+*/
+#define LUA_TNONE		(-1)
+
+#define LUA_TNIL		0
+#define LUA_TBOOLEAN		1
+#define LUA_TLIGHTUSERDATA	2
+#define LUA_TNUMBER		3
+#define LUA_TSTRING		4
+#define LUA_TTABLE		5
+#define LUA_TFUNCTION		6
+#define LUA_TUSERDATA		7
+#define LUA_TTHREAD		8
+
+#define LUA_NUMTAGS		9
+
+
+
+/* minimum Lua stack available to a C function */
+#define LUA_MINSTACK	20
+
+
+/* predefined values in the registry */
+#define LUA_RIDX_MAINTHREAD	1
+#define LUA_RIDX_GLOBALS	2
+#define LUA_RIDX_LAST		LUA_RIDX_GLOBALS
+
+
+/* type of numbers in Lua */
+typedef LUA_NUMBER lua_Number;
+
+
+/* type for integer functions */
+typedef LUA_INTEGER lua_Integer;
+
+/* unsigned integer type */
+typedef LUA_UNSIGNED lua_Unsigned;
+
+/* type for continuation-function contexts */
+typedef LUA_KCONTEXT lua_KContext;
+
+
+/*
+** Type for C functions registered with Lua
+*/
+typedef int (*lua_CFunction) (lua_State *L);
+
+/*
+** Type for continuation functions
+*/
+typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx);
+
+
+/*
+** Type for functions that read/write blocks when loading/dumping Lua chunks
+*/
+typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
+
+typedef int (*lua_Writer) (lua_State *L, const void *p, size_t sz, void *ud);
+
+
+/*
+** Type for memory-allocation functions
+*/
+typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
+
+
+
+/*
+** generic extra include file
+*/
+#if defined(LUA_USER_H)
+#include LUA_USER_H
+#endif
+
+
+/*
+** RCS ident string
+*/
+extern const char lua_ident[];
+
+
+/*
+** state manipulation
+*/
+LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);
+LUA_API void       (lua_close) (lua_State *L);
+LUA_API lua_State *(lua_newthread) (lua_State *L);
+
+LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
+
+
+LUA_API const lua_Number *(lua_version) (lua_State *L);
+
+
+/*
+** basic stack manipulation
+*/
+LUA_API int   (lua_absindex) (lua_State *L, int idx);
+LUA_API int   (lua_gettop) (lua_State *L);
+LUA_API void  (lua_settop) (lua_State *L, int idx);
+LUA_API void  (lua_pushvalue) (lua_State *L, int idx);
+LUA_API void  (lua_rotate) (lua_State *L, int idx, int n);
+LUA_API void  (lua_copy) (lua_State *L, int fromidx, int toidx);
+LUA_API int   (lua_checkstack) (lua_State *L, int n);
+
+LUA_API void  (lua_xmove) (lua_State *from, lua_State *to, int n);
+
+
+/*
+** access functions (stack -> C)
+*/
+
+LUA_API int             (lua_isnumber) (lua_State *L, int idx);
+LUA_API int             (lua_isstring) (lua_State *L, int idx);
+LUA_API int             (lua_iscfunction) (lua_State *L, int idx);
+LUA_API int             (lua_isinteger) (lua_State *L, int idx);
+LUA_API int             (lua_isuserdata) (lua_State *L, int idx);
+LUA_API int             (lua_type) (lua_State *L, int idx);
+LUA_API const char     *(lua_typename) (lua_State *L, int tp);
+
+LUA_API lua_Number      (lua_tonumberx) (lua_State *L, int idx, int *isnum);
+LUA_API lua_Integer     (lua_tointegerx) (lua_State *L, int idx, int *isnum);
+LUA_API int             (lua_toboolean) (lua_State *L, int idx);
+LUA_API const char     *(lua_tolstring) (lua_State *L, int idx, size_t *len);
+LUA_API size_t          (lua_rawlen) (lua_State *L, int idx);
+LUA_API lua_CFunction   (lua_tocfunction) (lua_State *L, int idx);
+LUA_API void	       *(lua_touserdata) (lua_State *L, int idx);
+LUA_API lua_State      *(lua_tothread) (lua_State *L, int idx);
+LUA_API const void     *(lua_topointer) (lua_State *L, int idx);
+
+
+/*
+** Comparison and arithmetic functions
+*/
+
+#define LUA_OPADD	0	/* ORDER TM, ORDER OP */
+#define LUA_OPSUB	1
+#define LUA_OPMUL	2
+#define LUA_OPMOD	3
+#define LUA_OPPOW	4
+#define LUA_OPDIV	5
+#define LUA_OPIDIV	6
+#define LUA_OPBAND	7
+#define LUA_OPBOR	8
+#define LUA_OPBXOR	9
+#define LUA_OPSHL	10
+#define LUA_OPSHR	11
+#define LUA_OPUNM	12
+#define LUA_OPBNOT	13
+
+LUA_API void  (lua_arith) (lua_State *L, int op);
+
+#define LUA_OPEQ	0
+#define LUA_OPLT	1
+#define LUA_OPLE	2
+
+LUA_API int   (lua_rawequal) (lua_State *L, int idx1, int idx2);
+LUA_API int   (lua_compare) (lua_State *L, int idx1, int idx2, int op);
+
+
+/*
+** push functions (C -> stack)
+*/
+LUA_API void        (lua_pushnil) (lua_State *L);
+LUA_API void        (lua_pushnumber) (lua_State *L, lua_Number n);
+LUA_API void        (lua_pushinteger) (lua_State *L, lua_Integer n);
+LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t len);
+LUA_API const char *(lua_pushstring) (lua_State *L, const char *s);
+LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,
+                                                      va_list argp);
+LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);
+LUA_API void  (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);
+LUA_API void  (lua_pushboolean) (lua_State *L, int b);
+LUA_API void  (lua_pushlightuserdata) (lua_State *L, void *p);
+LUA_API int   (lua_pushthread) (lua_State *L);
+
+
+/*
+** get functions (Lua -> stack)
+*/
+LUA_API int (lua_getglobal) (lua_State *L, const char *name);
+LUA_API int (lua_gettable) (lua_State *L, int idx);
+LUA_API int (lua_getfield) (lua_State *L, int idx, const char *k);
+LUA_API int (lua_geti) (lua_State *L, int idx, lua_Integer n);
+LUA_API int (lua_rawget) (lua_State *L, int idx);
+LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n);
+LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p);
+
+LUA_API void  (lua_createtable) (lua_State *L, int narr, int nrec);
+LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
+LUA_API int   (lua_getmetatable) (lua_State *L, int objindex);
+LUA_API int  (lua_getuservalue) (lua_State *L, int idx);
+
+
+/*
+** set functions (stack -> Lua)
+*/
+LUA_API void  (lua_setglobal) (lua_State *L, const char *name);
+LUA_API void  (lua_settable) (lua_State *L, int idx);
+LUA_API void  (lua_setfield) (lua_State *L, int idx, const char *k);
+LUA_API void  (lua_seti) (lua_State *L, int idx, lua_Integer n);
+LUA_API void  (lua_rawset) (lua_State *L, int idx);
+LUA_API void  (lua_rawseti) (lua_State *L, int idx, lua_Integer n);
+LUA_API void  (lua_rawsetp) (lua_State *L, int idx, const void *p);
+LUA_API int   (lua_setmetatable) (lua_State *L, int objindex);
+LUA_API void  (lua_setuservalue) (lua_State *L, int idx);
+
+
+/*
+** 'load' and 'call' functions (load and run Lua code)
+*/
+LUA_API void  (lua_callk) (lua_State *L, int nargs, int nresults,
+                           lua_KContext ctx, lua_KFunction k);
+#define lua_call(L,n,r)		lua_callk(L, (n), (r), 0, NULL)
+
+LUA_API int   (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc,
+                            lua_KContext ctx, lua_KFunction k);
+#define lua_pcall(L,n,r,f)	lua_pcallk(L, (n), (r), (f), 0, NULL)
+
+LUA_API int   (lua_load) (lua_State *L, lua_Reader reader, void *dt,
+                          const char *chunkname, const char *mode);
+
+LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip);
+
+
+/*
+** coroutine functions
+*/
+LUA_API int  (lua_yieldk)     (lua_State *L, int nresults, lua_KContext ctx,
+                               lua_KFunction k);
+LUA_API int  (lua_resume)     (lua_State *L, lua_State *from, int narg);
+LUA_API int  (lua_status)     (lua_State *L);
+LUA_API int (lua_isyieldable) (lua_State *L);
+
+#define lua_yield(L,n)		lua_yieldk(L, (n), 0, NULL)
+
+
+/*
+** garbage-collection function and options
+*/
+
+#define LUA_GCSTOP		0
+#define LUA_GCRESTART		1
+#define LUA_GCCOLLECT		2
+#define LUA_GCCOUNT		3
+#define LUA_GCCOUNTB		4
+#define LUA_GCSTEP		5
+#define LUA_GCSETPAUSE		6
+#define LUA_GCSETSTEPMUL	7
+#define LUA_GCISRUNNING		9
+
+LUA_API int (lua_gc) (lua_State *L, int what, int data);
+
+
+/*
+** miscellaneous functions
+*/
+
+LUA_API int   (lua_error) (lua_State *L);
+
+LUA_API int   (lua_next) (lua_State *L, int idx);
+
+LUA_API void  (lua_concat) (lua_State *L, int n);
+LUA_API void  (lua_len)    (lua_State *L, int idx);
+
+LUA_API size_t   (lua_stringtonumber) (lua_State *L, const char *s);
+
+LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
+LUA_API void      (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);
+
+
+
+/*
+** {==============================================================
+** some useful macros
+** ===============================================================
+*/
+
+#define lua_getextraspace(L)	((void *)((char *)(L) - LUA_EXTRASPACE))
+
+#define lua_tonumber(L,i)	lua_tonumberx(L,(i),NULL)
+#define lua_tointeger(L,i)	lua_tointegerx(L,(i),NULL)
+
+#define lua_pop(L,n)		lua_settop(L, -(n)-1)
+
+#define lua_newtable(L)		lua_createtable(L, 0, 0)
+
+#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
+
+#define lua_pushcfunction(L,f)	lua_pushcclosure(L, (f), 0)
+
+#define lua_isfunction(L,n)	(lua_type(L, (n)) == LUA_TFUNCTION)
+#define lua_istable(L,n)	(lua_type(L, (n)) == LUA_TTABLE)
+#define lua_islightuserdata(L,n)	(lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
+#define lua_isnil(L,n)		(lua_type(L, (n)) == LUA_TNIL)
+#define lua_isboolean(L,n)	(lua_type(L, (n)) == LUA_TBOOLEAN)
+#define lua_isthread(L,n)	(lua_type(L, (n)) == LUA_TTHREAD)
+#define lua_isnone(L,n)		(lua_type(L, (n)) == LUA_TNONE)
+#define lua_isnoneornil(L, n)	(lua_type(L, (n)) <= 0)
+
+#define lua_pushliteral(L, s)	lua_pushstring(L, "" s)
+
+#define lua_pushglobaltable(L)  \
+	((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS))
+
+#define lua_tostring(L,i)	lua_tolstring(L, (i), NULL)
+
+
+#define lua_insert(L,idx)	lua_rotate(L, (idx), 1)
+
+#define lua_remove(L,idx)	(lua_rotate(L, (idx), -1), lua_pop(L, 1))
+
+#define lua_replace(L,idx)	(lua_copy(L, -1, (idx)), lua_pop(L, 1))
+
+/* }============================================================== */
+
+
+/*
+** {==============================================================
+** compatibility macros for unsigned conversions
+** ===============================================================
+*/
+#if defined(LUA_COMPAT_APIINTCASTS)
+
+#define lua_pushunsigned(L,n)	lua_pushinteger(L, (lua_Integer)(n))
+#define lua_tounsignedx(L,i,is)	((lua_Unsigned)lua_tointegerx(L,i,is))
+#define lua_tounsigned(L,i)	lua_tounsignedx(L,(i),NULL)
+
+#endif
+/* }============================================================== */
+
+/*
+** {======================================================================
+** Debug API
+** =======================================================================
+*/
+
+
+/*
+** Event codes
+*/
+#define LUA_HOOKCALL	0
+#define LUA_HOOKRET	1
+#define LUA_HOOKLINE	2
+#define LUA_HOOKCOUNT	3
+#define LUA_HOOKTAILCALL 4
+
+
+/*
+** Event masks
+*/
+#define LUA_MASKCALL	(1 << LUA_HOOKCALL)
+#define LUA_MASKRET	(1 << LUA_HOOKRET)
+#define LUA_MASKLINE	(1 << LUA_HOOKLINE)
+#define LUA_MASKCOUNT	(1 << LUA_HOOKCOUNT)
+
+typedef struct lua_Debug lua_Debug;  /* activation record */
+
+
+/* Functions to be called by the debugger in specific events */
+typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
+
+
+LUA_API int (lua_getstack) (lua_State *L, int level, lua_Debug *ar);
+LUA_API int (lua_getinfo) (lua_State *L, const char *what, lua_Debug *ar);
+LUA_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n);
+LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n);
+
+LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n);
+LUA_API void  (lua_upvaluejoin) (lua_State *L, int fidx1, int n1,
+                                               int fidx2, int n2);
+
+LUA_API void (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count);
+LUA_API lua_Hook (lua_gethook) (lua_State *L);
+LUA_API int (lua_gethookmask) (lua_State *L);
+LUA_API int (lua_gethookcount) (lua_State *L);
+
+
+struct lua_Debug {
+  int event;
+  const char *name;	/* (n) */
+  const char *namewhat;	/* (n) 'global', 'local', 'field', 'method' */
+  const char *what;	/* (S) 'Lua', 'C', 'main', 'tail' */
+  const char *source;	/* (S) */
+  int currentline;	/* (l) */
+  int linedefined;	/* (S) */
+  int lastlinedefined;	/* (S) */
+  unsigned char nups;	/* (u) number of upvalues */
+  unsigned char nparams;/* (u) number of parameters */
+  char isvararg;        /* (u) */
+  char istailcall;	/* (t) */
+  char short_src[LUA_IDSIZE]; /* (S) */
+  /* private part */
+  struct CallInfo *i_ci;  /* active function */
+};
+
+/* }====================================================================== */
+
+
+/******************************************************************************
+* Copyright (C) 1994-2020 Lua.org, PUC-Rio.
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to deal in the Software without restriction, including
+* without limitation the rights to use, copy, modify, merge, publish,
+* distribute, sublicense, and/or sell copies of the Software, and to
+* permit persons to whom the Software is furnished to do so, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice shall be
+* included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+******************************************************************************/
+
+
+#endif

include/lua.hpp

@@ -0,0 +1,9 @@
+// lua.hpp
+// Lua header files for C++
+// <<extern "C">> not supplied automatically because Lua also compiles as C++
+
+extern "C" {
+#include "lua.h"
+#include "lualib.h"
+#include "lauxlib.h"
+}

include/luaconf.h

@@ -0,0 +1,793 @@
+/*
+** $Id: luaconf.h,v 1.259.1.1 2017/04/19 17:29:57 roberto Exp $
+** Configuration file for Lua
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef luaconf_h
+#define luaconf_h
+
+#include <limits.h>
+#include <stddef.h>
+
+/*
+** ===================================================================
+** Search for "@@" to find all configurable definitions.
+** ===================================================================
+*/
+
+
+/*
+** {====================================================================
+** System Configuration: macros to adapt (if needed) Lua to some
+** particular platform, for instance compiling it with 32-bit numbers or
+** restricting it to C89.
+** =====================================================================
+*/
+
+/*
+@@ LUA_32BITS enables Lua with 32-bit integers and 32-bit floats. You
+** can also define LUA_32BITS in the make file, but changing here you
+** ensure that all software connected to Lua will be compiled with the
+** same configuration.
+*/
+/* #define LUA_32BITS */
+
+
+/*
+@@ LUA_USE_C89 controls the use of non-ISO-C89 features.
+** Define it if you want Lua to avoid the use of a few C99 features
+** or Windows-specific features on Windows.
+*/
+/* #define LUA_USE_C89 */
+
+
+/*
+** By default, Lua on Windows use (some) specific Windows features
+*/
+#if !defined(LUA_USE_C89) && defined(_WIN32) && !defined(_WIN32_WCE)
+#define LUA_USE_WINDOWS  /* enable goodies for regular Windows */
+#endif
+
+
+#if defined(LUA_USE_WINDOWS)
+#define LUA_DL_DLL	/* enable support for DLL */
+#define LUA_USE_C89	/* broadly, Windows is C89 */
+#endif
+
+
+#if defined(LUA_USE_LINUX)
+#define LUA_USE_POSIX
+#define LUA_USE_DLOPEN		/* needs an extra library: -ldl */
+#define LUA_USE_READLINE	/* needs some extra libraries */
+#endif
+
+
+#if defined(LUA_USE_MACOSX)
+#define LUA_USE_POSIX
+#define LUA_USE_DLOPEN		/* MacOS does not need -ldl */
+#define LUA_USE_READLINE	/* needs an extra library: -lreadline */
+#endif
+
+
+/*
+@@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for
+** C89 ('long' and 'double'); Windows always has '__int64', so it does
+** not need to use this case.
+*/
+#if defined(LUA_USE_C89) && !defined(LUA_USE_WINDOWS)
+#define LUA_C89_NUMBERS
+#endif
+
+
+
+/*
+@@ LUAI_BITSINT defines the (minimum) number of bits in an 'int'.
+*/
+/* avoid undefined shifts */
+#if ((INT_MAX >> 15) >> 15) >= 1
+#define LUAI_BITSINT	32
+#else
+/* 'int' always must have at least 16 bits */
+#define LUAI_BITSINT	16
+#endif
+
+
+/*
+@@ LUA_INT_TYPE defines the type for Lua integers.
+@@ LUA_FLOAT_TYPE defines the type for Lua floats.
+** Lua should work fine with any mix of these options (if supported
+** by your C compiler). The usual configurations are 64-bit integers
+** and 'double' (the default), 32-bit integers and 'float' (for
+** restricted platforms), and 'long'/'double' (for C compilers not
+** compliant with C99, which may not have support for 'long long').
+*/
+
+/* predefined options for LUA_INT_TYPE */
+#define LUA_INT_INT		1
+#define LUA_INT_LONG		2
+#define LUA_INT_LONGLONG	3
+
+/* predefined options for LUA_FLOAT_TYPE */
+#define LUA_FLOAT_FLOAT		1
+#define LUA_FLOAT_DOUBLE	2
+#define LUA_FLOAT_LONGDOUBLE	3
+
+#if defined(LUA_32BITS)		/* { */
+/*
+** 32-bit integers and 'float'
+*/
+#if LUAI_BITSINT >= 32  /* use 'int' if big enough */
+#define LUA_INT_TYPE	LUA_INT_INT
+#else  /* otherwise use 'long' */
+#define LUA_INT_TYPE	LUA_INT_LONG
+#endif
+#define LUA_FLOAT_TYPE	LUA_FLOAT_FLOAT
+
+#elif defined(LUA_C89_NUMBERS)	/* }{ */
+/*
+** largest types available for C89 ('long' and 'double')
+*/
+#define LUA_INT_TYPE	LUA_INT_LONG
+#define LUA_FLOAT_TYPE	LUA_FLOAT_DOUBLE
+
+#endif				/* } */
+
+
+/*
+** default configuration for 64-bit Lua ('long long' and 'double')
+*/
+#if !defined(LUA_INT_TYPE)
+#define LUA_INT_TYPE	LUA_INT_LONGLONG
+#endif
+
+#if !defined(LUA_FLOAT_TYPE)
+#define LUA_FLOAT_TYPE	LUA_FLOAT_DOUBLE
+#endif
+
+/* }================================================================== */
+
+
+
+
+/*
+** {==================================================================
+** Configuration for Paths.
+** ===================================================================
+*/
+
+/*
+** LUA_PATH_SEP is the character that separates templates in a path.
+** LUA_PATH_MARK is the string that marks the substitution points in a
+** template.
+** LUA_EXEC_DIR in a Windows path is replaced by the executable's
+** directory.
+*/
+#define LUA_PATH_SEP            ";"
+#define LUA_PATH_MARK           "?"
+#define LUA_EXEC_DIR            "!"
+
+
+/*
+@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
+** Lua libraries.
+@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for
+** C libraries.
+** CHANGE them if your machine has a non-conventional directory
+** hierarchy or if you want to install your libraries in
+** non-conventional directories.
+*/
+#define LUA_VDIR	LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
+#if defined(_WIN32)	/* { */
+/*
+** In Windows, any exclamation mark ('!') in the path is replaced by the
+** path of the directory of the executable file of the current process.
+*/
+#define LUA_LDIR	"!\\lua\\"
+#define LUA_CDIR	"!\\"
+#define LUA_SHRDIR	"!\\..\\share\\lua\\" LUA_VDIR "\\"
+#define LUA_PATH_DEFAULT  \
+		LUA_LDIR"?.lua;"  LUA_LDIR"?\\init.lua;" \
+		LUA_CDIR"?.lua;"  LUA_CDIR"?\\init.lua;" \
+		LUA_SHRDIR"?.lua;" LUA_SHRDIR"?\\init.lua;" \
+		".\\?.lua;" ".\\?\\init.lua"
+#define LUA_CPATH_DEFAULT \
+		LUA_CDIR"?.dll;" \
+		LUA_CDIR"..\\lib\\lua\\" LUA_VDIR "\\?.dll;" \
+		LUA_CDIR"loadall.dll;" ".\\?.dll"
+
+#else			/* }{ */
+
+#define LUA_ROOT	"/dp2/"
+#define LUA_CDIR	LUA_ROOT "lua/"
+#define LUA_CDIR2	LUA_ROOT "lua2/"
+#define LUA_PATH_DEFAULT  \
+		LUA_CDIR"?.lua;"  LUA_CDIR"?/init.lua;" \
+        LUA_CDIR2"?.lua;"  LUA_CDIR2"?/init.lua;"
+#define LUA_CPATH_DEFAULT \
+		LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" \
+        LUA_CDIR2"?.so;" LUA_CDIR2"loadall.so"
+#endif			/* } */
+
+
+/*
+@@ LUA_DIRSEP is the directory separator (for submodules).
+** CHANGE it if your machine does not use "/" as the directory separator
+** and is not Windows. (On Windows Lua automatically uses "\".)
+*/
+#if defined(_WIN32)
+#define LUA_DIRSEP	"\\"
+#else
+#define LUA_DIRSEP	"/"
+#endif
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Marks for exported symbols in the C code
+** ===================================================================
+*/
+
+/*
+@@ LUA_API is a mark for all core API functions.
+@@ LUALIB_API is a mark for all auxiliary library functions.
+@@ LUAMOD_API is a mark for all standard library opening functions.
+** CHANGE them if you need to define those functions in some special way.
+** For instance, if you want to create one Windows DLL with the core and
+** the libraries, you may want to use the following definition (define
+** LUA_BUILD_AS_DLL to get it).
+*/
+#if defined(LUA_BUILD_AS_DLL)	/* { */
+
+#if defined(LUA_CORE) || defined(LUA_LIB)	/* { */
+#define LUA_API __declspec(dllexport)
+#else						/* }{ */
+#define LUA_API __declspec(dllimport)
+#endif						/* } */
+
+#else				/* }{ */
+
+#ifndef __cplusplus
+#define LUA_API		extern __attribute__((visibility("default")))
+#else
+#define LUA_API		extern "C" __attribute__((visibility("default")))
+#endif
+
+#endif				/* } */
+
+
+/* more often than not the libs go together with the core */
+#define LUALIB_API	LUA_API
+#define LUAMOD_API	LUALIB_API
+
+
+/*
+@@ LUAI_FUNC is a mark for all extern functions that are not to be
+** exported to outside modules.
+@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables
+** that are not to be exported to outside modules (LUAI_DDEF for
+** definitions and LUAI_DDEC for declarations).
+** CHANGE them if you need to mark them in some special way. Elf/gcc
+** (versions 3.2 and later) mark them as "hidden" to optimize access
+** when Lua is compiled as a shared library. Not all elf targets support
+** this attribute. Unfortunately, gcc does not offer a way to check
+** whether the target offers that support, and those without support
+** give a warning about it. To avoid these warnings, change to the
+** default definition.
+*/
+#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
+    defined(__ELF__)		/* { */
+#define LUAI_FUNC	__attribute__((visibility("hidden"))) extern
+#else				/* }{ */
+#define LUAI_FUNC	extern
+#endif				/* } */
+
+#define LUAI_DDEC	LUAI_FUNC
+#define LUAI_DDEF	/* empty */
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Compatibility with previous versions
+** ===================================================================
+*/
+
+/*
+@@ LUA_COMPAT_5_2 controls other macros for compatibility with Lua 5.2.
+@@ LUA_COMPAT_5_1 controls other macros for compatibility with Lua 5.1.
+** You can define it to get all options, or change specific options
+** to fit your specific needs.
+*/
+#if defined(LUA_COMPAT_5_2)	/* { */
+
+/*
+@@ LUA_COMPAT_MATHLIB controls the presence of several deprecated
+** functions in the mathematical library.
+*/
+#define LUA_COMPAT_MATHLIB
+
+/*
+@@ LUA_COMPAT_BITLIB controls the presence of library 'bit32'.
+*/
+#define LUA_COMPAT_BITLIB
+
+/*
+@@ LUA_COMPAT_IPAIRS controls the effectiveness of the __ipairs metamethod.
+*/
+#define LUA_COMPAT_IPAIRS
+
+/*
+@@ LUA_COMPAT_APIINTCASTS controls the presence of macros for
+** manipulating other integer types (lua_pushunsigned, lua_tounsigned,
+** luaL_checkint, luaL_checklong, etc.)
+*/
+#define LUA_COMPAT_APIINTCASTS
+
+#endif				/* } */
+
+
+#if defined(LUA_COMPAT_5_1)	/* { */
+
+/* Incompatibilities from 5.2 -> 5.3 */
+#define LUA_COMPAT_MATHLIB
+#define LUA_COMPAT_APIINTCASTS
+
+/*
+@@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'.
+** You can replace it with 'table.unpack'.
+*/
+#define LUA_COMPAT_UNPACK
+
+/*
+@@ LUA_COMPAT_LOADERS controls the presence of table 'package.loaders'.
+** You can replace it with 'package.searchers'.
+*/
+#define LUA_COMPAT_LOADERS
+
+/*
+@@ macro 'lua_cpcall' emulates deprecated function lua_cpcall.
+** You can call your C function directly (with light C functions).
+*/
+#define lua_cpcall(L,f,u)  \
+	(lua_pushcfunction(L, (f)), \
+	 lua_pushlightuserdata(L,(u)), \
+	 lua_pcall(L,1,0,0))
+
+
+/*
+@@ LUA_COMPAT_LOG10 defines the function 'log10' in the math library.
+** You can rewrite 'log10(x)' as 'log(x, 10)'.
+*/
+#define LUA_COMPAT_LOG10
+
+/*
+@@ LUA_COMPAT_LOADSTRING defines the function 'loadstring' in the base
+** library. You can rewrite 'loadstring(s)' as 'load(s)'.
+*/
+#define LUA_COMPAT_LOADSTRING
+
+/*
+@@ LUA_COMPAT_MAXN defines the function 'maxn' in the table library.
+*/
+#define LUA_COMPAT_MAXN
+
+/*
+@@ The following macros supply trivial compatibility for some
+** changes in the API. The macros themselves document how to
+** change your code to avoid using them.
+*/
+#define lua_strlen(L,i)		lua_rawlen(L, (i))
+
+#define lua_objlen(L,i)		lua_rawlen(L, (i))
+
+#define lua_equal(L,idx1,idx2)		lua_compare(L,(idx1),(idx2),LUA_OPEQ)
+#define lua_lessthan(L,idx1,idx2)	lua_compare(L,(idx1),(idx2),LUA_OPLT)
+
+/*
+@@ LUA_COMPAT_MODULE controls compatibility with previous
+** module functions 'module' (Lua) and 'luaL_register' (C).
+*/
+#define LUA_COMPAT_MODULE
+
+#endif				/* } */
+
+
+/*
+@@ LUA_COMPAT_FLOATSTRING makes Lua format integral floats without a
+@@ a float mark ('.0').
+** This macro is not on by default even in compatibility mode,
+** because this is not really an incompatibility.
+*/
+/* #define LUA_COMPAT_FLOATSTRING */
+
+/* }================================================================== */
+
+
+
+/*
+** {==================================================================
+** Configuration for Numbers.
+** Change these definitions if no predefined LUA_FLOAT_* / LUA_INT_*
+** satisfy your needs.
+** ===================================================================
+*/
+
+/*
+@@ LUA_NUMBER is the floating-point type used by Lua.
+@@ LUAI_UACNUMBER is the result of a 'default argument promotion'
+@@ over a floating number.
+@@ l_mathlim(x) corrects limit name 'x' to the proper float type
+** by prefixing it with one of FLT/DBL/LDBL.
+@@ LUA_NUMBER_FRMLEN is the length modifier for writing floats.
+@@ LUA_NUMBER_FMT is the format for writing floats.
+@@ lua_number2str converts a float to a string.
+@@ l_mathop allows the addition of an 'l' or 'f' to all math operations.
+@@ l_floor takes the floor of a float.
+@@ lua_str2number converts a decimal numeric string to a number.
+*/
+
+
+/* The following definitions are good for most cases here */
+
+#define l_floor(x)		(l_mathop(floor)(x))
+
+#define lua_number2str(s,sz,n)  \
+	l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n))
+
+/*
+@@ lua_numbertointeger converts a float number to an integer, or
+** returns 0 if float is not within the range of a lua_Integer.
+** (The range comparisons are tricky because of rounding. The tests
+** here assume a two-complement representation, where MININTEGER always
+** has an exact representation as a float; MAXINTEGER may not have one,
+** and therefore its conversion to float may have an ill-defined value.)
+*/
+#define lua_numbertointeger(n,p) \
+  ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \
+   (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \
+      (*(p) = (LUA_INTEGER)(n), 1))
+
+
+/* now the variable definitions */
+
+#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT		/* { single float */
+
+#define LUA_NUMBER	float
+
+#define l_mathlim(n)		(FLT_##n)
+
+#define LUAI_UACNUMBER	double
+
+#define LUA_NUMBER_FRMLEN	""
+#define LUA_NUMBER_FMT		"%.7g"
+
+#define l_mathop(op)		op##f
+
+#define lua_str2number(s,p)	strtof((s), (p))
+
+
+#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE	/* }{ long double */
+
+#define LUA_NUMBER	long double
+
+#define l_mathlim(n)		(LDBL_##n)
+
+#define LUAI_UACNUMBER	long double
+
+#define LUA_NUMBER_FRMLEN	"L"
+#define LUA_NUMBER_FMT		"%.19Lg"
+
+#define l_mathop(op)		op##l
+
+#define lua_str2number(s,p)	strtold((s), (p))
+
+#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE	/* }{ double */
+
+#define LUA_NUMBER	double
+
+#define l_mathlim(n)		(DBL_##n)
+
+#define LUAI_UACNUMBER	double
+
+#define LUA_NUMBER_FRMLEN	""
+#define LUA_NUMBER_FMT		"%.14g"
+
+#define l_mathop(op)		op
+
+#define lua_str2number(s,p)	strtod((s), (p))
+
+#else						/* }{ */
+
+#error "numeric float type not defined"
+
+#endif					/* } */
+
+
+
+/*
+@@ LUA_INTEGER is the integer type used by Lua.
+**
+@@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER.
+**
+@@ LUAI_UACINT is the result of a 'default argument promotion'
+@@ over a lUA_INTEGER.
+@@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers.
+@@ LUA_INTEGER_FMT is the format for writing integers.
+@@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER.
+@@ LUA_MININTEGER is the minimum value for a LUA_INTEGER.
+@@ lua_integer2str converts an integer to a string.
+*/
+
+
+/* The following definitions are good for most cases here */
+
+#define LUA_INTEGER_FMT		"%" LUA_INTEGER_FRMLEN "d"
+
+#define LUAI_UACINT		LUA_INTEGER
+
+#define lua_integer2str(s,sz,n)  \
+	l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n))
+
+/*
+** use LUAI_UACINT here to avoid problems with promotions (which
+** can turn a comparison between unsigneds into a signed comparison)
+*/
+#define LUA_UNSIGNED		unsigned LUAI_UACINT
+
+
+/* now the variable definitions */
+
+#if LUA_INT_TYPE == LUA_INT_INT		/* { int */
+
+#define LUA_INTEGER		int
+#define LUA_INTEGER_FRMLEN	""
+
+#define LUA_MAXINTEGER		INT_MAX
+#define LUA_MININTEGER		INT_MIN
+
+#elif LUA_INT_TYPE == LUA_INT_LONG	/* }{ long */
+
+#define LUA_INTEGER		long
+#define LUA_INTEGER_FRMLEN	"l"
+
+#define LUA_MAXINTEGER		LONG_MAX
+#define LUA_MININTEGER		LONG_MIN
+
+#elif LUA_INT_TYPE == LUA_INT_LONGLONG	/* }{ long long */
+
+/* use presence of macro LLONG_MAX as proxy for C99 compliance */
+#if defined(LLONG_MAX)		/* { */
+/* use ISO C99 stuff */
+
+#define LUA_INTEGER		long long
+#define LUA_INTEGER_FRMLEN	"ll"
+
+#define LUA_MAXINTEGER		LLONG_MAX
+#define LUA_MININTEGER		LLONG_MIN
+
+#elif defined(LUA_USE_WINDOWS) /* }{ */
+/* in Windows, can use specific Windows types */
+
+#define LUA_INTEGER		__int64
+#define LUA_INTEGER_FRMLEN	"I64"
+
+#define LUA_MAXINTEGER		_I64_MAX
+#define LUA_MININTEGER		_I64_MIN
+
+#else				/* }{ */
+
+#error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \
+  or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)"
+
+#endif				/* } */
+
+#else				/* }{ */
+
+#error "numeric integer type not defined"
+
+#endif				/* } */
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Dependencies with C99 and other C details
+** ===================================================================
+*/
+
+/*
+@@ l_sprintf is equivalent to 'snprintf' or 'sprintf' in C89.
+** (All uses in Lua have only one format item.)
+*/
+#if !defined(LUA_USE_C89)
+#define l_sprintf(s,sz,f,i)	snprintf(s,sz,f,i)
+#else
+#define l_sprintf(s,sz,f,i)	((void)(sz), sprintf(s,f,i))
+#endif
+
+
+/*
+@@ lua_strx2number converts an hexadecimal numeric string to a number.
+** In C99, 'strtod' does that conversion. Otherwise, you can
+** leave 'lua_strx2number' undefined and Lua will provide its own
+** implementation.
+*/
+#if !defined(LUA_USE_C89)
+#define lua_strx2number(s,p)		lua_str2number(s,p)
+#endif
+
+
+/*
+@@ lua_pointer2str converts a pointer to a readable string in a
+** non-specified way.
+*/
+#define lua_pointer2str(buff,sz,p)	l_sprintf(buff,sz,"%p",p)
+
+
+/*
+@@ lua_number2strx converts a float to an hexadecimal numeric string.
+** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that.
+** Otherwise, you can leave 'lua_number2strx' undefined and Lua will
+** provide its own implementation.
+*/
+#if !defined(LUA_USE_C89)
+#define lua_number2strx(L,b,sz,f,n)  \
+	((void)L, l_sprintf(b,sz,f,(LUAI_UACNUMBER)(n)))
+#endif
+
+
+/*
+** 'strtof' and 'opf' variants for math functions are not valid in
+** C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the
+** availability of these variants. ('math.h' is already included in
+** all files that use these macros.)
+*/
+#if defined(LUA_USE_C89) || (defined(HUGE_VAL) && !defined(HUGE_VALF))
+#undef l_mathop  /* variants not available */
+#undef lua_str2number
+#define l_mathop(op)		(lua_Number)op  /* no variant */
+#define lua_str2number(s,p)	((lua_Number)strtod((s), (p)))
+#endif
+
+
+/*
+@@ LUA_KCONTEXT is the type of the context ('ctx') for continuation
+** functions.  It must be a numerical type; Lua will use 'intptr_t' if
+** available, otherwise it will use 'ptrdiff_t' (the nearest thing to
+** 'intptr_t' in C89)
+*/
+#define LUA_KCONTEXT	ptrdiff_t
+
+#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \
+    __STDC_VERSION__ >= 199901L
+#include <stdint.h>
+#if defined(INTPTR_MAX)  /* even in C99 this type is optional */
+#undef LUA_KCONTEXT
+#define LUA_KCONTEXT	intptr_t
+#endif
+#endif
+
+
+/*
+@@ lua_getlocaledecpoint gets the locale "radix character" (decimal point).
+** Change that if you do not want to use C locales. (Code using this
+** macro must include header 'locale.h'.)
+*/
+#if !defined(lua_getlocaledecpoint)
+#define lua_getlocaledecpoint()		(localeconv()->decimal_point[0])
+#endif
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Language Variations
+** =====================================================================
+*/
+
+/*
+@@ LUA_NOCVTN2S/LUA_NOCVTS2N control how Lua performs some
+** coercions. Define LUA_NOCVTN2S to turn off automatic coercion from
+** numbers to strings. Define LUA_NOCVTS2N to turn off automatic
+** coercion from strings to numbers.
+*/
+/* #define LUA_NOCVTN2S */
+/* #define LUA_NOCVTS2N */
+
+
+/*
+@@ LUA_USE_APICHECK turns on several consistency checks on the C API.
+** Define it as a help when debugging C code.
+*/
+#if defined(LUA_USE_APICHECK)
+#include <assert.h>
+#define luai_apicheck(l,e)	assert(e)
+#endif
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Macros that affect the API and must be stable (that is, must be the
+** same when you compile Lua and when you compile code that links to
+** Lua). You probably do not want/need to change them.
+** =====================================================================
+*/
+
+/*
+@@ LUAI_MAXSTACK limits the size of the Lua stack.
+** CHANGE it if you need a different limit. This limit is arbitrary;
+** its only purpose is to stop Lua from consuming unlimited stack
+** space (and to reserve some numbers for pseudo-indices).
+*/
+#if LUAI_BITSINT >= 32
+#define LUAI_MAXSTACK		1000000
+#else
+#define LUAI_MAXSTACK		15000
+#endif
+
+
+/*
+@@ LUA_EXTRASPACE defines the size of a raw memory area associated with
+** a Lua state with very fast access.
+** CHANGE it if you need a different size.
+*/
+#define LUA_EXTRASPACE		(sizeof(void *))
+
+
+/*
+@@ LUA_IDSIZE gives the maximum size for the description of the source
+@@ of a function in debug information.
+** CHANGE it if you want a different size.
+*/
+#define LUA_IDSIZE	60
+
+
+/*
+@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
+** CHANGE it if it uses too much C-stack space. (For long double,
+** 'string.format("%.99f", -1e4932)' needs 5034 bytes, so a
+** smaller buffer would force a memory allocation for each call to
+** 'string.format'.)
+*/
+#if LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE
+#define LUAL_BUFFERSIZE		8192
+#else
+#define LUAL_BUFFERSIZE   ((int)(0x80 * sizeof(void*) * sizeof(lua_Integer)))
+#endif
+
+/* }================================================================== */
+
+
+/*
+@@ LUA_QL describes how error messages quote program elements.
+** Lua does not use these macros anymore; they are here for
+** compatibility only.
+*/
+#define LUA_QL(x)	"'" x "'"
+#define LUA_QS		LUA_QL("%s")
+
+
+
+
+/* =================================================================== */
+
+/*
+** Local configuration. You can use this space to add your redefinitions
+** without modifying the main part of the file.
+*/
+
+
+
+
+
+#endif
+

include/lualib.h

@@ -0,0 +1,61 @@
+/*
+** $Id: lualib.h,v 1.45.1.1 2017/04/19 17:20:42 roberto Exp $
+** Lua standard libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lualib_h
+#define lualib_h
+
+#include "lua.h"
+
+
+/* version suffix for environment variable names */
+#define LUA_VERSUFFIX          "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR
+
+
+LUAMOD_API int (luaopen_base) (lua_State *L);
+
+#define LUA_COLIBNAME	"coroutine"
+LUAMOD_API int (luaopen_coroutine) (lua_State *L);
+
+#define LUA_TABLIBNAME	"table"
+LUAMOD_API int (luaopen_table) (lua_State *L);
+
+#define LUA_IOLIBNAME	"io"
+LUAMOD_API int (luaopen_io) (lua_State *L);
+
+#define LUA_OSLIBNAME	"os"
+LUAMOD_API int (luaopen_os) (lua_State *L);
+
+#define LUA_STRLIBNAME	"string"
+LUAMOD_API int (luaopen_string) (lua_State *L);
+
+#define LUA_UTF8LIBNAME	"utf8"
+LUAMOD_API int (luaopen_utf8) (lua_State *L);
+
+#define LUA_BITLIBNAME	"bit32"
+LUAMOD_API int (luaopen_bit32) (lua_State *L);
+
+#define LUA_MATHLIBNAME	"math"
+LUAMOD_API int (luaopen_math) (lua_State *L);
+
+#define LUA_DBLIBNAME	"debug"
+LUAMOD_API int (luaopen_debug) (lua_State *L);
+
+#define LUA_LOADLIBNAME	"package"
+LUAMOD_API int (luaopen_package) (lua_State *L);
+
+
+/* open all previous libraries */
+LUALIB_API void (luaL_openlibs) (lua_State *L);
+
+
+
+#if !defined(lua_assert)
+#define lua_assert(x)	((void)0)
+#endif
+
+
+#endif