Transport.cpp

Go to the documentation of this file.

/*
* This file is part of Project SkyFire https://www.projectskyfire.org.
* See LICENSE.md file for Copyright information
*/
 
#include "Cell.h"
#include "CellImpl.h"
#include "Common.h"
#include "DBCStores.h"
#include "GameObjectAI.h"
#include "GameObjectTransportTiming.h"
#include "MapManager.h"
#include "MapReference.h"
#include "ObjectMgr.h"
#include "Path.h"
#include "Player.h"
#include "ScriptMgr.h"
#include "Transport.h"
#include "Vehicle.h"
#include "World.h"
#include "WorldPacket.h"
#include <G3D/Quat.h>
 
Transport::Transport() : GameObject(),
_transportInfo(NULL), _isMoving(true), _pendingStop(false), _triggeredArrivalEvent(false), _triggeredDepartureEvent(false)
{
    m_updateFlag = UPDATEFLAG_TRANSPORT | UPDATEFLAG_LOWGUID | UPDATEFLAG_STATIONARY_POSITION | UPDATEFLAG_ROTATION;
}
 
Transport::~Transport()
{
    ASSERT(_passengers.empty());
    UnloadStaticPassengers();
}
 
bool Transport::Create(uint32 guidlow, uint32 entry, uint32 mapid, float x, float y, float z, float ang, uint32 animprogress)
{
    Relocate(x, y, z, ang);
 
    if (!IsPositionValid())
    {
        SF_LOG_ERROR("entities.transport", "Transport (GUID: %u) not created. Suggested coordinates isn't valid (X: %f Y: %f)",
            guidlow, x, y);
        return false;
    }
 
    Object::_Create(guidlow, 0, HIGHGUID_MO_TRANSPORT);
 
    GameObjectTemplate const* goinfo = sObjectMgr->GetGameObjectTemplate(entry);
 
    if (!goinfo)
    {
        SF_LOG_ERROR("sql.sql", "Transport not created: entry in `gameobject_template` not found, guidlow: %u map: %u  (X: %f Y: %f Z: %f) ang: %f", guidlow, mapid, x, y, z, ang);
        return false;
    }
 
    m_goInfo = goinfo;
 
    TransportTemplate const* tInfo = sTransportMgr->GetTransportTemplate(entry);
    if (!tInfo)
    {
        SF_LOG_ERROR("sql.sql", "Transport %u (name: %s) will not be created, missing `transport_template` entry.", entry, goinfo->name.c_str());
        return false;
    }
 
    _transportInfo = tInfo;
 
    // initialize waypoints
    _nextFrame = tInfo->keyFrames.begin();
    _currentFrame = _nextFrame++;
    _triggeredArrivalEvent = false;
    _triggeredDepartureEvent = false;
 
    m_goValue.Transport.PathProgress = 0;
    SetFloatValue(OBJECT_FIELD_SCALE, goinfo->size);
    SetUInt32Value(GAMEOBJECT_FIELD_FACTION_TEMPLATE, goinfo->faction);
    SetUInt32Value(GAMEOBJECT_FIELD_FLAGS, goinfo->flags);
    SetPeriod(tInfo->pathTime);
    SetEntry(goinfo->entry);
    SetDisplayId(goinfo->displayId);
    SetGoState(GOState::GO_STATE_READY);
    _pendingStop = goinfo->moTransport.canBeStopped != 0;
    SetGoType(GAMEOBJECT_TYPE_MO_TRANSPORT);
    SetGoAnimProgress(animprogress);
    SetName(goinfo->name);
    UpdateRotationFields(0.0f, 1.0f);
    m_model = CreateModel();
    return true;
}
 
