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

Major rework of yield events.

Browse source
This commit is contained in:
Mordred 2023-02-01 13:34:21 +01:00
parent 9491b549a1
commit 00d62fbc6c
14 changed files with 656 additions and 282 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

258
src/common/Network/PacketDef/Zone/ServerZoneDef.h
View file

@ -1240,47 +1240,13 @@ namespace Sapphire::Network::Packets::WorldPackets::Server
uint32_t handlerIds[ArgCount];
};
struct FFXIVIpcMapMarker2 :
FFXIVIpcBasePacket< MapMarker2 >,
FFXIVIpcMapMarkerN< 2 >
{
};
struct FFXIVIpcMapMarker4 :
FFXIVIpcBasePacket< MapMarker4 >,
FFXIVIpcMapMarkerN< 4 >
{
};
struct FFXIVIpcMapMarker8 :
FFXIVIpcBasePacket< MapMarker8 >,
FFXIVIpcMapMarkerN< 8 >
{
};
struct FFXIVIpcMapMarker16 :
FFXIVIpcBasePacket< MapMarker16 >,
FFXIVIpcMapMarkerN< 16 >
{
};
struct FFXIVIpcMapMarker32 :
FFXIVIpcBasePacket< MapMarker32 >,
FFXIVIpcMapMarkerN< 32 >
{
};
struct FFXIVIpcMapMarker64 :
FFXIVIpcBasePacket< MapMarker64 >,
FFXIVIpcMapMarkerN< 64 >
{
};
struct FFXIVIpcMapMarker128 :
FFXIVIpcBasePacket< MapMarker128 >,
FFXIVIpcMapMarkerN< 128 >
{
};
struct FFXIVIpcMapMarker2 : FFXIVIpcBasePacket< MapMarker2 >, FFXIVIpcMapMarkerN< 2 > {};
struct FFXIVIpcMapMarker4 : FFXIVIpcBasePacket< MapMarker4 >, FFXIVIpcMapMarkerN< 4 > {};
struct FFXIVIpcMapMarker8 : FFXIVIpcBasePacket< MapMarker8 >, FFXIVIpcMapMarkerN< 8 > {};
struct FFXIVIpcMapMarker16 : FFXIVIpcBasePacket< MapMarker16 >, FFXIVIpcMapMarkerN< 16 > {};
struct FFXIVIpcMapMarker32 : FFXIVIpcBasePacket< MapMarker32 >, FFXIVIpcMapMarkerN< 32 > {};
struct FFXIVIpcMapMarker64 : FFXIVIpcBasePacket< MapMarker64 >, FFXIVIpcMapMarkerN< 64 > {};
struct FFXIVIpcMapMarker128 : FFXIVIpcBasePacket< MapMarker128 >, FFXIVIpcMapMarkerN< 128 > {};
template< int ArgCount >
struct FFXIVIpcBattleTalkN
@ -1301,29 +1267,10 @@ namespace Sapphire::Network::Packets::WorldPackets::Server
uint32_t args[ArgCount];
};
struct FFXIVIpcBattleTalkHeader :
FFXIVIpcBasePacket< BattleTalkHeader >,
FFXIVIpcBattleTalkN< 1 >
{
};
struct FFXIVIpcBattleTalk2 :
FFXIVIpcBasePacket< BattleTalk2 >,
FFXIVIpcBattleTalkN< 2 >
{
};
struct FFXIVIpcBattleTalk4 :
FFXIVIpcBasePacket< BattleTalk4 >,
FFXIVIpcBattleTalkN< 4 >
{
};
struct FFXIVIpcBattleTalk8 :
FFXIVIpcBasePacket< BattleTalk8 >,
FFXIVIpcBattleTalkN< 8 >
{
};
struct FFXIVIpcBattleTalkHeader : FFXIVIpcBasePacket< BattleTalkHeader >, FFXIVIpcBattleTalkN< 1 > {};
struct FFXIVIpcBattleTalk2 : FFXIVIpcBasePacket< BattleTalk2 >, FFXIVIpcBattleTalkN< 2 > {};
struct FFXIVIpcBattleTalk4 : FFXIVIpcBasePacket< BattleTalk4 >, FFXIVIpcBattleTalkN< 4 > {};
struct FFXIVIpcBattleTalk8 : FFXIVIpcBasePacket< BattleTalk8 >, FFXIVIpcBattleTalkN< 8 > {};
template< int ArgCount >
struct FFXIVIpcEventLogMessageN
@ -1338,41 +1285,32 @@ namespace Sapphire::Network::Packets::WorldPackets::Server
uint32_t unknown_1;
};
struct FFXIVIpcEventLogMessageHeader :
FFXIVIpcBasePacket< EventLogMessageHeader >,
FFXIVIpcEventLogMessageN< 1 >
struct FFXIVIpcEventLogMessageHeader : FFXIVIpcBasePacket< EventLogMessageHeader >, FFXIVIpcEventLogMessageN< 1 > {};
struct FFXIVIpcEventLogMessage2 : FFXIVIpcBasePacket< EventLogMessage2 >, FFXIVIpcEventLogMessageN< 2 > {};
struct FFXIVIpcEventLogMessage4 : FFXIVIpcBasePacket< EventLogMessage4 >, FFXIVIpcEventLogMessageN< 4 > {};
struct FFXIVIpcEventLogMessage8 : FFXIVIpcBasePacket< EventLogMessage8 >, FFXIVIpcEventLogMessageN< 8 > {};
struct FFXIVIpcEventLogMessage16 : FFXIVIpcBasePacket< EventLogMessage16 >, FFXIVIpcEventLogMessageN< 16 > {};
struct FFXIVIpcEventLogMessage32 : FFXIVIpcBasePacket< EventLogMessage32 >, FFXIVIpcEventLogMessageN< 32 > {};
template< int ArgCount >
struct FFXIVIpcUpdateEventSceneN
{
uint32_t handlerId;
uint16_t sceneId;
uint8_t numOfArgs;
uint8_t __padding1;
uint32_t args[ArgCount];
};
struct FFXIVIpcEventLogMessage2 :
FFXIVIpcBasePacket< EventLogMessage2 >,
FFXIVIpcEventLogMessageN< 2 >
{
};
struct FFXIVIpcEventLogMessage4 :
FFXIVIpcBasePacket< EventLogMessage4 >,
FFXIVIpcEventLogMessageN< 4 >
{
};
struct FFXIVIpcEventLogMessage8 :
FFXIVIpcBasePacket< EventLogMessage8 >,
FFXIVIpcEventLogMessageN< 8 >
{
};
struct FFXIVIpcEventLogMessage16 :
FFXIVIpcBasePacket< EventLogMessage16 >,
FFXIVIpcEventLogMessageN< 16 >
{
};
struct FFXIVIpcEventLogMessage32 :
FFXIVIpcBasePacket< EventLogMessage32 >,
FFXIVIpcEventLogMessageN< 32 >
{
};
struct FFXIVIpcUpdateEventSceneHeader : FFXIVIpcBasePacket< UpdateEventSceneHeader >, FFXIVIpcUpdateEventSceneN< 1 > {};
struct FFXIVIpcUpdateEventScene2 : FFXIVIpcBasePacket< UpdateEventScene2 >, FFXIVIpcUpdateEventSceneN< 2 > {};
struct FFXIVIpcUpdateEventScene4 : FFXIVIpcBasePacket< UpdateEventScene4 >, FFXIVIpcUpdateEventSceneN< 4 > {};
struct FFXIVIpcUpdateEventScene8 : FFXIVIpcBasePacket< UpdateEventScene8 >, FFXIVIpcUpdateEventSceneN< 8 > {};
struct FFXIVIpcUpdateEventScene16 : FFXIVIpcBasePacket< UpdateEventScene16 >, FFXIVIpcUpdateEventSceneN< 16 > {};
struct FFXIVIpcUpdateEventScene32 : FFXIVIpcBasePacket< UpdateEventScene32 >, FFXIVIpcUpdateEventSceneN< 32 > {};
struct FFXIVIpcUpdateEventScene64 : FFXIVIpcBasePacket< UpdateEventScene64 >, FFXIVIpcUpdateEventSceneN< 64 > {};
struct FFXIVIpcUpdateEventScene128 : FFXIVIpcBasePacket< UpdateEventScene128 >, FFXIVIpcUpdateEventSceneN< 128 > {};
struct FFXIVIpcUpdateEventScene255 : FFXIVIpcBasePacket< UpdateEventScene255 >, FFXIVIpcUpdateEventSceneN< 255 > {};
template< int ArgCount >
struct FFXIVIpcPlayEventSceneN
@ -1391,59 +1329,15 @@ namespace Sapphire::Network::Packets::WorldPackets::Server
* Structural representation of the packet sent by the server
* to play an event
*/
struct FFXIVIpcPlayEventSceneHeader :
FFXIVIpcBasePacket< EventPlayHeader >,
FFXIVIpcPlayEventSceneN< 1 >
{
};
struct FFXIVIpcPlayEventScene2 :
FFXIVIpcBasePacket< EventPlay2 >,
FFXIVIpcPlayEventSceneN< 2 >
{
};
struct FFXIVIpcPlayEventScene4 :
FFXIVIpcBasePacket< EventPlay4 >,
FFXIVIpcPlayEventSceneN< 4 >
{
};
struct FFXIVIpcPlayEventScene8 :
FFXIVIpcBasePacket< EventPlay8 >,
FFXIVIpcPlayEventSceneN< 8 >
{
};
struct FFXIVIpcPlayEventScene16 :
FFXIVIpcBasePacket< EventPlay16 >,
FFXIVIpcPlayEventSceneN< 16 >
{
};
struct FFXIVIpcPlayEventScene32 :
FFXIVIpcBasePacket< EventPlay32 >,
FFXIVIpcPlayEventSceneN< 32 >
{
};
struct FFXIVIpcPlayEventScene64 :
FFXIVIpcBasePacket< EventPlay64 >,
FFXIVIpcPlayEventSceneN< 64 >
{
};
struct FFXIVIpcPlayEventScene128:
FFXIVIpcBasePacket< EventPlay128 >,
FFXIVIpcPlayEventSceneN< 128 >
{
};
struct FFXIVIpcPlayEventScene255:
FFXIVIpcBasePacket< EventPlay255 >,
FFXIVIpcPlayEventSceneN< 255 >
{
};
struct FFXIVIpcPlayEventSceneHeader : FFXIVIpcBasePacket< EventPlayHeader >, FFXIVIpcPlayEventSceneN< 1 > {};
struct FFXIVIpcPlayEventScene2 : FFXIVIpcBasePacket< EventPlay2 >, FFXIVIpcPlayEventSceneN< 2 > {};
struct FFXIVIpcPlayEventScene4 : FFXIVIpcBasePacket< EventPlay4 >, FFXIVIpcPlayEventSceneN< 4 > {};
struct FFXIVIpcPlayEventScene8 : FFXIVIpcBasePacket< EventPlay8 >, FFXIVIpcPlayEventSceneN< 8 > {};
struct FFXIVIpcPlayEventScene16 : FFXIVIpcBasePacket< EventPlay16 >, FFXIVIpcPlayEventSceneN< 16 > {};
struct FFXIVIpcPlayEventScene32 : FFXIVIpcBasePacket< EventPlay32 >, FFXIVIpcPlayEventSceneN< 32 > {};
struct FFXIVIpcPlayEventScene64 : FFXIVIpcBasePacket< EventPlay64 >, FFXIVIpcPlayEventSceneN< 64 > {};
struct FFXIVIpcPlayEventScene128 : FFXIVIpcBasePacket< EventPlay128 >, FFXIVIpcPlayEventSceneN< 128 > {};
struct FFXIVIpcPlayEventScene255 : FFXIVIpcBasePacket< EventPlay255 >, FFXIVIpcPlayEventSceneN< 255 > {};
/**
* Structural representation of the packet sent by the server
@ -1478,26 +1372,26 @@ namespace Sapphire::Network::Packets::WorldPackets::Server
uint32_t eventArg;
};
struct FFXIVIpcEventPlay255 :
FFXIVIpcBasePacket< EventPlay255 >,
FFXIVIpcPlayEventSceneN< 255 >
{
};
/**
* Structural representation of the packet sent by the server
* to respond to a linkshell creation event
*/
struct FFXIVIpcResumeEventScene2 : FFXIVIpcBasePacket< ResumeEventScene2 >
template< int ArgCount >
struct FFXIVIpcResumeEventSceneN
{
uint32_t handlerId;
uint16_t sceneId;
uint8_t resumeId;
uint8_t numOfArgs;
uint32_t args[4];
uint32_t args[ArgCount];
};
struct FFXIVIpcResumeEventSceneHeader : FFXIVIpcBasePacket< ResumeEventSceneHeader >, FFXIVIpcResumeEventSceneN< 1 > {};
struct FFXIVIpcResumeEventScene2 : FFXIVIpcBasePacket< ResumeEventScene2 >, FFXIVIpcResumeEventSceneN< 2 > {};
struct FFXIVIpcResumeEventScene4 : FFXIVIpcBasePacket< ResumeEventScene4 >, FFXIVIpcResumeEventSceneN< 4 > {};
struct FFXIVIpcResumeEventScene8 : FFXIVIpcBasePacket< ResumeEventScene8 >, FFXIVIpcResumeEventSceneN< 8 > {};
struct FFXIVIpcResumeEventScene16 : FFXIVIpcBasePacket< ResumeEventScene16 >, FFXIVIpcResumeEventSceneN< 16 > {};
struct FFXIVIpcResumeEventScene32 : FFXIVIpcBasePacket< ResumeEventScene32 >, FFXIVIpcResumeEventSceneN< 32 > {};
struct FFXIVIpcResumeEventScene64 : FFXIVIpcBasePacket< ResumeEventScene64 >, FFXIVIpcResumeEventSceneN< 64 > {};
struct FFXIVIpcResumeEventScene128 : FFXIVIpcBasePacket< ResumeEventScene128 >, FFXIVIpcResumeEventSceneN< 128 > {};
struct FFXIVIpcResumeEventScene255 : FFXIVIpcBasePacket< ResumeEventScene255 >, FFXIVIpcResumeEventSceneN< 255 > {};
/**
* Structural representation of the packet sent by the server
* to send the active quests
@ -1553,11 +1447,6 @@ namespace Sapphire::Network::Packets::WorldPackets::Server
uint32_t args[Size];
};
struct FFXIVIpcNoticeHeader :
FFXIVIpcBasePacket< NoticeHeader >,
FFXIVIpcNoticeN< 1 >
{
};
/*!
* Structural representation of the packet sent by the server
@ -1566,35 +1455,12 @@ namespace Sapphire::Network::Packets::WorldPackets::Server
* type 1 icon
* type 5 status
*/
struct FFXIVIpcNotice2 :
FFXIVIpcBasePacket< Notice2 >,
FFXIVIpcNoticeN< 2 >
{
};
struct FFXIVIpcNotice4 :
FFXIVIpcBasePacket< Notice4 >,
FFXIVIpcNoticeN< 4 >
{
};
struct FFXIVIpcNotice8 :
FFXIVIpcBasePacket< Notice8 >,
FFXIVIpcNoticeN< 8 >
{
};
struct FFXIVIpcNotice16 :
FFXIVIpcBasePacket< Notice16 >,
FFXIVIpcNoticeN< 16 >
{
};
struct FFXIVIpcNotice32 :
FFXIVIpcBasePacket< Notice32 >,
FFXIVIpcNoticeN< 32 >
{
};
struct FFXIVIpcNoticeHeader : FFXIVIpcBasePacket< NoticeHeader >, FFXIVIpcNoticeN< 1 > {};
struct FFXIVIpcNotice2 : FFXIVIpcBasePacket< Notice2 >, FFXIVIpcNoticeN< 2 > {};
struct FFXIVIpcNotice4 : FFXIVIpcBasePacket< Notice4 >, FFXIVIpcNoticeN< 4 > {};
struct FFXIVIpcNotice8 : FFXIVIpcBasePacket< Notice8 >, FFXIVIpcNoticeN< 8 > {};
struct FFXIVIpcNotice16 : FFXIVIpcBasePacket< Notice16 >, FFXIVIpcNoticeN< 16 > {};
struct FFXIVIpcNotice32 : FFXIVIpcBasePacket< Notice32 >, FFXIVIpcNoticeN< 32 > {};
struct FFXIVIpcQuestTracker : FFXIVIpcBasePacket< Tracking >
{

63
src/scripts/common/CmnDefLinkShell.cpp
View file

@ -42,44 +42,13 @@ public:
// create linkshell
void Scene00002( Entity::Player& player )
{
auto callback = [ this ]( Entity::Player& player, const Event::SceneResult& result )
{
auto ls = linkshellMgr().createLinkshell( result.resultString, player );
if( !ls )
{
eventMgr().resumeScene( player, result.eventId, result.sceneId, { 0x15a }, false );
linkshellMgr().finishLinkshellAction( result.resultString, 0x15a, player, 1 );
}
else
{
eventMgr().resumeScene( player, result.eventId, result.sceneId, { 0 }, true );
linkshellMgr().finishLinkshellAction( result.resultString, 0, player, 1 );
}
};
eventMgr().playScene( player, getId(), 2, HIDE_HOTBAR, callback );
eventMgr().playScene( player, getId(), 2, HIDE_HOTBAR );
}
// rename linkshell
void Scene00003( Entity::Player& player )
{
auto callback = [ this ]( Entity::Player& player, const Event::SceneResult& result )
{
auto ls = linkshellMgr().renameLinkshell( result.intResult, result.resultString, player );
if( !ls )
{
eventMgr().resumeScene( player, result.eventId, result.sceneId, { 0x15a }, false );
linkshellMgr().finishLinkshellAction( result.resultString, 0x15a, player, 3 );
}
else
{
eventMgr().resumeScene( player, result.eventId, result.sceneId, { 0 }, true );
linkshellMgr().finishLinkshellAction( result.resultString, 0, player, 3 );
}
};
eventMgr().playScene( player, getId(), 3, HIDE_HOTBAR, callback );
eventMgr().playScene( player, getId(), 3, HIDE_HOTBAR );
}
// remove linkshell
@ -92,6 +61,34 @@ public:
{
Scene00001( player );
}
void onYield( uint32_t eventId, uint16_t sceneId, uint8_t yieldId, Entity::Player& player, const std::string& resultString, uint64_t resultInt ) override
{
auto errorCode = 0u;
switch( sceneId )
{
case 2:
{
auto ls = linkshellMgr().createLinkshell( resultString, player );
if( !ls )
errorCode = 0x15a;
eventMgr().resumeScene( player, eventId, sceneId, yieldId, { errorCode } );
linkshellMgr().finishLinkshellAction( resultString, errorCode, player, 1 );
break;
}
case 3:
{
auto ls = linkshellMgr().renameLinkshell( resultInt, resultString, player );
if( !ls )
errorCode = 0x15a;
eventMgr().resumeScene( player, eventId, sceneId, yieldId, { errorCode } );
linkshellMgr().finishLinkshellAction( resultString, errorCode, player, 3 );
break;
}
}
}
};
EXPOSE_SCRIPT( CmnDefLinkShell );

