public void Commit([CallerMemberName] string member = "", [CallerLineNumber] int line = 0, [CallerFilePath] string file = "")
        {
            var profiler = ThreadProfiler;

            profiler.Stopwatch.Restart();
            if (!Paused)
            {
                profiler.CommitFrame();
            }
            else
            {
                profiler.ClearFrame();
            }
            profiler.ProfileCustomValue("Profiler.Commit", member, line, file, 0, MyTimeSpan.FromMiliseconds(profiler.Stopwatch.ElapsedMilliseconds), null, null);
        }
 private void UnmarkEntityBreakable(bool checkTime)
 {
     if (m_markedBreakImpulse != MyTimeSpan.Zero && (!checkTime || MySandboxGame.Static.UpdateTime - m_markedBreakImpulse > MyTimeSpan.FromSeconds(1.5)))
     {
         m_markedBreakImpulse = MyTimeSpan.Zero;
         if (Physics != null && Physics.HavokWorld != null)
         {
             Physics.HavokWorld.BreakOffPartsUtil.UnmarkEntityBreakable(Physics.RigidBody);
             if (checkTime)
             {
                 CreateEasyPenetrationAction(1f);
             }
         }
     }
 }
Exemple #3
0
        public void ApplyDeltaLinearVelocity(MyTimeSpan timestamp, Vector3 linearVelocityDelta)
        {
            int i = 0;

            while (i < m_history.Count)
            {
                if (timestamp <= m_history[i].Timestamp)
                {
                    var item = m_history[i];
                    item.Snapshot.LinearVelocity += linearVelocityDelta;
                    m_history[i] = item;
                }
                i++;
            }
        }
Exemple #4
0
        internal void StopShooting(float hitDelaySec)
        {
            if (!IsShooting)
            {
                return;
            }

            m_lastHit  = MySandboxGame.Static.UpdateTime;
            m_hitDelay = MyTimeSpan.FromSeconds(hitDelaySec);

            m_owner.PlayCharacterAnimation(m_shotHitCondition.Animation, MyBlendOption.Immediate, MyFrameOption.JustFirstFrame, 0.2f, m_shotHitCondition.AnimationTimeScale, false, null, true);
            m_shotToolAction = null;

            m_wasShooting = false;
        }
Exemple #5
0
        public void ApplyDeltaPosition(MyTimeSpan timestamp, Vector3D positionDelta)
        {
            int i = 0;

            while (i < m_history.Count)
            {
                if (timestamp <= m_history[i].Timestamp)
                {
                    var item = m_history[i];
                    item.Snapshot.Position += positionDelta;
                    m_history[i]            = item;
                }
                i++;
            }
        }
Exemple #6
0
        public void Read(BitStream stream, MyTimeSpan timeStamp)
        {
            var snapshot = new MySnapshot(stream);

            if (m_entity.Parent == null && m_entity.Physics != null)
            {
                if (m_entity.Physics.IsInWorld && m_entity.Physics.RigidBody != null && !m_entity.Physics.RigidBody.IsActive && snapshot.Active)
                {
                    m_entity.Physics.RigidBody.Activate();
                }
                if (m_entity.Physics.RigidBody == null || m_entity.Physics.RigidBody.IsActive)
                {
                    m_receivedQueue.Add(snapshot, timeStamp);
                }
            }
        }