bool Transport::CreateLocal(uint32 guidlow, uint32 entry, Map* map, float x, float y, float z, float ang, float rotation0, float rotation1, float rotation2, float rotation3, uint32 animprogress)
{
    Relocate(x, y, z, ang);
    m_stationaryPosition.Relocate(x, y, z, ang);
 
    if (!IsPositionValid())
    {
        SF_LOG_ERROR("entities.transport", "Transport (Entry: %u) not created. Suggested coordinates isn't valid (X: %f Y: %f)", entry, x, y);
        return false;
    }
 
    SetMap(map);
 
    Object::_Create(guidlow ? guidlow : sObjectMgr->GenerateLowGuid(HIGHGUID_MO_TRANSPORT), 0, HIGHGUID_MO_TRANSPORT);
 
    GameObjectTemplate const* goinfo = sObjectMgr->GetGameObjectTemplate(entry);
    if (!goinfo)
    {
        SF_LOG_ERROR("entities.transport", "Transport not created: entry in `gameobject_template` not found, entry: %u map: %u  (X: %f Y: %f Z: %f) ang: %f", entry, map->GetId(), x, y, z, ang);
        return false;
    }
 
    if (goinfo->type != GAMEOBJECT_TYPE_TRANSPORT)
    {
        SF_LOG_ERROR("entities.transport", "Transport %u (name: %s) has unsupported local transport type %u.", entry, goinfo->name.c_str(), goinfo->type);
        return false;
    }
 
    m_goInfo = goinfo;
    m_goValue.Transport.AnimationInfo = sTransportMgr->GetTransportAnimInfo(entry);
    if (!m_goValue.Transport.AnimationInfo)
    {
        SF_LOG_ERROR("entities.transport", "Transport %u (name: %s) will not be created, missing data in TransportAnimation.dbc", entry, goinfo->name.c_str());
        return false;
    }
 
    _triggeredArrivalEvent = false;
    _triggeredDepartureEvent = false;
 
    uint32 flags = goinfo->flags;
    switch (entry)
    {
        case 218203:
        case 218204:
        case 218205:
        case 218206:
        case 218207:
        case 218208:
            flags |= GO_FLAG_TRANSPORT | GO_FLAG_NODESPAWN;
            break;
        default:
            break;
    }
 
    SetObjectScale(goinfo->size);
    SetUInt32Value(GAMEOBJECT_FIELD_FACTION_TEMPLATE, goinfo->faction);
    SetUInt32Value(GAMEOBJECT_FIELD_FLAGS, flags);
    SetEntry(goinfo->entry);
    SetDisplayId(goinfo->displayId);
    SetGoType(GAMEOBJECT_TYPE_TRANSPORT);
    SetName(goinfo->name);
 
    SetFloatValue(GAMEOBJECT_FIELD_PARENT_ROTATION + 0, rotation0);
    SetFloatValue(GAMEOBJECT_FIELD_PARENT_ROTATION + 1, rotation1);
    UpdateRotationFields(rotation2, rotation3);
 
    InitializeLegacyTransport();
    GOState const initialTransportState = GOState(Skyfire::GameObjects::GetInitialLegacyTransportState(
        goinfo->transport.startOpen != 0, !m_transportPauseTimes.empty()));
    SetByteValue(GAMEOBJECT_FIELD_PERCENT_HEALTH, 0, GetGOStateValue(initialTransportState));
    SetLegacyTransportStopped(!m_transportPauseTimes.empty());
    SetGoAnimProgress(animprogress);
 
    m_model = CreateModel();
    LastUsedScriptID = GetGOInfo()->ScriptId;
    AIM_Initialize();
    return true;
}
 
