mirrors/sapphire
1
Fork 0
mirror of https://github.com/SapphireServer/Sapphire.git synced 2025-04-24 13:47:46 +00:00
Code Activity

Merge pull request #199 from GokuWeedLord/feature/nativescripting

Browse source 
Native Scripting
This commit is contained in:
Mordred 2017-12-14 09:11:20 +01:00 • committed by GitHub
commit 28609515a2
35 changed files with 1447 additions and 564 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
.appveyor.yml
View file

@ -9,8 +9,8 @@ platform:
environment:
MSVC_DEFAULT_OPTIONS: ON
BOOST_ROOT_DIR: "C:\\Libraries\\boost_1_60_0"
BOOST_LIB_DIR: "C:\\Libraries\\boost_1_60_0\\lib32-msvc-14.0"
BOOST_ROOT_DIR: "C:\\Libraries\\boost_1_63_0"
BOOST_LIB_DIR: "C:\\Libraries\\boost_1_63_0\\lib32-msvc-14.0"
MYSQL_PWD: "Password12!"
services:

1
.gitignore vendored
View file

@ -38,6 +38,7 @@ build/
*.la
*.a
*.lib
*.exp
# Executables
*.exe

6
.travis.yml
View file

@ -29,9 +29,9 @@ cache:
before_install:
- eval "${MATRIX_EVAL}"
- gem install --no-ri --no-rdoc mtime_cache
- sudo add-apt-repository -y ppa:rexut/recoil
- sudo apt-get update
- sudo apt-get install -y libboost-dev libboost-all-dev
- sudo apt-get install -y libmysqlclient-dev libmysqlcppconn-dev
- sudo apt-get install -y libboost1.63-dev libboost1.63-all-dev
# Build steps
script:
@ -39,6 +39,6 @@ script:
- mtime_cache src/**/*.{%{cpp}} -c .mtime_cache/cache.json
- mkdir -p build
- cd build
- cmake .. -DSAPPHIRE_BOOST_VER="1.54.0" && make -j 3
- cmake .. -DSAPPHIRE_BOOST_VER="1.63.0" && make -j 3
- cd ..
- bash sql_import.sh

8
CMakeLists.txt
View file

@ -4,8 +4,9 @@ project (Sapphire)
set(CMAKE_BINARY_DIR ${CMAKE_SOURCE_DIR}/bin)
set(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR})
set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR})
set(EXECUTABLE_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/bin)
set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin)
set(EXECUTABLE_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin)
set(PROJECT_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/include)
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/cmake)
@ -42,7 +43,6 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/servers/Server_Common/Version.cp
##########################################################################
# Common include folders
include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/libraries/external/ChaiScript-6.0.0/include/")
include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/libraries/sapphire/datReader/")
include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/libraries/sapphire/mysqlConnector/")
include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src")
@ -66,3 +66,5 @@ add_subdirectory("src/tools/exd_struct_gen")
add_subdirectory("src/tools/exd_struct_test")
add_subdirectory("src/tools/quest_parser")
add_subdirectory("src/tools/pcb_reader")
add_subdirectory("scripts/native")

2
bin/config/settings_rest.xml
View file

@ -6,7 +6,7 @@
<!-- Ip the lobby server listens on -->
<ListenIp>127.0.0.1</ListenIp>
<!-- Path of FFXIV dat files -->
<DataPath>C:\\SquareEnix\\FINAL FANTASY XIV - A Realm Reborn\\game\\sqpack\\ffxiv</DataPath>
<DataPath>H:\\SteamLibrary\\steamapps\\common\\FINAL FANTASY XIV - A Realm Reborn\\game\\sqpack\\ffxiv</DataPath>
<!-- <DataPath>/opt/sapphire_3_15_0/bin/sqpack</DataPath> -->
<!-- IP of the lobby server -->
<LobbyHost>127.0.0.1</LobbyHost>

18
bin/config/settings_zone.xml
View file

@ -1,14 +1,26 @@
<Settings>
<General>
<!-- Port the zone server accepts game conenctions on -->
<ListenPort>54992</ListenPort>
<!-- Ip the zone server conenctions on -->
<ListenIp>127.0.0.1</ListenIp>
<!-- Path of FFXIV dat files -->
<DataPath>C:\\SquareEnix\\FINAL FANTASY XIV - A Realm Reborn\\game\\sqpack\\ffxiv</DataPath>
<DataPath>H:\\SteamLibrary\\steamapps\\common\\FINAL FANTASY XIV - A Realm Reborn\\game\\sqpack\\ffxiv</DataPath>
<Scripts>
<!-- where compiled scripts are placed -->
<Path>./compiledscripts/</Path>
<CachePath>./cache/</CachePath>
<HotSwap>
<Enabled>1</Enabled>
<BuildDir>../cmake-build-debug/</BuildDir>
<BuildCmd>cmake --build %1% --target %2%</BuildCmd>
</HotSwap>
</Scripts>
<!-- Path of Chai script files -->
<ScriptPath>../scripts/chai</ScriptPath>
<ScriptPath>./compiledscripts/</ScriptPath>
<!-- Connection settings for the mysql db -->
<Mysql>
<Host>127.0.0.1</Host>

1
cmake/mysql.cmake
View file

@ -11,6 +11,7 @@ if(UNIX)
/usr/local/mysql/include/mysql
$ENV{ProgramFiles}/MySQL/*/include
$ENV{SystemDrive}/MySQL/*/include
${LIBRARY_DIR}/external/MySQL/
)
if(MYSQL_INCLUDE_DIR)

47
scripts/native/CMakeLists.txt Normal file
View file

@ -0,0 +1,47 @@
cmake_minimum_required(VERSION 3.0)
project(Sapphire_Script)
file(GLOB SCRIPT_INCLUDE_FILES "${CMAKE_CURRENT_SOURCE_DIR}/*.h")
file(GLOB_RECURSE SCRIPT_FILES "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp")
include_directories("${CMAKE_SOURCE_DIR}/src/servers/")
include_directories("${CMAKE_SOURCE_DIR}/src/servers/Server_Zone/")
if(MSVC)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Yc${CMAKE_CURRENT_SOURCE_DIR}/ScriptObject.h /FI${CMAKE_CURRENT_SOURCE_DIR}/ScriptObject.h")
endif()
message( "exec: ${EXECUTABLE_OUTPUT_DIRECTORY}" )
set( SCRIPT_LIB_DIR "${EXECUTABLE_OUTPUT_DIRECTORY}/compiledscripts/" )
set( EXECUTABLE_OUTPUT_PATH "${SCRIPT_LIB_DIR}")
set( LIBRARY_OUTPUT_PATH "${SCRIPT_LIB_DIR}")
set( RUNTIME_OUTPUT_DIRECTORY "${SCRIPT_LIB_DIR}")
foreach(_sourcefile ${SCRIPT_FILES})
get_filename_component(_file "${_sourcefile}" NAME_WE)
add_library("${_file}" MODULE "${_sourcefile}" "${SCRIPT_INCLUDE_FILES}")
if(MSVC)
set_source_files_properties("${_file}" PROPERTIES
COMPILE_FLAGS "/Yc${CMAKE_CURRENT_SOURCE_DIR}/ScriptObject.h"
)
set_target_properties(${_file} PROPERTIES
CXX_STANDARD 14
CXX_STANDARD_REQUIRED ON
CXX_EXTENSIONS ON
LIBRARY_OUTPUT_DIRECTORY_DEBUG "${SCRIPT_LIB_DIR}"
LIBRARY_OUTPUT_DIRECTORY_RELEASE "${SCRIPT_LIB_DIR}"
LIBRARY_OUTPUT_DIRECTORY_RELWITHDEBINFO "${SCRIPT_LIB_DIR}"
LIBRARY_OUTPUT_DIRECTORY_MINSIZEREL "${SCRIPT_LIB_DIR}"
)
endif()
target_link_libraries("${_file}" server_zone)
add_custom_command(TARGET "${_file}" POST_BUILD
COMMAND ${CMAKE_COMMAND} -E remove "${SCRIPT_LIB_DIR}/${_file}.exp"
COMMAND ${CMAKE_COMMAND} -E remove "${SCRIPT_LIB_DIR}/${_file}.lib"
COMMAND ${CMAKE_COMMAND} -E remove "${SCRIPT_LIB_DIR}/${_file}.ilk"
)
endforeach(_sourcefile ${SCRIPT_FILES})

38
scripts/native/CmnDef/CmnDefCutSceneReplay.cpp Normal file
View file