Exemple #7
0
        unsafe void ControlMessageReceived(byte[] data, int dataSize, ulong sender, MyTimeSpan timestamp, MyTimeSpan receivedTime)
        {
            ProfilerShort.Begin("Process control message");

            m_controlReceiveStream.Reset(data, dataSize);

            MyControlMessageEnum msgId = (MyControlMessageEnum)m_controlReceiveStream.ReadUShort();

            ITransportCallback handler;

            if (m_controlMessageHandlers.TryGetValue((int)msgId, out handler))
            {
                handler.Receive(m_controlReceiveStream, sender, MyTimeSpan.Zero);
            }
            ProfilerShort.End();
        }
        protected MyBehaviorTreeState TryReserveAreaAroundEntity([BTParam] string areaName, [BTParam] float radius, [BTParam] int timeMs)
        {
            var logic = Bot.HumanoidLogic;
            MyBehaviorTreeState retStatus = MyBehaviorTreeState.FAILURE;

            if (logic != null)
            {
                switch (logic.ReservationStatus)
                {
                case Logic.MyReservationStatus.NONE:
                    logic.ReservationStatus   = Logic.MyReservationStatus.WAITING;
                    logic.ReservationAreaData = new MyAiTargetManager.ReservedAreaData()
                    {
                        WorldPosition    = Bot.HumanoidEntity.WorldMatrix.Translation,
                        Radius           = radius,
                        ReservationTimer = MyTimeSpan.FromMiliseconds(timeMs),
                        ReserverId       = new World.MyPlayer.PlayerId(Bot.Player.Id.SteamId, Bot.Player.Id.SerialId)
                    };
                    MyAiTargetManager.OnAreaReservationResult += AreaReservationHandler;
                    MyAiTargetManager.Static.RequestAreaReservation(areaName, Bot.HumanoidEntity.WorldMatrix.Translation, radius, timeMs, Bot.Player.Id.SerialId);
                    m_reservationTimeOut    = MySandboxGame.Static.UpdateTime + MyTimeSpan.FromSeconds(RESERVATION_WAIT_TIMEOUT_SECONDS);
                    logic.ReservationStatus = Logic.MyReservationStatus.WAITING;
                    retStatus = MyBehaviorTreeState.RUNNING;
                    break;

                case Logic.MyReservationStatus.SUCCESS:
                    retStatus = MyBehaviorTreeState.SUCCESS;
                    break;

                case Logic.MyReservationStatus.FAILURE:
                    retStatus = MyBehaviorTreeState.FAILURE;
                    break;

                case Logic.MyReservationStatus.WAITING:
                    if (m_reservationTimeOut < MySandboxGame.Static.UpdateTime)
                    {
                        retStatus = MyBehaviorTreeState.FAILURE;
                    }
                    else
                    {
                        retStatus = MyBehaviorTreeState.RUNNING;
                    }
                    break;
                }
            }
            return(retStatus);
        }
Exemple #9
0
        static void GatherFrame(MyFrameProfiling frame)
        {
            QueryDataTimestampDisjoint disjoint = MyImmediateRC.RC.Context.GetData <QueryDataTimestampDisjoint>(frame.m_disjoint.m_query, AsynchronousFlags.DoNotFlush);

            if (!disjoint.Disjoint)
            {
                var    freq    = disjoint.Frequency;
                double invFreq = 1.0 / (double)freq;

                m_timestampStack.Clear();

                int stackDepth = 0;

                while (frame.m_issued.Count > 0)
                {
                    var q = frame.m_issued.Dequeue();

                    ulong timestamp;
                    MyImmediateRC.RC.Context.GetData <ulong>(q.m_query, AsynchronousFlags.DoNotFlush, out timestamp);

                    if (q.m_info == MyIssuedQueryEnum.BlockStart)
                    {
                        stackDepth++;
                        MyRender11.GetRenderProfiler().GPU_StartProfilingBlock(q.m_tag);
                        m_timestampStack.Push(timestamp);
                    }
                    else if (q.m_info == MyIssuedQueryEnum.BlockEnd)
                    {
                        stackDepth--;
                        var start = m_timestampStack.Pop();
                        var time  = (timestamp - start) * invFreq;

                        // tick is 100 nanoseconds = 10^-7 second
                        MyRender11.GetRenderProfiler().GPU_EndProfilingBlock(0, MyTimeSpan.FromSeconds(time));
                    }

                    Debug.Assert(stackDepth >= 0);

                    MyQueryFactory.RelaseTimestampQuery(q.m_query);
                }

                Debug.Assert(stackDepth == 0);
            }

            frame.Clear();
        }