void Transport::Update(uint32 diff)
{
    uint32 const positionUpdateDelay = 200;
 
    if (AI())
        AI()->UpdateAI(diff);
    else if (!AIM_Initialize())
        SF_LOG_ERROR("entities.transport", "Could not initialize GameObjectAI for Transport");
 
    if (GetGoType() == GAMEOBJECT_TYPE_TRANSPORT)
    {
        UpdateLegacyTransportPathProgress();
 
        uint32 const period = GetPeriod();
        TransportAnimation const* animation = GetGOValue()->Transport.AnimationInfo;
        if (period && animation && !animation->Path.empty())
        {
            uint32 const timer = GetTimer() % period;
            TransportPathContainer::const_iterator nextItr = animation->Path.upper_bound(timer);
            if (nextItr == animation->Path.end())
                nextItr = animation->Path.begin();
 
            TransportPathContainer::const_iterator prevItr = nextItr;
            if (prevItr == animation->Path.begin())
                prevItr = animation->Path.end();
            --prevItr;
 
            TransportAnimationEntry const* prev = prevItr->second;
            TransportAnimationEntry const* next = nextItr->second;
 
            float segmentPct = 0.0f;
            if (prev != next)
            {
                uint32 const prevTime = prev->TimeSeg;
                uint32 const nextTime = next->TimeSeg;
                uint32 const segmentLength = nextTime > prevTime ? nextTime - prevTime : period - prevTime + nextTime;
                uint32 const segmentProgress = timer >= prevTime ? timer - prevTime : period - prevTime + timer;
 
                if (segmentLength)
                    segmentPct = float(segmentProgress) / float(segmentLength);
            }
 
            G3D::Vector3 offset(prev->X, prev->Y, prev->Z);
            if (prev != next)
                offset = offset.lerp(G3D::Vector3(next->X, next->Y, next->Z), segmentPct);
 
            G3D::Quat parentRotation(
                GetFloatValue(GAMEOBJECT_FIELD_PARENT_ROTATION + 0),
                GetFloatValue(GAMEOBJECT_FIELD_PARENT_ROTATION + 1),
                GetFloatValue(GAMEOBJECT_FIELD_PARENT_ROTATION + 2),
                GetFloatValue(GAMEOBJECT_FIELD_PARENT_ROTATION + 3));
 
            G3D::Vector3 pos = G3D::Vector3(GetStationaryX(), GetStationaryY(), GetStationaryZ()) + parentRotation.toRotationMatrix() * offset;
            UpdatePosition(pos.x, pos.y, pos.z, GetStationaryO());
        }
 
        sScriptMgr->OnTransportUpdate(this, diff);
        return;
    }
 
    if (GetKeyFrames().size() <= 1)
        return;
 
    m_goValue.Transport.PathProgress += diff;
 
    uint32 timer = m_goValue.Transport.PathProgress % GetPeriod();
 
    // Set current waypoint
    // Desired outcome: _currentFrame->DepartureTime < timer < _nextFrame->ArriveTime
    // ... arrive | ... delay ... | departure
    //      event /         event /
    for (;;)
    {
        if (timer >= _currentFrame->ArriveTime)
        {
            if (!_triggeredArrivalEvent)
            {
                DoEventIfAny(*_currentFrame, false);
                _triggeredArrivalEvent = true;
            }
 
            if (timer < _currentFrame->DepartureTime)
            {
                SetMoving(false);
                if (_pendingStop)
                    SetGoState(GOState::GO_STATE_READY);
                break;  // its a stop frame and we are waiting
            }
        }
 
        if (_pendingStop && timer >= _currentFrame->DepartureTime && GetGoState() == GOState::GO_STATE_READY)
        {
            m_goValue.Transport.PathProgress = (m_goValue.Transport.PathProgress / GetPeriod());
            m_goValue.Transport.PathProgress *= GetPeriod();
            m_goValue.Transport.PathProgress += _currentFrame->ArriveTime;
            break;
        }
 
        if (timer >= _currentFrame->DepartureTime && !_triggeredDepartureEvent)
        {
            DoEventIfAny(*_currentFrame, true); // departure event
            _triggeredDepartureEvent = true;
        }
 
        if (timer >= _currentFrame->DepartureTime && timer < _currentFrame->NextArriveTime)
            break;  // found current waypoint
 
        MoveToNextWaypoint();
 
        // not waiting anymore
        SetMoving(true);
 
        // Enable movement
        if (GetGOInfo()->moTransport.canBeStopped)
            SetGoState(GOState::GO_STATE_ACTIVE);
 
        sScriptMgr->OnRelocate(this, _currentFrame->Node->index, _currentFrame->Node->mapid, _currentFrame->Node->x, _currentFrame->Node->y, _currentFrame->Node->z);
 
        SF_LOG_DEBUG("entities.transport", "Transport %u (%s) moved to node %u %u %f %f %f", GetEntry(), GetName().c_str(), _currentFrame->Node->index, _currentFrame->Node->mapid, _currentFrame->Node->x, _currentFrame->Node->y, _currentFrame->Node->z);
 
        // Departure event
        if (_currentFrame->IsTeleportFrame())
            if (TeleportTransport(_nextFrame->Node->mapid, _nextFrame->Node->x, _nextFrame->Node->y, _nextFrame->Node->z))
                return; // Update more in new map thread
    }
 
    // Set position
    _positionChangeTimer.Update(diff);
    if (_positionChangeTimer.Passed())
    {
        _positionChangeTimer.Reset(positionUpdateDelay);
        if (IsMoving())
        {
            float t = CalculateSegmentPos(float(timer) * 0.001f);
            G3D::Vector3 pos, dir;
            _currentFrame->Spline->evaluate_percent(_currentFrame->Index, t, pos);
            _currentFrame->Spline->evaluate_derivative(_currentFrame->Index, t, dir);
            UpdatePosition(pos.x, pos.y, pos.z, atan2(dir.x, dir.y));
        }
    }
 
    sScriptMgr->OnTransportUpdate(this, diff);
}
 
