Merge pull request #8 from SapphireMordred/housing

Housing

src/servers/Scripts/common/WarpTaxi.cpp

@@ -0,0 +1,50 @@
+#include <ScriptObject.h>
+#include <Actor/Player.h>
+
+#include <Exd/ExdDataGenerated.h>
+#include <Framework.h>
+
+using namespace Core;
+
+class WarpTaxi : public Sapphire::ScriptAPI::EventScript
+{
+public:
+  WarpTaxi() :
+    Sapphire::ScriptAPI::EventScript( 0x0002005a )
+  {
+  }
+
+  void inner( Entity::Player& player, const Event::SceneResult& result )
+  {
+    if( result.param1 != 256 )
+    {
+      std::function< void( Entity::Player&, const Event::SceneResult& ) > fn = std::bind( &WarpTaxi::inner, this, std::placeholders::_1, std::placeholders::_2 );
+
+      player.playScene( 1310721, 0, HIDE_HOTBAR, 0, 1, 341, fn );
+    }
+  }
+
+  void inner2( Entity::Player& player, uint64_t actorId )
+  {
+    player.eventStart( actorId, 1310721, Event::EventHandler::Nest, 0, 0  );
+    std::function< void( Entity::Player&, const Event::SceneResult& ) > fn = std::bind( &WarpTaxi::inner, this, std::placeholders::_1, std::placeholders::_2 );
+    player.playScene( 1310721, 0, HIDE_HOTBAR, 0, 1, 341, fn );
+  }
+
+  void onTalk( uint32_t eventId, Entity::Player& player, uint64_t actorId ) override
+  {
+    auto exddata = getFramework()->get< Core::Data::ExdDataGenerated >();
+    if( !exddata )
+      return;
+
+    auto warp = exddata->get< Core::Data::Warp >( eventId );
+    if( !warp )
+      return;
+
+    player.eventStart( actorId, warp->defaultTalk1, Event::EventHandler::Nest, 0, 0, std::bind( &WarpTaxi::inner2, this, std::placeholders::_1, std::placeholders::_2 ) );
+    player.playScene( warp->defaultTalk1, 0, HIDE_HOTBAR, [warp, this]( Entity::Player& player, const Event::SceneResult& result )
+    {
+
+    } );
+  }
+};

src/servers/sapphire_zone/Actor/Player.h

@@ -61,7 +61,7 @@ namespace Core::Entity
     /*! start/register a normal event */
     void
     eventStart( uint64_t actorId, uint32_t eventId, Event::EventHandler::EventType eventParam, uint8_t eventParam1,
-                uint32_t eventParam2 );
+                uint32_t eventParam2, Event::EventHandler::EventFinishCallback callback = nullptr );
 
     /*! play a subevent */
     void playScene( uint32_t eventId, uint32_t scene, uint32_t flags, uint32_t eventParam2, uint32_t eventParam3 );

src/servers/sapphire_zone/Actor/PlayerEvent.cpp

