public bool Update(MyPlayer player, MyEntity entity) //returns if lost
        {
            //MySessionComponentMission.Static.TryCreateFromDefault(Id);

            //if (IsLocal(player.Id))
            //    UpdateLocal(player.Id);

            if (!Sync.IsServer)
                return false;

            MyMissionTriggers mtrig;
            if (!MissionTriggers.TryGetValue(player.Id, out mtrig))
            {
                //Debug.Assert(false,"Bad ID for update in missionTriggers");
                mtrig = TryCreateFromDefault(player.Id, false);
            }
            mtrig.UpdateWin(player, entity);
            if (!mtrig.Won)
                mtrig.UpdateLose(player, entity);
            else
            {
                m_someoneWon = true;
                MyAnalyticsHelper.ReportTutorialEnd();
            }
            return mtrig.Lost;
        }

 public override bool Update(MyEntity me)
 {
     if (MySession.Static.IsScenario)
         if (m_limit <= DateTime.UtcNow - MyScenarioSystem.Static.ServerStartGameTime)
             m_IsTrue = true;
     return IsTrue;
 }

 public override ChangeInfo Update(MyEntity owner, long playerID = 0)
 {
     if (MyCubeBuilder.Static==null)
         return ChangeInfo.None;
     var blockDefinition = MyCubeBuilder.Static.IsActivated ? MyCubeBuilder.Static.ToolbarBlockDefinition : null;
     if ((MyCubeBuilder.Static.BlockCreationIsActivated || MyCubeBuilder.Static.MultiBlockCreationIsActivated) && blockDefinition != null && (!MyFakes.ENABLE_BATTLE_SYSTEM || !MySession.Static.Battle))
     {
         var blockDef = (this.Definition as Sandbox.Definitions.MyCubeBlockDefinition);
         if (blockDefinition.BlockPairName == blockDef.BlockPairName)
         {
             WantsToBeSelected = true;
         }
         else if (blockDef.BlockStages != null && blockDef.BlockStages.Contains(blockDefinition.Id))
         {
             WantsToBeSelected = true;
         }
         else
         {
             WantsToBeSelected = false;
         }
     }
     else
     {
         WantsToBeSelected = false;
     }
     return ChangeInfo.None;
 }

        public MyEntity Spawn(MyFixedPoint amount, MatrixD worldMatrix, MyEntity owner = null)
        {
            if (Content is MyObjectBuilder_BlockItem)
            {
                Debug.Assert(MyFixedPoint.IsIntegral(amount), "Spawning fractional number of grids!");

                var blockItem = Content as MyObjectBuilder_BlockItem;
                var builder = MyObjectBuilderSerializer.CreateNewObject(typeof(MyObjectBuilder_CubeGrid)) as MyObjectBuilder_CubeGrid;
                builder.GridSizeEnum = MyCubeSize.Small;
                builder.IsStatic = false;
                builder.PersistentFlags |= MyPersistentEntityFlags2.InScene | MyPersistentEntityFlags2.Enabled;
                builder.PositionAndOrientation = new MyPositionAndOrientation(worldMatrix);

                var block = MyObjectBuilderSerializer.CreateNewObject(blockItem.BlockDefId) as MyObjectBuilder_CubeBlock;
                builder.CubeBlocks.Add(block);

                MyCubeGrid firstGrid = null;
                for (int i = 0; i < amount; ++i)
                {
                    builder.EntityId = MyEntityIdentifier.AllocateId();
                    block.EntityId = MyEntityIdentifier.AllocateId();
                    MyCubeGrid newGrid = MyEntities.CreateFromObjectBuilder(builder) as MyCubeGrid;
                    firstGrid = firstGrid ?? newGrid;
                    MyEntities.Add(newGrid);
                    Sandbox.Game.Multiplayer.MySyncCreate.SendEntityCreated(builder);
                }
                return firstGrid;
            }
            else
                return MyFloatingObjects.Spawn(new MyPhysicalInventoryItem(amount, Content),worldMatrix, owner != null ? owner.Physics : null);
        }

        private void voxelMap_OnClose(MyEntity entity)
        {
            var voxelMap = entity as MyVoxelMap;
            if (voxelMap == null) return;

            m_navigationMeshes.Remove(voxelMap);
        }

		public override void Unregister(MyEntity entity, Vector3I forwardVector)
		{
			base.Unregister(entity, forwardVector);
			var thrust = entity as MyThrust;
			if (thrust == null)
				return;

			thrust.EnabledChanged -= thrust_EnabledChanged;
			thrust.SlimBlock.ComponentStack.IsFunctionalChanged -= ComponentStack_IsFunctionalChanged;

            // Need to recalculate the slowdown factor. Maybe save different levels of the factors and just revert back to previous one
		    SlowdownFactor = 0f;
		    foreach (var direction in Base6Directions.IntDirections)
		    {
		        foreach (var dataByType in m_dataByFuelType)
		        {
		            foreach (var entityInDirection in dataByType.ThrustsByDirection[direction])
		            {
		                var thrustInDirection = entityInDirection as MyThrust;
		                if (thrustInDirection == null)
		                    continue;

		                SlowdownFactor = Math.Max(thrustInDirection.BlockDefinition.SlowdownFactor, SlowdownFactor);
		            }
		        }
		    }
		}

        //  Not used apparently
        public static void AddShotgun(MyProjectileAmmoDefinition ammoDefinition, MyEntity ignorePhysObject, Vector3 origin, Vector3 initialVelocity, Vector3 directionNormalized, bool groupStart, float thicknessMultiplier, MyEntity weapon, float frontBillboardSize, MyEntity ownerEntity = null, float projectileCountMultiplier = 1)
        {
            MyProjectile newProjectile = m_projectiles.Allocate();
            if (newProjectile != null)
            {
                //newProjectile.Start(
                //    ammoDefinition,
                //    ignorePhysObject,
                //    origin,
                //    initialVelocity,
                //    directionNormalized,
                //    groupStart,
                //    thicknessMultiplier,
                //    1,
                //    weapon,
                //    projectileCountMultiplier
                //    );

            //    newProjectile.BlendByCameraDirection = true;
            //    newProjectile.FrontBillboardMaterial = "ShotgunParticle";
            //    newProjectile.LengthMultiplier = 2;
            //    newProjectile.FrontBillboardSize = frontBillboardSize;
             //   newProjectile.OwnerEntity = ownerEntity != null ? ownerEntity : ignorePhysObject;
            }
        }

 public override bool Update(MyEntity me)
 {
     bool isSomethingAlive=false;
     foreach(var item in m_blocks)
     {
         if (item.Value == BlockState.MessageShown)
             continue;
         if (item.Key.SlimBlock.IsDestroyed)
         {
             m_blocksHelper.Add(item.Key);
             continue;
         }
         isSomethingAlive = true;
     }
     if (!isSomethingAlive)
         m_IsTrue = true;
     if (m_blocksHelper.Count()>0)
     {
         foreach(var block in m_blocksHelper)
             m_blocks[block] = BlockState.Destroyed;
         m_blocksHelper.Clear();
         m_needsSingleMessage = true;
     }
     return base.Update(me);
 }

 public void SetTarget(MyEntity entity, Vector3? relativeTarget = null)
 {
     m_mode = AimingMode.TARGET;
     m_aimTarget = entity;
     m_relativeTarget = relativeTarget;
     Update();
 }

 public override bool Update(MyPlayer player, MyEntity me)
 {
     if (me!=null)
         if (Vector3D.DistanceSquared(me.PositionComp.GetPosition(), TargetPos) < m_maxDistance2)
             m_IsTrue = true;
     return IsTrue;
 }

 public void SetTarget(MyEntity entity, Vector3? relativeTarget = null)
 {
     m_followMovement = false;
     m_aimTarget = entity;
     m_relativeTarget = relativeTarget;
     Update();
 }

 void m_entity_OnClose(MyEntity obj)
 {
     if (m_shotSmoke != null)
     {
         MyParticlesManager.RemoveParticleEffect(m_shotSmoke);
         m_shotSmoke = null;
     }
 }

	    protected override float CalculateForceMultiplier(MyEntity thrustEntity)
	    {


	        float forceMultiplier = 1.0f;

	        return forceMultiplier;
	    }

        private void MyEntities_OnEntityAdd(MyEntity entity)
        {
            var voxelMap = entity as MyVoxelMap;
            if (voxelMap == null) return;

            m_navigationMeshes.Add(voxelMap, new MyVoxelNavigationMesh(voxelMap, m_coordinator, MyAIComponent.Static.Pathfinding.NextTimestampFunction));
            RegisterVoxelMapEvents(voxelMap);
        }

        public override ChangeInfo Update(MyEntity owner, long playerID = 0)
        {
            bool thisWeaponIsCurrent = false;
            bool shipHasThisWeapon = false;
            var character = MySession.LocalCharacter;
            bool characterHasThisWeapon = character != null && (character.GetInventory().ContainItems(1, Definition.Id) || MyPerGameSettings.EnableWeaponWithoutInventory);
            ChangeInfo changed = ChangeInfo.None;

            if (characterHasThisWeapon)
            {
                var currentWeapon = character.CurrentWeapon;
                if (currentWeapon != null)
                    thisWeaponIsCurrent = MyDefinitionManager.Static.GetPhysicalItemForHandItem(currentWeapon.DefinitionId).Id == Definition.Id;
                if (thisWeaponIsCurrent && currentWeapon is MyAutomaticRifleGun)
                {
                    int amount = character.CurrentWeapon.GetAmmunitionAmount();
                    if (m_lastAmmoCount != amount)
                    {
                        m_lastAmmoCount = amount;
                        IconText.Clear().AppendInt32(amount);
                        changed |= ChangeInfo.IconText;
                    }
                }
            }

            var shipControler = MySession.ControlledEntity as MyShipController;
            if (shipControler != null && shipControler.GridSelectionSystem.WeaponSystem != null)
            {
            //    var shipWeaponType = shipControler.GetWeaponType(Definition.Id.TypeId);
            //    shipHasThisWeapon = shipWeaponType.HasValue && shipControler.GridSelectionSystem.WeaponSystem.HasGunsOfId(shipWeaponType.Value);
                shipHasThisWeapon = shipControler.GridSelectionSystem.WeaponSystem.HasGunsOfId(Definition.Id);
                if (shipHasThisWeapon)
                {
                    IMyGunObject<MyDeviceBase> gunObject = shipControler.GridSelectionSystem.WeaponSystem.GetGun(Definition.Id);
                    if (gunObject.GunBase is MyGunBase)
                    {
                        int ammo = 0;
                        foreach (var gun in shipControler.GridSelectionSystem.WeaponSystem.GetGunsById(Definition.Id))
                        {
                            ammo += gun.GetAmmunitionAmount();
                        }
                        if (ammo != m_lastAmmoCount)
                        {
                            m_lastAmmoCount = ammo;
                            IconText.Clear().AppendInt32(ammo);
                            changed |= ChangeInfo.IconText;
                        }
                    }
                }

                thisWeaponIsCurrent = shipControler.GridSelectionSystem.GetGunId() == Definition.Id;
            }

            changed |= SetEnabled(characterHasThisWeapon || shipHasThisWeapon);
            WantsToBeSelected = thisWeaponIsCurrent;
            m_needsWeaponSwitching = !thisWeaponIsCurrent;
            return changed;
        }

        /// <summary>
        /// Algorithm to predict the position of the target
        /// </summary>
     
        public static bool GetPredictedTargetPosition(MyGunBase gun, MyEntity shooter, MyEntity target, out Vector3 predictedPosition, out float timeToHit, float shootDelay = 0)
        {
            Debug.Assert(target != null && target.PositionComp != null, "Null target!");
            Debug.Assert(shooter != null && shooter.PositionComp != null, "Null shooter!");

            if (target == null || target.PositionComp == null || shooter == null || shooter.PositionComp == null)
            {
                predictedPosition = Vector3.Zero;
                timeToHit = 0;
                return false;
            }
            
            Vector3 targetPosition = target.PositionComp.WorldAABB.Center;
            Vector3 muzzlePosition = gun.GetMuzzleWorldPosition();
            
            Vector3 toTarget = targetPosition - muzzlePosition;
            Vector3 targetVelocity = Vector3.Zero;
            if (target.Physics != null)
            {
                targetVelocity = target.Physics.LinearVelocity;
            }
            Vector3 shooterVelocity = Vector3.Zero;
            if (shooter.Physics != null)
            {
                shooterVelocity = shooter.Physics.LinearVelocity;
            }
            Vector3 diffVelocity = targetVelocity - shooterVelocity;

            float projectileSpeed = GetProjectileSpeed(gun);

            float a = diffVelocity.LengthSquared() - projectileSpeed * projectileSpeed;
            float b = 2 * Vector3.Dot(diffVelocity, toTarget);
            float c = toTarget.LengthSquared();

            float p = -b / (2 * a);
            float q = (float)Math.Sqrt((b * b) - 4 * a * c) / (2 * a);

            float t1 = p - q;
            float t2 = p + q;
            float t;

            if (t1 > t2 && t2 > 0)
            {
                t = t2;
            }
            else
            {
                t = t1;
            }

            t = t + shootDelay;

            predictedPosition = targetPosition + diffVelocity * t;
            Vector3 bulletPath = predictedPosition - muzzlePosition;
            timeToHit = bulletPath.Length() / projectileSpeed;

            return true;
        }

        void grid_OnClose(MyEntity entity)
        {
            var grid = entity as MyCubeGrid;
            if (grid == null) return;

            if (!GridCanHaveNavmesh(grid)) return;

            m_coordinator.RemoveGridNavmeshLinks(grid);
            m_navigationMeshes.Remove(grid);
        }

        public void StartManipulation(MyManipulationTool.MyState state, MyEntity otherEntity, Vector3D hitPosition, ref MatrixD ownerWorldHeadMatrix)
        {
            StartManipulationMsg msg = new StartManipulationMsg();
            msg.EntityId = m_entityId;
            msg.ToolState = state;
            msg.OtherEntity = otherEntity.EntityId;
            msg.HitPosition = hitPosition;
            msg.OwnerWorldHeadMatrix = ownerWorldHeadMatrix;

            MySession.Static.SyncLayer.SendMessageToAllAndSelf(ref msg);
        }

 public override ChangeInfo Update(MyEntity owner, long playerID = 0)
 {
     if (ActionId == null)
     {
         var actions = AllActions;
         if (actions.Count > 0)
         {
             ActionId = actions.ItemAt(0).Id;
         }
     }
     return ChangeInfo.None;
 }

        public override void Init(MyEntity entity, MyLargeTurretBase turretBase)
        {
            base.Init(entity, turretBase);

            // backward compatibility with old models/mods
            if (!m_gunBase.HasDummies)
            {
                Matrix muzzle = Matrix.Identity;
                muzzle.Translation += entity.PositionComp.WorldMatrix.Forward * 3;
                m_gunBase.AddMuzzleMatrix(MyAmmoType.Missile, muzzle);
            }
        }