Exemple #10
0
        public void TickSync()
        {
            if (MyRenderProxy.EnableAppEventsCall)
            {
                if ((m_timer.Elapsed - m_appEventsTime).Milliseconds > 10)
                {
#if !XB1
                    Application.DoEvents();
#endif
                    m_appEventsTime = m_timer.Elapsed;
                }
#if !XB1
                Application.DoEvents();
#endif
            }
            RenderCallback();
        }
        public override void SendUpdate()
        {
            ProfilerShort.Begin("ClientState.WriteAcks");

            // Client ACK Packet - reliable
            SendStream.ResetWrite();

            // ACK Header
            // Write last state sync packet id
            SendStream.WriteByte(m_lastStateSyncPacketId);

            // Write ACKs
            byte num = (byte)m_acks.Count;

            SendStream.WriteByte(num);
            for (int i = 0; i < num; i++)
            {
                SendStream.WriteByte(m_acks[i]);
            }
            SendStream.Terminate();
            m_acks.Clear();
            ProfilerShort.End();
            m_callback.SendClientAcks(SendStream);

            // Client Update Packet
            SendStream.ResetWrite();

            m_clientPacketId++;
            SendStream.WriteByte(m_clientPacketId);
            SendStream.WriteDouble(MyTimeSpan.FromTicks(Stopwatch.GetTimestamp()).Milliseconds);
            ProfilerShort.Begin("ClientState.Serialize");
            if (VRage.MyCompilationSymbols.EnableNetworkPacketTracking)
            {
                Trace.MyTrace.Send(Trace.TraceWindow.MPackets, "Send client update: ");
            }
            // Write Client state
            ClientState.Serialize(SendStream, false);
            ProfilerShort.End();
            SendStream.Terminate();

            ProfilerShort.Begin("SendClientUpdate");
            m_callback.SendClientUpdate(SendStream);
            ProfilerShort.End();

            //Client.SendMessageToServer(m_sendStream, PacketReliabilityEnum.UNRELIABLE, PacketPriorityEnum.IMMEDIATE_PRIORITY, MyChannelEnum.StateDataSync);
        }
Exemple #12
0
        private void HandleMessage(byte[] data, int dataSize, ulong sender, MyTimeSpan timestamp, MyTimeSpan receivedTime)
        {
            if (dataSize < sizeof(byte)) // This would cause crash, message has to contain at least MyMessageId
            {
                return;
            }

            ProfilerShort.Begin("Handle message");

            if (sender != Sync.MyId)
            {
                ByteCountReceived += dataSize;
            }

            MyMessageId id = (MyMessageId)data[0];

            LogStats(ReceiveStats, "", dataSize, 1, P2PMessageEnum.Reliable);


            m_thisFrameTraffic[(int)id] += dataSize;

            if (id == MyMessageId.OLD_GAME_EVENT_FLUSH) // Flush buffer
            {
                if (m_buffer != null)
                {
                    m_buffer.Clear();
                }
            }
            else if (IsBuffering && id != MyMessageId.JOIN_RESULT && id != MyMessageId.WORLD_DATA && id != MyMessageId.WORLD_BATTLE_DATA)  // Buffer event
            {
                var buff = new Buffer();
                buff.Sender = sender;
                buff.Data   = new byte[dataSize];
                Array.Copy(data, buff.Data, dataSize);
                buff.ReceivedTime = MyTimeSpan.FromTicks(Stopwatch.GetTimestamp());
                m_buffer.Add(buff);
            }
            else // Process event
            {
                NetProfiler.Begin("Live data", 0);
                ProcessMessage(data, dataSize, sender, timestamp, receivedTime);
                NetProfiler.End();
            }

            ProfilerShort.End();
        }
Exemple #13
0
        public void ProcessRpc(BitReaderWriter reader)
        {
            reader.ReadData(m_sender, false);
            MyPacket packet;

            packet.Data   = m_sender.ReceiveStream.Data;
            packet.Sender = MyEventContext.Current.Sender;
            if (packet.Sender.IsNull)
            {
                packet.Sender = new EndpointId(Sync.MyId);
            }
            packet.Timestamp     = MyTimeSpan.Zero;
            packet.PayloadOffset = 0;
            packet.PayloadLength = (int)m_sender.ReceiveStream.Position;
            packet.ReceivedTime  = MyTimeSpan.FromTicks(Stopwatch.GetTimestamp());
            TransportLayer.HandleOldGameEvent(packet);
        }
Exemple #14
0
        MyTimeSpan GetPieceAgeLength(MyFracturedPiece piece)
        {
            if (piece.Physics == null || piece.Physics.BreakableBody == null)
            {
                return(MyTimeSpan.Zero);
            }

            if (piece.Physics.RigidBody.Layer == FakePieceLayer)
            {
                return(MyTimeSpan.FromSeconds(8 + MyRandom.Instance.NextFloat(0, 4)));
            }

            float volume            = piece.Physics.BreakableBody.BreakableShape.Volume;
            float proposedAgeInSecs = volume * LIFE_OF_CUBIC_PIECE;

            return(MyTimeSpan.FromSeconds(proposedAgeInSecs));
        }
        void MyEntities_OnEntityAdd(MyEntity obj)
        {
            var fp = obj as MyFracturedPiece;

            if (fp != null)
            {
                MyTimeSpan age = GetPieceAgeLength(obj as MyFracturedPiece);
                m_piecesTimesOfDeath[fp] = MySandboxGame.Static.UpdateTime + age;
                m_addedThisFrame++;
                if (!fp.Physics.RigidBody.IsActive)
                {
                    m_inactivePieces.Add(fp);
                }
                fp.Physics.RigidBody.Activated   += RigidBody_Activated;
                fp.Physics.RigidBody.Deactivated += RigidBody_Deactivated;
            }
        }