void Transport::AddPassenger(WorldObject* passenger)
{
    if (!IsInWorld())
        return;
 
    if (_passengers.insert(passenger).second)
    {
        passenger->SetTransport(this);
        passenger->m_movementInfo.transport.guid = GetGUID();
 
        if (GetGoType() == GAMEOBJECT_TYPE_TRANSPORT)
            if (Unit* unit = passenger->ToUnit())
                unit->AddUnitState(UNIT_STATE_IGNORE_PATHFINDING);
 
        SF_LOG_DEBUG("entities.transport", "Object %s boarded transport %s.", passenger->GetName().c_str(), GetName().c_str());
 
        if (Player* plr = passenger->ToPlayer())
            sScriptMgr->OnAddPassenger(this, plr);
    }
}
 
void Transport::RemovePassenger(WorldObject* passenger)
{
    if (_passengers.erase(passenger) || _staticPassengers.erase(passenger)) // static passenger can remove itself in case of grid unload
    {
        passenger->m_movementInfo.transport.Reset();
        passenger->SetTransport(NULL);
 
        if (GetGoType() == GAMEOBJECT_TYPE_TRANSPORT)
            if (Unit* unit = passenger->ToUnit())
                unit->ClearUnitState(UNIT_STATE_IGNORE_PATHFINDING);
 
        SF_LOG_DEBUG("entities.transport", "Object %s removed from transport %s.", passenger->GetName().c_str(), GetName().c_str());
 
        if (Player* plr = passenger->ToPlayer())
            sScriptMgr->OnRemovePassenger(this, plr);
    }
}
 
Creature* Transport::CreateNPCPassenger(uint32 guid, CreatureData const* data)
{
    Map* map = GetMap();
    Creature* creature = new Creature();
 
    if (!creature->LoadCreatureFromDB(guid, map, false))
    {
        delete creature;
        return NULL;
    }
 
    float x = data->posX;
    float y = data->posY;
    float z = data->posZ;
    float o = data->orientation;
 
    creature->SetTransport(this);
    creature->m_movementInfo.transport.guid = GetGUID();
    creature->m_movementInfo.transport.pos.Relocate(x, y, z, o);
    CalculatePassengerPosition(x, y, z, &o);
    creature->Relocate(x, y, z, o);
    creature->SetHomePosition(creature->GetPositionX(), creature->GetPositionY(), creature->GetPositionZ(), creature->GetOrientation());
    creature->SetTransportHomePosition(creature->m_movementInfo.transport.pos);

    creature->AddUnitState(UNIT_STATE_IGNORE_PATHFINDING);
 
    if (!creature->IsPositionValid())
    {
        SF_LOG_ERROR("entities.transport", "Creature (guidlow %d, entry %d) not created. Suggested coordinates aren't valid (X: %f Y: %f)",
            creature->GetGUIDLow(), creature->GetEntry(), creature->GetPositionX(), creature->GetPositionY());
        delete creature;
        return NULL;
    }
 
    if (!map->AddToMap(creature))
    {
        delete creature;
        return NULL;
    }
 
    _staticPassengers.insert(creature);
    sScriptMgr->OnAddCreaturePassenger(this, creature);
    return creature;
}
 