12
src/scripts/common/ComDefFreeCompany.cpp
View file

@ -43,6 +43,12 @@ class ComDefFreeCompany : public Sapphire::ScriptAPI::EventScript
Scene00000( player );
}
void onYield( uint32_t eventId, uint16_t sceneId, uint8_t yieldId, Entity::Player& player, const std::string& resultString, uint64_t resultInt ) override
{
if( yieldId == 0x11 )
eventMgr().resumeScene( player, eventId, sceneId, yieldId, { 3, 2, 7, 2149548032, 118598, 1, 0, 1, 1, 1 } );
}
private:
//////////////////////////////////////////////////////////////////////
@ -51,18 +57,20 @@ class ComDefFreeCompany : public Sapphire::ScriptAPI::EventScript
void Scene00000( Entity::Player& player )
{
eventMgr().playScene( player, getId(), 0, NONE, bindSceneReturn( &ComDefFreeCompany::Scene00000Return ) );
eventMgr().playScene( player, getId(), 0, HIDE_HOTBAR, bindSceneReturn( &ComDefFreeCompany::Scene00000Return ) );
}
void Scene00000Return( Entity::Player& player, const Event::SceneResult& result )
{
//Scene00001( player );
}
//////////////////////////////////////////////////////////////////////
void Scene00001( Entity::Player& player )
{
eventMgr().playScene( player, getId(), 1, NONE, bindSceneReturn( &ComDefFreeCompany::Scene00001Return ) );
eventMgr().playScene( player, getId(), 1, HIDE_HOTBAR, bindSceneReturn( &ComDefFreeCompany::Scene00001Return ) );
}
void Scene00001Return( Entity::Player& player, const Event::SceneResult& result )