Exemple #16
0
        private void ProcessMessage(byte[] data, int dataSize, ulong sender, MyTimeSpan timestamp, MyTimeSpan receivedTime)
        {
            Debug.Assert(data.Length >= dataSize, "Wrong size");

            MyMessageId id = (MyMessageId)data[0];

            if (id == MyMessageId.CLIENT_CONNNECTED)
            {
                MyNetworkClient player;
                if (Sync.Layer != null && Sync.Layer.Clients != null)
                {
                    bool playerFound = Sync.Layer.Clients.TryGetClient(sender, out player);

                    if (!playerFound)
                    {
                        Sync.Layer.Clients.AddClient(sender);
                    }
                }
            }

            MyPacket p = new MyPacket
            {
                Data = data,
                // First byte is message id
                PayloadOffset = 1,
                PayloadLength = dataSize - 1,
                Sender        = new VRage.Network.EndpointId(sender),
                Timestamp     = timestamp,
                ReceivedTime  = receivedTime
            };

            Action <MyPacket> handler;

            if (m_handlers.TryGetValue(id, out handler))
            {
                ProfilerShort.Begin(MyEnum <MyMessageId> .GetName(id));
                NetProfiler.Begin(MyEnum <MyMessageId> .GetName(id));
                handler(p);
                NetProfiler.End(p.PayloadLength);
                ProfilerShort.End();
            }
            else
            {
                Debug.Fail("No handler for message type: " + id);
            }
        }
Exemple #17
0
 public void Clear()
 {
     Lock.Enter();
     try
     {
         ClearUnsafe();
         if (Count > 0)
         {
             Count = 0;
         }
         LastRefresh = MyTimeSpan.Zero;
     }
     finally
     {
         Lock.Exit();
     }
 }
Exemple #18
0
        protected MyBehaviorTreeState TryReserveAreaAroundEntity([BTParam] string areaName, [BTParam] float radius, [BTParam] int timeMs)
        {
            MyHumanoidBotLogic  humanoidLogic = this.Bot.HumanoidLogic;
            MyBehaviorTreeState fAILURE       = MyBehaviorTreeState.FAILURE;

            if (humanoidLogic != null)
            {
                switch (humanoidLogic.ReservationStatus)
                {
                case MyReservationStatus.NONE:
                {
                    humanoidLogic.ReservationStatus = MyReservationStatus.WAITING;
                    MyAiTargetManager.ReservedAreaData data = new MyAiTargetManager.ReservedAreaData {
                        WorldPosition    = this.Bot.HumanoidEntity.WorldMatrix.Translation,
                        Radius           = radius,
                        ReservationTimer = MyTimeSpan.FromMilliseconds((double)timeMs),
                        ReserverId       = new MyPlayer.PlayerId(this.Bot.Player.Id.SteamId, this.Bot.Player.Id.SerialId)
                    };
                    humanoidLogic.ReservationAreaData          = data;
                    MyAiTargetManager.OnAreaReservationResult += new Sandbox.Game.AI.MyAiTargetManager.AreaReservationHandler(this.AreaReservationHandler);
                    MyAiTargetManager.Static.RequestAreaReservation(areaName, this.Bot.HumanoidEntity.WorldMatrix.Translation, radius, (long)timeMs, this.Bot.Player.Id.SerialId);
                    this.m_reservationTimeOut       = MySandboxGame.Static.TotalTime + MyTimeSpan.FromSeconds(3.0);
                    humanoidLogic.ReservationStatus = MyReservationStatus.WAITING;
                    fAILURE = MyBehaviorTreeState.RUNNING;
                    break;
                }

                case MyReservationStatus.WAITING:
                    fAILURE = (this.m_reservationTimeOut >= MySandboxGame.Static.TotalTime) ? MyBehaviorTreeState.RUNNING : MyBehaviorTreeState.FAILURE;
                    break;

                case MyReservationStatus.SUCCESS:
                    fAILURE = MyBehaviorTreeState.SUCCESS;
                    break;

                case MyReservationStatus.FAILURE:
                    fAILURE = MyBehaviorTreeState.FAILURE;
                    break;

                default:
                    break;
                }
            }
            return(fAILURE);
        }
        public void End(bool memoryProfiling, MyTimeSpan?customTime = null)
        {
            EndManagedMB   = System.GC.GetTotalMemory(false);
            DeltaManagedB += EndManagedMB - StartManagedMB;

            if (memoryProfiling)
            {
                // TODO: OP! Use better non-alloc call
                EndProcessMB   = System.Environment.WorkingSet; // WorkingSet is allocating memory in each call, also its expensive (about 7ms per 2000 calls).
                DeltaProcessB += EndProcessMB - StartProcessMB;
            }

            // Time stamp at the end, include own overhead
            long endTimestamp = Stopwatch.GetTimestamp();

            ElapsedTimestamp = endTimestamp - MeasureStartTimestamp;
            Elapsed         += customTime ?? new MyTimeSpan(ElapsedTimestamp);
        }
        private void SetHealth(float health)
        {
            if (health <= 0)
            {
                CurrentState = State.NoBreath;
            }
            else if (health < 20)
            {
                //play heavy breath indefinitely
                m_healthOverride = MyTimeSpan.MaxValue;
            }
            else if (health < 100)
            {
                m_healthOverride = MySandboxGame.Static.UpdateTime + MyTimeSpan.FromSeconds(300 / (health - 19.99));
            }

            Update(true);
        }
