#include "CinematicMgr.h"

Public Member Functions
	CinematicMgr (Player &player)

	~CinematicMgr ()=default

void	StartCinematic (uint32 const cinematicSequenceId)

uint32	GetActiveCinematicCamera () const

void	SetActiveCinematicCamera (uint32 cinematicCameraId=0)

bool	IsOnCinematic () const

void	StartCinematicCamera ()

void	EndCinematic ()

void	UpdateCinematic (uint32 const diff)

Position const &	GetRemoteSightPosition () const

Private Attributes
Player &	_player

uint32	_cinematicDiff

uint32	_activeCinematicCameraId

std::vector< FlyByCamera > const *	_cinematicCamera

Position	_remoteSightPosition

IntervalTimer	_cinematicUpdateTimer

Detailed Description

Constructor & Destructor Documentation

◆ CinematicMgr()

CinematicMgr::CinematicMgr ( Player & player )

explicit

                                         : _player(player)
{
    _cinematicDiff = 0;
    _activeCinematicCameraId = 0;
    _cinematicCamera = nullptr;
    _remoteSightPosition = Position(0.0f, 0.0f, 0.0f);
    _cinematicUpdateTimer.SetInterval(CINEMATIC_UPDATEDIFF);
}

References _activeCinematicCameraId, _cinematicCamera, _cinematicDiff, _cinematicUpdateTimer, _remoteSightPosition, CINEMATIC_UPDATEDIFF, and IntervalTimer::SetInterval().

◆ ~CinematicMgr()

CinematicMgr::~CinematicMgr ( )

default

Member Function Documentation

◆ EndCinematic()

void CinematicMgr::EndCinematic ( )

{
    if (_activeCinematicCameraId == 0)
        return;
 
    _cinematicDiff = 0;
    _cinematicUpdateTimer.Reset();
    _cinematicCamera = nullptr;
    _activeCinematicCameraId = 0;
    _player.UpdateVisibilityForPlayer();
}

References _activeCinematicCameraId, _cinematicCamera, _cinematicDiff, _cinematicUpdateTimer, _player, IntervalTimer::Reset(), and Player::UpdateVisibilityForPlayer().

Referenced by WorldSession::HandleCompleteCinematic(), and UpdateCinematic().

◆ GetActiveCinematicCamera()

uint32 CinematicMgr::GetActiveCinematicCamera ( ) const

inline

40{ return _activeCinematicCameraId; }

◆ GetRemoteSightPosition()

Position const & CinematicMgr::GetRemoteSightPosition ( ) const

inline

46{ return _remoteSightPosition; }

Referenced by Player::GetSightPosition().

◆ IsOnCinematic()

bool CinematicMgr::IsOnCinematic ( ) const

inline

42{ return (_cinematicCamera != nullptr); }

Referenced by Player::GetSightPosition().

◆ SetActiveCinematicCamera()

void CinematicMgr::SetActiveCinematicCamera ( uint32 cinematicCameraId = 0 )

inline

41{ _activeCinematicCameraId = cinematicCameraId; }

Referenced by StartCinematic().

◆ StartCinematic()

void CinematicMgr::StartCinematic ( uint32 const cinematicSequenceId )

{
    _player.SendCinematicStart(cinematicSequenceId);
    if (CinematicSequencesEntry const* sequence = sCinematicSequencesStore.LookupEntry(cinematicSequenceId))
        SetActiveCinematicCamera(sequence->cinematicCamera);
}

References _player, sCinematicSequencesStore, Player::SendCinematicStart(), and SetActiveCinematicCamera().

Referenced by debug_commandscript::HandleDebugPlayCinematicCommand(), WorldSession::HandlePlayerLoginFromDB(), and GameObject::Use().

◆ StartCinematicCamera()

void CinematicMgr::StartCinematicCamera ( )

{
    // Sanity check for active camera set
    if (_activeCinematicCameraId == 0)
        return;
 
    if (std::vector<FlyByCamera> const* flyByCameras = GetFlyByCameras(_activeCinematicCameraId))
    {
        // Initialize diff, and set camera
        _cinematicDiff = 0;
        _cinematicUpdateTimer.Reset();
        _cinematicCamera = flyByCameras;
 
        auto camitr = _cinematicCamera->begin();
        if (camitr != _cinematicCamera->end())
        {
            Position const& pos = camitr->locations;
            if (!pos.IsPositionValid())
                return;
 
            _player.GetMap()->LoadGridsInRange(pos, MAX_VISIBILITY_DISTANCE);
            _remoteSightPosition.Relocate(pos);
            _player.UpdateVisibilityForPlayer();
        }
    }
}