@ -0,0 +1,38 @@
#include "../ScriptObject.h"
class CmnDefCutSceneReplay : public EventScript
{
public:
CmnDefCutSceneReplay() : EventScript( "CmnDefCutSceneReplay", 721028 )
{}
void Scene00000( Entity::Player& player )
{
auto callback = [ this ]( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
{
if( param2 != 0 )
{
Scene00001( player, param2 );
}
};
player.eventPlay( getId(), 0, 0x2000, 0, 1, callback );
}
void Scene00001( Entity::Player& player, uint16_t returnScene )
{
auto callback = []( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
{
// todo: this is fucked
};
player.eventPlay( getId(), 1, 0xFB2EC8F8, 0, 1, returnScene, callback );
}
void onTalk( uint32_t eventId, Entity::Player& player, uint64_t actorId ) override
{
Scene00000( player );
}
};
EXPORT_SCRIPTOBJECT( CmnDefCutSceneReplay )

58
scripts/native/CmnDef/CmnDefInnBed.cpp Normal file
View file

@ -0,0 +1,58 @@
#include "../ScriptObject.h"
class CmnDefInnBed : public EventScript
{
public:
CmnDefInnBed() : EventScript( "CmnDefInnBed", 720916 )
{}
// menu
void Scene00000( Entity::Player& player )
{
auto callback = [ this ]( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
{
if( param2 > 0 )
Scene00001( player, param2 );
};
player.eventPlay( getId(), 0, 0x2000, 0, 1, callback );
}
// lay down
void Scene00001( Entity::Player& player, uint16_t param )
{
auto callback = [ this ]( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
{
Scene00002( player, param2 );
};
player.eventPlay( getId(), 1, 0xF32E48F8, 0, 1, param, callback );
}
// logout
void Scene00002( Entity::Player& player, uint16_t param )
{
player.eventPlay( getId(), 2, 0xF32E48F8, 0, 1, param, nullptr );
}
// wake up
void Scene00100( Entity::Player& player )
{
auto callback = []( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
{};
player.eventPlay( getId(), 100, 0x800, 0, 0, callback );
}
void onTalk( uint32_t eventId, Entity::Player& player, uint64_t actorId ) override
{
Scene00000( player );
}
void onEnterZone( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2 ) override
{
Scene00100( player );
}
};
EXPORT_SCRIPTOBJECT( CmnDefInnBed )

60
scripts/native/CmnDef/CmnDefLinkShell.cpp Normal file
View file

@ -0,0 +1,60 @@
#include "../ScriptObject.h"
#define ACTION_CREATE 2
#define ACTION_RENAME 3
#define ACTION_REMOVE 4
class CmnDefLinkShell : public EventScript
{
public:
CmnDefLinkShell() : EventScript( "CmnDefLinkShell", 0xB0006 )
{}
void Scene00001( Entity::Player& player )
{
auto callback = [ this ]( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
{
switch( param2 )
{
case ACTION_CREATE:
Scene00002( player );
break;
case ACTION_RENAME:
Scene00003( player );
break;
case ACTION_REMOVE:
Scene00004( player );
break;
}
};
player.eventPlay( getId(), 1, 0, 0, 0, callback );
}
// create linkshell
void Scene00002( Entity::Player& player )
{
player.eventPlay( getId(), 2, 0, 0, 0 );
}
// rename linkshell
void Scene00003( Entity::Player& player )
{
player.eventPlay( getId(), 3, 0, 0, 0 );
}
// remove linkshell
void Scene00004( Entity::Player& player )
{
player.eventPlay( getId(), 4, 0, 0, 0 );
}
void onTalk( uint32_t eventId, Entity::Player& player, uint64_t actorId ) override
{
Scene00001( player );
}
};
EXPORT_SCRIPTOBJECT( CmnDefLinkShell )

20
scripts/native/CmnDef/HouFurOrchestrion.cpp Normal file
View file

@ -0,0 +1,20 @@
#include "../ScriptObject.h"
class HouFurOrchestrionDef : public EventScript
{
public:
HouFurOrchestrionDef() : EventScript( "HouFurOrchestrionDef", 721226 )
{}
void Scene00000( Entity::Player& player )
{
player.eventPlay( getId(), 0, 0x2000, 0, 1 );
}
void onTalk( uint32_t eventId, Entity::Player& player, uint64_t actorId ) override
{
Scene00000( player );
}
};
EXPORT_SCRIPTOBJECT( HouFurOrchestrionDef )

10
scripts/native/ScriptObject.h Normal file
View file

@ -0,0 +1,10 @@
#ifndef SAPPHIRE_SCRIPTOBJECT_H
#define SAPPHIRE_SCRIPTOBJECT_H
#include <Script/NativeScriptApi.h>
#include <Forwards.h>
#include <Actor/Actor.h>
#include <Actor/Player.h>
#endif //SAPPHIRE_SCRIPTOBJECT_H

15
scripts/native/action/ActionSprint3.cpp Normal file
View file

@ -0,0 +1,15 @@
#include "../ScriptObject.h"
class ActionSprint3 : public ActionScript
{
public:
ActionSprint3() : ActionScript( "ActionSprint3", 3 )
{}
void onCastFinish( Core::Entity::Player& player, Core::Entity::Actor& targetActor ) override
{
player.addStatusEffectByIdIfNotExist( 50, 20000, player, 30 );
}
};
EXPORT_SCRIPTOBJECT( ActionSprint3 )

48
scripts/native/aetheryte/Aethernet.cpp Normal file
View file

@ -0,0 +1,48 @@
#include "../ScriptObject.h"
#define ACTION_ATTUNE 0x13
#define AetheryteBaseId 0x50000
#define AETHERYTE_MENU_AETHERNET 1
#define AETHERYTE_MENU_HOUSING 2
#define AETHERYTE_MENU_HOME_POINT 3
#define AETHERYTE_MENU_FAVORITE_POINT 4
#define AETHERYTE_MENU_FAVORITE_POINT_SECURITY_TOKEN 5
class Aethernet : public EventScript
{
public:
Aethernet() : EventScript( "Aethernet", EVENTSCRIPT_AETHERNET_ID )
{}
void onTalk( uint32_t eventId, Entity::Player& player, uint64_t actorId ) override
{
if( player.isAetheryteRegistered( eventId & 0xFFFF ) )
{
player.eventPlay( eventId, 2, 0, []( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
{
if( param1 == 256 )
{
player.teleport( param2, 2 );
}
} );
}
else
{
player.eventActionStart( eventId, ACTION_ATTUNE, []( Entity::Player& player, uint32_t eventId, uint64_t additional )
{
player.registerAetheryte( eventId & 0xFFFF );
player.eventPlay( eventId, 3, 0, 0, 0 );
},
[] ( Entity::Player& ply, uint32_t evntId, uint64_t additional )
{
}, 0 );
player.unlock();
}
}
};
EXPORT_SCRIPTOBJECT( Aethernet )

70
scripts/native/aetheryte/Aetheryte.cpp Normal file
View file

@ -0,0 +1,70 @@
#include "../ScriptObject.h"
#define ACTION_ATTUNE 0x13
#define ACTION_TELEPORT 0x4
#define AetheryteBaseId 0x50000
#define AETHERYTE_MENU_AETHERNET 1
#define AETHERYTE_MENU_HOUSING 2
#define AETHERYTE_MENU_HOME_POINT 3
#define AETHERYTE_MENU_FAVORITE_POINT 4
#define AETHERYTE_MENU_FAVORITE_POINT_SECURITY_TOKEN 5
class Aetheryte : public EventScript
{
public:
Aetheryte() : EventScript( "Aetheryte", EVENTSCRIPT_AETHERYTE_ID )
{}
void onTalk( uint32_t eventId, Entity::Player& player, uint64_t actorId ) override
{
if( player.isAetheryteRegistered( eventId & 0xFFFF ) )
{
player.eventPlay( eventId, 0, 1, []( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
{
if( param1 == 256 ) // set homepoint
{
player.setHomepoint( eventId & 0xFFFF );
player.sendQuestMessage( eventId, 2, 0xEA, 0, 0 );
}
else if( param1 == 512 ) // aethernet access
{
if( param2 == 4 )
{
player.teleport( param3, 2 );
}
else if( param2 == 2 ) // register favored destination
{
}
// else if( param2 == 0xC3E1 ) // register free destination
// {
//
// }
}
} );
}
else
{
player.eventActionStart( eventId, ACTION_ATTUNE, []( Entity::Player& player, uint32_t eventId, uint64_t additional )
{
player.registerAetheryte( eventId & 0xFFFF );
if( player.isActionLearned( ACTION_TELEPORT ) )
{
player.sendQuestMessage( eventId, 0, 2, 0, 0 );
}
else
{
player.sendQuestMessage( eventId, 0, 1, 1, 0 );
player.learnAction( ACTION_TELEPORT );
}
},
[] ( Entity::Player& player, uint32_t eventId, uint64_t additional )
{}, 0 );
}
}
};
EXPORT_SCRIPTOBJECT( Aetheryte )

91
scripts/native/opening/OpeningGridania.cpp Normal file
View file

@ -0,0 +1,91 @@
#include "../ScriptObject.h"
#define ERANGE_HOWTO_ANN_AND_QUEST 2117539
#define ERANGE_HOWTO_QUEST_REWARD 2366417
#define ERANGE_SEQ_1_CLOSED_1 2351918
#define POS_SEQ_1_CLOSED_RETURN_1 2351921
#define ERANGE_SEQ_1_CLOSED_2 2351919
#define POS_SEQ_1_CLOSED_RETURN_2 2351921
#define ERANGE_ALWAYS_CLOSED_1 2280846
#define POS_ALWAYS_CLOSED_RETURN_1 2320804
#define ENPC_ALWAYS_CLOSED_1 2367988
#define ERANGE_ALWAYS_CLOSED_3 2280851
#define POS_ALWAYS_CLOSED_RETURN_3 2320811
#define ENPC_ALWAYS_CLOSED_3 2563491
#define BGM_MUSIC_ZONE_FST_TWN 1003
#define NCUT_FST_1 3
#define NCUT_FST_2 53
#define NCUT_FST_3 226
#define ENPC_QUEST_OFFER 1985150
#define NCUT_LIGHT_ALL 2
#define NCUT_LIGHT_FST_1 147
#define NCUT_LIGHT_FST_2 146
class OpeningGridania : public EventScript
{
public:
OpeningGridania() : EventScript( "OpeningGridania", 1245186 )
{}
void Scene00000( Entity::Player& player )
{
auto callback = [ this ]( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
{
player.setOpeningSequence( 1 );
Scene00001( player );
};
player.eventPlay( getId(), 0, 0x04AC05, 0, 1, callback );
}
void Scene00001( Entity::Player& player )
{
player.eventPlay( getId(), 1, 0x2001, 1, 0x32 );
}
void Scene00020( Entity::Player& player )
{
player.eventPlay( getId(), 20, 0x2001, 0, 1 );
}
void Scene00030( Entity::Player& player )
{
player.eventPlay( getId(), 30, 0x2001, 0, 0 );
}
void Scene00040( Entity::Player& player )
{
auto callback = [ this ]( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
{
if( player.getOpeningSequence() == 2 )
{
// update the instance boundaries
Scene00030( player );
}
};
}
///////////////////////////////
void onEnterZone( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2 ) override
{
if( player.getOpeningSequence() == 0 )
{
Scene00000( player );
}
else
{
Scene00040( player );
}
}
void onWithinRange( Entity::Player& player, uint32_t eventId, uint32_t param1, float x, float y, float z ) override
{
if( param1 == ERANGE_SEQ_1_CLOSED_1 || param1 == ERANGE_SEQ_1_CLOSED_2 )
{
Scene00020( player );
}
}
};
EXPORT_SCRIPTOBJECT( OpeningGridania )

0
scripts/native/opening/OpeningLimsa.cpp Normal file
View file

0
scripts/native/opening/OpeningUldah.cpp Normal file
View file

16
src/servers/Server_Common/Script/ChaiscriptStdLib.cpp
View file

@ -1,16 +0,0 @@
#include <chaiscript/chaiscript_stdlib.hpp>
#include <chaiscript/chaiscript.hpp>
#include "ChaiscriptStdLib.h"
#include <boost/make_shared.hpp>
std::shared_ptr< chaiscript::Module > Core::Scripting::create_chaiscript_stdlib()
{
return chaiscript::Std_Lib::library();
}
boost::shared_ptr< chaiscript::ChaiScript > Core::Scripting::create_chaiscript()
{
auto chai = boost::make_shared< chaiscript::ChaiScript >();
//create_chaiscript_bindings( chai );
return chai;
}

19
src/servers/Server_Common/Script/ChaiscriptStdLib.h
View file

@ -1,19 +0,0 @@
#ifndef CHAISCRIPT_STDLIB
#define CHAISCRIPT_STDLIB
#include <boost/shared_ptr.hpp>
namespace chaiscript
{
class Module;
class ChaiScript;
}
namespace Core { namespace Scripting {
std::shared_ptr<chaiscript::Module> create_chaiscript_stdlib();
boost::shared_ptr< chaiscript::ChaiScript > create_chaiscript();
} }
#endif

2
src/servers/Server_Zone/CMakeLists.txt
View file

@ -46,6 +46,8 @@ set_target_properties(server_zone PROPERTIES
CXX_STANDARD 14
CXX_STANDARD_REQUIRED ON
CXX_EXTENSIONS ON
ENABLE_EXPORTS ON
WINDOWS_EXPORT_ALL_SYMBOLS ON
RUNTIME_OUTPUT_DIRECTORY_DEBUG "${CMAKE_CURRENT_SOURCE_DIR}/../../../bin/"
RUNTIME_OUTPUT_DIRECTORY_RELEASE "${CMAKE_CURRENT_SOURCE_DIR}/../../../bin/"
RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_CURRENT_SOURCE_DIR}/../../../bin/"

110
src/servers/Server_Zone/DebugCommand/DebugCommandHandler.cpp
View file

@ -19,6 +19,7 @@
#include "Network/PacketWrappers/InitUIPacket.h"
#include "Network/GameConnection.h"
#include "Script/ScriptManager.h"
#include "Script/NativeScriptManager.h"
#include "Actor/Player.h"
#include "Actor/BattleNpc.h"
@ -30,6 +31,7 @@
#include "StatusEffect/StatusEffect.h"
#include "Session.h"
#include <boost/make_shared.hpp>
#include <boost/format.hpp>
#include <cinttypes>
@ -48,11 +50,11 @@ Core::DebugCommandHandler::DebugCommandHandler()
registerCommand( "add", &DebugCommandHandler::add, "Loads and injects a premade Packet.", 1 );
registerCommand( "inject", &DebugCommandHandler::injectPacket, "Loads and injects a premade packet.", 1 );
registerCommand( "injectc", &DebugCommandHandler::injectChatPacket, "Loads and injects a premade chat packet.", 1 );
registerCommand( "script_reload", &DebugCommandHandler::scriptReload, "Reload all server scripts", 1 );
registerCommand( "nudge", &DebugCommandHandler::nudge, "Nudges you forward/up/down", 1 );
registerCommand( "info", &DebugCommandHandler::serverInfo, "Send server info", 0 );
registerCommand( "unlock", &DebugCommandHandler::unlockCharacter, "Unlock character", 1 );
registerCommand( "help", &DebugCommandHandler::help, "Shows registered commands", 0 );
registerCommand( "script", &DebugCommandHandler::script, "Server script utilities", 1 );
}
// clear all loaded commands
@ -117,13 +119,6 @@ void Core::DebugCommandHandler::execCommand( char * data, Entity::Player& player
// Definition of the commands
///////////////////////////////////////////////////////////////////////////////////////
void Core::DebugCommandHandler::scriptReload( char * data, Entity::Player& player,
boost::shared_ptr< DebugCommand > command )
{
g_scriptMgr.reload();
player.sendDebug( "Scripts reloaded." );
}
void Core::DebugCommandHandler::help( char* data, Entity::Player& player, boost::shared_ptr< DebugCommand > command )
{
player.sendDebug( "Registered debug commands:" );
@ -519,5 +514,102 @@ void Core::DebugCommandHandler::serverInfo( char * data, Entity::Player& player,
void Core::DebugCommandHandler::unlockCharacter( char* data, Entity::Player& player, boost::shared_ptr< DebugCommand > command )
{
player.unlock( );
player.unlock();
}
void Core::DebugCommandHandler::script( char* data, Entity::Player &player, boost::shared_ptr< DebugCommand > command )
{
std::string subCommand;
std::string params = "";
// check if the command has parameters
std::string tmpCommand = std::string( data + command->getName().length() + 1 );
std::size_t pos = tmpCommand.find_first_of( " " );
if( pos != std::string::npos )
// command has parameters, grab the first part
subCommand = tmpCommand.substr( 0, pos );
else
// no subcommand given
subCommand = tmpCommand;
// todo: fix params so it's empty if there's no params
if( command->getName().length() + 1 + pos + 1 < strlen( data ) )
params = std::string( data + command->getName().length() + 1 + pos + 1 );
g_log.debug( "[" + std::to_string( player.getId() ) + "] " +
"subCommand " + subCommand + " params: " + params );
if( subCommand == "unload" )
{
if ( subCommand == params )
player.sendDebug( "Command failed: requires name of script" );
else
if( g_scriptMgr.getNativeScriptHandler().unloadScript( params ) )
player.sendDebug( "Unloaded script successfully." );
else
player.sendDebug( "Failed to unload script: " + params );
}
else if( subCommand == "find" || subCommand == "f" )
{
if( subCommand == params )
player.sendDebug( "Because reasons of filling chat with nonsense, please enter a search term" );
else
{
std::set< Core::Scripting::ScriptInfo* > scripts;
g_scriptMgr.getNativeScriptHandler().findScripts( scripts, params );
if( !scripts.empty() )
{
player.sendDebug( "Found " + std::to_string( scripts.size() ) + " scripts" );
for( auto it = scripts.begin(); it != scripts.end(); ++it )
{
auto script = *it;
player.sendDebug( " - '" + script->script_name + "' loaded at @ 0x" +
boost::str( boost::format( "%|X|" ) % script->handle ) +
", script ptr: 0x" + boost::str( boost::format( "%|X|" ) % script->script ) );
}
}
else
player.sendDebug( "No scripts found with search term: " + params );
}
}
else if( subCommand == "load" || subCommand == "l" )
{
if( subCommand == params )
player.sendDebug( "Command failed: requires relative path to script" );
else
{
if ( g_scriptMgr.getNativeScriptHandler().loadScript( params ) )
player.sendDebug( "Loaded '" + params + "' successfully" );
else
player.sendDebug( "Failed to load '" + params + "'" );
}
}
else if( subCommand == "reload" || subCommand == "rl" )
{
if( subCommand == params )
player.sendDebug( "Command failed: requires name of script to reload" );
else
if( g_scriptMgr.getNativeScriptHandler().reloadScript( params ) )
player.sendDebug( "Reloaded '" + params + "' successfully" );
else
player.sendDebug( "Failed to reload '" + params + "'" );
}
else if( subCommand == "build" || subCommand == "b" )
{
if( subCommand == params )
player.sendDebug( "Command failed: requires name of cmake target" );
else
{
}
}
else
{
player.sendDebug( "Unknown script subcommand: " + subCommand );
}
}

4
src/servers/Server_Zone/DebugCommand/DebugCommandHandler.h
View file

@ -35,7 +35,6 @@ public:
void get( char * data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
void add( char * data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
//void debug( char * data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
void scriptReload( char * data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
void injectPacket( char * data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
void injectChatPacket( char * data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
@ -43,7 +42,8 @@ public:
void serverInfo( char * data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
void unlockCharacter( char* data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
void targetInfo( char* data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
void script( char* data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
};

1
src/servers/Server_Zone/Forwards.h
View file

@ -70,6 +70,7 @@ namespace Core
namespace Scripting
{
class NativeScriptManager;
typedef std::function< void( Entity::Player&, uint32_t, uint16_t, uint16_t, uint16_t ) > EventReturnCallback;
}

132
src/servers/Server_Zone/Script/NativeScriptApi.h Normal file
View file

@ -0,0 +1,132 @@
#ifndef NATIVE_SCRIPT_API
#define NATIVE_SCRIPT_API
#include <string>
#include <Actor/Actor.h>
#include <Actor/Player.h>
#include <StatusEffect/StatusEffect.h>
#ifdef _MSC_VER
#define EXPORT __declspec( dllexport )
#else
#define EXPORT __attribute__((visibility("default")))
#endif
#define EXPORT_SCRIPTOBJECT( type ) \
extern "C" EXPORT ScriptObject* getScript() \
{ return static_cast< ScriptObject* >( new type ); }
using namespace Core;
// constant script ids for certain events
#define EVENTSCRIPT_AETHERYTE_ID 0x50000
#define EVENTSCRIPT_AETHERNET_ID 0x50001
enum ScriptType
{
StatusEffect,
Action,
Quest,
BattleNpc,
Zone
};
class ScriptObject
{
protected:
std::string m_scriptName;
uint32_t m_id;
ScriptType m_type;
public:
ScriptObject( std::string name, uint32_t id, ScriptType type ) :
m_scriptName( name ),
m_id( id ),
m_type( type )
{ }
virtual const std::string& getName() const
{
return m_scriptName;
}
virtual uint32_t getId() const
{
return m_id;
}
virtual ScriptType getType() const
{
return m_type;
}
};
class StatusEffectScript : public ScriptObject
{
public:
StatusEffectScript( std::string name, uint32_t effectId ) :
ScriptObject( name, effectId, ScriptType::StatusEffect )
{ }
virtual void onTick( Entity::Actor& actor ) { }
virtual void onApply( Entity::Actor& actor ) { }
virtual void onRemove( Entity::Actor& actor ) { }
virtual void onExpire( Entity::Actor& actor ) { }
virtual void onPlayerCollision( Entity::Actor& actor, Entity::Actor& actorHit ) { }
virtual void onPlayerFinishCast( Entity::Actor& actor ) { }
virtual void onPlayerDamaged( Entity::Actor& actor ) { }
virtual void onPlayerDeath( Entity::Actor& actor ) { }
};
class ActionScript : public ScriptObject
{
public:
ActionScript( std::string name, uint32_t abilityId ) :
ScriptObject( name, abilityId, ScriptType::Action )
{ }
virtual void onStart( Entity::Actor& sourceActor, Entity::Actor& targetActor ) { }
virtual void onCastFinish( Entity::Player& player, Entity::Actor& targetActor ) { }
virtual void onInterrupt( Entity::Actor& sourceActor/*, Core::Entity::Actor targetActor*/ ) { }
};
class EventScript : public ScriptObject
{
public:
EventScript( std::string name, uint32_t questId ) :
ScriptObject( name, questId, ScriptType::Quest )
{ }
virtual void onTalk( uint32_t eventId, Entity::Player& player, uint64_t actorId ) { }
virtual void onNpcKill( uint32_t npcId, Entity::Player& player ) { }
virtual void onEmote( uint64_t actorId, uint32_t eventId, uint32_t emoteId, Entity::Player& player ) { }
virtual void onEnterZone( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2 ) { }
virtual void onWithinRange( Entity::Player& player, uint32_t eventId, uint32_t param1, float x, float y, float z ) { }
virtual void onOutsideRange( Entity::Player& player, uint32_t eventId, uint32_t param1, float x, float y, float z ) { }
virtual void onEventItem( Entity::Player& player, uint32_t eventItemId, uint32_t eventId, uint32_t castTime, uint64_t targetId ) { }
virtual void onEventHandlerTradeReturn( Entity::Player& player, uint32_t eventId, uint16_t subEvent, uint16_t param, uint32_t catalogId ) { }
};
class BattleNpcScript : public ScriptObject
{
public:
BattleNpcScript( std::string name, uint32_t npcId ) :
ScriptObject( name, npcId, ScriptType::BattleNpc )
{ }
};
class ZoneScript : public ScriptObject
{
public:
ZoneScript( std::string name, uint32_t zoneId ) :
ScriptObject( name, zoneId, ScriptType::Zone )
{ }
virtual void onZoneInit() { }
};
#endif

167
src/servers/Server_Zone/Script/NativeScriptManager.cpp Normal file
View file

@ -0,0 +1,167 @@
#include "NativeScriptManager.h"
namespace Core {
namespace Scripting {
NativeScriptManager::NativeScriptManager( )
{ }
StatusEffectScript* NativeScriptManager::getStatusEffectScript( uint32_t statusId )
{
auto script = m_statusEffectScripts.find( statusId );
if( script == m_statusEffectScripts.end() )
return nullptr;
return script->second;
}
ActionScript* NativeScriptManager::getActionScript( uint32_t actionId )
{
auto script = m_actionScripts.find( actionId );
if( script == m_actionScripts.end() )
return nullptr;
return script->second;
}
EventScript* NativeScriptManager::getEventScript( uint32_t questId )
{
auto script = m_eventScripts.find( questId );
if( script == m_eventScripts.end() )
return nullptr;
return script->second;
}
BattleNpcScript* NativeScriptManager::getBattleNpcScript( uint32_t npcId )
{
auto script = m_battleNpcScripts.find( npcId );
if( script == m_battleNpcScripts.end() )
return nullptr;
return script->second;
}
ZoneScript* NativeScriptManager::getZoneScript( uint32_t zoneId )
{
auto script = m_zoneScripts.find( zoneId );
if( script == m_zoneScripts.end() )
return nullptr;
return script->second;
}
bool NativeScriptManager::loadScript( const std::string& path )
{
auto module = m_loader.loadModule( path );
if( !module )
return false;
auto script = m_loader.getScriptObject( module->handle );
if( !script )
{
m_loader.unloadScript( module );
return false;
}
module->script = script;
module->script_name = script->getName();
module->type = script->getType();
switch( script->getType() )
{
case ScriptType::StatusEffect:
m_statusEffectScripts[ script->getId() ] = dynamic_cast< StatusEffectScript* >( script );
break;
case ScriptType::Action:
m_actionScripts[ script->getId() ] = dynamic_cast< ActionScript* >( script );
break;
case ScriptType::Quest:
m_eventScripts[ script->getId() ] = dynamic_cast< EventScript* >( script );
break;
case ScriptType::BattleNpc:
m_battleNpcScripts[ script->getId() ] = dynamic_cast< BattleNpcScript* >( script );
break;
case ScriptType::Zone:
m_zoneScripts[ script->getId() ] = dynamic_cast< ZoneScript* >( script );
break;
default:
m_loader.unloadScript( module );
return false;
}
return true;
}
const std::string NativeScriptManager::getModuleExtension()
{
return m_loader.getModuleExtension();
}
bool NativeScriptManager::unloadScript( const std::string& name )
{
auto info = m_loader.getScriptInfo( name );
if( !info )
return false;
return unloadScript( info );
}
bool NativeScriptManager::unloadScript( ScriptInfo* info )
{
auto ptr = info->script;
switch( info->type )
{
case ScriptType::StatusEffect:
removeValueFromMap< uint32_t, StatusEffectScript* >( ptr, m_statusEffectScripts );
break;
case ScriptType::Action:
removeValueFromMap< uint32_t, ActionScript* >( ptr, m_actionScripts );
break;
case ScriptType::Quest:
removeValueFromMap< uint32_t, EventScript* >( ptr, m_eventScripts );
break;
case ScriptType::BattleNpc:
removeValueFromMap< uint32_t, BattleNpcScript* >( ptr, m_battleNpcScripts );
break;
case ScriptType::Zone:
removeValueFromMap< uint32_t, ZoneScript* >( ptr, m_zoneScripts );
break;
default:
return false;
}
return m_loader.unloadScript( info );
}
bool NativeScriptManager::reloadScript( const std::string& name )
{
auto info = m_loader.getScriptInfo( name );
if( !info )
return false;
// backup actual lib path
std::string libPath( info->library_path );
if( !unloadScript( info ) )
return false;
return loadScript( libPath );
}
void NativeScriptManager::findScripts( std::set< Core::Scripting::ScriptInfo* >& scripts, const std::string& search )
{
return m_loader.findScripts( scripts, search );
}
boost::shared_ptr< NativeScriptManager > createNativeScriptMgr()
{
return boost::make_shared< NativeScriptManager >();
}
}
}

69
src/servers/Server_Zone/Script/NativeScriptManager.h Normal file
View file

@ -0,0 +1,69 @@
#ifndef NATIVE_SCRIPT_H
#define NATIVE_SCRIPT_H
#include <unordered_map>
#include <set>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <boost/filesystem.hpp>
#include <Server_Common/Crypt/md5.h>
#include "ScriptLoader.h"
namespace Core {
namespace Scripting {
class NativeScriptManager
{
protected:
std::unordered_map< uint32_t, StatusEffectScript* > m_statusEffectScripts;
std::unordered_map< uint32_t, ActionScript* > m_actionScripts;
std::unordered_map< uint32_t, EventScript* > m_eventScripts;
std::unordered_map< uint32_t, BattleNpcScript* > m_battleNpcScripts;
std::unordered_map< uint32_t, ZoneScript* > m_zoneScripts;
ScriptLoader m_loader;
bool unloadScript( ScriptInfo* info );
public:
NativeScriptManager( );
StatusEffectScript* getStatusEffectScript( uint32_t statusId );
ActionScript* getActionScript( uint32_t actionId );
EventScript* getEventScript( uint32_t questId );
BattleNpcScript* getBattleNpcScript( uint32_t npcId );
ZoneScript* getZoneScript( uint32_t zoneId );
bool loadScript( const std::string& path );
bool unloadScript( const std::string& name );
bool reloadScript( const std::string& name );
void findScripts( std::set< Core::Scripting::ScriptInfo* >& scripts, const std::string& search );
const std::string getModuleExtension();
template< typename key, typename val >
bool removeValueFromMap( ScriptObject* ptr, std::unordered_map< key, val >& map )
{
for( typename std::unordered_map< key, val >::iterator it = map.begin(); it != map.end(); ++it )
{
if( ptr == static_cast< ScriptObject* >( it->second ) )
{
map.erase( it );
return true;
}
}
return false;
}
};
boost::shared_ptr< NativeScriptManager > createNativeScriptMgr();
} }
#endif

34
src/servers/Server_Zone/Script/ScriptInfo.h Normal file
View file

@ -0,0 +1,34 @@
#ifndef SAPPHIRE_SCRIPTINFO_H
#define SAPPHIRE_SCRIPTINFO_H
#include "NativeScriptApi.h"
#ifdef _WIN32
#include <windows.h>
typedef HMODULE ModuleHandle;
#else
typedef void* ModuleHandle;
#endif
namespace Core {
namespace Scripting {
class ScriptInfo
{
public:
ScriptInfo() = default;
std::string library_name;
std::string cache_path;
std::string library_path;
std::string script_name;
ModuleHandle handle;
ScriptObject* script;
ScriptType type;
};
}
}
#endif //SAPPHIRE_SCRIPTINFO_H

187
src/servers/Server_Zone/Script/ScriptLoader.cpp Normal file
View file

@ -0,0 +1,187 @@
#include "ScriptLoader.h"
#include <Server_Common/Logging/Logger.h>
#include <Server_Common/Config/XMLConfig.h>
#include "ServerZone.h"
#include <boost/format.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/filesystem.hpp>
extern Core::Logger g_log;
extern Core::ServerZone g_serverZone;
namespace fs = boost::filesystem;
Core::Scripting::ScriptLoader::ScriptLoader()
{}
const std::string Core::Scripting::ScriptLoader::getModuleExtension()
{
#ifdef _WIN32
return ".dll";
#elif __APPLE__
return ".dylib";
#else
return ".so";
#endif
}
bool Core::Scripting::ScriptLoader::unloadModule( ModuleHandle handle )
{
#ifdef _WIN32
bool success = FreeLibrary( handle ) != 0;
#else
bool success = dlclose( handle ) == 0;
#endif
if( !success )
{
g_log.error( "Failed to unload module @ 0x" + boost::str( boost::format( "%|08X|" ) % handle ) );
return false;
}
g_log.debug( "Unloaded module @ 0x" + boost::str( boost::format( "%|08X|" ) % handle ) );
return true;
}
Core::Scripting::ScriptInfo* Core::Scripting::ScriptLoader::loadModule( const std::string& path )
{
fs::path f( path );
if ( isModuleLoaded( f.stem().string() ) )
{
g_log.error( "Unable to load module '" + f.stem().string() + "' as it is already loaded" );
return nullptr;
}
// copy to temp dir
fs::path cacheDir( f.parent_path() /= g_serverZone.getConfig()->getValue< std::string >( "Settings.General.Scripts.CachePath", "./cache/" ) );
fs::create_directories( cacheDir );
fs::path dest( cacheDir /= f.filename().string() );
if ( fs::exists( dest ) )
{
fs::remove( dest );
}
fs::copy_file( f, dest );
#ifdef _WIN32
ModuleHandle handle = LoadLibrary( dest.string().c_str() );
#else
ModuleHandle handle = dlopen( dest.string().c_str(), RTLD_LAZY );
#endif
if( !handle )
{
g_log.error( "Failed to load module from: " + path );
return nullptr;
}
g_log.info( "Loaded module '" + f.filename().string() + "' @ 0x" + boost::str( boost::format( "%|08X|" ) % handle ) );
auto info = new ScriptInfo;
info->handle = handle;
info->library_name = f.stem().string();
info->cache_path = dest.string();
info->library_path = f.string();
m_scriptMap.insert( std::make_pair( f.stem().string(), info ) );
return info;
}
ScriptObject* Core::Scripting::ScriptLoader::getScriptObject( ModuleHandle handle )
{
using getScript = ScriptObject*(*)();
#ifdef _WIN32
getScript func = reinterpret_cast< getScript >( GetProcAddress( handle, "getScript" ) );
#else
getScript func = reinterpret_cast< getScript >( dlsym( handle, "getScript" ) );
#endif
if( func )
{
auto ptr = func();
g_log.debug( "got ScriptObject @ 0x" + boost::str( boost::format( "%|08X|" ) % ptr ) );
g_log.debug( "script info -> name: " + std::string( ptr->getName() ) + ", id: " + std::to_string( ptr->getId() ) );
return ptr;
}
else
return nullptr;
}
bool Core::Scripting::ScriptLoader::unloadScript( Core::Scripting::ScriptInfo* info )
{
return unloadScript( info->handle );
}
bool Core::Scripting::ScriptLoader::unloadScript( ModuleHandle handle )
{
for( auto it = m_scriptMap.begin(); it != m_scriptMap.end(); ++it )
{
if( it->second->handle == handle )
{
auto info = it->second;
m_scriptMap.erase( it );
if( unloadModule( handle ) )
{
// remove cached file
fs::remove( info->cache_path );
delete info;
return true;
}
g_log.error( "failed to unload module: " + info->library_name );
return false;
}
}
return false;
}
bool Core::Scripting::ScriptLoader::isModuleLoaded( std::string name )
{
for( auto it = m_scriptMap.begin(); it != m_scriptMap.end(); ++it )
{
if( boost::iequals( it->second->library_name, name ) )
return true;
}
return false;
}
Core::Scripting::ScriptInfo* Core::Scripting::ScriptLoader::getScriptInfo( std::string name )
{
for( auto it = m_scriptMap.begin(); it != m_scriptMap.end(); ++it )
{
if( it->second->script_name == name )
{
return it->second;
}
}
return nullptr;
}
void Core::Scripting::ScriptLoader::findScripts( std::set< Core::Scripting::ScriptInfo* >& scripts, const std::string& search )
{
for( auto it = m_scriptMap.begin(); it != m_scriptMap.end(); ++it )
{
if( it->second->script_name.find( search ) != std::string::npos )
{
scripts.insert( it->second );
}
}
}

48
src/servers/Server_Zone/Script/ScriptLoader.h Normal file
View file

@ -0,0 +1,48 @@
#ifndef SAPPHIRE_SCRIPTLOADER_H
#define SAPPHIRE_SCRIPTLOADER_H
#include <string>
#include <unordered_map>
#include <set>
#include "NativeScriptApi.h"
#include "ScriptInfo.h"
#ifdef _WIN32
#include <windows.h>
typedef HMODULE ModuleHandle;
#else
#include <dlfcn.h>
typedef void* ModuleHandle;
#endif
namespace Core {
namespace Scripting {
class ScriptLoader {
protected:
std::unordered_map< std::string, ScriptInfo* > m_scriptMap;
bool unloadModule( ModuleHandle );
public:
ScriptLoader();
const std::string getModuleExtension();
ScriptInfo* loadModule( const std::string& );
bool unloadScript( ScriptInfo* );
bool unloadScript( ModuleHandle );
ScriptInfo* getScriptInfo( std::string name );
ScriptObject* getScriptObject( ModuleHandle handle );
bool isModuleLoaded( std::string name );
void findScripts( std::set< Core::Scripting::ScriptInfo* >& scripts, const std::string& search );
};
}
}
#endif //SAPPHIRE_SCRIPTLOADER_H

490
src/servers/Server_Zone/Script/ScriptManager.cpp
View file

@ -1,8 +1,7 @@
#include <Server_Common/Logging/Logger.h>
#include <Server_Common/Exd/ExdData.h>
#include <chaiscript/chaiscript.hpp>
#include <Server_Common/Script/ChaiscriptStdLib.h>
#include "NativeScriptManager.h"
#include "Zone/Zone.h"
#include "Actor/Player.h"
@ -20,13 +19,15 @@
#include <boost/format.hpp>
#include <boost/foreach.hpp>
#include <Server_Common/Config/XMLConfig.h>
extern Core::Logger g_log;
extern Core::Data::ExdData g_exdData;
extern Core::ServerZone g_serverZone;
Core::Scripting::ScriptManager::ScriptManager()
{
m_pChaiHandler = create_chaiscript();
m_nativeScriptManager = createNativeScriptMgr();
}
Core::Scripting::ScriptManager::~ScriptManager()
@ -34,7 +35,24 @@ Core::Scripting::ScriptManager::~ScriptManager()
}
void Core::Scripting::ScriptManager::loadDir( std::string dirname, std::set<std::string>& chaiFiles )
bool Core::Scripting::ScriptManager::init()
{
std::set< std::string > files;
loadDir( g_serverZone.getConfig()->getValue< std::string >( "Settings.General.Scripts.Path", "./compiledscripts/" ),
files, m_nativeScriptManager->getModuleExtension() );
for( auto itr = files.begin(); itr != files.end(); ++itr )
{
auto& path = *itr;
m_nativeScriptManager->loadScript( path );
}
return true;
}
void Core::Scripting::ScriptManager::loadDir( std::string dirname, std::set<std::string>& files, std::string ext )
{
g_log.info( "ScriptEngine: loading scripts from " + dirname );
@ -45,11 +63,9 @@ void Core::Scripting::ScriptManager::loadDir( std::string dirname, std::set<std:
BOOST_FOREACH( boost::filesystem::path const& i, make_pair( iter, eod ) )
{
if( is_regular_file( i ) && boost::filesystem::extension( i.string() ) == ".chai" ||
boost::filesystem::extension( i.string() ) == ".inc" )
if( is_regular_file( i ) && boost::filesystem::extension( i.string() ) == ext )
{
chaiFiles.insert( i.string() );
files.insert( i.string() );
}
}
@ -57,15 +73,15 @@ void Core::Scripting::ScriptManager::loadDir( std::string dirname, std::set<std:
void Core::Scripting::ScriptManager::onPlayerFirstEnterWorld( Entity::Player& player )
{
try
{
std::string test = m_onFirstEnterWorld( player );
}
catch( const std::exception &e )
{
std::string what = e.what();
g_log.Log( LoggingSeverity::error, what );
}
// try
// {
// std::string test = m_onFirstEnterWorld( player );
// }
// catch( const std::exception &e )
// {
// std::string what = e.what();
// g_log.Log( LoggingSeverity::error, what );
// }
}
bool Core::Scripting::ScriptManager::registerBnpcTemplate( std::string templateName, uint32_t bnpcBaseId,
@ -74,19 +90,6 @@ bool Core::Scripting::ScriptManager::registerBnpcTemplate( std::string templateN
return g_serverZone.registerBnpcTemplate( templateName, bnpcBaseId, bnpcNameId, modelId, aiName );
}
void Core::Scripting::ScriptManager::reload()
{
auto handler = create_chaiscript();
m_pChaiHandler.swap( handler );
init();
}
const boost::shared_ptr< chaiscript::ChaiScript >& Core::Scripting::ScriptManager::getHandler() const
{
return m_pChaiHandler;
}
bool Core::Scripting::ScriptManager::onTalk( Entity::Player& player, uint64_t actorId, uint32_t eventId )
{
std::string eventName = "onTalk";
@ -101,24 +104,134 @@ bool Core::Scripting::ScriptManager::onTalk( Entity::Player& player, uint64_t ac
% static_cast< uint64_t >( eventId & 0xFFFFFFF ) ) + ")" );
uint16_t eventType = eventId >> 16;
uint32_t scriptId = eventId;
try
// aethernet/aetherytes need to be handled separately
if( eventType == Common::EventType::Aetheryte )
{
auto aetherInfo = g_exdData.getAetheryteInfo( eventId & 0xFFFF );
scriptId = EVENTSCRIPT_AETHERYTE_ID;
if( !aetherInfo->isAetheryte )
scriptId = EVENTSCRIPT_AETHERNET_ID;
}
auto script = m_nativeScriptManager->getEventScript( scriptId );
if( script )
{
// Get object from engine
auto obj = m_pChaiHandler->eval( objName );
player.sendDebug( "Calling: " + objName + "." + eventName );
player.eventStart( actorId, eventId, Event::Event::Talk, 0, 0 );
auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &,
uint32_t, Entity::Player&, uint64_t ) > >( eventName );
fn( obj, eventId, player, actorId );
script->onTalk( eventId, player, actorId );
player.checkEvent( eventId );
}
catch( std::exception& e )
else
{
player.sendDebug( e.what( ) );
if ( eventType == Common::EventType::Quest )
{
auto questInfo = g_exdData.getQuestInfo( eventId );
if ( questInfo )
{
player.sendUrgent( "Quest not implemented: " + questInfo->name );
}
}
return false;
}
return true;
}
bool Core::Scripting::ScriptManager::onEnterTerritory( Entity::Player& player, uint32_t eventId,
uint16_t param1, uint16_t param2 )
{
std::string eventName = "onEnterTerritory";
std::string objName = Event::getEventName( eventId );
player.sendDebug( "Calling: " + objName + "." + eventName + " - " + std::to_string( eventId ) );
auto script = m_nativeScriptManager->getEventScript( eventId );
if( script )
{
player.eventStart( player.getId(), eventId, Event::Event::EnterTerritory, 0, player.getZoneId() );
script->onEnterZone( player, eventId, param1, param2 );
player.checkEvent( eventId );
return true;
}
return false;
}
bool Core::Scripting::ScriptManager::onWithinRange( Entity::Player& player, uint32_t eventId, uint32_t param1,
float x, float y, float z )
{
std::string eventName = "onWithinRange";
std::string objName = Event::getEventName( eventId );
player.sendDebug( "Calling: " + objName + "." + eventName + " - " + std::to_string( eventId ) + " p1: " + std::to_string( param1 ) );
auto script = m_nativeScriptManager->getEventScript( eventId );
if( script )
{
player.eventStart( player.getId(), eventId, Event::Event::WithinRange, 1, param1 );
script->onWithinRange( player, eventId, param1, x, y, z );
player.checkEvent( eventId );
return true;
}
return false;
}
bool Core::Scripting::ScriptManager::onOutsideRange( Entity::Player& player, uint32_t eventId, uint32_t param1,
float x, float y, float z )
{
std::string eventName = "onOutsideRange";
std::string objName = Event::getEventName( eventId );
player.sendDebug( "Calling: " + objName + "." + eventName + " - " + std::to_string( eventId ) );
auto script = m_nativeScriptManager->getEventScript( eventId );
if( script )
{
player.eventStart( player.getId(), eventId, Event::Event::WithinRange, 1, param1 );
script->onOutsideRange( player, eventId, param1, x, y, z );
player.checkEvent( eventId );
return true;
}
return false;
}
bool Core::Scripting::ScriptManager::onEmote( Entity::Player& player, uint64_t actorId,
uint32_t eventId, uint8_t emoteId )
{
std::string eventName = "onEmote";
std::string objName = Event::getEventName( eventId );
auto script = m_nativeScriptManager->getEventScript( eventId );
if( script )
{
player.sendDebug( "Calling: " + objName + "." + eventName );
player.eventStart( actorId, eventId, Event::Event::Emote, 0, emoteId );
script->onEmote( actorId, eventId, emoteId, player );
player.checkEvent( eventId );
}
else
{
uint16_t eventType = eventId >> 16;
if( eventType == Common::EventType::Quest )
{
@ -129,134 +242,9 @@ bool Core::Scripting::ScriptManager::onTalk( Entity::Player& player, uint64_t ac
return false;
}
}
return false;
}
return true;
}
bool Core::Scripting::ScriptManager::onEnterTerritory( Entity::Player& player, uint32_t eventId,
uint16_t param1, uint16_t param2 )
{
std::string eventName = "onEnterTerritory";
std::string objName = Event::getEventName( eventId );
try
{
// Get object from engine
auto obj = m_pChaiHandler->eval( objName );
player.sendDebug( "Calling: " + objName + "." + eventName );
player.eventStart( player.getId(), eventId, Event::Event::EnterTerritory, 0, player.getZoneId() );
auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, uint32_t,
Entity::Player&, uint16_t, uint16_t ) > >( eventName );
fn( obj, eventId, player, param1, param2 );
player.checkEvent( eventId );
}
catch( std::exception& e )
{
player.sendDebug( e.what() );
return false;
}
return true;
}
bool Core::Scripting::ScriptManager::onWithinRange( Entity::Player& player, uint32_t eventId, uint32_t param1,
float x, float y, float z )
{
std::string eventName = "onWithinRange";
std::string objName = Event::getEventName( eventId );
try
{
// Get object from engine
auto obj = m_pChaiHandler->eval( Event::getEventName( eventId ) );
player.sendDebug( "Calling: " + objName + "." + eventName );
player.eventStart( player.getId(), eventId, Event::Event::WithinRange, 1, param1 );
auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, uint32_t, Entity::Player&, uint32_t,
float, float, float ) > >( eventName );
fn( obj, eventId, player, param1, x, y, z );
player.checkEvent( eventId );
}
catch( std::exception& e )
{
player.sendDebug( e.what() );
return false;
}
return true;
}
bool Core::Scripting::ScriptManager::onOutsideRange( Entity::Player& player, uint32_t eventId, uint32_t param1,
float x, float y, float z )
{
std::string eventName = "onOutsideRange";
std::string objName = Event::getEventName( eventId );
try
{
// Get object from engine
auto obj = m_pChaiHandler->eval( Event::getEventName( eventId ) );
player.sendDebug( "Calling: " + objName + "." + eventName );
player.eventStart( player.getId(), eventId, Event::Event::OutsideRange, 1, param1 );
auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, uint32_t, Entity::Player&, uint32_t,
float, float, float ) > >( eventName );
fn( obj, eventId, player, param1, x, y, z );
player.checkEvent( eventId );
}
catch( std::exception& e )
{
player.sendDebug( e.what() );
return false;
}
return true;
}
bool Core::Scripting::ScriptManager::onEmote( Entity::Player& player, uint64_t actorId,
uint32_t eventId, uint8_t emoteId )
{
std::string eventName = "onEmote";
std::string objName = Event::getEventName( eventId );
try
{
auto obj = m_pChaiHandler->eval( Event::getEventName( eventId ) );
player.sendDebug( "Calling: " + objName + "." + eventName );
player.eventStart( actorId, eventId, Event::Event::Emote, 0, emoteId );
auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, uint32_t, Entity::Player&,
uint64_t, uint8_t ) > >( eventName );
fn( obj, eventId, player, actorId, emoteId );
player.checkEvent( eventId );
}
catch( std::exception& e )
{
uint16_t eventType = eventId >> 16;
if( eventType == Common::EventType::Quest )
{
auto questInfo = g_exdData.getQuestInfo( eventId );
if( questInfo )
{
player.sendDebug( "Quest not implemented: " + questInfo->name + "\n" + e.what() );
return false;
}
}
return false;
}
return true;
}
@ -290,7 +278,7 @@ bool Core::Scripting::ScriptManager::onEventHandlerReturn( Entity::Player& playe
else
pEvent->setPlayedScene( false );
}
// else, finish the event.
// else, finish the event.
else
player.eventFinish( eventId, 1 );
}
@ -307,20 +295,15 @@ bool Core::Scripting::ScriptManager::onEventHandlerReturn( Entity::Player& playe
bool Core::Scripting::ScriptManager::onEventHandlerTradeReturn( Entity::Player& player, uint32_t eventId,
uint16_t subEvent, uint16_t param, uint32_t catalogId )
{
std::string eventName = Event::getEventName( eventId ) + "_TRADE";
auto script = m_nativeScriptManager->getEventScript( eventId );
if( script )
{
script->onEventHandlerTradeReturn( player, eventId, subEvent, param, catalogId );
try
{
auto fn = m_pChaiHandler->eval< std::function< void( Entity::Player&, uint32_t,
uint16_t, uint16_t, uint32_t ) > >( eventName );
fn( player, eventId, subEvent, param, catalogId );
}
catch( ... )
{
return false;
return true;
}
return true;
return false;
}
bool Core::Scripting::ScriptManager::onEventItem( Entity::Player& player, uint32_t eventItemId,
@ -328,34 +311,26 @@ bool Core::Scripting::ScriptManager::onEventItem( Entity::Player& player, uint32
{
std::string eventName = "onEventItem";
std::string objName = Event::getEventName( eventId );
player.sendDebug( "Calling: " + objName + "." + eventName + " - " + std::to_string( eventId ) );
try
auto script = m_nativeScriptManager->getEventScript( eventId );
if( script )
{
auto obj = m_pChaiHandler->eval( Event::getEventName( eventId ) );
player.sendDebug( "Calling: " + objName + "." + eventName );
player.eventStart( targetId, eventId, Event::Event::Item, 0, 0 );
auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, uint32_t, Entity::Player&,
uint32_t, uint32_t, uint64_t ) > >( eventName );
fn( obj, eventId, player, eventItemId, castTime, targetId );
}
catch( std::exception& e )
{
player.sendNotice( e.what() );
return false;
script->onEventItem( player, eventItemId, eventId, castTime, targetId );
return true;
}
return true;
return false;
}
bool Core::Scripting::ScriptManager::onMobKill( Entity::Player& player, uint16_t nameId )
{
std::string eventName = "onBnpcKill_" + std::to_string( nameId );
// loop through all active quests and try to call available onMobKill callbacks
for( size_t i = 0; i < 30; i++ )
{
@ -364,23 +339,15 @@ bool Core::Scripting::ScriptManager::onMobKill( Entity::Player& player, uint16_t
continue;
uint16_t questId = activeQuests->c.questId;
if( questId != 0 )
auto script = m_nativeScriptManager->getEventScript( questId );
if( script )
{
auto obj = m_pChaiHandler->eval( Event::getEventName( 0x00010000 | questId ) );
std::string objName = Event::getEventName( 0x00010000 | questId );
player.sendDebug("Calling: " + objName + "." + eventName);
try
{
auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, Entity::Player& ) > >(eventName);
fn( obj, player );
}
catch( std::exception& e )
{
g_log.info( e.what() );
}
script->onNpcKill( nameId, player );
}
}
@ -389,115 +356,76 @@ bool Core::Scripting::ScriptManager::onMobKill( Entity::Player& player, uint16_t
bool Core::Scripting::ScriptManager::onCastFinish( Entity::Player& player, Entity::ActorPtr pTarget, uint32_t actionId )
{
std::string eventName = "onFinish";
auto script = m_nativeScriptManager->getActionScript( actionId );
try
{
auto obj = m_pChaiHandler->eval( "skillDef_" + std::to_string( actionId ) );
std::string objName = "skillDef_" + std::to_string( actionId );
if( script )
script->onCastFinish( player, *pTarget );
player.sendDebug( "Calling: " + objName + "." + eventName );
auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, Entity::Player&,
Entity::Actor& ) > >( eventName );
fn( obj, player, *pTarget );
}
catch( std::exception& e )
{
player.sendUrgent( e.what() );
}
return true;
return true;
}
bool Core::Scripting::ScriptManager::onStatusReceive( Entity::ActorPtr pActor, uint32_t effectId )
{
std::string eventName = "onReceive";
try
{
auto obj = m_pChaiHandler->eval( "statusDef_" + std::to_string( effectId ) );
std::string objName = "statusDef_" + std::to_string( effectId );
if( pActor->isPlayer() )
pActor->getAsPlayer()->sendDebug( "Calling: " + objName + "." + eventName );
auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, Entity::Actor&) > >( eventName );
fn( obj, *pActor );
}
catch( std::exception& e )
auto script = m_nativeScriptManager->getStatusEffectScript( effectId );
if( script )
{
if( pActor->isPlayer() )
pActor->getAsPlayer()->sendUrgent( e.what() );
pActor->getAsPlayer()->sendDebug( "Calling status receive for statusid: " + std::to_string( effectId ) );
script->onApply( *pActor );
return true;
}
return true;
return false;
}
bool Core::Scripting::ScriptManager::onStatusTick( Entity::ActorPtr pActor, Core::StatusEffect::StatusEffect& effect )
{
std::string eventName = "onTick";
try
{
auto obj = m_pChaiHandler->eval( "statusDef_" + std::to_string( effect.getId() ) );
std::string objName = "statusDef_" + std::to_string( effect.getId() );
if( pActor->isPlayer() )
pActor->getAsPlayer()->sendDebug( "Calling: " + objName + "." + eventName );
auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, Entity::Actor&,
StatusEffect::StatusEffect& ) > >( eventName );
fn( obj, *pActor, effect );
}
catch( std::exception& e )
auto script = m_nativeScriptManager->getStatusEffectScript( effect.getId() );
if( script )
{
if( pActor->isPlayer() )
pActor->getAsPlayer()->sendUrgent( e.what() );
pActor->getAsPlayer()->sendDebug( "Calling status tick for statusid: " + std::to_string( effect.getId() ) );
script->onTick( *pActor );
return true;
}
return true;
return false;
}
bool Core::Scripting::ScriptManager::onStatusTimeOut( Entity::ActorPtr pActor, uint32_t effectId )
{
std::string eventName = "onTimeOut";
try
{
auto obj = m_pChaiHandler->eval( "statusDef_" + std::to_string( effectId ) );
std::string objName = "statusDef_" + std::to_string( effectId );
if( pActor->isPlayer() )
pActor->getAsPlayer()->sendDebug( "Calling: " + objName + "." + eventName );
auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, Entity::Actor& ) > >( eventName );
fn( obj, *pActor );
}
catch( std::exception& e )
auto script = m_nativeScriptManager->getStatusEffectScript( effectId );
if( script )
{
if( pActor->isPlayer() )
pActor->getAsPlayer()->sendUrgent( e.what() );
pActor->getAsPlayer()->sendDebug( "Calling status timeout for statusid: " + std::to_string( effectId ) );
script->onExpire( *pActor );
return true;
}
return true;
return false;
}
bool Core::Scripting::ScriptManager::onZoneInit( ZonePtr pZone )
{
std::string eventName = "onZoneInit_" + pZone->getInternalName();
auto script = m_nativeScriptManager->getZoneScript( pZone->getId() );
if( script )
{
script->onZoneInit();
try
{
auto fn = m_pChaiHandler->eval< std::function< void( Zone& ) > >( eventName );
fn( *pZone );
}
catch( std::exception& e )
{
g_log.info( e.what() );
return false;
return true;
}
return true;
return false;
}
Scripting::NativeScriptManager& Core::Scripting::ScriptManager::getNativeScriptHandler()
{
return *m_nativeScriptManager;
}

20
src/servers/Server_Zone/Script/ScriptManager.h
View file

@ -8,12 +8,6 @@
#include <Server_Common/Common.h>
#include "Forwards.h"
namespace chaiscript
{
class ChaiScript;
}
namespace Core
{
namespace Scripting
@ -23,7 +17,7 @@ namespace Core
{
private:
boost::shared_ptr< chaiscript::ChaiScript > m_pChaiHandler;
boost::shared_ptr< NativeScriptManager > m_nativeScriptManager;
std::function< std::string( Entity::Player& ) > m_onFirstEnterWorld;
// auto fn = m_pChaiHandler->eval< std::function<const std::string( Entity::Player ) > >( "onFirstEnterWorld" );
@ -32,11 +26,9 @@ namespace Core
ScriptManager();
~ScriptManager();
int32_t init();
bool init();
void reload();
const boost::shared_ptr< chaiscript::ChaiScript >& getHandler() const;
void onPlayerFirstEnterWorld( Entity::Player& player );
static bool registerBnpcTemplate( std::string templateName, uint32_t bnpcBaseId, uint32_t bnpcNameId, uint32_t modelId, std::string aiName );
@ -57,14 +49,14 @@ namespace Core
bool onStatusTimeOut( Entity::ActorPtr pActor, uint32_t effectId );
bool onZoneInit( ZonePtr pZone );
bool onEventHandlerReturn( Entity::Player& player, uint32_t eventId, uint16_t subEvent, uint16_t param1, uint16_t param2, uint16_t param3 );
bool onEventHandlerTradeReturn( Entity::Player& player, uint32_t eventId, uint16_t subEvent, uint16_t param, uint32_t catalogId );
void loadDir( std::string dirname, std::set<std::string>& chaiFiles );
void loadDir( std::string dirname, std::set<std::string>& files, std::string ext );
NativeScriptManager& getNativeScriptHandler();
};
}
}

207
src/servers/Server_Zone/Script/ScriptManagerInit.cpp
View file

@ -1,207 +0,0 @@
#include <chaiscript/chaiscript.hpp>
#include <Server_Common/Config/XMLConfig.h>
#include <Server_Common/Logging/Logger.h>
#include <Server_Common/Script/ChaiscriptStdLib.h>
#include "ServerZone.h"
#include "Script/ScriptManager.h"
#include "Zone/Zone.h"
#include "Actor/Player.h"
#include "Actor/BattleNpc.h"
#include "Event/Event.h"
#include "Event/EventHelper.h"
#include "Network/PacketWrappers/ServerNoticePacket.h"
#include "StatusEffect/StatusEffect.h"
#include <boost/lexical_cast.hpp>
extern Core::Logger g_log;
extern Core::ServerZone g_serverZone;
int Core::Scripting::ScriptManager::init()
{
// ACTOR / PLAYER BINDINGS
/////////////////////////////////////////////////////////////////////////////////////////////
m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::getName ), "getName" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::getId ), "getId" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::getHp ), "getHp" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::getMp ), "getMp" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::getTp ), "getTp" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::getLevel ), "getLevel" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::getTargetId ), "getTargetId" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::addStatusEffect ), "addStatusEffect" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::addStatusEffectById ), "addStatusEffectById" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::addStatusEffectByIdIfNotExist ), "addStatusEffectByIdIfNotExist" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::takeDamage ), "takeDamage" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::forceZoneing ), "setZone" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getClassAsInt ), "getClass" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getRace ), "getRace" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getGender ), "getGender" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::gainExp ), "gainExp" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::unlock ), "unlock" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::registerAetheryte ), "aetheryteRegister" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::learnAction ), "learnAction" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getHomepoint ), "getHomepoint" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setHomepoint ), "setHomepoint" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::returnToHomepoint ), "returnToHomepoint" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::teleport ), "teleport" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::prepareZoning ), "prepareZoning" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::isInCombat ), "isInCombat" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getCurrency ), "getCurrency" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::addCurrency ), "addCurrency" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::removeCurrency ), "removeCurrency" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getCrystal ), "getCrystals" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::addCrystal ), "addCrystals" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::removeCrystal ), "removeCrystals" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::updateQuest ), "questUpdate" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::finishQuest ), "questFinish" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::sendQuestMessage ), "questMessage" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestSeq ), "questGetSeq" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::hasQuest ), "hasQuest" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getZoneId ), "getZoneId" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::handleScriptSkill ), "handleScriptSkill" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getOpeningSequence ), "getOpeningSequence" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setOpeningSequence ), "setOpeningSequence" );
m_pChaiHandler->add( chaiscript::fun( &Core::Event::mapEventActorToRealActor ), "mapActor" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8A ), "getQuestUI8A" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8B ), "getQuestUI8B" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8C ), "getQuestUI8C" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8D ), "getQuestUI8D" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8E ), "getQuestUI8E" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8F ), "getQuestUI8F" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8AH ), "getQuestUI8AH" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8BH ), "getQuestUI8BH" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8CH ), "getQuestUI8CH" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8DH ), "getQuestUI8DH" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8EH ), "getQuestUI8EH" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8FH ), "getQuestUI8FH" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8AL ), "getQuestUI8AL" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8BL ), "getQuestUI8BL" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8CL ), "getQuestUI8CL" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8DL ), "getQuestUI8DL" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8EL ), "getQuestUI8EL" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8FL ), "getQuestUI8FL" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI16A ), "getQuestUI16A" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI16B ), "getQuestUI16B" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI16C ), "getQuestUI16C" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI32A ), "getQuestUI32A" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestBitFlag8 ), "getQuestBitFlag8" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestBitFlag16 ), "getQuestBitFlag16" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestBitFlag24 ), "getQuestBitFlag24" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestBitFlag32 ), "getQuestBitFlag32" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestBitFlag40 ), "getQuestBitFlag40" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestBitFlag48 ), "getQuestBitFlag48" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8A ), "setQuestUI8A" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8B ), "setQuestUI8B" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8C ), "setQuestUI8C" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8D ), "setQuestUI8D" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8E ), "setQuestUI8E" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8F ), "setQuestUI8F" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8AH ), "setQuestUI8AH" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8BH ), "setQuestUI8BH" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8CH ), "setQuestUI8CH" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8DH ), "setQuestUI8DH" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8EH ), "setQuestUI8EH" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8FH ), "setQuestUI8FH" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8AL ), "setQuestUI8AL" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8BL ), "setQuestUI8BL" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8CL ), "setQuestUI8CL" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8DL ), "setQuestUI8DL" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8EL ), "setQuestUI8EL" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8FL ), "setQuestUI8FL" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI16A ), "setQuestUI16A" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI16B ), "setQuestUI16B" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI16C ), "setQuestUI16C" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI32A ), "setQuestUI32A" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestBitFlag8 ), "setQuestBitFlag8" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestBitFlag16 ), "setQuestBitFlag16" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestBitFlag24 ), "setQuestBitFlag24" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestBitFlag32 ), "setQuestBitFlag32" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestBitFlag40 ), "setQuestBitFlag40" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestBitFlag48 ), "setQuestBitFlag48" );
m_pChaiHandler->add(chaiscript::fun(&Entity::Player::giveQuestRewards), "giveQuestRewards");
m_pChaiHandler->add( chaiscript::fun< void, Entity::Player, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t >( &Entity::Player::eventPlay ), "eventPlay" );
m_pChaiHandler->add( chaiscript::fun< void, Entity::Player, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, EventReturnCallback >( &Entity::Player::eventPlay ), "eventPlay" );
m_pChaiHandler->add( chaiscript::fun< void, Entity::Player, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, EventReturnCallback >( &Entity::Player::eventPlay ), "eventPlay" );
m_pChaiHandler->add( chaiscript::fun< void, Entity::Player, uint32_t, uint32_t, uint32_t, EventReturnCallback >( &Entity::Player::eventPlay ), "eventPlay" );
m_pChaiHandler->add( chaiscript::fun< void, Entity::Player, uint32_t, uint32_t, uint32_t >( &Entity::Player::eventPlay ), "eventPlay" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::eventActionStart ), "eventActionStart" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::eventItemActionStart ), "eventItemActionStart" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::changePosition ), "changePos" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::tryAddItem ), "tryAddItem" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::isAetheryteRegistered ), "isAetheryteRegistered" );
m_pChaiHandler->add( chaiscript::fun( &Entity::Player::isActionLearned ), "isActionLearned" );
m_pChaiHandler->add( chaiscript::base_class< Entity::Actor, Entity::Player >() );
m_pChaiHandler->add( chaiscript::base_class< Entity::Actor, Entity::BattleNpc >() );
m_pChaiHandler->add( chaiscript::user_type< Entity::Actor >(), "Actor" );
m_pChaiHandler->add( chaiscript::user_type< Entity::Player >(), "Player" );
m_pChaiHandler->add( chaiscript::user_type< Entity::BattleNpc >(), "BattleNpc" );
m_pChaiHandler->add( chaiscript::user_type< StatusEffect::StatusEffect >(), "StatusEffect" );
m_pChaiHandler->add( chaiscript::fun( &StatusEffect::StatusEffect::registerTickEffect ), "registerTickEffect" );
m_pChaiHandler->add( chaiscript::user_type< Zone >(), "Zone" );
m_pChaiHandler->add( chaiscript::fun( &Zone::getName ), "getName" );
m_pChaiHandler->add( chaiscript::fun( &registerBnpcTemplate ), "registerBnpcTemplate" );
// EVENT BINDINGS
/////////////////////////////////////////////////////////////////////////////////////////////
std::set< std::string > chaiFiles;
loadDir( g_serverZone.getConfig()->getValue< std::string >( "Settings.General.ScriptPath", "../scripts/chai" ), chaiFiles );
uint16_t scriptCount = 0;
uint16_t errorCount = 0;
for( auto itr = chaiFiles.begin(); itr != chaiFiles.end(); ++itr )
{
auto& fileName = *itr;
try
{
m_pChaiHandler->eval_file( fileName );
scriptCount++;
}
catch( std::exception& e )
{
g_log.Log( LoggingSeverity::error, e.what() );
errorCount++;
}
}
g_log.info( "\tloaded " + std::to_string( scriptCount ) +
" scripts, " + std::to_string( errorCount ) + " errors." );
std::function<std::string( Entity::Player& ) > f =
m_pChaiHandler->eval< std::function<std::string( Entity::Player& ) > >( "onFirstEnterWorld" );
m_onFirstEnterWorld = f;
return true;
}

8
src/servers/Server_Zone/ServerZone.cpp
View file

@ -64,7 +64,7 @@ size_t Core::ServerZone::getSessionCount() const
return m_sessionMapById.size();
}
bool Core::ServerZone::registerBnpcTemplate( std::string templateName, uint32_t bnpcBaseId,
bool Core::ServerZone::registerBnpcTemplate( std::string templateName, uint32_t bnpcBaseId,
uint32_t bnpcNameId, uint32_t modelId, std::string aiName )
{
@ -222,14 +222,14 @@ void Core::ServerZone::run( int32_t argc, char* argv[] )
Network::HivePtr hive( new Network::Hive() );
Network::addServerToHive< Network::GameConnection >( m_ip, m_port, hive );
g_scriptMgr.init();
g_log.info( "ZoneMgr: Setting up zones" );
g_zoneMgr.createZones();
g_scriptMgr.init();
std::vector< std::thread > thread_list;
thread_list.emplace_back( std::thread( std::bind( &Network::Hive::Run, hive.get() ) ) );
g_log.info( "Server listening on port: " + std::to_string( m_port ) );
g_log.info( "Ready for connections..." );