Exemple #21
0
        public void ClientUpdate(MyTimeSpan clientTimestamp)
        {
            const int ClientUpdateSleepFrames = 6;

            // Don't sync more often then once per 6 frames (~100 ms)
            if (m_dirtyProperties.Bits != 0 && MyMultiplayer.Static.FrameCounter - m_lastUpdateFrame >= ClientUpdateSleepFrames)
            {
                foreach (var property in m_properties)
                {
                    if (m_dirtyProperties[property.Id])
                    {
                        MyMultiplayer.RaiseEvent(this, x => x.SyncPropertyChanged_Implementation, (byte)property.Id, (BitReaderWriter)property);
                    }
                }
                m_dirtyProperties.Reset(false);
                m_lastUpdateFrame = MyMultiplayer.Static.FrameCounter;
            }
        }
        public bool ShouldPlayVoice(MyPlayer player, MyTimeSpan timestamp, out MySoundDimensions dimension, out float maxDistance)
        {
            MyTimeSpan now             = MySandboxGame.Static.UpdateTime;
            double     startPlaybackMs = VRage.Game.MyEngineConstants.UPDATE_STEP_SIZE_IN_SECONDS * 30 * 1000;

            if ((now - timestamp).Milliseconds > startPlaybackMs)
            {
                dimension   = MySoundDimensions.D3;
                maxDistance = float.MaxValue;
                return(true);
            }
            else
            {
                dimension   = MySoundDimensions.D2;
                maxDistance = 0;
                return(false);
            }
        }
Exemple #23
0
 public override void ClientUpdate(MyTimeSpan clientTimestamp)
 {
     if (IsControlledLocally)
     {
         if (Entity.JetpackRunning)
         {
             SnapshotSync.Update(clientTimestamp, m_ControlledJetPackSettings);
         }
         else
         {
             SnapshotSync.Update(clientTimestamp, m_ControlledSettings);
         }
     }
     else
     {
         SnapshotSync.Update(clientTimestamp, m_Settings);
     }
 }
            public void End(bool memoryProfiling, MyTimeSpan?customTime = null)
            {
                MyTimeSpan delta = customTime ?? (new MyTimeSpan(Stopwatch.GetTimestamp()) - MeasureStart);

                Elapsed += delta;

                if (memoryProfiling)
                {
                    EndManagedMB = System.GC.GetTotalMemory(false);
                    EndProcessMB = System.Environment.WorkingSet;
                }

                DeltaManagedB += EndManagedMB - StartManagedMB;
                if (memoryProfiling)
                {
                    DeltaProcessB += EndProcessMB - StartProcessMB;
                }
            }
        public virtual void Serialize(BitStream stream, EndpointId forClient, MyTimeSpan timeStamp, byte packetId, int maxBitPosition)
        {
            //System.Diagnostics.Debug.Assert((m_lastWrittenTimeStamps.ContainsKey(forClient) && m_lastWrittenTimeStamps[forClient] != timeStamp) || !m_lastWrittenTimeStamps.ContainsKey(forClient), "Sending same data twice");

            if (stream.Writing)
            {
                SnapshotSync.Write(stream);
            }
            else
            {
                SnapshotSync.Read(stream, timeStamp);
            }

            if (stream.BitPosition <= maxBitPosition)
            {
                m_lastWrittenTimeStamps[forClient] = timeStamp;
            }
        }