GameObject* Transport::CreateGOPassenger(uint32 guid, GameObjectData const* data)
{
    Map* map = GetMap();
    GameObject* go = new GameObject();
 
    if (!go->LoadGameObjectFromDB(guid, map, false))
    {
        delete go;
        return NULL;
    }
 
    float x = data->posX;
    float y = data->posY;
    float z = data->posZ;
    float o = data->orientation;
 
    go->SetTransport(this);
    go->m_movementInfo.transport.guid = GetGUID();
    go->m_movementInfo.transport.pos.Relocate(x, y, z, o);
    CalculatePassengerPosition(x, y, z, &o);
    go->Relocate(x, y, z, o);
 
    if (!go->IsPositionValid())
    {
        SF_LOG_ERROR("entities.transport", "GameObject (guidlow %d, entry %d) not created. Suggested coordinates aren't valid (X: %f Y: %f)", go->GetGUIDLow(), go->GetEntry(), go->GetPositionX(), go->GetPositionY());
        delete go;
        return NULL;
    }
 
    if (!map->AddToMap(go))
    {
        delete go;
        return NULL;
    }
 
    _staticPassengers.insert(go);
    return go;
}
 
void Transport::UpdatePosition(float x, float y, float z, float o)
{
    bool newActive = GetMap()->IsGridLoaded(x, y);
 
    Relocate(x, y, z, o);
    if (GetGoType() == GAMEOBJECT_TYPE_TRANSPORT)
        UpdateWorldRotationField();
    else
        UpdateRotationFields(std::sin(o / 2.0f), std::cos(o / 2.0f));
    UpdateModelPosition();
 
    UpdatePassengerPositions(_passengers);
 
    if (GetGoType() == GAMEOBJECT_TYPE_TRANSPORT)
        return;
 
    /* There are four possible scenarios that trigger loading/unloading passengers:
      1. transport moves from inactive to active grid
      2. the grid that transport is currently in becomes active
      3. transport moves from active to inactive grid
      4. the grid that transport is currently in unloads
    */
    if (_staticPassengers.empty() && newActive) // 1. and 2.
        LoadStaticPassengers();
    else if (!_staticPassengers.empty() && !newActive && Cell(x, y).DiffGrid(Cell(GetPositionX(), GetPositionY()))) // 3.
        UnloadStaticPassengers();
    else
        UpdatePassengerPositions(_staticPassengers);
    // 4. is handed by grid unload
}
 
void Transport::LoadStaticPassengers()
{
    if (uint32 mapId = GetGOInfo()->moTransport.mapID)
    {
        CellObjectGuidsMap const& cells = sObjectMgr->GetMapObjectGuids(mapId, GetMap()->GetSpawnMode());
        CellGuidSet::const_iterator guidEnd;
        for (CellObjectGuidsMap::const_iterator cellItr = cells.begin(); cellItr != cells.end(); ++cellItr)
        {
            // Creatures on transport
            guidEnd = cellItr->second.creatures.end();
            for (CellGuidSet::const_iterator guidItr = cellItr->second.creatures.begin(); guidItr != guidEnd; ++guidItr)
                CreateNPCPassenger(*guidItr, sObjectMgr->GetCreatureData(*guidItr));
 
            // GameObjects on transport
            guidEnd = cellItr->second.gameobjects.end();
            for (CellGuidSet::const_iterator guidItr = cellItr->second.gameobjects.begin(); guidItr != guidEnd; ++guidItr)
                CreateGOPassenger(*guidItr, sObjectMgr->GetGOData(*guidItr));
        }
    }
}
 
void Transport::UnloadStaticPassengers()
{
    while (!_staticPassengers.empty())
    {
        WorldObject* obj = *_staticPassengers.begin();
        obj->AddObjectToRemoveList();   // also removes from _staticPassengers
    }
}
 
void Transport::EnableMovement(bool enabled)
{
    if (GetGoType() == GAMEOBJECT_TYPE_TRANSPORT)
    {
        SetGoState(enabled ? GOState::GO_STATE_ACTIVE : GOState::GO_STATE_READY);
        return;
    }
 
    if (!GetGOInfo()->moTransport.canBeStopped)
        return;
 
    _pendingStop = !enabled;
}
 
