AURUMVORAX/PyG2O
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Added server-side functions

Browse Source
This commit is contained in:
AURUMVORXX
2024-11-09 03:09:07 +03:00
parent 0596853161
commit 58ec459ea5
12 changed files with 897 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@@ -74,6 +74,8 @@ file(GLOB_RECURSE SOURCE
"src/classes/py/*.cpp"
"src/constants/*.h"
"src/constants/*.cpp"
"src/functions/*.h"
"src/functions/*.cpp"
"src/*.h"
"src/*.cpp"
"src/events/*.h"

27
docs/comparing.md
View File

@@ -11,7 +11,7 @@ def evtInitSecond(**kwargs):
print('World')
```
---
* Positional arguments replaced with keyword arguments (see names of all keywords on the each event page)
* Positional arguments inside event handles replaced with keyword arguments (see names of all keywords on the each event page)
```python
@g2o.event('onPlayerChangeColor')
def evtColor(**kwargs):
@@ -49,5 +49,26 @@ def evtDrop(**kwargs):
print(evtDrop.cancelled)
print(evtDrop.eventName)
```
---
* `eventValue` has been removed (RIP)
-----
* Following functions have been removed <sub><sup>RIP :(</sub></sup>
* `md5`
* `sha1`
* `sha256`
* `sha384`
* `sha512`
* `setReloadCallback`
* `setUnloadCallback`
* `getTimerExecuteTimes`
* `getTimerInterval`
* `killTimer`
* `setTimer`
* `setTimerExecuteTimes`
* `setTimerInterval`
* `sscanf`
* `hexToRgb`
* `rgbToHex`
* `getTickCount`
* `eventValue`
* `getPlayerMagicLevel`
* `setPlayerMagicLevel`

41
src/NoNut/core/CustomTypes.cpp
View File

@@ -135,6 +135,47 @@ namespace nonut
result.convert(value);
data[sq_objtostring(&key)] = result.data;
}
else if (value._type == OT_ARRAY)
{
SqList result = SqList();
result.convert(value);
data[sq_objtostring(&key)] = result.data;
}
}
}
void SqList::convert(SQObject object)
{
Sqrat::Array tab = Sqrat::Array(object);
Sqrat::Object::iterator arrIterator;
int i = 0;
while (tab.Next(arrIterator))
{
HSQOBJECT key = arrIterator.getKey();
HSQOBJECT value = arrIterator.getValue();
if (key._type != OT_INTEGER)
continue;
if (value._type == OT_STRING)
data.insert(sq_objtointeger(&key), sq_objtofloat(&value));
else if (value._type == OT_INTEGER)
data.insert(sq_objtointeger(&key), sq_objtointeger(&value));
else if (value._type == OT_FLOAT)
data.insert(sq_objtointeger(&key), sq_objtofloat(&value));
else if (value._type == OT_TABLE)
{
SqDict result = SqDict();
result.convert(value);
data.insert(sq_objtointeger(&key), result.data);
}
else if (value._type == OT_ARRAY)
{
SqList result = SqList();
result.convert(value);
data.insert(sq_objtointeger(&key), result.data);
}
}
}
}

6
src/NoNut/core/CustomTypes.h
View File

@@ -172,5 +172,11 @@ namespace nonut
void convert(SQObject object) override;
py::dict data{};
};
struct SqList : CustomType
{
void convert(SQObject object) override;
py::list data{};
};
}
#endif // NONUT_G2O_SHARED_CUSTOM_TYPES_H

140
src/bind.cpp
View File

@@ -1,10 +1,14 @@
#include <pybind11/embed.h>
#include "classes/py/Packet.h"
#include "classes/py/DamageDescription.h"
#include "classes/py/ItemGround.h"
#include "classes/py/Daedalus.h"
#include "classes/py/Sky.h"
#include "classes/py/ItemsGround.h"
#include "functions/pyfunctions.h"
#include <NoNut/core/Constant.h>
namespace py = pybind11;
@@ -95,4 +99,140 @@ PYBIND11_EMBEDDED_MODULE(sqg2o, m) {
.def_static("getById", [](int value){ return PyItemsGround::getById(value); })
.def_static("create", [](py::dict value){ return PyItemsGround::create(value); })
.def_static("destroy", [](int value){ return PyItemsGround::destroy(value); });
// -------------------------------------------------------------------------
m.def("getHostname", &py_getHostname);
m.def("getMaxSlots", &py_getMaxSlots);
m.def("getPlayersCount", &py_getPlayersCount);
m.def("getDistance2d", &py_getDistance2d);
m.def("getDistance3d", &py_getDistance3d);
m.def("getVectorAngle", &py_getVectorAngle);
m.def("exit", &py_exit, py::arg() = 0);
m.def("getDayLength", &py_getDayLength);
m.def("getServerDescription", &py_getServerDescription);
m.def("getServerWorld", &py_getServerWorld);
m.def("getTime", &py_getTime);
m.def("serverLog", &py_serverLog);
m.def("setDayLength", &py_setDayLength);
m.def("setServerDescription", &py_setServerDescription);
m.def("setServerWorld", &py_setServerWorld);
m.def("setTime", &py_setTime, py::arg(), py::arg(), py::arg() = 0);
m.def("clearNpcActions", &py_clearNpcActions);
m.def("createNpc", &py_createNpc, py::arg(), py::arg() = "PC_HERO");
m.def("destroyNpc", &py_destroyNpc);
m.def("getNpcAction", &py_getNpcAction);
// m.def("getNpcActionType", &py_getNpcActionType);
m.def("getNpcActtions", &py_getNpcActions);
m.def("getNpcActtionsCount", &py_getNpcActionsCount);
m.def("getNpcHostPlayer", &py_getNpcHostPlayer);
m.def("getNpcLastActionId", &py_getNpcLastActionId);
m.def("isNpc", &py_isNpc);
m.def("isNpcActionFinished", &py_isNpcActionFinished);
m.def("npcAttackMelee", &py_npcAttackMelee);
m.def("npcAttackRanged", &py_npcAttackRanged);
m.def("npcSpellCast", &py_npcSpellCast);
m.def("npcUseClosestMob", &py_npcUseClosestMob);
// m.def("pushNpcAction", &py_pushNpcAction);
m.def("setNpcHostPlayer", &py_setNpcHostPlayer);
m.def("addBan", &py_addBan);
m.def("applyPlayerOverlay", &py_applyPlayerOverlay);
m.def("ban", &py_ban, py::arg(), py::arg() = 0, py::arg());
m.def("drawWeapon", &py_drawWeapon);
m.def("equipItem", &py_equipItem, py::arg(), py::arg(), py::arg() = -1);
m.def("getPlayerAmulet", &py_getPlayerAmulet);
m.def("getPlayerAngle", &py_getPlayerAngle);
m.def("getPlayerAni", &py_getPlayerAni);
m.def("getPlayerArmor", &py_getPlayerArmor);
m.def("getPlayerAtVector", &py_getPlayerAtVector);
m.def("getPlayerBelt", &py_getPlayerBelt);
m.def("getPlayerCameraPosition",&py_getPlayerCameraPosition);
m.def("getPlayerCollision", &py_getPlayerCollision);
m.def("getPlayerColor", &py_getPlayerColor);
m.def("getPlayerContext", &py_getPlayerContext);
m.def("getPlayerDexterity", &py_getPlayerDexterity);
m.def("getPlayerFaceAnis", &py_getPlayerFaceAnis);
m.def("getPlayerFatness", &py_getPlayerFatness);
m.def("getPlayerFocus", &py_getPlayerFocus);
m.def("getPlayerHealth", &py_getPlayerHealth);
m.def("getPlayerHelmet", &py_getPlayerHelmet);
m.def("getPlayerIP", &py_getPlayerIP);
m.def("getPlayerInstance", &py_getPlayerInstance);
m.def("getPlayerMacAddr", &py_getPlayerMacAddr);
m.def("getPlayerMana", &py_getPlayerMana);
m.def("getPlayerMaxHealth", &py_getPlayerMaxHealth);
m.def("getPlayerMaxMana", &py_getPlayerMaxMana);
m.def("getPlayerMeleeWeapon", &py_getPlayerMeleeWeapon);
m.def("getPlayerName", &py_getPlayerName);
m.def("getPlayerPing", &py_getPlayerPing);
m.def("getPlayerPosition", &py_getPlayerPosition);
m.def("getPlayerRangedWeapon", &py_getPlayerRangedWeapon);
m.def("getPlayerRespawnTime", &py_getPlayerRespawnTime);
m.def("getPlayerRing", &py_getPlayerRing);
m.def("getPlayerScale", &py_getPlayerScale);
m.def("getPlayerSerial", &py_getPlayerSerial);
m.def("getPlayerShield", &py_getPlayerShield);
m.def("getPlayerSkillWeapon", &py_getPlayerSkillWeapon);
m.def("getPlayerSpell", &py_getPlayerSpell);
m.def("getPlayerStrength", &py_getPlayerStrength);
m.def("getPlayerTalent", &py_getPlayerTalent);
m.def("getPlayerVirtualWorld", &py_getPlayerVirtualWorld);
m.def("getPlayerVisual", &py_getPlayerVisual);
m.def("getPlayerWeaponMode", &py_getPlayerWeaponMode);
m.def("getPlayerWorld", &py_getPlayerWorld);
m.def("giveItem", &py_giveItem);
m.def("hitPlayer", &py_hitPlayer);
m.def("isPlayerConnected", &py_isPlayerConnected);
m.def("isPlayerDead", &py_isPlayerDead);
m.def("isPlayerUnconscious", &py_isPlayerUnconscious);
m.def("kick", &py_kick);
m.def("playAni", &py_playAni);
m.def("playFaceAni", &py_playFaceAni);
m.def("readySpell", &py_readySpell);
m.def("removeItem", &py_removeItem);
m.def("removePlayerOverlay", &py_removePlayerOverlay);
m.def("removeWeapon", &py_removeWeapon);
m.def("respawnPlayer", &py_respawnPlayer);
m.def("setPlayerAngle", &py_setPlayerAngle);
m.def("setPlayerCollision", &py_setPlayerCollision);
m.def("setPlayerColor", &py_setPlayerColor);
m.def("setPlayerContext", &py_setPlayerContext);
m.def("setPlayerDexterity", &py_setPlayerDexterity);
m.def("setPlayerFatness", &py_setPlayerFatness);
m.def("setPlayerHealth", &py_setPlayerHealth);
m.def("setPlayerInstance", &py_setPlayerInstance);
m.def("setPlayerInvisible", &py_setPlayerInvisible);
m.def("setPlayerMana", &py_setPlayerMana);
m.def("setPlayerMaxHealth", &py_setPlayerMaxHealth);
m.def("setPlayerMaxMana", &py_setPlayerMaxMana);
m.def("setPlayerName", &py_setPlayerName);
m.def("setPlayerPosition", &py_setPlayerPosition);
m.def("setPlayerRespawnTime", &py_setPlayerRespawnTime);
m.def("setPlayerScale", &py_setPlayerScale);
m.def("setPlayerSkillWeapon", &py_setPlayerSkillWeapon);
m.def("setPlayerStrength", &py_setPlayerStrength);
m.def("setPlayerTalent", &py_setPlayerTalent);
m.def("setPlayerVirtualWorld", &py_setPlayerVirtualWorld);
m.def("setPlayerVisual", &py_setPlayerVisual);
m.def("setPlayerWeaponMode", &py_setPlayerWeaponMode);
m.def("setPlayerWorld", &py_setPlayerWorld);
m.def("spawnPlayer", &py_spawnPlayer);
m.def("stopAni", &py_stopAni, py::arg(), py::arg() = "");
m.def("stopFaceAni", &py_stopFaceAni, py::arg(), py::arg() = "");
m.def("unequipItem", &py_unequipItem);
m.def("unreadySpell", &py_unreadySpell);
m.def("unspawnPlayer", &py_unspawnPlayer);
m.def("useItem", &py_useItem);
m.def("useItemToState", &py_useItemToState);
m.def("findNearbyPlayers", &py_findNearbyPlayers);
m.def("getSpawnedPlayersForPlayer", &py_getSpawnedPlayersForPlayer);
m.def("getStreamedPlayersByPlayer", &py_getStreamedPlayersByPlayer);
m.def("getNearestWaypoint", &py_getNearestWaypoint);
m.def("getWaypoint", &py_getWaypoint);
}

2
src/classes/sq/Daedalus.h
View File

@@ -14,7 +14,7 @@ namespace nonut
Function<Int, String> index;
Function<SqDict, String> symbol;
Function<SqDict, String> instance;
Function<SqDict, String> instance;
private:

60
src/events/sqevents_player.cpp
View File

@@ -270,7 +270,9 @@ SQInteger sq_onPlayerShoot(HSQUIRRELVM vm)
const SQChar* munition;
nonut::sqGetValue(vm, 2, &playerid);
nonut::sqGetValue(vm, 3, &munition);
if (sq_gettype(vm, 3) != OT_NULL)
nonut::sqGetValue(vm, 3, &munition);
py::dict kwargs = py::dict("playerid"_a=playerid, "munition"_a=munition);
callEvent("onPlayerShoot", kwargs);
@@ -284,7 +286,8 @@ SQInteger sq_onPlayerSpellCast(HSQUIRRELVM vm)
const SQChar* instance;
nonut::sqGetValue(vm, 2, &playerid);
nonut::sqGetValue(vm, 3, &instance);
if (sq_gettype(vm, 3) != OT_NULL)
nonut::sqGetValue(vm, 3, &instance);
py::dict kwargs = py::dict("playerid"_a=playerid, "instance"_a=instance);
callEvent("onPlayerSpellCast", kwargs);
@@ -298,7 +301,8 @@ SQInteger sq_onPlayerSpellSetup(HSQUIRRELVM vm)
const SQChar* instance;
nonut::sqGetValue(vm, 2, &playerid);
nonut::sqGetValue(vm, 3, &instance);
if (sq_gettype(vm, 3) != OT_NULL)
nonut::sqGetValue(vm, 3, &instance);
py::dict kwargs = py::dict("playerid"_a=playerid, "instance"_a=instance);
callEvent("onPlayerSpellSetup", kwargs);
@@ -355,10 +359,11 @@ SQInteger sq_onPlayerToggleFaceAni(HSQUIRRELVM vm)
SQInteger sq_onPlayerEquipAmulet(HSQUIRRELVM vm)
{
SQInteger playerid;
const SQChar* instance;
const SQChar* instance = "";
nonut::sqGetValue(vm, 2, &playerid);
nonut::sqGetValue(vm, 3, &instance);
if (sq_gettype(vm, 3) != OT_NULL)
nonut::sqGetValue(vm, 3, &instance);
py::dict kwargs = py::dict("playerid"_a=playerid, "instance"_a=instance);
callEvent("onPlayerEquipAmulet", kwargs);
@@ -369,10 +374,11 @@ SQInteger sq_onPlayerEquipAmulet(HSQUIRRELVM vm)
SQInteger sq_onPlayerEquipArmor(HSQUIRRELVM vm)
{
SQInteger playerid;
const SQChar* instance;
const SQChar* instance = "";
nonut::sqGetValue(vm, 2, &playerid);
nonut::sqGetValue(vm, 3, &instance);
if (sq_gettype(vm, 3) != OT_NULL)
nonut::sqGetValue(vm, 3, &instance);
py::dict kwargs = py::dict("playerid"_a=playerid, "instance"_a=instance);
callEvent("onPlayerEquipArmor", kwargs);
@@ -383,10 +389,11 @@ SQInteger sq_onPlayerEquipArmor(HSQUIRRELVM vm)
SQInteger sq_onPlayerEquipBelt(HSQUIRRELVM vm)
{
SQInteger playerid;
const SQChar* instance;
const SQChar* instance = "";
nonut::sqGetValue(vm, 2, &playerid);
nonut::sqGetValue(vm, 3, &instance);
if (sq_gettype(vm, 3) != OT_NULL)
nonut::sqGetValue(vm, 3, &instance);
py::dict kwargs = py::dict("playerid"_a=playerid, "instance"_a=instance);
callEvent("onPlayerEquipBelt", kwargs);
@@ -397,11 +404,12 @@ SQInteger sq_onPlayerEquipBelt(HSQUIRRELVM vm)
SQInteger sq_onPlayerEquipHandItem(HSQUIRRELVM vm)
{
SQInteger playerid, hand;
const SQChar* instance;
const SQChar* instance = "";
nonut::sqGetValue(vm, 2, &playerid);
nonut::sqGetValue(vm, 3, &hand);
nonut::sqGetValue(vm, 4, &instance);
if (sq_gettype(vm, 4) != OT_NULL)
nonut::sqGetValue(vm, 4, &instance);
py::dict kwargs = py::dict("playerid"_a=playerid, "hand"_a = hand, "instance"_a=instance);
callEvent("onPlayerEquipHandItem", kwargs);
@@ -412,10 +420,11 @@ SQInteger sq_onPlayerEquipHandItem(HSQUIRRELVM vm)
SQInteger sq_onPlayerEquipHelmet(HSQUIRRELVM vm)
{
SQInteger playerid;
const SQChar* instance;
const SQChar* instance = "";
nonut::sqGetValue(vm, 2, &playerid);
nonut::sqGetValue(vm, 3, &instance);
if (sq_gettype(vm, 3) != OT_NULL)
nonut::sqGetValue(vm, 3, &instance);
py::dict kwargs = py::dict("playerid"_a=playerid, "instance"_a=instance);
callEvent("onPlayerEquipHelmet", kwargs);
@@ -426,10 +435,11 @@ SQInteger sq_onPlayerEquipHelmet(HSQUIRRELVM vm)
SQInteger sq_onPlayerEquipMeleeWeapon(HSQUIRRELVM vm)
{
SQInteger playerid;
const SQChar* instance;
const SQChar* instance = "";
nonut::sqGetValue(vm, 2, &playerid);
nonut::sqGetValue(vm, 3, &instance);
if (sq_gettype(vm, 3) != OT_NULL)
nonut::sqGetValue(vm, 3, &instance);
py::dict kwargs = py::dict("playerid"_a=playerid, "instance"_a=instance);
callEvent("onPlayerEquipMeleeWeapon", kwargs);
@@ -440,10 +450,11 @@ SQInteger sq_onPlayerEquipMeleeWeapon(HSQUIRRELVM vm)
SQInteger sq_onPlayerEquipRangedWeapon(HSQUIRRELVM vm)
{
SQInteger playerid;
const SQChar* instance;
const SQChar* instance = "";
nonut::sqGetValue(vm, 2, &playerid);
nonut::sqGetValue(vm, 3, &instance);
if (sq_gettype(vm, 3) != OT_NULL)
nonut::sqGetValue(vm, 3, &instance);
py::dict kwargs = py::dict("playerid"_a=playerid, "instance"_a=instance);
callEvent("onPlayerEquipRangedWeapon", kwargs);
@@ -454,11 +465,12 @@ SQInteger sq_onPlayerEquipRangedWeapon(HSQUIRRELVM vm)
SQInteger sq_onPlayerEquipRing(HSQUIRRELVM vm)
{
SQInteger playerid, hand;
const SQChar* instance;
const SQChar* instance = "";
nonut::sqGetValue(vm, 2, &playerid);
nonut::sqGetValue(vm, 3, &hand);
nonut::sqGetValue(vm, 4, &instance);
if (sq_gettype(vm, 4) != OT_NULL)
nonut::sqGetValue(vm, 4, &instance);
py::dict kwargs = py::dict("playerid"_a=playerid, "hand"_a = hand, "instance"_a=instance);
callEvent("onPlayerEquipRing", kwargs);
@@ -469,10 +481,11 @@ SQInteger sq_onPlayerEquipRing(HSQUIRRELVM vm)
SQInteger sq_onPlayerEquipShield(HSQUIRRELVM vm)
{
SQInteger playerid;
const SQChar* instance;
const SQChar* instance = "";
nonut::sqGetValue(vm, 2, &playerid);
nonut::sqGetValue(vm, 3, &instance);
if (sq_gettype(vm, 3) != OT_NULL)
nonut::sqGetValue(vm, 3, &instance);
py::dict kwargs = py::dict("playerid"_a=playerid, "instance"_a=instance);
callEvent("onPlayerEquipShield", kwargs);
@@ -483,11 +496,12 @@ SQInteger sq_onPlayerEquipShield(HSQUIRRELVM vm)
SQInteger sq_onPlayerEquipSpell(HSQUIRRELVM vm)
{
SQInteger playerid, slotId;
const SQChar* instance;
const SQChar* instance = "";
nonut::sqGetValue(vm, 2, &playerid);
nonut::sqGetValue(vm, 3, &slotId);
nonut::sqGetValue(vm, 4, &instance);
if (sq_gettype(vm, 4) != OT_NULL)
nonut::sqGetValue(vm, 4, &instance);
py::dict kwargs = py::dict("playerid"_a=playerid, "slotId"_a = slotId, "instance"_a=instance);
callEvent("onPlayerEquipSpell", kwargs);

185
src/functions/pyfunctions.cpp Normal file
View File

@@ -0,0 +1,185 @@
#include <sqapi.h>
#include <pybind11/embed.h>
#include "pyfunctions.h"
#include "sqfunctions.h"
#include "classes/Dictionary.h"
#include <NoNut/core/CustomTypes.h>
namespace py = pybind11;
#define SERVERFUNC nonut::ServerFunctions::getInstance()
std::string py_getHostname() { return SERVERFUNC->getHostname(); }
int py_getMaxSlots() { return SERVERFUNC->getMaxSlots(); }
int py_getPlayersCount() { return SERVERFUNC->getPlayersCount(); }
float py_getDistance2d(float x1, float y1, float x2, float y2) { return SERVERFUNC->getDistance2d(x1, y1, x2, y2); }
float py_getDistance3d(float x1, float y1, float z1, float x2, float y2, float z2) { return SERVERFUNC->getDistance3d(x1, y1, z1, x2, y2, z2); }
float py_getVectorAngle(float x1, float y1, float x2, float y2) { return SERVERFUNC->getVectorAngle(x1, y1, x2, y2); }
void py_sendMessageToAll(int r, int g, int b, std::string text) { return SERVERFUNC->sendMessageToAll(r, g, b, text); }
void py_sendMessageToPlayer(int id, int r, int g, int b, std::string text) { return SERVERFUNC->sendMessageToPlayer(id, r, g, b, text); }
void py_sendPlayerMessageToAll(int id, int r, int g, int b, std::string text) { return SERVERFUNC->sendPlayerMessageToAll(id, r, g, b, text); }
void py_sendPlayerMessageToPlayer(int id, int to, int r, int g, int b, std::string text) { return SERVERFUNC->sendPlayerMessageToPlayer(id, to, r, g, b, text); }
void py_exit(int code) { return SERVERFUNC->exit(code); }
float py_getDayLength() { return SERVERFUNC->getDayLength(); }
std::string py_getServerDescription() { return SERVERFUNC->getServerDescription(); }
std::string py_getServerWorld() { return SERVERFUNC->getServerWorld(); }
py::dict py_getTime() { return SERVERFUNC->getTime().data; }
void py_serverLog(std::string text) { return SERVERFUNC->serverLog(text); }
void py_setDayLength(float ms) { return SERVERFUNC->setDayLength(ms); }
bool py_setServerDescription(std::string text) { return SERVERFUNC->setServerDescription(text); }
void py_setServerWorld(std::string text) { return SERVERFUNC->setServerWorld(text); }
void py_setTime(int h, int m, int d) { return SERVERFUNC->setTime(h, m, d); }
void py_clearNpcActions(int npc_id) { return SERVERFUNC->clearNpcActions(npc_id); }
int py_createNpc(std::string name, std::string instance) { return SERVERFUNC->createNpc(name, instance); }
bool py_destroyNpc(int npc_id) { return SERVERFUNC->destroyNpc(npc_id); }
py::dict py_getNpcAction(int npc_id, int index) { return SERVERFUNC->getNpcAction(npc_id, index).data; }
// ??? py_getNpcActionType
py::list py_getNpcActions(int npc_id) { return SERVERFUNC->getNpcActions(npc_id).data; }
int py_getNpcActionsCount(int npc_id) { return SERVERFUNC->getNpcActionsCount(npc_id); }
int py_getNpcHostPlayer(int npc_id) { return SERVERFUNC->getNpcHostPlayer(npc_id); }
int py_getNpcLastActionId(int npc_id) { return SERVERFUNC->getNpcLastActionId(npc_id); }
bool py_isNpc(int npc_id) { return SERVERFUNC->isNpc(npc_id); }
bool py_isNpcActionFinished(int npc_id, int action_id) { return SERVERFUNC->isNpcActionFinished(npc_id, action_id); }
void py_npcAttackMelee(int a_id, int e_id, int a_type, int combo) { return SERVERFUNC->npcAttackMelee(a_id, e_id, a_type, combo); }
void py_npcAttackRanged(int a_id, int e_id) { return SERVERFUNC->npcAttackRanged(a_id, e_id); }
void py_npcSpellCast(int a_id, int e_id) { return SERVERFUNC->npcSpellCast(a_id, e_id); }
void py_npcUseClosestMob(int npc_id, std::string sceme, int target_state) { return SERVERFUNC->npcUseClosestMob(npc_id, sceme, target_state); }
//??? py_pushNpcAction
bool py_setNpcHostPlayer(int npc_id, int host_id) { return SERVERFUNC->setNpcHostPlayer(npc_id, host_id); }
bool py_addBan(py::dict info)
{
Sqrat::Table* pTable = PyDictionary::toSqObject(info);
nonut::Int result = SERVERFUNC->addBan(pTable->GetObject());
delete pTable;
return result;
}
bool py_applyPlayerOverlay(int id, int overlayId) { return SERVERFUNC->applyPlayerOverlay(id, overlayId); }
void py_ban(int id, int minutes, std::string reason) { return SERVERFUNC->ban(id, minutes, reason); }
void py_drawWeapon(int id, int weaponMode) { return SERVERFUNC->drawWeapon(id, weaponMode); }
void py_equipItem(int id, std::string instance, int slotId) { return SERVERFUNC->equipItem(id, instance, slotId); }
std::string py_getPlayerAmulet(int id) { return SERVERFUNC->getPlayerAmulet(id); }
float py_getPlayerAngle(int id) { return SERVERFUNC->getPlayerAngle(id); }
std::string py_getPlayerAni(int id) { return SERVERFUNC->getPlayerAni(id); }
std::string py_getPlayerArmor(int id) { return SERVERFUNC->getPlayerArmor(id); }
py::dict py_getPlayerAtVector(int id)
{
py::dict result;
nonut::Position3d pos = SERVERFUNC->getPlayerAtVector(id);
result["x"] = pos.x;
result["y"] = pos.y;
result["z"] = pos.z;
return result;
}
std::string py_getPlayerBelt(int id) { return SERVERFUNC->getPlayerBelt(id); }
py::dict py_getPlayerCameraPosition(int id)
{
py::dict result;
nonut::Position3d pos = SERVERFUNC->getPlayerCameraPosition(id);
result["x"] = pos.x;
result["y"] = pos.y;
result["z"] = pos.z;
return result;
}
bool py_getPlayerCollision(int id) { return SERVERFUNC->getPlayerCollision(id); }
py::dict py_getPlayerColor(int id)
{
py::dict result;
nonut::Color pos = SERVERFUNC->getPlayerColor(id);
result["r"] = pos.r;
result["g"] = pos.g;
result["b"] = pos.b;
return result;
}
int py_getPlayerContext(int id, int type) { return SERVERFUNC->getPlayerContext(id, type); }
int py_getPlayerDexterity(int id) { return SERVERFUNC->getPlayerDexterity(id); }
py::list py_getPlayerFaceAnis(int id) { return SERVERFUNC->getPlayerFaceAnis(id).data; }
float py_getPlayerFatness(int id) { return SERVERFUNC->getPlayerFatness(id); }
int py_getPlayerFocus(int id) { return SERVERFUNC->getPlayerFocus(id); }
int py_getPlayerHealth(int id) { return SERVERFUNC->getPlayerHealth(id); }
std::string py_getPlayerHelmet(int id) { return SERVERFUNC->getPlayerHelmet(id); }
std::string py_getPlayerIP(int id) { return SERVERFUNC->getPlayerIP(id); }
std::string py_getPlayerInstance(int id) { return SERVERFUNC->getPlayerInstance(id); }
std::string py_getPlayerMacAddr(int id) { return SERVERFUNC->getPlayerMacAddr(id); }
int py_getPlayerMana(int id) { return SERVERFUNC->getPlayerMana(id); }
int py_getPlayerMaxHealth(int id) { return SERVERFUNC->getPlayerMaxHealth(id); }
int py_getPlayerMaxMana(int id) { return SERVERFUNC->getPlayerMaxMana(id); }
std::string py_getPlayerMeleeWeapon(int id) { return SERVERFUNC->getPlayerMeleeWeapon(id); }
std::string py_getPlayerName(int id) { return SERVERFUNC->getPlayerName(id); }
int py_getPlayerPing(int id) { return SERVERFUNC->getPlayerPing(id); }
py::dict py_getPlayerPosition(int id) { return SERVERFUNC->getPlayerPosition(id).data; }
std::string py_getPlayerRangedWeapon(int id) { return SERVERFUNC->getPlayerRangedWeapon(id); }
int py_getPlayerRespawnTime(int id) { return SERVERFUNC->getPlayerRespawnTime(id); }
std::string py_getPlayerRing(int id, int handId) { return SERVERFUNC->getPlayerRing(id, handId); }
py::dict py_getPlayerScale(int id) { return SERVERFUNC->getPlayerScale(id).data; }
std::string py_getPlayerSerial(int id) { return SERVERFUNC->getPlayerSerial(id); }
std::string py_getPlayerShield(int id) { return SERVERFUNC->getPlayerShield(id); }
int py_getPlayerSkillWeapon(int id, int skillId) { return SERVERFUNC->getPlayerSkillWeapon(id, skillId); }
std::string py_getPlayerSpell(int id, int slotId) { return SERVERFUNC->getPlayerSpell(id, slotId); }
int py_getPlayerStrength(int id) { return SERVERFUNC->getPlayerStrength(id); }
int py_getPlayerTalent(int id, int talentId) { return SERVERFUNC->getPlayerTalent(id, talentId); }
int py_getPlayerVirtualWorld(int id) { return SERVERFUNC->getPlayerVirtualWorld(id); }
py::dict py_getPlayerVisual(int id) { return SERVERFUNC->getPlayerVisual(id).data; }
int py_getPlayerWeaponMode(int id) { return SERVERFUNC->getPlayerWeaponMode(id); }
std::string py_getPlayerWorld(int id) { return SERVERFUNC->getPlayerWorld(id); }
void py_giveItem(int id, std::string instance, int amount) { return SERVERFUNC->giveItem(id, instance, amount); }
bool py_hitPlayer(int id, int targetid) { return SERVERFUNC->hitPlayer(id, targetid); }
bool py_isPlayerConnected(int id) { return SERVERFUNC->isPlayerConnected(id); }
bool py_isPlayerDead(int id) { return SERVERFUNC->isPlayerDead(id); }
bool py_isPlayerUnconscious(int id) { return SERVERFUNC->isPlayerUnconscious(id); }
void py_kick(int id, std::string reason) { return SERVERFUNC->kick(id, reason); }
void py_playAni(int id, std::string aniName) { return SERVERFUNC->playAni(id, aniName); }
void py_playFaceAni(int id, std::string aniName) { return SERVERFUNC->playFaceAni(id, aniName); }
void py_readySpell(int id, int slotId, int manaInvested) { return SERVERFUNC->readySpell(id, slotId, manaInvested); }
void py_removeItem(int id, std::string instance, int amount) { return SERVERFUNC->removeItem(id, instance, amount); }
bool py_removePlayerOverlay(int id, int overlayId) { return SERVERFUNC->removePlayerOverlay(id, overlayId); }
void py_removeWeapon(int id) { return SERVERFUNC->removeWeapon(id); }
void py_respawnPlayer(int id) { return SERVERFUNC->respawnPlayer(id); }
void py_setPlayerAngle(int id, float angle) { return SERVERFUNC->setPlayerAngle(id, angle); }
void py_setPlayerCollision(int id, bool collision) { return SERVERFUNC->setPlayerCollision(id, collision); }
void py_setPlayerColor(int id, int r, int g, int b) { return SERVERFUNC->setPlayerColor(id, r, g, b); }
void py_setPlayerContext(int id, int type, int value) { return SERVERFUNC->setPlayerContext(id, type, value); }
void py_setPlayerDexterity(int id, int dexterity) { return SERVERFUNC->setPlayerDexterity(id, dexterity); }
void py_setPlayerFatness(int id, float fatness) { return SERVERFUNC->setPlayerFatness(id, fatness); }
void py_setPlayerHealth(int id, int health) { return SERVERFUNC->setPlayerHealth(id, health); }
void py_setPlayerInstance(int id, std::string instance) { return SERVERFUNC->setPlayerInstance(id, instance); }
void py_setPlayerInvisible(int id, bool toggle) { return SERVERFUNC->setPlayerInvisible(id, toggle); }
void py_setPlayerMana(int id, int mana) { return SERVERFUNC->setPlayerMana(id, mana); }
void py_setPlayerMaxHealth(int id, int maxHealth) { return SERVERFUNC->setPlayerMaxHealth(id, maxHealth); }
void py_setPlayerMaxMana(int id, int maxMana) { return SERVERFUNC->setPlayerMaxMana(id, maxMana); }
void py_setPlayerName(int id, std::string name) { return SERVERFUNC->setPlayerName(id, name); }
void py_setPlayerPosition(int id, float x, float y, float z) { return SERVERFUNC->setPlayerPosition(id, x, y, z); }
void py_setPlayerRespawnTime(int id, int respawnTime) { return SERVERFUNC->setPlayerRespawnTime(id, respawnTime); }
void py_setPlayerScale(int id, float x, float y, float z) { return SERVERFUNC->setPlayerScale(id, x, y, z); }
void py_setPlayerSkillWeapon(int id, int skillId, int percentage) { return SERVERFUNC->setPlayerSkillWeapon(id, skillId, percentage); }
void py_setPlayerStrength(int id, int strength) { return SERVERFUNC->setPlayerStrength(id, strength); }
void py_setPlayerTalent(int id, int talentId, int talentValue) { return SERVERFUNC->setPlayerTalent(id, talentId, talentValue); }
void py_setPlayerVirtualWorld(int id, int virtualWorld) { return SERVERFUNC->setPlayerVirtualWorld(id, virtualWorld); }
void py_setPlayerVisual(int id, std::string bMdl, int bTxt, std::string hMdl, int hTxt) { return SERVERFUNC->setPlayerVisual(id, bMdl, bTxt, hMdl, hTxt); }
void py_setPlayerWeaponMode(int id, int weaponMode) { return SERVERFUNC->setPlayerWeaponMode(id, weaponMode); }
void py_setPlayerWorld(int id, std::string world, std::string startPointName) { return SERVERFUNC->setPlayerWorld(id, world, startPointName); }
void py_spawnPlayer(int id) { return SERVERFUNC->spawnPlayer(id); }
void py_stopAni(int id, std::string aniName) { return SERVERFUNC->stopAni(id, aniName); }
void py_stopFaceAni(int id, std::string aniName) { return SERVERFUNC->stopFaceAni(id, aniName); }
void py_unequipItem(int id, std::string instance) { return SERVERFUNC->unequipItem(id, instance); }
void py_unreadySpell(int id) { return SERVERFUNC->unreadySpell(id); }
void py_unspawnPlayer(int id) { return SERVERFUNC->unspawnPlayer(id); }
void py_useItem(int id, std::string instance) { return SERVERFUNC->useItem(id, instance); }
void py_useItemToState(int id, std::string instance, int state) { return SERVERFUNC->useItemToState(id, instance, state); }
py::list py_findNearbyPlayers(py::dict position, int radius, std::string world, int vWorld)
{
Sqrat::Table* pTable = PyDictionary::toSqObject(position);
py::list result = SERVERFUNC->findNearbyPlayers(pTable->GetObject(), radius, world, vWorld).data;
delete pTable;
return result;
}
py::list py_getSpawnedPlayersForPlayer(int id) { return SERVERFUNC->getSpawnedPlayersForPlayer(id).data; }
py::list py_getStreamedPlayersByPlayer(int id) { return SERVERFUNC->getStreamedPlayersByPlayer(id).data; }
py::dict py_getNearestWaypoint(std::string world, int x, int y, int z) { return SERVERFUNC->getNearestWaypoint(world, x, y, z).data; }
py::dict py_getWaypoint(std::string world, std::string name) { return SERVERFUNC->getWaypoint(world, name).data; }

146
src/functions/pyfunctions.h Normal file
View File

@@ -0,0 +1,146 @@
#ifndef _PYFUNCTIONS_
#define _PYFUNCTIONS_
#include <pybind11/embed.h>
namespace py = pybind11;
// Shared functions
std::string py_getHostname();
int py_getMaxSlots();
int py_getPlayersCount();
float py_getDistance2d(float, float, float, float);
float py_getDistance3d(float, float, float, float, float, float);
float py_getVectorAngle(float, float, float, float);
void py_sendMessageToAll(int, int, int, std::string);
void py_sendMessageToPlayer(int, int, int, int, std::string);
void py_sendPlayerMessageToAll(int, int, int, int, std::string);
void py_sendPlayerMessageToPlayer(int, int, int, int, int, std::string);
void py_exit(int);
float py_getDayLength();
std::string py_getServerDescription();
std::string py_getServerWorld();
py::dict py_getTime();
void py_serverLog(std::string);
void py_setDayLength(float);
bool py_setServerDescription(std::string);
void py_setServerWorld(std::string);
void py_setTime(int, int, int);
void py_clearNpcActions(int);
int py_createNpc(std::string, std::string);
bool py_destroyNpc(int);
py::dict py_getNpcAction(int, int);
// ??? py_getNpcActionType
py::list py_getNpcActions(int);
int py_getNpcActionsCount(int);
int py_getNpcHostPlayer(int);
int py_getNpcLastActionId(int);
bool py_isNpc(int);
bool py_isNpcActionFinished(int, int);
void py_npcAttackMelee(int, int, int, int);
void py_npcAttackRanged(int, int);
void py_npcSpellCast(int, int);
void py_npcUseClosestMob(int, std::string, int);
//??? py_pushNpcAction
bool py_setNpcHostPlayer(int, int);
bool py_addBan(py::dict);
bool py_applyPlayerOverlay(int, int);
void py_ban(int, int, std::string);
void py_drawWeapon(int, int);
void py_equipItem(int, std::string, int);
std::string py_getPlayerAmulet(int);
float py_getPlayerAngle(int);
std::string py_getPlayerAni(int);
std::string py_getPlayerArmor(int);
py::dict py_getPlayerAtVector(int);
std::string py_getPlayerBelt(int);
py::dict py_getPlayerCameraPosition(int);
bool py_getPlayerCollision(int);
py::dict py_getPlayerColor(int);
int py_getPlayerContext(int, int);
int py_getPlayerDexterity(int);
py::list py_getPlayerFaceAnis(int);
float py_getPlayerFatness(int);
int py_getPlayerFocus(int);
int py_getPlayerHealth(int);
std::string py_getPlayerHelmet(int);
std::string py_getPlayerIP(int);
std::string py_getPlayerInstance(int);
std::string py_getPlayerMacAddr(int);
int py_getPlayerMana(int);
int py_getPlayerMaxHealth(int);
int py_getPlayerMaxMana(int);
std::string py_getPlayerMeleeWeapon(int);
std::string py_getPlayerName(int);
int py_getPlayerPing(int);
py::dict py_getPlayerPosition(int);
std::string py_getPlayerRangedWeapon(int);
int py_getPlayerRespawnTime(int);
std::string py_getPlayerRing(int, int);
py::dict py_getPlayerScale(int);
std::string py_getPlayerSerial(int);
std::string py_getPlayerShield(int);
int py_getPlayerSkillWeapon(int, int);
std::string py_getPlayerSpell(int, int);
int py_getPlayerStrength(int);
int py_getPlayerTalent(int, int);
int py_getPlayerVirtualWorld(int);
py::dict py_getPlayerVisual(int);
int py_getPlayerWeaponMode(int);
std::string py_getPlayerWorld(int);
void py_giveItem(int, std::string, int);
bool py_hitPlayer(int, int);
bool py_isPlayerConnected(int);
bool py_isPlayerDead(int);
bool py_isPlayerUnconscious(int);
void py_kick(int, std::string);
void py_playAni(int, std::string);
void py_playFaceAni(int, std::string);
void py_readySpell(int, int, int);
void py_removeItem(int, std::string, int);
bool py_removePlayerOverlay(int, int);
void py_removeWeapon(int);
void py_respawnPlayer(int);
void py_setPlayerAngle(int, float);
void py_setPlayerCollision(int, bool);
void py_setPlayerColor(int, int, int, int);
void py_setPlayerContext(int, int, int);
void py_setPlayerDexterity(int, int);
void py_setPlayerFatness(int, float);
void py_setPlayerHealth(int, int);
void py_setPlayerInstance(int, std::string);
void py_setPlayerInvisible(int, bool);
void py_setPlayerMana(int, int);
void py_setPlayerMaxHealth(int, int);
void py_setPlayerMaxMana(int, int);
void py_setPlayerName(int, std::string);
void py_setPlayerPosition(int, float, float, float);
void py_setPlayerRespawnTime(int, int);
void py_setPlayerScale(int, float, float, float);
void py_setPlayerSkillWeapon(int, int, int);
void py_setPlayerStrength(int, int);
void py_setPlayerTalent(int, int, int);
void py_setPlayerVirtualWorld(int, int);
void py_setPlayerVisual(int, std::string, int, std::string, int);
void py_setPlayerWeaponMode(int, int);
void py_setPlayerWorld(int, std::string, std::string);
void py_spawnPlayer(int);
void py_stopAni(int, std::string);
void py_stopFaceAni(int, std::string);
void py_unequipItem(int, std::string);
void py_unreadySpell(int);
void py_unspawnPlayer(int);
void py_useItem(int, std::string);
void py_useItemToState(int, std::string, int);
py::list py_findNearbyPlayers(py::dict, int, std::string, int);
py::list py_getSpawnedPlayersForPlayer(int);
py::list py_getStreamedPlayersByPlayer(int);
py::dict py_getNearestWaypoint(std::string, int, int, int);
py::dict py_getWaypoint(std::string, std::string);
#endif

154
src/functions/sqfunctions.cpp Normal file
View File

@@ -0,0 +1,154 @@
#include <sqapi.h>
#include "sqfunctions.h"
namespace nonut
{
ServerFunctions::ServerFunctions() :
FUNCTION_CTOR(getMaxSlots),
FUNCTION_CTOR(getHostname),
FUNCTION_CTOR(getPlayersCount),
FUNCTION_CTOR(getDistance2d),
FUNCTION_CTOR(getDistance3d),
FUNCTION_CTOR(getVectorAngle),
FUNCTION_CTOR(sendMessageToAll),
FUNCTION_CTOR(sendMessageToPlayer),
FUNCTION_CTOR(sendPlayerMessageToAll),
FUNCTION_CTOR(sendPlayerMessageToPlayer),
FUNCTION_CTOR(exit),
FUNCTION_CTOR(getDayLength),
FUNCTION_CTOR(getServerDescription),
FUNCTION_CTOR(getServerWorld),
FUNCTION_CTOR(getTime),
FUNCTION_CTOR(serverLog),
FUNCTION_CTOR(setDayLength),
FUNCTION_CTOR(setServerDescription),
FUNCTION_CTOR(setServerWorld),
FUNCTION_CTOR(setTime),
FUNCTION_CTOR(clearNpcActions),
FUNCTION_CTOR(createNpc),
FUNCTION_CTOR(destroyNpc),
FUNCTION_CTOR(getNpcAction),
//FUNCTION_CTOR(getNpcActionType),
FUNCTION_CTOR(getNpcActions),
FUNCTION_CTOR(getNpcActionsCount),
FUNCTION_CTOR(getNpcHostPlayer),
FUNCTION_CTOR(getNpcLastActionId),
FUNCTION_CTOR(isNpc),
FUNCTION_CTOR(isNpcActionFinished),
FUNCTION_CTOR(npcAttackMelee),
FUNCTION_CTOR(npcAttackRanged),
FUNCTION_CTOR(npcSpellCast),
FUNCTION_CTOR(npcUseClosestMob),
//FUNCTION_CTOR(pushNpcAction),
FUNCTION_CTOR(setNpcHostPlayer),
FUNCTION_CTOR(addBan),
FUNCTION_CTOR(applyPlayerOverlay),
FUNCTION_CTOR(ban),
FUNCTION_CTOR(drawWeapon),
FUNCTION_CTOR(equipItem),
FUNCTION_CTOR(getPlayerAmulet),
FUNCTION_CTOR(getPlayerAngle),
FUNCTION_CTOR(getPlayerAni),
FUNCTION_CTOR(getPlayerArmor),
FUNCTION_CTOR(getPlayerAtVector),
FUNCTION_CTOR(getPlayerBelt),
FUNCTION_CTOR(getPlayerCameraPosition),
FUNCTION_CTOR(getPlayerCollision),
FUNCTION_CTOR(getPlayerColor),
FUNCTION_CTOR(getPlayerContext),
FUNCTION_CTOR(getPlayerDexterity),
FUNCTION_CTOR(getPlayerFaceAnis),
FUNCTION_CTOR(getPlayerFatness),
FUNCTION_CTOR(getPlayerFocus),
FUNCTION_CTOR(getPlayerHealth),
FUNCTION_CTOR(getPlayerHelmet),
FUNCTION_CTOR(getPlayerIP),
FUNCTION_CTOR(getPlayerInstance),
FUNCTION_CTOR(getPlayerMacAddr),
FUNCTION_CTOR(getPlayerMana),
FUNCTION_CTOR(getPlayerMaxHealth),
FUNCTION_CTOR(getPlayerMaxMana),
FUNCTION_CTOR(getPlayerMeleeWeapon),
FUNCTION_CTOR(getPlayerName),
FUNCTION_CTOR(getPlayerPing),
FUNCTION_CTOR(getPlayerPosition),
FUNCTION_CTOR(getPlayerRangedWeapon),
FUNCTION_CTOR(getPlayerRespawnTime),
FUNCTION_CTOR(getPlayerRing),
FUNCTION_CTOR(getPlayerScale),
FUNCTION_CTOR(getPlayerSerial),
FUNCTION_CTOR(getPlayerShield),
FUNCTION_CTOR(getPlayerSkillWeapon),
FUNCTION_CTOR(getPlayerSpell),
FUNCTION_CTOR(getPlayerStrength),
FUNCTION_CTOR(getPlayerTalent),
FUNCTION_CTOR(getPlayerVirtualWorld),
FUNCTION_CTOR(getPlayerVisual),
FUNCTION_CTOR(getPlayerWeaponMode),
FUNCTION_CTOR(getPlayerWorld),
FUNCTION_CTOR(giveItem),
FUNCTION_CTOR(hitPlayer),
FUNCTION_CTOR(isPlayerConnected),
FUNCTION_CTOR(isPlayerDead),
FUNCTION_CTOR(isPlayerUnconscious),
FUNCTION_CTOR(kick),
FUNCTION_CTOR(playAni),
FUNCTION_CTOR(playFaceAni),
FUNCTION_CTOR(readySpell),
FUNCTION_CTOR(removeItem),
FUNCTION_CTOR(removePlayerOverlay),
FUNCTION_CTOR(removeWeapon),
FUNCTION_CTOR(respawnPlayer),
FUNCTION_CTOR(setPlayerAngle),
FUNCTION_CTOR(setPlayerCollision),
FUNCTION_CTOR(setPlayerColor),
FUNCTION_CTOR(setPlayerContext),
FUNCTION_CTOR(setPlayerDexterity),
FUNCTION_CTOR(setPlayerFatness),
FUNCTION_CTOR(setPlayerHealth),
FUNCTION_CTOR(setPlayerInstance),
FUNCTION_CTOR(setPlayerInvisible),
FUNCTION_CTOR(setPlayerMana),
FUNCTION_CTOR(setPlayerMaxHealth),
FUNCTION_CTOR(setPlayerMaxMana),
FUNCTION_CTOR(setPlayerName),
FUNCTION_CTOR(setPlayerPosition),
FUNCTION_CTOR(setPlayerRespawnTime),
FUNCTION_CTOR(setPlayerScale),
FUNCTION_CTOR(setPlayerSkillWeapon),
FUNCTION_CTOR(setPlayerStrength),
FUNCTION_CTOR(setPlayerTalent),
FUNCTION_CTOR(setPlayerVirtualWorld),
FUNCTION_CTOR(setPlayerVisual),
FUNCTION_CTOR(setPlayerWeaponMode),
FUNCTION_CTOR(setPlayerWorld),
FUNCTION_CTOR(spawnPlayer),
FUNCTION_CTOR(stopAni),
FUNCTION_CTOR(stopFaceAni),
FUNCTION_CTOR(unequipItem),
FUNCTION_CTOR(unreadySpell),
FUNCTION_CTOR(unspawnPlayer),
FUNCTION_CTOR(useItem),
FUNCTION_CTOR(useItemToState),
FUNCTION_CTOR(findNearbyPlayers),
FUNCTION_CTOR(getSpawnedPlayersForPlayer),
FUNCTION_CTOR(getStreamedPlayersByPlayer),
FUNCTION_CTOR(getNearestWaypoint),
FUNCTION_CTOR(getWaypoint)
{}
ServerFunctions* ServerFunctions::getInstance()
{
if (instance == nullptr)
{
instance = new ServerFunctions();
}
return instance;
}
}

160
src/functions/sqfunctions.h Normal file
View File

@@ -0,0 +1,160 @@
#ifndef _SQFUNCTIONS_
#define _SQFUNCTIONS_
#include <NoNut/core/Function.h>
#include <NoNut/core/CustomTypes.h>
namespace nonut
{
class ServerFunctions
{
protected:
ServerFunctions();
static inline ServerFunctions* instance = nullptr;
public:
ServerFunctions(ServerFunctions& other) = delete;
void operator=(const ServerFunctions&) = delete;
static ServerFunctions* getInstance();
Function<String> getHostname;
Function<Int> getMaxSlots;
Function<Int> getPlayersCount;
Function<Float, Float, Float, Float, Float> getDistance2d;
Function<Float, Float, Float, Float, Float, Float, Float> getDistance3d;
Function<Float, Float, Float, Float, Float> getVectorAngle;
Function<void, Int, Int, Int, String> sendMessageToAll;
Function<void, Int, Int, Int, Int, String> sendMessageToPlayer;
Function<void, Int, Int, Int, Int, String> sendPlayerMessageToAll;
Function<void, Int, Int, Int, Int, Int, String> sendPlayerMessageToPlayer;
Function<void, Int> exit;
Function<Float> getDayLength;
Function<String> getServerDescription;
Function<String> getServerWorld;
Function<SqDict> getTime;
Function<void, String> serverLog;
Function<void, Float> setDayLength;
Function<Bool, String> setServerDescription;
Function<void, String> setServerWorld;
Function<void, Int, Int, Int> setTime;
Function<void, Int> clearNpcActions;
Function<Int, String, String> createNpc;
Function<Bool, Int> destroyNpc;
Function<SqDict, Int, Int> getNpcAction;
//Function<???> getNpcActionType;
Function<SqList, Int> getNpcActions;
Function<Int, Int> getNpcActionsCount;
Function<Int, Int> getNpcHostPlayer;
Function<Int, Int> getNpcLastActionId;
Function<Bool, Int> isNpc;
Function<Bool, Int, Int> isNpcActionFinished;
Function<void, Int, Int, Int, Int> npcAttackMelee;
Function<void, Int, Int> npcAttackRanged;
Function<void, Int, Int> npcSpellCast;
Function<void, Int, String, Int> npcUseClosestMob;
//Function<???> pushNpcAction;
Function<Bool, Int, Int> setNpcHostPlayer;
Function<Bool, SQObject> addBan;
Function<Bool, Int, Int> applyPlayerOverlay;
Function<void, Int, Int, String> ban;
Function<void, Int, Int> drawWeapon;
Function<void, Int, String, Int> equipItem;
Function<String, Int> getPlayerAmulet;
Function<Float, Int> getPlayerAngle;
Function<String, Int> getPlayerAni;
Function<String, Int> getPlayerArmor;
Function<Position3d, Int> getPlayerAtVector;
Function<String, Int> getPlayerBelt;
Function<Position3d, Int> getPlayerCameraPosition;
Function<Bool, Int> getPlayerCollision;
Function<Color, Int> getPlayerColor;
Function<Int, Int, Int> getPlayerContext;
Function<Int, Int> getPlayerDexterity;
Function<SqList, Int> getPlayerFaceAnis;
Function<Float, Int> getPlayerFatness;
Function<Int, Int> getPlayerFocus;
Function<Int, Int> getPlayerHealth;
Function<String, Int> getPlayerHelmet;
Function<String, Int> getPlayerIP;
Function<String, Int> getPlayerInstance;
Function<String, Int> getPlayerMacAddr;
Function<Int, Int> getPlayerMana;
Function<Int, Int> getPlayerMaxHealth;
Function<Int, Int> getPlayerMaxMana;
Function<String, Int> getPlayerMeleeWeapon;
Function<String, Int> getPlayerName;
Function<Int, Int> getPlayerPing;
Function<SqDict, Int> getPlayerPosition;
Function<String, Int> getPlayerRangedWeapon;
Function<Int, Int> getPlayerRespawnTime;
Function<String, Int, Int> getPlayerRing;
Function<SqDict, Int> getPlayerScale;
Function<String, Int> getPlayerSerial;
Function<String, Int> getPlayerShield;
Function<Int, Int, Int> getPlayerSkillWeapon;
Function<String, Int, Int> getPlayerSpell;
Function<Int, Int> getPlayerStrength;
Function<Int, Int, Int> getPlayerTalent;
Function<Int, Int> getPlayerVirtualWorld;
Function<SqDict, Int> getPlayerVisual;
Function<Int, Int> getPlayerWeaponMode;
Function<String, Int> getPlayerWorld;
Function<void, Int, String, Int> giveItem;
Function<Bool, Int, Int> hitPlayer;
Function<Bool, Int> isPlayerConnected;
Function<Bool, Int> isPlayerDead;
Function<Bool, Int> isPlayerUnconscious;
Function<void, Int, String> kick;
Function<void, Int, String> playAni;
Function<void, Int, String> playFaceAni;
Function<void, Int, Int, Int> readySpell;
Function<void, Int, String, Int> removeItem;
Function<Bool, Int, Int> removePlayerOverlay;
Function<void, Int> removeWeapon;
Function<void, Int> respawnPlayer;
Function<void, Int, Float> setPlayerAngle;
Function<void, Int, Bool> setPlayerCollision;
Function<void, Int, Int, Int, Int> setPlayerColor;
Function<void, Int, Int, Int> setPlayerContext;
Function<void, Int, Int> setPlayerDexterity;
Function<void, Int, Float> setPlayerFatness;
Function<void, Int, Int> setPlayerHealth;
Function<void, Int, String> setPlayerInstance;
Function<void, Int, Bool> setPlayerInvisible;
Function<void, Int, Int> setPlayerMana;
Function<void, Int, Int> setPlayerMaxHealth;
Function<void, Int, Int> setPlayerMaxMana;
Function<void, Int, String> setPlayerName;
Function<void, Int, Float, Float, Float> setPlayerPosition;
Function<void, Int, Int> setPlayerRespawnTime;
Function<void, Int, Float, Float, Float> setPlayerScale;
Function<void, Int, Int, Int> setPlayerSkillWeapon;
Function<void, Int, Int> setPlayerStrength;
Function<void, Int, Int, Int> setPlayerTalent;
Function<void, Int, Int> setPlayerVirtualWorld;
Function<void, Int, String, Int, String, Int> setPlayerVisual;
Function<void, Int, Int> setPlayerWeaponMode;
Function<void, Int, String, String> setPlayerWorld;
Function<void, Int> spawnPlayer;
Function<void, Int, String> stopAni;
Function<void, Int, String> stopFaceAni;
Function<void, Int, String> unequipItem;
Function<void, Int> unreadySpell;
Function<void, Int> unspawnPlayer;
Function<void, Int, String> useItem;
Function<void, Int, String, Int> useItemToState;
Function<SqList, SQObject, Int, String, Int> findNearbyPlayers;
Function<SqList, Int> getSpawnedPlayersForPlayer;
Function<SqList, Int> getStreamedPlayersByPlayer;
Function<SqDict, String, Int, Int, Int> getNearestWaypoint;
Function<SqDict, String, String> getWaypoint;
};
}
#endif

2
src/main.cpp
View File

@@ -2,6 +2,7 @@
#include <pybind11/embed.h>
#include "events/sqevents.h"
#include "constants/sqconstants.h"
#include "functions/sqfunctions.h"
namespace py = pybind11;
py::scoped_interpreter guard{};
@@ -10,7 +11,6 @@ py::module_ pysys = py::module_::import("sys");
py::module_ g2o;
py::module_ scripts;
extern "C" SQRESULT SQRAT_API sqmodule_load(HSQUIRRELVM vm, HSQAPI api)
{
SqModule::Initialize(vm, api);