@@ -92,11 +92,13 @@ void Core::Entity::Player::directorPlayScene( uint32_t eventId, uint32_t scene,
 
 void Core::Entity::Player::eventStart( uint64_t actorId, uint32_t eventId,
                                        Event::EventHandler::EventType eventType, uint8_t eventParam1,
-                                       uint32_t eventParam2 )
+                                       uint32_t eventParam2, Event::EventHandler::EventFinishCallback callback )
 {
 
   auto newEvent = Event::make_EventHandler( this, actorId, eventId, eventType, eventParam2 );
 
+  newEvent->setEventFinishCallback( callback );
+
   addEvent( newEvent );
 
   setStateFlag( PlayerStateFlag::InNpcEvent );
@@ -163,8 +165,8 @@ Core::Event::EventHandlerPtr Core::Entity::Player::bootstrapSceneEvent( uint32_t
   if( !pEvent && getEventCount() )
   {
     // We're trying to play a nested event, need to start it first.
-    eventStart( getId(), eventId, Event::EventHandler::Nest, 0, 0 );
+    //eventStart( getId(), eventId, Event::EventHandler::Nest, 0, 0 );
-    pEvent = getEvent( eventId );
+    //pEvent = getEvent( eventId );
   }
   else if( !pEvent )
   {
@@ -185,6 +187,16 @@ void Core::Entity::Player::playScene( uint32_t eventId, uint32_t scene,
   if( !pEvent )
     return;
 
+  if( pEvent->getEventType() == Event::EventHandler::Nest  )
+  {
+    auto events = eventList();
+
+    for( auto it : events )
+    {
+      it.second->setPlayedScene( true );
+    }
+  }
+
   pEvent->setPlayedScene( true );
   pEvent->setEventReturnCallback( eventCallback );
   pEvent->setSceneChainCallback( nullptr );
@@ -246,12 +258,17 @@ void Core::Entity::Player::eventFinish( uint32_t eventId, uint32_t freePlayer )
     case Event::EventHandler::Nest:
     {
       queuePacket( std::make_shared< EventFinishPacket >( getId(), pEvent->getId(),
-                                                            pEvent->getEventType(), pEvent->getEventParam() ) );
+                                                          pEvent->getEventType(), pEvent->getEventParam() ) );
       removeEvent( pEvent->getId() );
 
+      auto callback = pEvent->getEventFinishCallback();
+
+      if( callback )
+        callback( *this, pEvent->getActorId() );
+
       auto events = eventList();
 
-      for( auto it : events )
+      /*for( auto it : events )
       {
 
         if( it.second->hasPlayedScene() == false )
@@ -262,14 +279,14 @@ void Core::Entity::Player::eventFinish( uint32_t eventId, uint32_t freePlayer )
                                                                 it.second->getEventParam() ) );
           removeEvent( it.second->getId() );
         }
-      }
+      }*/
 
       break;
     }
     default:
     {
       queuePacket( std::make_shared< EventFinishPacket >( getId(), pEvent->getId(),
-                                                            pEvent->getEventType(), pEvent->getEventParam() ) );
+                                                          pEvent->getEventType(), pEvent->getEventParam() ) );
       break;
     }
   }

src/servers/sapphire_zone/Event/EventHandler.cpp

@@ -64,6 +64,16 @@ void Core::Event::EventHandler::setSceneChainCallback( Core::Event::EventHandler
   m_chainCallback = callback;
 }
 
+Core::Event::EventHandler::EventFinishCallback Core::Event::EventHandler::getEventFinishCallback() const
+{
+  return m_finishCallback;
+}
+
+void Core::Event::EventHandler::setEventFinishCallback( EventFinishCallback callback )
+{
+  m_finishCallback = callback;
+}
+
 bool Core::Event::EventHandler::hasPlayedScene() const
 {
   return m_playedScene;

src/servers/sapphire_zone/Event/EventHandler.h

@@ -75,6 +75,7 @@ namespace Core::Event
 
     using SceneReturnCallback = std::function< void( Entity::Player&, const SceneResult& ) >;
     using SceneChainCallback = std::function< void( Entity::Player& ) >;
+    using EventFinishCallback = std::function< void( Entity::Player&, uint64_t ) >;
 
     EventHandler( Entity::Player* pOwner, uint64_t actorId, uint32_t eventId, EventType eventType,
                   uint32_t eventParam );
@@ -107,6 +108,10 @@ namespace Core::Event
 
     void setSceneChainCallback( SceneChainCallback callback );
 
+    EventFinishCallback getEventFinishCallback() const;
+
+    void setEventFinishCallback( EventFinishCallback callback );
+
     bool hasNestedEvent() const;
 
     void removeNestedEvent();
@@ -125,6 +130,7 @@ namespace Core::Event
     bool m_playedScene;
     SceneReturnCallback m_returnCallback;
     SceneChainCallback m_chainCallback;
+    EventFinishCallback m_finishCallback;
   };
 
 }