void Transport::MoveToNextWaypoint()
{
    // Clear events flagging
    _triggeredArrivalEvent = false;
    _triggeredDepartureEvent = false;
 
    // Set frames
    _currentFrame = _nextFrame++;
    if (_nextFrame == GetKeyFrames().end())
        _nextFrame = GetKeyFrames().begin();
}
 
float Transport::CalculateSegmentPos(float now)
{
    KeyFrame const& frame = *_currentFrame;
    const float speed = float(m_goInfo->moTransport.moveSpeed);
    const float accel = float(m_goInfo->moTransport.accelRate);
    float timeSinceStop = frame.TimeFrom + (now - (1.0f / float(IN_MILLISECONDS)) * frame.DepartureTime);
    float timeUntilStop = frame.TimeTo - (now - (1.0f / float(IN_MILLISECONDS)) * frame.DepartureTime);
    float segmentPos, dist;
    float accelTime = _transportInfo->accelTime;
    float accelDist = _transportInfo->accelDist;
    // calculate from nearest stop, less confusing calculation...
    if (timeSinceStop < timeUntilStop)
    {
        if (timeSinceStop < accelTime)
            dist = 0.5f * accel * timeSinceStop * timeSinceStop;
        else
            dist = accelDist + (timeSinceStop - accelTime) * speed;
        segmentPos = dist - frame.DistSinceStop;
    }
    else
    {
        if (timeUntilStop < _transportInfo->accelTime)
            dist = 0.5f * accel * timeUntilStop * timeUntilStop;
        else
            dist = accelDist + (timeUntilStop - accelTime) * speed;
        segmentPos = frame.DistUntilStop - dist;
    }
 
    return segmentPos / frame.NextDistFromPrev;
}
 
bool Transport::TeleportTransport(uint32 newMapid, float x, float y, float z)
{
    Map const* oldMap = GetMap();
 
    if (oldMap->GetId() != newMapid)
    {
        Map* newMap = sMapMgr->CreateBaseMap(newMapid);
        Map::PlayerList const& oldPlayers = GetMap()->GetPlayers();
        if (!oldPlayers.isEmpty())
        {
            UpdateData data(GetMapId());
            BuildOutOfRangeUpdateBlock(&data);
            WorldPacket packet;
            data.BuildPacket(&packet);
            for (Map::PlayerList::const_iterator itr = oldPlayers.begin(); itr != oldPlayers.end(); ++itr)
                if (itr->GetSource()->GetTransport() != this)
                    itr->GetSource()->SendDirectMessage(&packet);
        }
 
        UnloadStaticPassengers();
        GetMap()->RemoveFromMap<Transport>(this, false);
        SetMap(newMap);
 
        Map::PlayerList const& newPlayers = GetMap()->GetPlayers();
        if (!newPlayers.isEmpty())
        {
            for (Map::PlayerList::const_iterator itr = newPlayers.begin(); itr != newPlayers.end(); ++itr)
            {
                if (itr->GetSource()->GetTransport() != this)
                {
                    UpdateData data(newMapid);
                    BuildCreateUpdateBlockForPlayer(&data, itr->GetSource());
                    WorldPacket packet;
                    data.BuildPacket(&packet);
                    itr->GetSource()->SendDirectMessage(&packet);
                }
            }
        }
 
        for (std::set<WorldObject*>::iterator itr = _passengers.begin(); itr != _passengers.end();)
        {
            WorldObject* obj = (*itr++);
 
            float destX, destY, destZ, destO;
            obj->m_movementInfo.transport.pos.GetPosition(destX, destY, destZ, destO);
            TransportBase::CalculatePassengerPosition(destX, destY, destZ, &destO, x, y, z, GetOrientation());
 
            switch (obj->GetTypeId())
            {
                case TypeID::TYPEID_UNIT:
                    obj->ToCreature()->FarTeleportTo(newMap, destX, destY, destZ, destO);
                    break;
                case TypeID::TYPEID_GAMEOBJECT:
                {
                    GameObject* go = obj->ToGameObject();
                    go->GetMap()->RemoveFromMap(go, false);
                    go->Relocate(destX, destY, destZ, destO);
                    go->SetMap(newMap);
                    newMap->AddToMap(go);
                    break;
                }
                case TypeID::TYPEID_PLAYER:
                    if (!obj->ToPlayer()->TeleportTo(newMapid, destX, destY, destZ, destO, TELE_TO_NOT_LEAVE_TRANSPORT | TELE_TO_NOT_UNSUMMON_PET))
                        _passengers.erase(obj);
                    break;
                default:
                    break;
            }
        }
 
        Relocate(x, y, z, GetOrientation());
        UpdateModelPosition();
        GetMap()->AddToMap<Transport>(this);
        return true;
    }
    else
    {
        // Teleport players, they need to know it
        for (std::set<WorldObject*>::iterator itr = _passengers.begin(); itr != _passengers.end(); ++itr)
        {
            if ((*itr)->GetTypeId() == TypeID::TYPEID_PLAYER)
            {
                float destX, destY, destZ, destO;
                (*itr)->m_movementInfo.transport.pos.GetPosition(destX, destY, destZ, destO);
                TransportBase::CalculatePassengerPosition(destX, destY, destZ, &destO, x, y, z, GetOrientation());
 
                (*itr)->ToUnit()->NearTeleportTo(destX, destY, destZ, destO);
            }
        }
 
        UpdatePosition(x, y, z, GetOrientation());
        return false;
    }
}
 