References _activeCinematicCameraId, _cinematicCamera, _cinematicDiff, _cinematicUpdateTimer, _player, _remoteSightPosition, GetFlyByCameras(), WorldObject::GetMap(), Position::IsPositionValid(), Map::LoadGridsInRange(), MAX_VISIBILITY_DISTANCE, Position::Relocate(), IntervalTimer::Reset(), and Player::UpdateVisibilityForPlayer().

Referenced by WorldSession::HandleNextCinematicCamera().

◆ UpdateCinematic()

void CinematicMgr::UpdateCinematic ( uint32 const diff )

{
    if (_activeCinematicCameraId == 0 || !_cinematicCamera || _cinematicCamera->empty())
        return;
 
    _cinematicDiff += diff;
    _cinematicUpdateTimer.Update(diff);
    if (!_cinematicUpdateTimer.Passed())
        return;
 
    _cinematicUpdateTimer.Reset();
 
    Position lastPosition;
    uint32 lastTimestamp = 0;
    Position nextPosition;
    uint32 nextTimestamp = 0;
 
    // Obtain direction of travel
    for (FlyByCamera const& cam : *_cinematicCamera)
    {
        if (cam.timeStamp > _cinematicDiff)
        {
            nextPosition.Relocate(cam.locations);
            nextTimestamp = cam.timeStamp;
            break;
        }
        lastPosition.Relocate(cam.locations);
        lastTimestamp = cam.timeStamp;
    }
    float angle = lastPosition.GetAbsoluteAngle(&nextPosition);
    angle -= lastPosition.GetOrientation();
    angle = Position::NormalizeOrientation(angle);
 
    // Look for position around 2 second ahead of us.
    int32 workDiff = _cinematicDiff;
 
    // Modify result based on camera direction (Humans for example, have the camera point behind)
    workDiff += static_cast<int32>(float(CINEMATIC_LOOKAHEAD) * cos(angle));
 
    // Get an iterator to the last entry in the cameras, to make sure we don't go beyond the end
    auto endItr = _cinematicCamera->rbegin();
    if (endItr != _cinematicCamera->rend() && workDiff > static_cast<int32>(endItr->timeStamp))
        workDiff = endItr->timeStamp;
 
    // Never try to go back in time before the start of cinematic!
    if (workDiff < 0)
        workDiff = _cinematicDiff;
 
    // Obtain the previous and next waypoint based on timestamp
    for (FlyByCamera const& cam : *_cinematicCamera)
    {
        if (static_cast<int32>(cam.timeStamp) >= workDiff)
        {
            nextPosition.Relocate(cam.locations);
            nextTimestamp = cam.timeStamp;
            break;
        }
        lastPosition.Relocate(cam.locations);
        lastTimestamp = cam.timeStamp;
    }
 
    // Never try to go beyond the end of the cinematic
    if (workDiff > static_cast<int32>(nextTimestamp))
        workDiff = static_cast<int32>(nextTimestamp);
 
    // Interpolate the position for this moment in time (or the adjusted moment in time)
    uint32 timeDiff = nextTimestamp - lastTimestamp;
    uint32 interDiff = workDiff - lastTimestamp;
    float xDiff = nextPosition.m_positionX - lastPosition.m_positionX;
    float yDiff = nextPosition.m_positionY - lastPosition.m_positionY;
    float zDiff = nextPosition.m_positionZ - lastPosition.m_positionZ;
    Position interPosition(lastPosition.m_positionX + (xDiff * (float(interDiff) / float(timeDiff))), lastPosition.m_positionY +
        (yDiff * (float(interDiff) / float(timeDiff))), lastPosition.m_positionZ + (zDiff * (float(interDiff) / float(timeDiff))));
 
    // Advance _remoteSightPosition to new position
    if (interPosition.IsPositionValid())
    {
        _player.GetMap()->LoadGridsInRange(interPosition, MAX_VISIBILITY_DISTANCE);
        _remoteSightPosition.Relocate(interPosition);
        _player.UpdateVisibilityForPlayer();
    }
 
    // If we never received an end packet 10 seconds after the final timestamp then force an end
    if (_cinematicDiff > _cinematicCamera->back().timeStamp + 10 * IN_MILLISECONDS)
        EndCinematic();
}