Exemple #26
0
        public void Serialize(BitStream stream, MyClientInfo forClient, MyTimeSpan serverTimestamp, MyTimeSpan lastClientTimestamp, byte packetId, int maxBitPosition,
                              HashSet <string> cachedData)
        {
            var endpoint = forClient.EndpointId;

            if (!stream.Writing)
            {
                return;
            }

            if (!_serverData.TryGetValue(endpoint, out var data))
            {
                var bits = new SmallBitField(false);
                stream.WriteUInt64(bits.Bits, 0);
                return;
            }

            var dirtyProperties = data.DirtyProperties;

            if (!data.HasRights)
            {
                dirtyProperties[VOLUME_PROP_INDEX] = false;
            }
            stream.WriteUInt64(dirtyProperties.Bits, m_properties.Count);

            for (var i = 0; i < m_properties.Count; i++)
            {
                if (!dirtyProperties[i])
                {
                    continue;
                }
                var milliseconds = m_propertyTimestamps[i].Milliseconds;
                stream.WriteDouble(milliseconds);
                m_properties[i].Serialize(stream, false);
            }

            if (stream.BitPosition <= maxBitPosition)
            {
                var dataPerClient = _serverData[endpoint];
                dataPerClient.SentProperties[packetId].Bits = dataPerClient.DirtyProperties.Bits;
                dataPerClient.DirtyProperties.Bits          = 0UL;
            }
        }
Exemple #27
0
        public override void Serialize(BitStream stream, EndpointId forClient, MyTimeSpan timeStamp, byte packetId, int maxBitPosition)
        {
            base.Serialize(stream, forClient, timeStamp, packetId, maxBitPosition);

            if (stream.Writing)
            {
                MyCharacterNetState charNetState;
                Entity.GetNetState(out charNetState);
                charNetState.Serialize(stream);
            }
            else
            {
                var charNetState = new MyCharacterNetState(stream);
                if (!IsControlledLocally)
                {
                    Entity.SetNetState(ref charNetState, true);
                }
            }
        }
Exemple #28
0
        public static void Process(MyTimeSpan lag)
        {
            try
            {
                foreach (var item in m_channels)
                {
                    m_tmpList.Add(item.Value);
                }

                foreach (var chan in m_tmpList)
                {
                    chan.Queue.Process(chan.Handler, lag);
                }
            }
            finally
            {
                m_tmpList.Clear();
            }
        }
            void ITransportCallback.Receive(ByteStream source, ulong sender, MyTimeSpan timestamp)
            {
                // TODO: msg pool as member in this class?

                TMsg msg;

                try
                {
                    Serializer.Deserialize(source, out msg);
                    MyTrace.Send(TraceWindow.Multiplayer, "Received: " + msg.ToString(), sender + ", " + source.Position + " B");
                }
                catch (Exception e)
                {
                    // Catch, add more info (what message) and write to log
                    MySandboxGame.Log.WriteLine(new Exception(String.Format("Error deserializing '{0}', message size '{1}'", typeof(TMsg).Name, source.Length), e));
                    return;
                }

                Handle(ref msg, sender, timestamp);
            }
Exemple #30
0
        public void Update(MyTimeSpan clientTimestamp, MySnapshotSyncSetup setup)
        {
            // skip entities with parent
            if (m_entity.Parent != null)
            {
                return;
            }
            if (m_entity.Physics == null) //trees
            {
                return;
            }
            if (m_entity.Physics.RigidBody != null && !m_entity.Physics.RigidBody.IsActive)
            {
                return;
            }

            VRage.Profiler.ProfilerShort.Begin("Sync Predicted" + m_entity.DisplayName);
            UpdatePrediction(clientTimestamp, setup);
            VRage.Profiler.ProfilerShort.End();
        }