void Transport::UpdatePassengerPositions(std::set<WorldObject*>& passengers)
{
    for (std::set<WorldObject*>::iterator itr = passengers.begin(); itr != passengers.end(); ++itr)
    {
        WorldObject* passenger = *itr;
        // transport teleported but passenger not yet (can happen for players)
        if (passenger->GetMap() != GetMap())
            continue;
 
        // if passenger is on vehicle we have to assume the vehicle is also on transport
        // and its the vehicle that will be updating its passengers
        if (Unit* unit = passenger->ToUnit())
            if (unit->GetVehicle())
                continue;
 
        // Do not use Unit::UpdatePosition here, we don't want to remove auras
        // as if regular movement occurred
        float x, y, z, o;
        passenger->m_movementInfo.transport.pos.GetPosition(x, y, z, o);
        CalculatePassengerPosition(x, y, z, &o);
        switch (passenger->GetTypeId())
        {
            case TypeID::TYPEID_UNIT:
            {
                Creature* creature = passenger->ToCreature();
                GetMap()->CreatureRelocation(creature, x, y, z, o, false);
                creature->GetTransportHomePosition(x, y, z, o);
                CalculatePassengerPosition(x, y, z, &o);
                creature->SetHomePosition(x, y, z, o);
                break;
            }
            case TypeID::TYPEID_PLAYER:
                GetMap()->PlayerRelocation(passenger->ToPlayer(), x, y, z, o);
                break;
            case TypeID::TYPEID_GAMEOBJECT:
                GetMap()->GameObjectRelocation(passenger->ToGameObject(), x, y, z, o, false);
                break;
            default:
                break;
        }
 
        if (Unit* unit = passenger->ToUnit())
            if (Vehicle* vehicle = unit->GetVehicleKit())
                vehicle->RelocatePassengers();
    }
}
 
void Transport::DoEventIfAny(KeyFrame const& node, bool departure)
{
    if (uint32 eventid = departure ? node.Node->departureEventID : node.Node->arrivalEventID)
    {
        SF_LOG_DEBUG("maps.script", "Taxi %s event %u of node %u of %s path", departure ? "departure" : "arrival", eventid, node.Node->index, GetName().c_str());
        GetMap()->ScriptsStart(sEventScripts, eventid, this, this);
        EventInform(eventid);
    }
}
 
void Transport::BuildUpdate(UpdateDataMapType& data_map)
{
    Map::PlayerList const& players = GetMap()->GetPlayers();
    if (players.isEmpty())
        return;
 
    for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
    {
        Player* player = itr->GetSource();
        if (!player->IsInWorld())
            continue;
 
        if (player->GetTransport() != this && !player->HaveAtClient(this))
            continue;
 
        BuildFieldsUpdate(player, data_map);
    }
 
    ClearUpdateMask(true);
}