178
src/scripts/common/ComDefGrandCompanyOfficer.cpp Normal file
View file

@ -0,0 +1,178 @@
// This is an automatically generated C++ script template
// Content needs to be added by hand to make it function
// In order for this script to be loaded, move it to the correct folder in <root>/scripts/
#include <Actor/Player.h>
#include "Manager/EventMgr.h"
#include <ScriptObject.h>
#include <Service.h>
// Script: ComDefGrandCompanyOfficer_00073
// Event Name: Small Talk
// Event ID: 720969
using namespace Sapphire;
class ComDefGrandCompanyOfficer : public Sapphire::ScriptAPI::EventScript
{
private:
// Basic event information
// Entities found in the script data of the event
static constexpr auto GcLeveUnlock = 1616;
static constexpr auto GcRank08 = 8;
static constexpr auto GcRankMax = 9;
static constexpr auto GcRankRewardDeliverly = 6;
static constexpr auto GcRankRewardGcchange = 9;
static constexpr auto GcRankRewardLv30Leve = 5;
static constexpr auto GcRankRewardLv45Leve = 8;
static constexpr auto GcTransferUnlock = 1617;
static constexpr auto GrandCompanyInvalid = 0;
static constexpr auto ImmortalFlames = 3;
static constexpr auto LogmsgGcTransferCfError = 3151;
static constexpr auto Maelstrom = 1;
static constexpr auto NpcOfGridania = 1002394;
static constexpr auto NpcOfLimsa = 1002388;
static constexpr auto NpcOfUldah = 1002391;
static constexpr auto OrderOfTwinAdder = 2;
static constexpr auto ProcurementMission = 720971;
static constexpr auto ScreenImageBooty = 70;
static constexpr auto ScreenImageLeve = 71;
public:
ComDefGrandCompanyOfficer() : Sapphire::ScriptAPI::EventScript( 720969 ){};
~ComDefGrandCompanyOfficer() = default;
//////////////////////////////////////////////////////////////////////
// Event Handlers
void onTalk( uint32_t eventId, Entity::Player& player, uint64_t actorId ) override
{
Scene00000( player );
}
private:
//////////////////////////////////////////////////////////////////////
// Available Scenes in this event, not necessarly all are used
//////////////////////////////////////////////////////////////////////
void Scene00000( Entity::Player& player )
{
eventMgr().playScene( player, getId(), 0, HIDE_HOTBAR, bindSceneReturn( &ComDefGrandCompanyOfficer::Scene00000Return ) );
}
void Scene00000Return( Entity::Player& player, const Event::SceneResult& result )
{
}
//////////////////////////////////////////////////////////////////////
void Scene00001( Entity::Player& player )
{
eventMgr().playScene( player, getId(), 1, HIDE_HOTBAR, bindSceneReturn( &ComDefGrandCompanyOfficer::Scene00001Return ) );
}
void Scene00001Return( Entity::Player& player, const Event::SceneResult& result )
{
}
//////////////////////////////////////////////////////////////////////
void Scene00002( Entity::Player& player )
{
eventMgr().playScene( player, getId(), 2, NONE, bindSceneReturn( &ComDefGrandCompanyOfficer::Scene00002Return ) );
}
void Scene00002Return( Entity::Player& player, const Event::SceneResult& result )
{
}
//////////////////////////////////////////////////////////////////////
void Scene00003( Entity::Player& player )
{
eventMgr().playScene( player, getId(), 3, NONE, bindSceneReturn( &ComDefGrandCompanyOfficer::Scene00003Return ) );
}
void Scene00003Return( Entity::Player& player, const Event::SceneResult& result )
{
}
//////////////////////////////////////////////////////////////////////
void Scene00004( Entity::Player& player )
{
eventMgr().playScene( player, getId(), 4, NONE, bindSceneReturn( &ComDefGrandCompanyOfficer::Scene00004Return ) );
}
void Scene00004Return( Entity::Player& player, const Event::SceneResult& result )
{
}
//////////////////////////////////////////////////////////////////////
void Scene00005( Entity::Player& player )
{
eventMgr().playScene( player, getId(), 5, FADE_OUT | HIDE_UI, bindSceneReturn( &ComDefGrandCompanyOfficer::Scene00005Return ) );
}
void Scene00005Return( Entity::Player& player, const Event::SceneResult& result )
{
}
//////////////////////////////////////////////////////////////////////
void Scene00006( Entity::Player& player )
{
eventMgr().playScene( player, getId(), 6, FADE_OUT | HIDE_UI, bindSceneReturn( &ComDefGrandCompanyOfficer::Scene00006Return ) );
}
void Scene00006Return( Entity::Player& player, const Event::SceneResult& result )
{
}
//////////////////////////////////////////////////////////////////////
void Scene00007( Entity::Player& player )
{
eventMgr().playScene( player, getId(), 7, NONE, bindSceneReturn( &ComDefGrandCompanyOfficer::Scene00007Return ) );
}
void Scene00007Return( Entity::Player& player, const Event::SceneResult& result )
{
}
//////////////////////////////////////////////////////////////////////
void Scene00008( Entity::Player& player )
{
eventMgr().playScene( player, getId(), 8, FADE_OUT | HIDE_UI, bindSceneReturn( &ComDefGrandCompanyOfficer::Scene00008Return ) );
}
void Scene00008Return( Entity::Player& player, const Event::SceneResult& result )
{
}
//////////////////////////////////////////////////////////////////////
void Scene00009( Entity::Player& player )
{
eventMgr().playScene( player, getId(), 9, FADE_OUT | HIDE_UI, bindSceneReturn( &ComDefGrandCompanyOfficer::Scene00009Return ) );
}
void Scene00009Return( Entity::Player& player, const Event::SceneResult& result )
{
}
//////////////////////////////////////////////////////////////////////
void Scene00010( Entity::Player& player )
{
eventMgr().playScene( player, getId(), 10, FADE_OUT | HIDE_UI, bindSceneReturn( &ComDefGrandCompanyOfficer::Scene00010Return ) );
}
void Scene00010Return( Entity::Player& player, const Event::SceneResult& result )
{
}
};
EXPOSE_SCRIPT( ComDefGrandCompanyOfficer );

