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,503 @@
+/*
+ * 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 Framework.GameMath;
+using Game.DataStorage;
+using Game.Entities;
+using Game.Maps;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Game.Movement
+{
+    public class WaypointMovementGenerator<T> : MovementGeneratorMedium<T> where T : Creature
+    {
+        const int FLIGHT_TRAVEL_UPDATE = 100;
+        const int TIMEDIFF_NEXT_WP = 250;
+        public WaypointMovementGenerator(uint pathid = 0, bool _repeating = true)
+        {
+            nextMoveTime = new TimeTrackerSmall(0);
+            isArrivalDone = false;
+            pathId = pathid;
+            repeating = _repeating;
+        }
+        public override void DoReset(T owner)
+        {
+            owner.AddUnitState(UnitState.Roaming | UnitState.RoamingMove);
+            StartMoveNow(owner);
+        }
+
+        public override void DoFinalize(T owner)
+        {
+            owner.ClearUnitState(UnitState.Roaming | UnitState.RoamingMove);
+            owner.SetWalk(false);
+        }
+        public override void DoInitialize(T owner)
+        {
+            LoadPath(owner);
+            owner.AddUnitState(UnitState.Roaming | UnitState.RoamingMove);
+        }
+        public override bool DoUpdate(T owner, uint time_diff)
+        {
+            // Waypoint movement can be switched on/off
+            // This is quite handy for escort quests and other stuff
+            if (owner.HasUnitState(UnitState.NotMove))
+            {
+                owner.ClearUnitState(UnitState.RoamingMove);
+                return true;
+            }
+            // prevent a crash at empty waypoint path.
+            if (path == null || path.Empty())
+                return false;
+
+            if (Stopped())
+            {
+                if (CanMove((int)time_diff))
+                    return StartMove(owner);
+            }
+            else
+            {
+                if (owner.IsStopped())
+                    Stop(WorldConfig.GetIntValue(WorldCfg.CreatureStopForPlayer));
+                else if (owner.moveSpline.Finalized())
+                {
+                    OnArrived(owner);
+                    return StartMove(owner);
+                }
+            }
+            return true;
+        }
+        void MovementInform(Creature creature)
+        {
+            if (creature.IsAIEnabled)
+                creature.GetAI().MovementInform(MovementGeneratorType.Waypoint, currentNode);
+        }
+
+        void Stop(int time)
+        {
+            nextMoveTime.Reset(time);
+        }
+        bool Stopped()
+        {
+            return !nextMoveTime.Passed();
+        }
+        bool CanMove(int diff)
+        {
+            nextMoveTime.Update(diff);
+            return nextMoveTime.Passed();
+        }
+        void StartMoveNow(Creature creature)
+        {
+            nextMoveTime.Reset(0);
+            StartMove(creature);
+        }
+        bool StartMove(Creature creature)
+        {
+            if (path == null || path.Empty())
+                return false;
+
+            if (Stopped())
+                return true;
+
+            bool transportPath = creature.GetTransport() != null;
+
+            if (isArrivalDone)
+            {
+                if ((currentNode == path.Count - 1) && !repeating) // If that's our last waypoint
+                {
+                    float x = path[(int)currentNode].x;
+                    float y = path[(int)currentNode].y;
+                    float z = path[(int)currentNode].z;
+                    float o = path[(int)currentNode].orientation;
+
+                    if (!transportPath)
+                        creature.SetHomePosition(x, y, z, o);
+                    else
+                    {
+                        Transport trans = creature.GetTransport();
+                        if (trans)
+                        {
+                            o -= trans.GetOrientation();
+                            creature.SetTransportHomePosition(x, y, z, o);
+                            trans.CalculatePassengerPosition(ref x, ref y, ref z, ref o);
+                            creature.SetHomePosition(x, y, z, o);
+                        }
+                        else
+                            transportPath = false;
+                        // else if (vehicle) - this should never happen, vehicle offsets are const
+                    }
+
+                    creature.GetMotionMaster().Initialize();
+                    return false;
+                }
+
+                currentNode = (uint)((currentNode + 1) % path.Count);
+            }
+
+            WaypointData node = path.LookupByIndex((int)currentNode);
+
+            isArrivalDone = false;
+
+            creature.AddUnitState(UnitState.RoamingMove);
+
+            MoveSplineInit init = new MoveSplineInit(creature);
+            Position formationDest = new Position(node.x, node.y, node.z);
+
+            //! If creature is on transport, we assume waypoints set in DB are already transport offsets
+            if (transportPath)
+            {
+                init.DisableTransportPathTransformations();
+                ITransport trans = creature.GetDirectTransport();
+                if (trans != null)
+                    trans.CalculatePassengerPosition(ref formationDest.posX, ref formationDest.posY, ref formationDest.posZ, ref formationDest.Orientation);
+            }
+
+            init.MoveTo(formationDest.posX, formationDest.posY, formationDest.posZ);
+
+            //! Accepts angles such as 0.00001 and -0.00001, 0 must be ignored, default value in waypoint table
+            if (node.orientation != 0 && node.delay != 0)
+                init.SetFacing(formationDest.Orientation);
+
+            switch (node.movetype)
+            {
+                case WaypointMoveType.Land:
+                    init.SetAnimation(AnimType.ToGround);
+                    break;
+                case WaypointMoveType.Takeoff:
+                    init.SetAnimation(AnimType.ToFly);
+                    break;
+                case WaypointMoveType.Run:
+                    init.SetWalk(false);
+                    break;
+                case WaypointMoveType.Walk:
+                    init.SetWalk(true);
+                    break;
+            }
+
+            init.Launch();
+
+            //Call for creature group update
+            if (creature.GetFormation() != null && creature.GetFormation().getLeader() == creature)
+            {
+                creature.SetWalk(node.movetype != WaypointMoveType.Run);
+                creature.GetFormation().LeaderMoveTo(formationDest.posX, formationDest.posY, formationDest.posZ);
+            }
+
+            return true;
+        }
+        void LoadPath(Creature creature)
+        {
+            if (pathId == 0)
+                pathId = creature.GetWaypointPath();
+
+            path = Global.WaypointMgr.GetPath(pathId);
+
+            if (path == null)
+            {
+                // No movement found for entry
+                Log.outError(LogFilter.ScriptsAi, "WaypointMovementGenerator.LoadPath: creature {0} (Entry: {1} GUID: {2}) doesn't have waypoint path id: {3}", creature.GetName(), creature.GetEntry(), creature.GetGUID().ToString(), pathId);
+                return;
+            }
+
+            StartMoveNow(creature);
+        }
+        void OnArrived(Creature creature)
+        {
+            if (path == null || path.Empty())
+                return;
+
+            if (isArrivalDone)
+                return;
+
+            creature.ClearUnitState(UnitState.RoamingMove);
+            isArrivalDone = true;
+
+            var wpData = path.LookupByIndex((int)currentNode);
+            if (wpData.event_id != 0 && RandomHelper.IRand(0, 99) < wpData.event_chance)
+            {
+                Log.outDebug(LogFilter.Unit, "Creature movement start script {0} at point {1} for {2}.", wpData.event_id, currentNode, creature.GetGUID());
+                creature.GetMap().ScriptsStart(ScriptsType.Waypoint, wpData.event_id, creature, null);
+            }
+
+            // Inform script
+            MovementInform(creature);
+            creature.UpdateWaypointID(currentNode);
+
+            if (wpData.delay != 0)
+            {
+                creature.ClearUnitState(UnitState.RoamingMove);
+                Stop((int)wpData.delay);
+            }
+        }
+
+        public override MovementGeneratorType GetMovementGeneratorType()
+        {
+            return MovementGeneratorType.Waypoint;
+        }
+
+        TimeTrackerSmall nextMoveTime;
+        bool isArrivalDone;
+        uint pathId;
+        bool repeating;
+        List<WaypointData> path;
+        uint currentNode;
+    }
+
+    public class FlightPathMovementGenerator : MovementGeneratorMedium<Player>
+    {
+        public FlightPathMovementGenerator() { }
+
+        public void LoadPath(Player player, uint startNode = 0)
+        {
+            i_path.Clear();
+            i_currentNode = (int)startNode;
+            _pointsForPathSwitch.Clear();
+            var taxi = player.m_taxi.GetPath();
+            for (int src = 0, dst = 1; dst < taxi.Count; src = dst++)
+            {
+                uint path, cost;
+                Global.ObjectMgr.GetTaxiPath(taxi[src], taxi[dst], out path, out cost);
+                if (path > CliDB.TaxiPathNodesByPath.Keys.Max())
+                    return;
+
+                var nodes = CliDB.TaxiPathNodesByPath[path];
+                if (!nodes.Empty())
+                {
+                    TaxiPathNodeRecord start = nodes[0];
+                    TaxiPathNodeRecord end = nodes[nodes.Length - 1];
+                    bool passedPreviousSegmentProximityCheck = false;
+                    for (uint i = 0; i < nodes.Length; ++i)
+                    {
+                        if (passedPreviousSegmentProximityCheck || src == 0 || i_path.Empty() || IsNodeIncludedInShortenedPath(i_path.Last(), nodes[i]))
+                        {
+                            if ((src == 0 || (IsNodeIncludedInShortenedPath(start, nodes[i]) && i >= 2)) &&
+                                (dst == taxi.Count - 1 || (IsNodeIncludedInShortenedPath(end, nodes[i]) && i < nodes.Length - 1)))
+                            {
+                                passedPreviousSegmentProximityCheck = true;
+                                i_path.Add(nodes[i]);
+                            }
+                        }
+                        else
+                        {
+                            i_path.RemoveAt(i_path.Count - 1);
+                            _pointsForPathSwitch[_pointsForPathSwitch.Count - 1].PathIndex -= 1;
+                        }
+                    }
+                }
+
+                _pointsForPathSwitch.Add(new TaxiNodeChangeInfo((uint)(i_path.Count - 1), (int)cost));
+            }
+        }
+
+        public override void DoInitialize(Player owner)
+        {
+            Reset(owner);
+            InitEndGridInfo();
+        }
+
+        public override void DoFinalize(Player owner)
+        {
+            // remove flag to prevent send object build movement packets for flight state and crash (movement generator already not at top of stack)
+            owner.ClearUnitState(UnitState.InFlight);
+
+            owner.Dismount();
+            owner.RemoveFlag(UnitFields.Flags, UnitFlags.RemoveClientControl | UnitFlags.TaxiFlight);
+
+            if (owner.m_taxi.empty())
+            {
+                owner.getHostileRefManager().setOnlineOfflineState(true);
+                // update z position to ground and orientation for landing point
+                // this prevent cheating with landing  point at lags
+                // when client side flight end early in comparison server side
+                owner.StopMoving();
+            }
+
+            owner.RemoveFlag(PlayerFields.Flags, PlayerFlags.TaxiBenchmark);
+        }
+
+        public override void DoReset(Player owner)
+        {
+            owner.getHostileRefManager().setOnlineOfflineState(false);
+            owner.AddUnitState(UnitState.InFlight);
+            owner.SetFlag(UnitFields.Flags, UnitFlags.RemoveClientControl | UnitFlags.TaxiFlight);
+
+            MoveSplineInit init = new MoveSplineInit(owner);
+            uint end = GetPathAtMapEnd();
+            init.args.path = new Vector3[end];
+            for (int i = i_currentNode; i != end; ++i)
+            {
+                Vector3 vertice = new Vector3(i_path[i].Loc.X, i_path[i].Loc.Y, i_path[i].Loc.Z);
+                init.args.path[i] = vertice;
+            }
+            init.SetFirstPointId(i_currentNode);
+            init.SetFly();
+            init.SetSmooth();
+            init.SetUncompressed();
+            init.SetWalk(true);
+            init.SetVelocity(30.0f);
+            init.Launch();
+        }
+
+        public override bool DoUpdate(Player player, uint time_diff)
+        {
+            uint pointId = (uint)player.moveSpline.currentPathIdx();
+            if (pointId > i_currentNode)
+            {
+                bool departureEvent = true;
+                do
+                {
+                    DoEventIfAny(player, i_path[i_currentNode], departureEvent);
+                    while (!_pointsForPathSwitch.Empty() && _pointsForPathSwitch[0].PathIndex <= i_currentNode)
+                    {
+                        _pointsForPathSwitch.RemoveAt(0);
+                        player.m_taxi.NextTaxiDestination();
+                        if (!_pointsForPathSwitch.Empty())
+                        {
+                            player.UpdateCriteria(CriteriaTypes.GoldSpentForTravelling, (uint)_pointsForPathSwitch[0].Cost);
+                            player.ModifyMoney(-_pointsForPathSwitch[0].Cost);
+                        }
+                    }
+
+                    if (pointId == i_currentNode)
+                        break;
+
+                    if (i_currentNode == _preloadTargetNode)
+                        PreloadEndGrid();
+                    i_currentNode += (departureEvent ? 1 : 0);
+                    departureEvent = !departureEvent;
+                }
+                while (true);
+            }
+
+            return i_currentNode < (i_path.Count - 1);
+        }
+
+        public void SetCurrentNodeAfterTeleport()
+        {
+            if (i_path.Empty() || i_currentNode >= i_path.Count)
+                return;
+
+            uint map0 = i_path[i_currentNode].MapID;
+            for (int i = i_currentNode + 1; i < i_path.Count; ++i)
+            {
+                if (i_path[i].MapID != map0)
+                {
+                    i_currentNode = i;
+                    return;
+                }
+            }
+
+        }
+
+        void DoEventIfAny(Player player, TaxiPathNodeRecord node, bool departure)
+        {
+            uint eventid = departure ? node.DepartureEventID : node.ArrivalEventID;
+            if (eventid != 0)
+            {
+                Log.outDebug(LogFilter.Scripts, "Taxi {0} event {1} of node {2} of path {3} for player {4}", departure ? "departure" : "arrival", eventid, node.NodeIndex, node.PathID, player.GetName());
+                player.GetMap().ScriptsStart(ScriptsType.Event, eventid, player, player);
+            }
+        }
+
+        bool GetResetPos(Player player, out float x, out float y, out float z)
+        {
+            TaxiPathNodeRecord node = i_path[i_currentNode];
+            x = node.Loc.X;
+            y = node.Loc.Y;
+            z = node.Loc.Z;
+            return true;
+        }
+
+        void InitEndGridInfo()
+        {
+            int nodeCount = i_path.Count;        //! Number of nodes in path.
+            _endMapId = i_path[nodeCount - 1].MapID; //! MapId of last node
+            _preloadTargetNode = (uint)nodeCount - 3;
+            _endGridX = i_path[nodeCount - 1].Loc.X;
+            _endGridY = i_path[nodeCount - 1].Loc.Y;
+        }
+
+        void PreloadEndGrid()
+        {
+            // used to preload the final grid where the flightmaster is
+            Map endMap = Global.MapMgr.FindBaseNonInstanceMap(_endMapId);
+
+            // Load the grid
+            if (endMap != null)
+            {
+                Log.outInfo(LogFilter.Server, "Preloading grid ({0}, {1}) for map {2} at node index {3}/{4}", _endGridX, _endGridY, _endMapId, _preloadTargetNode, i_path.Count - 1);
+                endMap.LoadGrid(_endGridX, _endGridY);
+            }
+            else
+                Log.outInfo(LogFilter.Server, "Unable to determine map to preload flightmaster grid");
+        }
+
+        uint GetPathAtMapEnd()
+        {
+            if (i_currentNode >= i_path.Count)
+                return (uint)i_path.Count;
+
+            uint curMapId = i_path[i_currentNode].MapID;
+            for (int i = i_currentNode; i < i_path.Count; ++i)
+            {
+                if (i_path[i].MapID != curMapId)
+                    return (uint)i;
+            }
+
+            return (uint)i_path.Count;
+        }
+
+        bool IsNodeIncludedInShortenedPath(TaxiPathNodeRecord p1, TaxiPathNodeRecord p2)
+        {
+            return p1.MapID != p2.MapID || Math.Pow(p1.Loc.X - p2.Loc.X, 2) + Math.Pow(p1.Loc.Y - p2.Loc.Y, 2) > (40.0f * 40.0f);
+        }
+
+        public override MovementGeneratorType GetMovementGeneratorType() { return MovementGeneratorType.Flight; }
+
+        public List<TaxiPathNodeRecord> GetPath() { return i_path; }
+
+        bool HasArrived() { return (i_currentNode >= i_path.Count); }
+
+        public void SkipCurrentNode() { ++i_currentNode; }
+
+        public uint GetCurrentNode() { return (uint)i_currentNode; }
+
+
+        float _endGridX;                //! X coord of last node location
+        float _endGridY;                //! Y coord of last node location
+        uint _endMapId;               //! map Id of last node location
+        uint _preloadTargetNode;      //! node index where preloading starts
+
+        int i_currentNode;
+        List<TaxiPathNodeRecord> i_path = new List<TaxiPathNodeRecord>();
+        List<TaxiNodeChangeInfo> _pointsForPathSwitch = new List<TaxiNodeChangeInfo>();    //! node indexes and costs where TaxiPath changes
+
+        class TaxiNodeChangeInfo
+        {
+            public TaxiNodeChangeInfo(uint pathIndex, int cost)
+            {
+                PathIndex = pathIndex;
+                Cost = cost;
+            }
+
+            public uint PathIndex;
+            public int Cost;
+        }
+    }
+}