public IMyBot CreateBot(MyPlayer player, MyObjectBuilder_Bot botBuilder, MyBotDefinition botDefinition)
 {
     var output = new MySandboxBot(player, botDefinition);
     if (botBuilder != null)
         output.Init(botBuilder);
     return output;
 }

        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 static void PlayerLost(MyPlayer.PlayerId id, int triggerIndex)
 {
     MySessionComponentMissionTriggers.Static.SetLost(id, triggerIndex);
     if (!Sync.MultiplayerActive || !MySession.Static.IsScenario)
         return;
     LostMsg msg = new LostMsg();
     msg.index = triggerIndex;
     msg.playerId = id;
     Sync.Layer.SendMessageToAll(ref msg, MyTransportMessageEnum.Success);
 }

        public void SendControlPilotMsg(MyPlayer player)
        {
            var msg = new ControlPilotMsg();

            msg.EntityId = Entity.Entity.EntityId;

            msg.SteamId = player.Id.SteamId;
            msg.SerialId = player.Id.SerialId;

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

        /*public bool Update(MyFaction faction, MyCharacter me)
        {
            bool res = false;
            if (faction != null)
                res = Update(faction.FactionId, me);
            else
                res = Update(me.EntityId, me);

            return res;
        }*/
        /*public bool Update()
        {
            return false;
        }*/

        public bool Update(MyPlayer.PlayerId Id, MyCharacter me)
        {
            MyMissionTriggers mtrig;
            if (!MissionTriggers.TryGetValue(Id, out mtrig))
            {
                //Debug.Assert(false,"Bad ID for update in missionTriggers");
                return false;
            }
            mtrig.UpdateWin(me);

            mtrig.UpdateLose(me);//!!
            return false;
        }

        public MySandboxBot(MyPlayer botPlayer, MyBotDefinition botDefinition)
        {
            m_definition = botDefinition as MyAgentDefinition;

            m_player = botPlayer;
            m_navigation = new MyBotNavigation();
            m_respawnRequestSent = false;
            m_actionCollection = null;
            m_botMemory = new MyBotMemory(this);

            m_player.Controller.ControlledEntityChanged += Controller_ControlledEntityChanged;

            m_navigation.ChangeEntity(m_player.Controller.ControlledEntity);
        }

        public MyHumanoidBot(MyPlayer player, MyBotDefinition botDefinition)
            : base(player, botDefinition)
        {
            Debug.Assert(botDefinition is MyHumanoidBotDefinition, "Provided bot definition is not of humanoid type");
            if (m_player.Controller.ControlledEntity is MyCharacter) // when loaded player already controls entity
            {
                var character = m_player.Controller.ControlledEntity as MyCharacter;
                if (character.CurrentWeapon == null && StartingWeaponId.SubtypeId != MyStringHash.NullOrEmpty)
                {
                    AddItems(character);
                }
            }

            Sandbox.Game.Gui.MyCestmirDebugInputComponent.PlacedAction += DebugGoto;
        }

        public void TryCreateFromDefault(MyPlayer.PlayerId newId, bool overwrite)
        {
            if (overwrite)
                MissionTriggers.Remove(newId);
            else
                if (MissionTriggers.ContainsKey(newId))
                    return;//already exists, thats ok for us
            MyMissionTriggers mtrig = new MyMissionTriggers();
            MissionTriggers.Add(newId, mtrig);

            MyMissionTriggers source;
            MissionTriggers.TryGetValue(new MyPlayer.PlayerId(0,0), out source);
            if (source == null)
                //older save which does not have defaults set
                return;
            mtrig.CopyTriggersFrom(source);
        }

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

            if (IsLocal(Id))
                UpdateLocal(Id);

            if (!Sync.IsServer)
                return false;

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

        public void ResetPlayerIdentity(MyPlayer player)
        {
            if (player.Identity != null)
            {
                if (MySession.Static.Settings.PermanentDeath.Value)
                {
                    if (!player.Identity.IsDead)
                        Sync.Players.KillPlayer(player);

                    var faction = MySession.Static.Factions.TryGetPlayerFaction(player.Identity.IdentityId);
                    if (faction != null)
                        MyFactionCollection.KickMember(faction.FactionId, player.Identity.IdentityId);

                    //Clear chat history
                    if (MySession.Static.ChatSystem != null)
                    {
                        MySession.Static.ChatSystem.ClearChatHistoryForPlayer(player.Identity);
                    }

                    var identity = Sync.Players.CreateNewIdentity(player.DisplayName);
                    player.Identity = identity;
                }
            }
        }

 public abstract void SetupCharacterDefault(MyPlayer player, MyWorldGenerator.Args args);

 public abstract MyIdentity CreateNewIdentity(string identityName, MyPlayer.PlayerId playerId, string modelName);

 public void SendNewGlobalMessage(MyPlayer.PlayerId senderId, string text)
 {
     MyMultiplayer.RaiseEvent(this, x => x.OnGlobalMessageRequest, senderId.SteamId, text);
 }

 public void SetPlayer(MyPlayer player, bool update = true)
 {
     m_controlInfo.Value = player.Id;
     if (Sync.IsServer && update)
     {
         MyPlayerCollection.ChangePlayerCharacter(player, this, this);
     }
 }

 public IMyBot CreateBot(MyPlayer player, MyObjectBuilder_Bot botBuilder, MyBotDefinition botDefinition)
 {
     Debug.Assert(m_botDataByBehaviorType.ContainsKey(botDefinition.BehaviorType), "Undefined behavior type. Bot is not going to be created");
     if (!m_botDataByBehaviorType.ContainsKey(botDefinition.BehaviorType))
         return null;
     Debug.Assert(m_botTypeByDefinitionType.ContainsKey(botDefinition.TypeDefinitionId.TypeId), "Type not found. Bot is not going to be created!");
     if (!m_botTypeByDefinitionType.ContainsKey(botDefinition.TypeDefinitionId.TypeId))
         return null;
     var botData = m_botDataByBehaviorType[botDefinition.BehaviorType];
     var behaviorTypeData = m_botTypeByDefinitionType[botDefinition.TypeDefinitionId.TypeId];
     IMyBot output = CreateBot(behaviorTypeData.BotType, player, botDefinition);
     CreateActions(output, botData.BotActionsType);
     CreateLogic(output, botData.LogicType, botDefinition.BehaviorSubtype);
     if (botBuilder != null)
         output.Init(botBuilder);
     return output;
 }

 public void TryTakeSpawneeOwnership(MyPlayer player)
 {
     if (MySession.Static.IsScenario && m_takeSpawneeOwnership && Sync.IsServer && OwnerId == 0)
         ChangeBlockOwnerRequest(player.Identity.IdentityId, MyOwnershipShareModeEnum.None);
 }

        private bool CheckRangeAndAccess(IMyControllableEntity controlledEntity, MyPlayer player)
        {
            var terminal = controlledEntity as MyTerminalBlock;
            if (terminal == null)
            {
                var character = controlledEntity as MyCharacter;
                if (character != null)
                {
                    return MyAntennaSystem.Static.CheckConnection(character, CubeGrid, player);
                }
                else
                {
                    return true;
                }
            }

            MyCubeGrid playerGrid = terminal.SlimBlock.CubeGrid;

            return MyAntennaSystem.Static.CheckConnection(playerGrid, CubeGrid, player);
        }

 private void AddPlayer(PlayerId playerId, MyPlayer newPlayer)
 {
     m_players.Add(playerId, newPlayer);
     OnPlayersChanged(true, playerId.SteamId);
 }

        public override void BeforeStart()
        {
            base.BeforeStart();

            m_botPlayer = Sync.Players.GetPlayerById(new MyPlayer.PlayerId(Sync.MyId, 1));
        }

 public void SendNewPlayerMessage(MyPlayer.PlayerId senderId, MyPlayer.PlayerId receiverId, string text, TimeSpan timestamp)
 {
     MyMultiplayer.RaiseEvent(this, x => x.OnPlayerMessageRequest, text, senderId.SteamId, receiverId.SteamId, timestamp.Ticks);
 }