3
src/scripts/common/FcTalk.cpp
View file

@ -5,8 +5,7 @@
using namespace Sapphire;
class FcTalk :
public Sapphire::ScriptAPI::EventScript
class FcTalk : public Sapphire::ScriptAPI::EventScript
{
public:
FcTalk() :

2
src/tools/custom_talk_parser/main.cpp
View file

@ -465,7 +465,7 @@ createScript( std::shared_ptr< Excel::ExcelStruct< Excel::CustomTalk > >& pQuest
scriptEntry += " //////////////////////////////////////////////////////////////////////\n // Event Handlers\n";
scriptEntry +=
" void onTalk( Entity::Player& player, uint64_t actorId ) override\n"
" void onTalk( uint32_t eventId, Entity::Player& player, uint64_t actorId ) override\n"
" {\n" ;
if( !actorList.empty() )
{

108
src/world/Manager/EventMgr.cpp
View file

@ -17,6 +17,7 @@
#include "Network/PacketWrappers/EventStartPacket.h"
#include "Network/PacketWrappers/EventPlayPacket.h"
#include "Network/PacketWrappers/EventFinishPacket.h"
#include "Network/PacketWrappers/EventResumePacket.h"
#include "Network/PacketWrappers/Notice2Packet.h"
#include "Territory/InstanceObjectCache.h"
@ -27,6 +28,7 @@
#include "Action/EventAction.h"
#include "WorldServer.h"
#include "Actor/Player.h"
#include <Script/ScriptMgr.h>
using namespace Sapphire;
using namespace Sapphire::Network::Packets;
@ -334,6 +336,58 @@ void EventMgr::handleReturnEventScene( Entity::Player& player, uint32_t eventId,
checkEvent( player, eventId );
}
void EventMgr::handleYieldEventScene( Entity::Player& player, uint32_t eventId, uint16_t sceneId, uint8_t resumeId,
uint8_t numOfResults, const std::vector< uint32_t >& results )
{
auto& scriptMgr = Common::Service< Scripting::ScriptMgr >::ref();
std::string eventName = getEventName( eventId );
PlayerMgr::sendDebug( player, "eventId: {0} ({0:08X}) scene: {1}, resumeId: {2} numArgs: {3}",
eventId, sceneId, resumeId, numOfResults );
uint8_t index = 0;
for( auto r : results )
{
PlayerMgr::sendDebug( player, "arg#{0}: {1} ({1:08X})", index++, r );
}
std::string tmp{};
if( !scriptMgr.onYield( player, eventId, sceneId, resumeId, tmp, 0 ) )
{
PlayerMgr::sendDebug( player, "Yield not implemented in script, sending default" );
}
}
void EventMgr::handleYieldStringEventScene( Entity::Player& player, uint32_t eventId, uint16_t sceneId, uint8_t resumeId, const std::string& resultString )
{
auto& scriptMgr = Common::Service< Scripting::ScriptMgr >::ref();
std::string eventName = getEventName( eventId );
PlayerMgr::sendDebug( player, "eventId: {0} ({0:08X}) scene: {1}, resumeId: {2} resultString: {3}",
eventId, sceneId, resumeId, resultString );
if( !scriptMgr.onYield( player, eventId, sceneId, resumeId, resultString, 0 ) )
{
PlayerMgr::sendDebug( player, "Yield not implemented in script, sending default" );
}
}
void EventMgr::handleYieldStringIntEventScene( Entity::Player& player, uint32_t eventId, uint16_t sceneId, uint8_t resumeId,
const std::string& resultString, uint64_t resultInt )
{
auto& scriptMgr = Common::Service< Scripting::ScriptMgr >::ref();
std::string eventName = getEventName( eventId );
PlayerMgr::sendDebug( player, "eventId: {0} ({0:08X}) scene: {1}, resumeId: {2} resultString: {3} resultInt: {4}",
eventId, sceneId, resumeId, resultString, resultInt );
if( !scriptMgr.onYield( player, eventId, sceneId, resumeId, resultString, resultInt ) )
{
PlayerMgr::sendDebug( player, "Yield not implemented in script, sending default" );
}
}
void EventMgr::handleReturnStringEventScene( Entity::Player& player, uint32_t eventId, uint16_t sceneId, const std::string& resultString )
{
std::string eventName = getEventName( eventId );
@ -643,26 +697,32 @@ void EventMgr::playScene( Entity::Player& player, uint32_t eventId, uint32_t sce
sendEventPlay( player, eventId, scene, flags );
}
void EventMgr::resumeScene( Entity::Player& player, uint32_t eventId, uint32_t scene, std::vector< uint32_t > values, bool resetCallback )
void EventMgr::resumeScene( Entity::Player& player, uint32_t eventId, uint32_t scene, uint8_t yieldId, std::vector< uint32_t > values )
{
auto pEvent = bootstrapSceneEvent( player, eventId, 0 );
if( !pEvent )
return;
FFXIVPacketBasePtr pPacket = nullptr;
size_t paramCount = values.size();
if( resetCallback )
pEvent->setEventReturnCallback( nullptr );
assert( paramCount <= 255 );
if( paramCount < 2 )
pPacket = std::move( std::make_shared< EventResume2Packet >( player, eventId, scene, yieldId, values ) );
else if( paramCount < 4 )
pPacket = std::move( std::make_shared< EventResume4Packet >( player, eventId, scene, yieldId, values ) );
else if( paramCount < 8 )
pPacket = std::move( std::make_shared< EventResume8Packet >( player, eventId, scene, yieldId, values ) );
else if( paramCount < 16 )
pPacket = std::move( std::make_shared< EventResume16Packet >( player, eventId, scene, yieldId, values ) );
else if( paramCount < 32 )
pPacket = std::move( std::make_shared< EventResume32Packet >( player, eventId, scene, yieldId, values ) );
else if( paramCount < 64 )
pPacket = std::move( std::make_shared< EventResume64Packet >( player, eventId, scene, yieldId, values ) );
else if( paramCount < 128 )
pPacket = std::move( std::make_shared< EventResume128Packet >( player, eventId, scene, yieldId, values ) );
else if ( paramCount < 255 )
pPacket = std::move( std::make_shared< EventResume255Packet >( player, eventId, scene, yieldId, values ) );
auto resumeEvent = makeZonePacket< FFXIVIpcResumeEventScene2 >( player.getId() );
resumeEvent->data().handlerId = eventId;
resumeEvent->data().sceneId = static_cast< uint8_t >( scene );
resumeEvent->data().numOfArgs = static_cast< uint8_t >( values.size() );
int i = 0;
for( auto& val : values )
{
resumeEvent->data().args[ i++ ] = val;
}
auto& server = Common::Service< World::WorldServer >::ref();
server.queueForPlayer( player.getCharacterId(), resumeEvent );
server.queueForPlayer( player.getCharacterId(), pPacket );
}
void EventMgr::playScene( Entity::Player& player, uint32_t eventId, uint32_t scene, uint32_t flags, Event::EventHandler::SceneReturnCallback eventCallback )
@ -750,37 +810,21 @@ bool EventMgr::sendEventPlay( Entity::Player& player, uint32_t eventId, uint32_t
assert( paramCount <= 255 );
if( paramCount < 2 )
{
pPacket = std::move( std::make_shared< EventPlayPacket2 >( player, pEvent->getActorId(), pEvent->getId(), scene, flags ) );
}
else if( paramCount < 4 )
{
pPacket = std::move( std::make_shared< EventPlayPacket4 >( player, pEvent->getActorId(), pEvent->getId(), scene, flags ) );
}
else if( paramCount < 8 )
{
pPacket = std::move( std::make_shared< EventPlayPacket8 >( player, pEvent->getActorId(), pEvent->getId(), scene, flags ) );
}
else if( paramCount < 16 )
{
pPacket = std::move( std::make_shared< EventPlayPacket16 >( player, pEvent->getActorId(), pEvent->getId(), scene, flags ) );
}
else if( paramCount < 32 )
{
pPacket = std::move( std::make_shared< EventPlayPacket32 >( player, pEvent->getActorId(), pEvent->getId(), scene, flags ) );
}
else if( paramCount < 64 )
{
pPacket = std::move( std::make_shared< EventPlayPacket64 >( player, pEvent->getActorId(), pEvent->getId(), scene, flags ) );
}
else if( paramCount < 128 )
{
pPacket = std::move( std::make_shared< EventPlayPacket128 >( player, pEvent->getActorId(), pEvent->getId(), scene, flags ) );
}
else if ( paramCount < 255 )
{
pPacket = std::move( std::make_shared< EventPlayPacket255 >( player, pEvent->getActorId(), pEvent->getId(), scene, flags ) );
}
auto& server = Common::Service< World::WorldServer >::ref();
server.queueForPlayer( player.getCharacterId(), pPacket );

9
src/world/Manager/EventMgr.h
View file

@ -21,6 +21,13 @@ namespace Sapphire::World::Manager
void handleReturnEventScene( Entity::Player& player, uint32_t eventId, uint16_t sceneId, uint8_t errorCode,
uint8_t numOfResults, const std::vector< uint32_t >& results );
void handleYieldEventScene( Entity::Player& player, uint32_t eventId, uint16_t sceneId, uint8_t resumeId,
uint8_t numOfResults, const std::vector< uint32_t >& results );
void handleYieldStringEventScene( Entity::Player& player, uint32_t eventId, uint16_t sceneId, uint8_t resumeId, const std::string& resultString );
void handleYieldStringIntEventScene( Entity::Player& player, uint32_t eventId, uint16_t sceneId, uint8_t resumeId,
const std::string& resultString, uint64_t resultInt );
void handleReturnStringEventScene( Entity::Player& player, uint32_t eventId, uint16_t sceneId, const std::string& resultString );
void handleReturnIntAndStringEventScene( Entity::Player& player, uint32_t eventId, uint16_t sceneId, const std::string& resultString, uint64_t resultInt );
@ -42,7 +49,7 @@ namespace Sapphire::World::Manager
Event::EventHandler::SceneReturnCallback eventReturnCallback = nullptr );
/*! resume a subevent */
void resumeScene( Entity::Player& player, uint32_t eventId, uint32_t scene, std::vector< uint32_t > values, bool resetCallback );
void resumeScene( Entity::Player& player, uint32_t eventId, uint32_t scene, uint8_t yieldId, std::vector< uint32_t > values );
/*! play a subevent */
void playScene( Entity::Player& player, uint32_t eventId, uint32_t scene, uint32_t flags,

22
src/world/Network/Handlers/EventHandlers.cpp
View file

@ -296,7 +296,7 @@ void Sapphire::Network::GameConnection::yieldEventSceneHeader( const Packets::FF
std::vector< uint32_t > results( std::begin( data.results ), std::end( data.results ) );
eventMgr.handleReturnEventScene( player, data.handlerId, data.sceneId, data.yieldId, data.numOfResults, results );
eventMgr.handleYieldEventScene( player, data.handlerId, data.sceneId, data.yieldId, data.numOfResults, results );
}
void Sapphire::Network::GameConnection::yieldEventScene2( const Packets::FFXIVARR_PACKET_RAW& inPacket, Entity::Player& player )
@ -308,7 +308,7 @@ void Sapphire::Network::GameConnection::yieldEventScene2( const Packets::FFXIVAR
std::vector< uint32_t > results( std::begin( data.results ), std::end( data.results ) );
eventMgr.handleReturnEventScene( player, data.handlerId, data.sceneId, data.yieldId, data.numOfResults, results );
eventMgr.handleYieldEventScene( player, data.handlerId, data.sceneId, data.yieldId, data.numOfResults, results );
}
void Sapphire::Network::GameConnection::yieldEventScene4( const Packets::FFXIVARR_PACKET_RAW& inPacket, Entity::Player& player )
@ -320,7 +320,7 @@ void Sapphire::Network::GameConnection::yieldEventScene4( const Packets::FFXIVAR
std::vector< uint32_t > results( std::begin( data.results ), std::end( data.results ) );
eventMgr.handleReturnEventScene( player, data.handlerId, data.sceneId, data.yieldId, data.numOfResults, results );
eventMgr.handleYieldEventScene( player, data.handlerId, data.sceneId, data.yieldId, data.numOfResults, results );
}
void Sapphire::Network::GameConnection::yieldEventScene8( const Packets::FFXIVARR_PACKET_RAW& inPacket, Entity::Player& player )
@ -332,7 +332,7 @@ void Sapphire::Network::GameConnection::yieldEventScene8( const Packets::FFXIVAR
std::vector< uint32_t > results( std::begin( data.results ), std::end( data.results ) );
eventMgr.handleReturnEventScene( player, data.handlerId, data.sceneId, data.yieldId, data.numOfResults, results );
eventMgr.handleYieldEventScene( player, data.handlerId, data.sceneId, data.yieldId, data.numOfResults, results );
}
void Sapphire::Network::GameConnection::yieldEventScene16( const Packets::FFXIVARR_PACKET_RAW& inPacket, Entity::Player& player )
@ -344,7 +344,7 @@ void Sapphire::Network::GameConnection::yieldEventScene16( const Packets::FFXIVA
std::vector< uint32_t > results( std::begin( data.results ), std::end( data.results ) );
eventMgr.handleReturnEventScene( player, data.handlerId, data.sceneId, data.yieldId, data.numOfResults, results );
eventMgr.handleYieldEventScene( player, data.handlerId, data.sceneId, data.yieldId, data.numOfResults, results );
}
void Sapphire::Network::GameConnection::yieldEventScene32( const Packets::FFXIVARR_PACKET_RAW& inPacket, Entity::Player& player )
@ -356,7 +356,7 @@ void Sapphire::Network::GameConnection::yieldEventScene32( const Packets::FFXIVA
std::vector< uint32_t > results( std::begin( data.results ), std::end( data.results ) );
eventMgr.handleReturnEventScene( player, data.handlerId, data.sceneId, data.yieldId, data.numOfResults, results );
eventMgr.handleYieldEventScene( player, data.handlerId, data.sceneId, data.yieldId, data.numOfResults, results );
}
void Sapphire::Network::GameConnection::yieldEventScene64( const Packets::FFXIVARR_PACKET_RAW& inPacket, Entity::Player& player )
@ -368,7 +368,7 @@ void Sapphire::Network::GameConnection::yieldEventScene64( const Packets::FFXIVA
std::vector< uint32_t > results( std::begin( data.results ), std::end( data.results ) );
eventMgr.handleReturnEventScene( player, data.handlerId, data.sceneId, data.yieldId, data.numOfResults, results );
eventMgr.handleYieldEventScene( player, data.handlerId, data.sceneId, data.yieldId, data.numOfResults, results );
}
void Sapphire::Network::GameConnection::yieldEventScene128( const Packets::FFXIVARR_PACKET_RAW& inPacket, Entity::Player& player )
@ -380,7 +380,7 @@ void Sapphire::Network::GameConnection::yieldEventScene128( const Packets::FFXIV
std::vector< uint32_t > results( std::begin( data.results ), std::end( data.results ) );
eventMgr.handleReturnEventScene( player, data.handlerId, data.sceneId, data.yieldId, data.numOfResults, results );
eventMgr.handleYieldEventScene( player, data.handlerId, data.sceneId, data.yieldId, data.numOfResults, results );
}
void Sapphire::Network::GameConnection::yieldEventScene255( const Packets::FFXIVARR_PACKET_RAW& inPacket, Entity::Player& player )
@ -392,7 +392,7 @@ void Sapphire::Network::GameConnection::yieldEventScene255( const Packets::FFXIV
std::vector< uint32_t > results( std::begin( data.results ), std::end( data.results ) );
eventMgr.handleReturnEventScene( player, data.handlerId, data.sceneId, data.yieldId, data.numOfResults, results );
eventMgr.handleYieldEventScene( player, data.handlerId, data.sceneId, data.yieldId, data.numOfResults, results );
}
void Sapphire::Network::GameConnection::yieldEventString( const Packets::FFXIVARR_PACKET_RAW& inPacket, Entity::Player& player )
@ -426,7 +426,7 @@ void Sapphire::Network::GameConnection::yieldEventString( const Packets::FFXIVAR
const auto packet = ZoneChannelPacket< FFXIVIpcYieldEventSceneString8 >( inPacket );
auto& data = packet.data();
eventMgr.handleReturnStringEventScene( player, data.handlerId, data.sceneId, inString );
eventMgr.handleYieldStringEventScene( player, data.handlerId, data.sceneId, data.yieldId, inString );
}
@ -439,7 +439,7 @@ void Sapphire::Network::GameConnection::yieldEventSceneIntAndString( const Packe
auto& data = packet.data();
inString = std::string( data.str );
eventMgr.handleReturnIntAndStringEventScene( player, data.handlerId, data.sceneId, inString, data.integer );
eventMgr.handleYieldStringIntEventScene( player, data.handlerId, data.sceneId, data.yieldId, inString, data.integer );
}
void Sapphire::Network::GameConnection::startEventSayHandler( const Packets::FFXIVARR_PACKET_RAW& inPacket, Entity::Player& player )

239
src/world/Network/PacketWrappers/EventResumePacket.h Normal file
View file

@ -0,0 +1,239 @@
#pragma once
#include <Network/GamePacket.h>
#include <Actor/Player.h>
#include <Event/EventHandler.h>
#include <Network/PacketDef/Zone/ServerZoneDef.h>
#include "Forwards.h"
namespace Sapphire::Network::Packets::WorldPackets::Server
{
/**
* @brief The packet sent to resume an event and fill it with additional data.
*/
class EventResumePacketHeader : public ZoneChannelPacket< FFXIVIpcResumeEventSceneHeader >
{
public:
EventResumePacketHeader( const Entity::Player& player, uint32_t handlerId, uint16_t sceneId, uint8_t resumeId, std::vector< uint32_t > args ) :
ZoneChannelPacket< FFXIVIpcResumeEventSceneHeader >( player.getId(), player.getId() )
{
initialize( player, handlerId, sceneId, resumeId, args );
};
private:
void initialize( const Entity::Player& player, uint32_t handlerId, uint16_t sceneId, uint8_t resumeId, std::vector< uint32_t > args )
{
m_data.handlerId = handlerId;
m_data.sceneId = sceneId;
m_data.resumeId = resumeId;
m_data.numOfArgs = static_cast< uint8_t >( args.size() );
if( !args.empty() )
{
int i = 0;
for( auto& val : args )
m_data.args[ i++ ] = val;
}
}
};
class EventResume2Packet : public ZoneChannelPacket< FFXIVIpcResumeEventScene2 >
{
public:
EventResume2Packet( const Entity::Player& player, uint32_t handlerId, uint16_t sceneId, uint8_t resumeId, std::vector< uint32_t > args ) :
ZoneChannelPacket< FFXIVIpcResumeEventScene2 >( player.getId(), player.getId() )
{
initialize( player, handlerId, sceneId, resumeId, args );
};
private:
void initialize( const Entity::Player& player, uint32_t handlerId, uint16_t sceneId, uint8_t resumeId, std::vector< uint32_t > args )
{
m_data.handlerId = handlerId;
m_data.sceneId = sceneId;
m_data.resumeId = resumeId;
m_data.numOfArgs = static_cast< uint8_t >( args.size() );
if( !args.empty() )
{
int i = 0;
for( auto& val : args )
m_data.args[ i++ ] = val;
}
}
};
class EventResume4Packet : public ZoneChannelPacket< FFXIVIpcResumeEventScene4 >
{
public:
EventResume4Packet( const Entity::Player& player, uint32_t handlerId, uint16_t sceneId, uint8_t resumeId, std::vector< uint32_t > args ) :
ZoneChannelPacket< FFXIVIpcResumeEventScene4 >( player.getId(), player.getId() )
{
initialize( player, handlerId, sceneId, resumeId, args );
};
private:
void initialize( const Entity::Player& player, uint32_t handlerId, uint16_t sceneId, uint8_t resumeId, std::vector< uint32_t > args )
{
m_data.handlerId = handlerId;
m_data.sceneId = sceneId;
m_data.resumeId = resumeId;
m_data.numOfArgs = static_cast< uint8_t >( args.size() );
if( !args.empty() )
{
int i = 0;
for( auto& val : args )
m_data.args[ i++ ] = val;
}
}
};
class EventResume8Packet : public ZoneChannelPacket< FFXIVIpcResumeEventScene8 >
{
public:
EventResume8Packet( const Entity::Player& player, uint32_t handlerId, uint16_t sceneId, uint8_t resumeId, std::vector< uint32_t > args ) :
ZoneChannelPacket< FFXIVIpcResumeEventScene8 >( player.getId(), player.getId() )
{
initialize( player, handlerId, sceneId, resumeId, args );
};
private:
void initialize( const Entity::Player& player, uint32_t handlerId, uint16_t sceneId, uint8_t resumeId, std::vector< uint32_t > args )
{
m_data.handlerId = handlerId;
m_data.sceneId = sceneId;
m_data.resumeId = resumeId;
m_data.numOfArgs = static_cast< uint8_t >( args.size() );
if( !args.empty() )
{
int i = 0;
for( auto& val : args )
m_data.args[ i++ ] = val;
}
}
};
class EventResume16Packet : public ZoneChannelPacket< FFXIVIpcResumeEventScene16 >
{
public:
EventResume16Packet( const Entity::Player& player, uint32_t handlerId, uint16_t sceneId, uint8_t resumeId, std::vector< uint32_t > args ) :
ZoneChannelPacket< FFXIVIpcResumeEventScene16 >( player.getId(), player.getId() )
{
initialize( player, handlerId, sceneId, resumeId, args );
};
private:
void initialize( const Entity::Player& player, uint32_t handlerId, uint16_t sceneId, uint8_t resumeId, std::vector< uint32_t > args )
{
m_data.handlerId = handlerId;
m_data.sceneId = sceneId;
m_data.resumeId = resumeId;
m_data.numOfArgs = static_cast< uint8_t >( args.size() );
if( !args.empty() )
{
int i = 0;
for( auto& val : args )
m_data.args[ i++ ] = val;
}
}
};
class EventResume32Packet : public ZoneChannelPacket< FFXIVIpcResumeEventScene32 >
{
public:
EventResume32Packet( const Entity::Player& player, uint32_t handlerId, uint16_t sceneId, uint8_t resumeId, std::vector< uint32_t > args ) :
ZoneChannelPacket< FFXIVIpcResumeEventScene32 >( player.getId(), player.getId() )
{
initialize( player, handlerId, sceneId, resumeId, args );
};
private:
void initialize( const Entity::Player& player, uint32_t handlerId, uint16_t sceneId, uint8_t resumeId, std::vector< uint32_t > args )
{
m_data.handlerId = handlerId;
m_data.sceneId = sceneId;
m_data.resumeId = resumeId;
m_data.numOfArgs = static_cast< uint8_t >( args.size() );
if( !args.empty() )
{
int i = 0;
for( auto& val : args )
m_data.args[ i++ ] = val;
}
}
};
class EventResume64Packet : public ZoneChannelPacket< FFXIVIpcResumeEventScene64 >
{
public:
EventResume64Packet( const Entity::Player& player, uint32_t handlerId, uint16_t sceneId, uint8_t resumeId, std::vector< uint32_t > args ) :
ZoneChannelPacket< FFXIVIpcResumeEventScene64 >( player.getId(), player.getId() )
{
initialize( player, handlerId, sceneId, resumeId, args );
};
private:
void initialize( const Entity::Player& player, uint32_t handlerId, uint16_t sceneId, uint8_t resumeId, std::vector< uint32_t > args )
{
m_data.handlerId = handlerId;
m_data.sceneId = sceneId;
m_data.resumeId = resumeId;
m_data.numOfArgs = static_cast< uint8_t >( args.size() );
if( !args.empty() )
{
int i = 0;
for( auto& val : args )
m_data.args[ i++ ] = val;
}
}
};
class EventResume128Packet : public ZoneChannelPacket< FFXIVIpcResumeEventScene128 >
{
public:
EventResume128Packet( const Entity::Player& player, uint32_t handlerId, uint16_t sceneId, uint8_t resumeId, std::vector< uint32_t > args ) :
ZoneChannelPacket< FFXIVIpcResumeEventScene128 >( player.getId(), player.getId() )
{
initialize( player, handlerId, sceneId, resumeId, args );
};
private:
void initialize( const Entity::Player& player, uint32_t handlerId, uint16_t sceneId, uint8_t resumeId, std::vector< uint32_t > args )
{
m_data.handlerId = handlerId;
m_data.sceneId = sceneId;
m_data.resumeId = resumeId;
m_data.numOfArgs = static_cast< uint8_t >( args.size() );
if( !args.empty() )
{
int i = 0;
for( auto& val : args )
m_data.args[ i++ ] = val;
}
}
};
class EventResume255Packet : public ZoneChannelPacket< FFXIVIpcResumeEventScene255 >
{
public:
EventResume255Packet( const Entity::Player& player, uint32_t handlerId, uint16_t sceneId, uint8_t resumeId, std::vector< uint32_t > args ) :
ZoneChannelPacket< FFXIVIpcResumeEventScene255 >( player.getId(), player.getId() )
{
initialize( player, handlerId, sceneId, resumeId, args );
};
private:
void initialize( const Entity::Player& player, uint32_t handlerId, uint16_t sceneId, uint8_t resumeId, std::vector< uint32_t > args )
{
m_data.handlerId = handlerId;
m_data.sceneId = sceneId;
m_data.resumeId = resumeId;
m_data.numOfArgs = static_cast< uint8_t >( args.size() );
if( !args.empty() )
{
int i = 0;
for( auto& val : args )
m_data.args[ i++ ] = val;
}
}
};
}

8
src/world/Script/NativeScriptApi.cpp
View file

@ -132,6 +132,11 @@ namespace Sapphire::ScriptAPI
{
}
void EventScript::onYield( uint32_t eventId, uint16_t sceneId, uint8_t yieldId, Entity::Player& player, const std::string& resultString, uint64_t resultInt )
{
eventMgr().resumeScene( player, eventId, sceneId, yieldId, { 0 } );
}
///////////////////////////////////////////////////////////////////
QuestScript::QuestScript( uint32_t eventId ) : ScriptObject( eventId, typeid( QuestScript ).hash_code() )
@ -188,8 +193,7 @@ namespace Sapphire::ScriptAPI
///////////////////////////////////////////////////////////////////
EventObjectScript::EventObjectScript( uint32_t eobjId ) :
ScriptObject( eobjId, typeid( EventObjectScript ).hash_code() )
EventObjectScript::EventObjectScript( uint32_t eobjId ) : ScriptObject( eobjId, typeid( EventObjectScript ).hash_code() )
{
}

5
src/world/Script/NativeScriptApi.h
View file

@ -181,6 +181,8 @@ namespace Sapphire::ScriptAPI
virtual void onEObjHit( Sapphire::Entity::Player& player, uint64_t actorId, uint32_t actionId );
virtual void onYield( uint32_t eventId, uint16_t sceneId, uint8_t yieldId, Entity::Player& player, const std::string& resultString, uint64_t returnInt );
Data::ExdData& exdData()
{
return Common::Service< Data::ExdData >::ref();
@ -262,8 +264,7 @@ namespace Sapphire::ScriptAPI
virtual void onPlayerDeath( World::Quest& quest, Sapphire::Entity::Player& player );
virtual void onEventHandlerTradeReturn( Sapphire::Entity::Player& player, uint32_t eventId, uint16_t subEvent, uint16_t param,
uint32_t catalogId );
virtual void onEventHandlerTradeReturn( Sapphire::Entity::Player& player, uint32_t eventId, uint16_t subEvent, uint16_t param, uint32_t catalogId );
virtual void onEObjHit( World::Quest& quest, Sapphire::Entity::Player& player, uint64_t actorId, uint32_t actionId );

29
src/world/Script/ScriptMgr.cpp
View file

@ -259,6 +259,35 @@ bool Sapphire::Scripting::ScriptMgr::onTalk( Entity::Player& player, uint64_t ac
return false;
}
bool Sapphire::Scripting::ScriptMgr::onYield( Entity::Player& player, uint32_t eventId, uint16_t sceneId, uint8_t resumeId,
const std::string& resultString, uint64_t resultInt )
{
auto eventType = static_cast< uint16_t >( eventId >> 16 );
auto& exdData = Common::Service< Data::ExdData >::ref();
if( eventType == Event::EventHandler::EventHandlerType::Quest )
{
Logger::error( "Yield unimplemented for EventHandlerType::Quest!" );
return false;
}
// check for a direct eventid match first, otherwise default to base type
auto script = m_nativeScriptMgr->getScript< Sapphire::ScriptAPI::EventScript >( eventId );
if( script )
{
script->onYield( eventId, sceneId, resumeId, player, resultString, resultInt );
return true;
}
else
{
script = m_nativeScriptMgr->getScript< Sapphire::ScriptAPI::EventScript >( eventId & 0xFFFF0000 );
if( !script )
return false;
script->onYield( eventId, sceneId, resumeId, player, resultString, resultInt );
return true;
}
}
bool Sapphire::Scripting::ScriptMgr::onEnterTerritory( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2 )
{
const auto eventType = static_cast< uint16_t >( eventId >> 16 );

2
src/world/Script/ScriptMgr.h
View file

@ -56,6 +56,8 @@ namespace Sapphire::Scripting
bool onTalk( Entity::Player& player, uint64_t actorId, uint32_t eventId );
bool onYield( Entity::Player& player, uint32_t eventId, uint16_t sceneId, uint8_t resumeId, const std::string& resultString, uint64_t resultInt );
bool onSay( Entity::Player& player, uint64_t actorId, uint32_t eventId, uint32_t sayId );
bool onEnterTerritory( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2 );