Ported .Net Core commits:

hondacrx: - Initial commit: Switch to .Net Core 2.0 - Fix build and removed not needed files Fabi: - Updated solution platforms. - Changed folder structure. - Change library target framework to netstandard2.0. - Updated solution platforms again... - Removed windows specific kernel32 function usage (Ctrl-C handler).
2017-10-26 17:23:44 +02:00
parent 227702e19c
commit a3dc7b3f48
844 changed files with 26064 additions and 1824 deletions
@@ -0,0 +1,651 @@
+/*
+ * Copyright (C) 2012-2017 CypherCore <http://github.com/CypherCore>
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using Framework.Constants;
+using Game.BattleGrounds;
+using Game.DataStorage;
+using Game.Entities;
+using Game.Garrisons;
+using Game.Maps;
+using Game.Movement;
+using Game.Network;
+using Game.Network.Packets;
+using System;
+using System.Collections.Generic;
+
+namespace Game
+{
+    public partial class WorldSession
+    {
+        [WorldPacketHandler(ClientOpcodes.MoveChangeTransport, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveFallReset, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveFallLand, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveHeartbeat, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveJump, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveSetFacing, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveSetPitch, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveStartAscend, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveStartBackward, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveStartDescend, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveStartForward, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveStartPitchDown, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveStartPitchUp, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveStartStrafeLeft, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveStartStrafeRight, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveStartSwim, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveStartTurnLeft, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveStartTurnRight, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveStop, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveStopAscend, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveStopPitch, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveStopStrafe, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveStopSwim, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveStopTurn, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveDoubleJump, Processing = PacketProcessing.ThreadSafe)]
+        void HandleMovement(ClientPlayerMovement packet)
+        {
+            HandleMovementOpcode(packet.GetOpcode(), packet.Status);
+        }
+
+        void HandleMovementOpcode(ClientOpcodes opcode, MovementInfo movementInfo)
+        {
+            Unit mover = GetPlayer().m_unitMovedByMe;
+            Player plrMover = mover.ToPlayer();
+
+            if (plrMover && plrMover.IsBeingTeleported())
+                return;
+
+            GetPlayer().ValidateMovementInfo(movementInfo);
+
+            if (movementInfo.Guid != mover.GetGUID())
+            {
+                Log.outError(LogFilter.Network, "HandleMovementOpcodes: guid error");
+                return;
+            }
+            if (!movementInfo.Pos.IsPositionValid())
+            {
+                Log.outError(LogFilter.Network, "HandleMovementOpcodes: Invalid Position");
+                return;
+            }
+
+            // stop some emotes at player move
+            if (plrMover && (plrMover.GetUInt32Value(UnitFields.NpcEmotestate) != 0))
+                plrMover.SetUInt32Value(UnitFields.NpcEmotestate, (uint)Emote.OneshotNone);
+
+            //handle special cases
+            if (!movementInfo.transport.guid.IsEmpty())
+            {
+                if (movementInfo.transport.pos.GetPositionX() > 50 || movementInfo.transport.pos.GetPositionY() > 50 || movementInfo.transport.pos.GetPositionZ() > 50)
+                    return;
+
+                if (!GridDefines.IsValidMapCoord(movementInfo.Pos.posX + movementInfo.transport.pos.posX, movementInfo.Pos.posY + movementInfo.transport.pos.posY,
+                    movementInfo.Pos.posZ + movementInfo.transport.pos.posZ, movementInfo.Pos.Orientation + movementInfo.transport.pos.Orientation))
+                    return;
+
+                if (plrMover)
+                {
+                    if (!plrMover.GetTransport())
+                    {
+                        Transport transport = plrMover.GetMap().GetTransport(movementInfo.transport.guid);
+                        if (transport)
+                            transport.AddPassenger(plrMover);
+                    }
+                    else if (plrMover.GetTransport().GetGUID() != movementInfo.transport.guid)
+                    {
+                        plrMover.GetTransport().RemovePassenger(plrMover);
+                        Transport transport = plrMover.GetMap().GetTransport(movementInfo.transport.guid);
+                        if (transport)
+                            transport.AddPassenger(plrMover);
+                        else
+                            movementInfo.ResetTransport();
+                    }
+                }
+
+                if (!mover.GetTransport() && !mover.GetVehicle())
+                {
+                    GameObject go = mover.GetMap().GetGameObject(movementInfo.transport.guid);
+                    if (!go || go.GetGoType() != GameObjectTypes.Transport)
+                        movementInfo.transport.Reset();
+                }
+            }
+            else if (plrMover && plrMover.GetTransport())                // if we were on a transport, leave
+                plrMover.GetTransport().RemovePassenger(plrMover);
+
+            // fall damage generation (ignore in flight case that can be triggered also at lags in moment teleportation to another map).
+            if (opcode == ClientOpcodes.MoveFallLand && plrMover && !plrMover.IsInFlight())
+                plrMover.HandleFall(movementInfo);
+
+            if (plrMover && movementInfo.HasMovementFlag(MovementFlag.Swimming) != plrMover.IsInWater())
+            {
+                // now client not include swimming flag in case jumping under water
+                plrMover.SetInWater(!plrMover.IsInWater() || plrMover.GetMap().IsUnderWater(movementInfo.Pos.posX, movementInfo.Pos.posY, movementInfo.Pos.posZ));
+            }
+
+            uint mstime = Time.GetMSTime();
+
+            if (m_clientTimeDelay == 0)
+                m_clientTimeDelay = mstime - movementInfo.Time;
+
+            movementInfo.Time = movementInfo.Time + m_clientTimeDelay;
+
+            movementInfo.Guid = mover.GetGUID();
+            mover.m_movementInfo = movementInfo;
+
+            // Some vehicles allow the passenger to turn by himself
+            Vehicle vehicle = mover.GetVehicle();
+            if (vehicle)
+            {
+                VehicleSeatRecord seat = vehicle.GetSeatForPassenger(mover);
+                if (seat != null)
+                {
+                    if (seat.Flags[0].HasAnyFlag((uint)VehicleSeatFlags.AllowTurning))
+                    {
+                        if (movementInfo.Pos.GetOrientation() != mover.GetOrientation())
+                        {
+                            mover.SetOrientation(movementInfo.Pos.GetOrientation());
+                            mover.RemoveAurasWithInterruptFlags(SpellAuraInterruptFlags.Turning);
+                        }
+                    }
+                }
+                return;
+            }
+
+            mover.UpdatePosition(movementInfo.Pos);
+
+            MoveUpdate moveUpdate = new MoveUpdate();
+            moveUpdate.Status = mover.m_movementInfo;
+            mover.SendMessageToSet(moveUpdate, GetPlayer());
+
+            if (plrMover)                                            // nothing is charmed, or player charmed
+            {
+                if (plrMover.IsSitState() && movementInfo.HasMovementFlag(MovementFlag.MaskMoving | MovementFlag.MaskTurning))
+                    plrMover.SetStandState(UnitStandStateType.Stand);
+
+                plrMover.UpdateFallInformationIfNeed(movementInfo, opcode);
+
+                if (movementInfo.Pos.posZ < plrMover.GetMap().GetMinHeight(movementInfo.Pos.GetPositionX(), movementInfo.Pos.GetPositionY()))
+                {
+                    if (!(plrMover.GetBattleground() && plrMover.GetBattleground().HandlePlayerUnderMap(GetPlayer())))
+                    {
+                        // NOTE: this is actually called many times while falling
+                        // even after the player has been teleported away
+                        /// @todo discard movement packets after the player is rooted
+                        if (plrMover.IsAlive())
+                        {
+                            plrMover.SetFlag(PlayerFields.Flags, PlayerFlags.IsOutOfBounds);
+                            plrMover.EnvironmentalDamage(EnviromentalDamage.FallToVoid, (uint)GetPlayer().GetMaxHealth());
+                            // player can be alive if GM/etc
+                            // change the death state to CORPSE to prevent the death timer from
+                            // starting in the next player update
+                            if (!plrMover.IsAlive())
+                                plrMover.KillPlayer();
+                        }
+                    }
+                }
+                else
+                    plrMover.RemoveFlag(PlayerFields.Flags, PlayerFlags.IsOutOfBounds);
+            }
+        }
+
+        [WorldPacketHandler(ClientOpcodes.WorldPortResponse, Status = SessionStatus.Transfer)]
+        void HandleMoveWorldportAck(WorldPortResponse packet)
+        {
+            HandleMoveWorldportAck();
+        }
+
+        void HandleMoveWorldportAck()
+        {
+            // ignore unexpected far teleports
+            if (!GetPlayer().IsBeingTeleportedFar())
+                return;
+
+            bool seamlessTeleport = GetPlayer().IsBeingTeleportedSeamlessly();
+            GetPlayer().SetSemaphoreTeleportFar(false);
+
+            // get the teleport destination
+            WorldLocation loc = GetPlayer().GetTeleportDest();
+
+            // possible errors in the coordinate validity check
+            if (!GridDefines.IsValidMapCoord(loc))
+            {
+                LogoutPlayer(false);
+                return;
+            }
+
+            // get the destination map entry, not the current one, this will fix homebind and reset greeting
+            MapRecord mapEntry = CliDB.MapStorage.LookupByKey(loc.GetMapId());
+            InstanceTemplate mInstance = Global.ObjectMgr.GetInstanceTemplate(loc.GetMapId());
+
+            // reset instance validity, except if going to an instance inside an instance
+            if (!GetPlayer().m_InstanceValid && mInstance == null)
+                GetPlayer().m_InstanceValid = true;
+
+            Map oldMap = GetPlayer().GetMap();
+            Map newMap = Global.MapMgr.CreateMap(loc.GetMapId(), GetPlayer());
+
+            if (GetPlayer().IsInWorld)
+            {
+                Log.outError(LogFilter.Network, "Player (Name {0}) is still in world when teleported from map {1} to new map {2}", GetPlayer().GetName(), oldMap.GetId(), loc.GetMapId());
+                oldMap.RemovePlayerFromMap(GetPlayer(), false);
+            }
+
+            // relocate the player to the teleport destination
+            // the CannotEnter checks are done in TeleporTo but conditions may change
+            // while the player is in transit, for example the map may get full
+            if (newMap == null || newMap.CannotEnter(GetPlayer()) != 0)
+            {
+                Log.outError(LogFilter.Network, "Map {0} could not be created for {1} ({2}), porting player to homebind", loc.GetMapId(), newMap ? newMap.GetMapName() : "Unknown", GetPlayer().GetGUID().ToString());
+                GetPlayer().TeleportTo(GetPlayer().GetHomebind());
+                return;
+            }
+
+            float z = loc.GetPositionZ();
+            if (GetPlayer().HasUnitMovementFlag(MovementFlag.Hover))
+                z += GetPlayer().GetFloatValue(UnitFields.HoverHeight);
+
+            GetPlayer().Relocate(loc.GetPositionX(), loc.GetPositionY(), z, loc.GetOrientation());
+
+            GetPlayer().ResetMap();
+            GetPlayer().SetMap(newMap);
+
+            ResumeToken resumeToken = new ResumeToken();
+            resumeToken.SequenceIndex = _player.m_movementCounter;
+            resumeToken.Reason = seamlessTeleport ? 2 : 1u;
+            SendPacket(resumeToken);
+
+            if (!seamlessTeleport)
+                GetPlayer().SendInitialPacketsBeforeAddToMap();
+
+            if (!GetPlayer().GetMap().AddPlayerToMap(GetPlayer(), !seamlessTeleport))
+            {
+                Log.outError(LogFilter.Network, "WORLD: failed to teleport player {0} ({1}) to map {2} ({3}) because of unknown reason!",
+                    GetPlayer().GetName(), GetPlayer().GetGUID().ToString(), loc.GetMapId(), newMap ? newMap.GetMapName() : "Unknown");
+                GetPlayer().ResetMap();
+                GetPlayer().SetMap(oldMap);
+                GetPlayer().TeleportTo(GetPlayer().GetHomebind());
+                return;
+            }
+
+            // Battleground state prepare (in case join to BG), at relogin/tele player not invited
+            // only add to bg group and object, if the player was invited (else he entered through command)
+            if (GetPlayer().InBattleground())
+            {
+                Battleground bg;
+                // cleanup setting if outdated
+                if (!mapEntry.IsBattlegroundOrArena())
+                {
+                    // We're not in BG
+                    GetPlayer().SetBattlegroundId(0, BattlegroundTypeId.None);
+                    // reset destination bg team
+                    GetPlayer().SetBGTeam(0);
+                }
+                // join to bg case
+                else if (bg = GetPlayer().GetBattleground())
+                {
+                    if (GetPlayer().IsInvitedForBattlegroundInstance(GetPlayer().GetBattlegroundId()))
+                        bg.AddPlayer(GetPlayer());
+                }
+            }
+
+            if (!seamlessTeleport)
+                GetPlayer().SendInitialPacketsAfterAddToMap();
+            else
+            {
+                GetPlayer().UpdateVisibilityForPlayer();
+                Garrison garrison = GetPlayer().GetGarrison();
+                if (garrison != null)
+                    garrison.SendRemoteInfo();
+            }
+
+            // flight fast teleport case
+            if (GetPlayer().GetMotionMaster().GetCurrentMovementGeneratorType() == MovementGeneratorType.Flight)
+            {
+                if (!GetPlayer().InBattleground())
+                {
+                    if (!seamlessTeleport)
+                    {
+                        // short preparations to continue flight
+                        FlightPathMovementGenerator flight = (FlightPathMovementGenerator)GetPlayer().GetMotionMaster().top();
+                        flight.Initialize(GetPlayer());
+                    }
+                    return;
+                }
+
+                // Battlegroundstate prepare, stop flight
+                GetPlayer().GetMotionMaster().MovementExpired();
+                GetPlayer().CleanupAfterTaxiFlight();
+            }
+
+            // resurrect character at enter into instance where his corpse exist after add to map
+            if (mapEntry.IsDungeon() && !GetPlayer().IsAlive())
+            { 
+                if (GetPlayer().GetCorpseLocation().GetMapId() == mapEntry.Id)
+                {
+                    GetPlayer().ResurrectPlayer(0.5f, false);
+                    GetPlayer().SpawnCorpseBones();
+                }
+            }
+
+            bool allowMount = !mapEntry.IsDungeon() || mapEntry.IsBattlegroundOrArena();
+            if (mInstance != null)
+            {
+                // check if this instance has a reset time and send it to player if so
+                Difficulty diff = GetPlayer().GetDifficultyID(mapEntry);
+                MapDifficultyRecord mapDiff = Global.DB2Mgr.GetMapDifficultyData(mapEntry.Id, diff);
+                if (mapDiff != null)
+                {
+                    if (mapDiff.GetRaidDuration() != 0)
+                    {
+                        long timeReset = Global.InstanceSaveMgr.GetResetTimeFor(mapEntry.Id, diff);
+                        if (timeReset != 0)
+                        {
+                            uint timeleft = (uint)(timeReset - Time.UnixTime);
+                            GetPlayer().SendInstanceResetWarning(mapEntry.Id, diff, timeleft, true);
+                        }
+                    }
+                }
+
+                // check if instance is valid
+                if (!GetPlayer().CheckInstanceValidity(false))
+                    GetPlayer().m_InstanceValid = false;
+
+                // instance mounting is handled in InstanceTemplate
+                allowMount = mInstance.AllowMount;
+            }
+
+            // mount allow check
+            if (!allowMount)
+                GetPlayer().RemoveAurasByType(AuraType.Mounted);
+
+            // update zone immediately, otherwise leave channel will cause crash in mtmap
+            uint newzone, newarea;
+            GetPlayer().GetZoneAndAreaId(out newzone, out newarea);
+            GetPlayer().UpdateZone(newzone, newarea);
+
+            // honorless target
+            if (GetPlayer().pvpInfo.IsHostile)
+                GetPlayer().CastSpell(GetPlayer(), 2479, true);
+
+            // in friendly area
+            else if (GetPlayer().IsPvP() && !GetPlayer().HasFlag(PlayerFields.Flags, PlayerFlags.InPVP))
+                GetPlayer().UpdatePvP(false, false);
+
+            // resummon pet
+            GetPlayer().ResummonPetTemporaryUnSummonedIfAny();
+
+            //lets process all delayed operations on successful teleport
+            GetPlayer().ProcessDelayedOperations();
+        }
+
+        [WorldPacketHandler(ClientOpcodes.SuspendTokenResponse, Status = SessionStatus.Transfer)]
+        void HandleSuspendTokenResponse(SuspendTokenResponse suspendTokenResponse)
+        {
+            if (!_player.IsBeingTeleportedFar())
+                return;
+
+            WorldLocation loc = GetPlayer().GetTeleportDest();
+
+            if (CliDB.MapStorage.LookupByKey(loc.GetMapId()).IsDungeon())
+            {
+                UpdateLastInstance updateLastInstance = new UpdateLastInstance();
+                updateLastInstance.MapID = loc.GetMapId();
+                SendPacket(updateLastInstance);
+            }
+
+            NewWorld packet = new NewWorld();
+            packet.MapID = loc.GetMapId();
+            packet.Pos = loc;
+            packet.Reason = (uint)(!_player.IsBeingTeleportedSeamlessly() ? NewWorldReason.Normal : NewWorldReason.Seamless);
+            SendPacket(packet);
+
+            if (_player.IsBeingTeleportedSeamlessly())
+                HandleMoveWorldportAck();
+        }
+
+        [WorldPacketHandler(ClientOpcodes.MoveTeleportAck, Processing = PacketProcessing.ThreadSafe)]
+        void HandleMoveTeleportAck(MoveTeleportAck packet)
+        {
+            Player plMover = GetPlayer().m_unitMovedByMe.ToPlayer();
+
+            if (!plMover || !plMover.IsBeingTeleportedNear())
+                return;
+
+            if (packet.MoverGUID != plMover.GetGUID())
+                return;
+
+            plMover.SetSemaphoreTeleportNear(false);
+
+            uint old_zone = plMover.GetZoneId();
+
+            WorldLocation dest = plMover.GetTeleportDest();
+
+            plMover.UpdatePosition(dest, true);
+
+            uint newzone, newarea;
+            plMover.GetZoneAndAreaId(out newzone, out newarea);
+            plMover.UpdateZone(newzone, newarea);
+
+            // new zone
+            if (old_zone != newzone)
+            {
+                // honorless target
+                if (plMover.pvpInfo.IsHostile)
+                    plMover.CastSpell(plMover, 2479, true);
+
+                // in friendly area
+                else if (plMover.IsPvP() && !plMover.HasFlag(PlayerFields.Flags, PlayerFlags.InPVP))
+                    plMover.UpdatePvP(false, false);
+            }
+
+            // resummon pet
+            GetPlayer().ResummonPetTemporaryUnSummonedIfAny();
+
+            //lets process all delayed operations on successful teleport
+            GetPlayer().ProcessDelayedOperations();
+        }
+
+        [WorldPacketHandler(ClientOpcodes.MoveForceFlightBackSpeedChangeAck, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveForceFlightSpeedChangeAck, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveForcePitchRateChangeAck, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveForceRunBackSpeedChangeAck, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveForceRunSpeedChangeAck, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveForceSwimBackSpeedChangeAck, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveForceSwimSpeedChangeAck, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveForceTurnRateChangeAck, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveForceWalkSpeedChangeAck, Processing = PacketProcessing.ThreadSafe)]
+        void HandleForceSpeedChangeAck(MovementSpeedAck packet)
+        {
+            GetPlayer().ValidateMovementInfo(packet.Ack.Status);
+
+            // now can skip not our packet
+            if (GetPlayer().GetGUID() != packet.Ack.Status.Guid)
+                return;
+
+            /*----------------*/
+            // client ACK send one packet for mounted/run case and need skip all except last from its
+            // in other cases anti-cheat check can be fail in false case
+            UnitMoveType move_type;
+
+            ClientOpcodes opcode = packet.GetOpcode();
+            switch (opcode)
+            {
+                case ClientOpcodes.MoveForceWalkSpeedChangeAck:
+                    move_type = UnitMoveType.Walk;
+                    break;
+                case ClientOpcodes.MoveForceRunSpeedChangeAck:
+                    move_type = UnitMoveType.Run;
+                    break;
+                case ClientOpcodes.MoveForceRunBackSpeedChangeAck:
+                    move_type = UnitMoveType.RunBack;
+                    break;
+                case ClientOpcodes.MoveForceSwimSpeedChangeAck:
+                    move_type = UnitMoveType.Swim;
+                    break;
+                case ClientOpcodes.MoveForceSwimBackSpeedChangeAck:
+                    move_type = UnitMoveType.SwimBack;
+                    break;
+                case ClientOpcodes.MoveForceTurnRateChangeAck:
+                    move_type = UnitMoveType.TurnRate;
+                    break;
+                case ClientOpcodes.MoveForceFlightSpeedChangeAck:
+                    move_type = UnitMoveType.Flight;
+                    break;
+                case ClientOpcodes.MoveForceFlightBackSpeedChangeAck:
+                    move_type = UnitMoveType.FlightBack;
+                    break;
+                case ClientOpcodes.MoveForcePitchRateChangeAck:
+                    move_type = UnitMoveType.PitchRate;
+                    break;
+                default:
+                    Log.outError(LogFilter.Network, "WorldSession.HandleForceSpeedChangeAck: Unknown move type opcode: {0}", opcode);
+                    return;
+            }
+
+            // skip all forced speed changes except last and unexpected
+            // in run/mounted case used one ACK and it must be skipped. m_forced_speed_changes[MOVE_RUN] store both.
+            if (GetPlayer().m_forced_speed_changes[(int)move_type] > 0)
+            {
+                --GetPlayer().m_forced_speed_changes[(int)move_type];
+                if (GetPlayer().m_forced_speed_changes[(int)move_type] > 0)
+                    return;
+            }
+
+            if (!GetPlayer().GetTransport() && Math.Abs(GetPlayer().GetSpeed(move_type) - packet.Speed) > 0.01f)
+            {
+                if (GetPlayer().GetSpeed(move_type) > packet.Speed)         // must be greater - just correct
+                {
+                    Log.outError(LogFilter.Network, "{0}SpeedChange player {1} is NOT correct (must be {2} instead {3}), force set to correct value",
+                        move_type, GetPlayer().GetName(), GetPlayer().GetSpeed(move_type), packet.Speed);
+                    GetPlayer().SetSpeedRate(move_type, GetPlayer().GetSpeedRate(move_type));
+                }
+                else                                                // must be lesser - cheating
+                {
+                    Log.outDebug(LogFilter.Server, "Player {0} from account id {1} kicked for incorrect speed (must be {2} instead {3})",
+                        GetPlayer().GetName(), GetPlayer().GetSession().GetAccountId(), GetPlayer().GetSpeed(move_type), packet.Speed);
+                    GetPlayer().GetSession().KickPlayer();
+                }
+            }
+        }
+
+        [WorldPacketHandler(ClientOpcodes.SetActiveMover)]
+        void HandleSetActiveMover(SetActiveMover packet)
+        {
+            if (GetPlayer().IsInWorld)
+            {
+                if (_player.m_unitMovedByMe.GetGUID() != packet.ActiveMover)
+                    Log.outError(LogFilter.Network, "HandleSetActiveMover: incorrect mover guid: mover is {0} and should be {1},", packet.ActiveMover.ToString(), _player.m_unitMovedByMe.GetGUID().ToString());
+            }
+        }
+
+        [WorldPacketHandler(ClientOpcodes.MoveKnockBackAck, Processing = PacketProcessing.ThreadSafe)]
+        void HandleMoveKnockBackAck(MoveKnockBackAck movementAck)
+        {
+            GetPlayer().ValidateMovementInfo(movementAck.Ack.Status);
+
+            if (GetPlayer().m_unitMovedByMe.GetGUID() != movementAck.Ack.Status.Guid)
+                return;
+
+            GetPlayer().m_movementInfo = movementAck.Ack.Status;
+
+            MoveUpdateKnockBack updateKnockBack = new MoveUpdateKnockBack();
+            updateKnockBack.Status = GetPlayer().m_movementInfo;
+            GetPlayer().SendMessageToSet(updateKnockBack, false);
+        }
+
+        [WorldPacketHandler(ClientOpcodes.MoveEnableSwimToFlyTransAck, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveFeatherFallAck, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveForceRootAck, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveForceUnrootAck, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveGravityDisableAck, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveGravityEnableAck, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveHoverAck, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveSetCanFlyAck, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveSetCanTurnWhileFallingAck, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveSetIgnoreMovementForcesAck, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveWaterWalkAck, Processing = PacketProcessing.ThreadSafe)]
+        [WorldPacketHandler(ClientOpcodes.MoveEnableDoubleJumpAck, Processing = PacketProcessing.ThreadSafe)]
+        void HandleMovementAckMessage(MovementAckMessage movementAck)
+        {
+            GetPlayer().ValidateMovementInfo(movementAck.Ack.Status);
+        }
+
+        [WorldPacketHandler(ClientOpcodes.SummonResponse)]
+        void HandleSummonResponseOpcode(SummonResponse packet)
+        {
+            if (!GetPlayer().IsAlive() || GetPlayer().IsInCombat())
+                return;
+
+            GetPlayer().SummonIfPossible(packet.Accept);
+        }
+
+        [WorldPacketHandler(ClientOpcodes.MoveSetCollisionHeightAck, Processing = PacketProcessing.ThreadSafe)]
+        void HandleSetCollisionHeightAck(MoveSetCollisionHeightAck packet)
+        {
+            GetPlayer().ValidateMovementInfo(packet.Data.Status);
+        }
+
+        [WorldPacketHandler(ClientOpcodes.MoveTimeSkipped, Processing = PacketProcessing.Inplace)]
+        void HandleMoveTimeSkipped(MoveTimeSkipped moveTimeSkipped)
+        {
+        }
+
+        [WorldPacketHandler(ClientOpcodes.MoveSplineDone, Processing = PacketProcessing.ThreadSafe)]
+        void HandleMoveSplineDoneOpcode(MoveSplineDone moveSplineDone)
+        {
+            MovementInfo movementInfo = moveSplineDone.Status;
+            _player.ValidateMovementInfo(movementInfo);
+
+            // in taxi flight packet received in 2 case:
+            // 1) end taxi path in far (multi-node) flight
+            // 2) switch from one map to other in case multim-map taxi path
+            // we need process only (1)
+
+            uint curDest = GetPlayer().m_taxi.GetTaxiDestination();
+            if (curDest != 0)
+            {
+                TaxiNodesRecord curDestNode = CliDB.TaxiNodesStorage.LookupByKey(curDest);
+
+                // far teleport case
+                if (curDestNode != null && curDestNode.MapID != GetPlayer().GetMapId())
+                {
+                    if (GetPlayer().GetMotionMaster().GetCurrentMovementGeneratorType() == MovementGeneratorType.Flight)
+                    {
+                        // short preparations to continue flight
+                        FlightPathMovementGenerator flight = (FlightPathMovementGenerator)GetPlayer().GetMotionMaster().top();
+
+                        flight.SetCurrentNodeAfterTeleport();
+                        TaxiPathNodeRecord node = flight.GetPath()[(int)flight.GetCurrentNode()];
+                        flight.SkipCurrentNode();
+
+                        GetPlayer().TeleportTo(curDestNode.MapID, node.Loc.X, node.Loc.Y, node.Loc.Z, GetPlayer().GetOrientation());
+                    }
+                }
+
+                return;
+            }
+
+            // at this point only 1 node is expected (final destination)
+            if (GetPlayer().m_taxi.GetPath().Count != 1)
+                return;
+
+            GetPlayer().CleanupAfterTaxiFlight();
+            GetPlayer().SetFallInformation(0, GetPlayer().GetPositionZ());
+            if (GetPlayer().pvpInfo.IsHostile)
+                GetPlayer().CastSpell(GetPlayer(), 2479, true);
+        }
+    }
+}