Example #1
0
        private void DoServerGetTerminalValues(MyEntity blockEntity, ulong steamId)
        {
            if (isOnline)
            {
                // get block settings
                TurretSetting settings = (blockEntity as IMyLargeMissileTurret).RetrieveTerminalValues();
                Logger.Instance.LogMessage("Settings For Block: " + blockEntity.EntityId + ": " + ((settings != null) ? settings.ToString() : "null"));

                // if we have settings to share (if this was not called for a block that was placed by a non server client)
                if (settings != null)
                {
                    // send enabled state as a fail safe
                    settings.Enabled = (blockEntity as IMyFunctionalBlock).Enabled;
                    // send settings to client
                    SendActionToClient(blockEntity, 0, steamId, BlockAction.GetTerminalValues, settings);
                }
                else
                {
                    // we have no settings wait until server inits block
                    // log block so settings can be sent later
                    if (PreInitBlockSettings.ContainsKey(steamId))
                    {
                        // check for this Entity
                        Dictionary <string, TurretSetting> entry = PreInitBlockSettings[steamId];
                        entry.Add(blockEntity.EntityId.ToString(), null);
                    }
                    else
                    {
                        Dictionary <string, TurretSetting> entry = new Dictionary <string, TurretSetting>();
                        entry.Add(blockEntity.EntityId.ToString(), settings);
                        PreInitBlockSettings.Add(steamId, entry);
                    }
                }
            }
        }
Example #2
0
        public void SetOffset(long EntityID, float offset)
        {
            var block = MyAPIGateway.Entities.GetEntityById(EntityID);

            if (!isServer)
            {
                // send command to server
                TurretSetting settings = new TurretSetting();
                settings.LightOffset = offset;
                SendToServer(block, PlayerId, BlockAction.SetOffset, settings);
            }
            else
            {
                // send offset change to block
                block.GameLogic.GetAs <TurretSpotlight>().SetTurretLightOffset(offset);
            }
        }
Example #3
0
        public void SetIntensity(long EntityID, float intensity)
        {
            var block = MyAPIGateway.Entities.GetEntityById(EntityID);

            if (!isServer)
            {
                // send command to server
                TurretSetting settings = new TurretSetting();
                settings.LightIntensity = intensity;
                SendToServer(block, PlayerId, BlockAction.SetIntensity, settings);
            }
            else
            {
                // send intensity change to block
                block.GameLogic.GetAs <TurretSpotlight>().SetTurretLightIntensity(intensity);
            }
        }
Example #4
0
        // Server and Client
        public void SetColor(long EntityID, Color color)
        {
            var block = MyAPIGateway.Entities.GetEntityById(EntityID);

            if (!isServer)
            {
                // send command to server
                TurretSetting settings = new TurretSetting();
                settings.LightColor = color;
                SendToServer(block, PlayerId, BlockAction.SetColor, settings);
            }
            else
            {
                // send color change to block
                block.GameLogic.GetAs <TurretSpotlight>().SetTurretLightColor(color);
            }
        }
Example #5
0
 private void LoadTerminalValues(IMyLargeMissileTurret turret, TurretSetting settings)
 {
     // load data
     if (settings != null)
     {
         Logger.Instance.LogDebug("Found settings for block: " + turret.CustomName);
         turret.GameLogic.GetAs <TurretSpotlight>().Light_Color          = settings.LightColor;
         turret.GameLogic.GetAs <TurretSpotlight>().Light_Radius         = settings.LightRadius;
         turret.GameLogic.GetAs <TurretSpotlight>().Light_Intensity      = settings.LightIntensity;
         turret.GameLogic.GetAs <TurretSpotlight>().Light_Offset         = settings.LightOffset;
         turret.GameLogic.GetAs <TurretSpotlight>().Light_Blink_Interval = settings.LightBlinkInterval;
         turret.GameLogic.GetAs <TurretSpotlight>().Light_Blink_Length   = settings.LightBlinkLength;
         turret.GameLogic.GetAs <TurretSpotlight>().Light_Blink_Offset   = settings.LightBlinkOffset;
         turret.GameLogic.GetAs <TurretSpotlight>().Turret_Azimuth       = settings.TurretAzimuth;
         turret.GameLogic.GetAs <TurretSpotlight>().Turret_Elevation     = settings.TurretElevation;
     }
 }
Example #6
0
        public void GetTerminalValues(long EntityID)
        {
            // get terminal values
            var block = MyAPIGateway.Entities.GetEntityById(EntityID);

            if (!isServer)
            {
                SendToServer(block, PlayerId, BlockAction.GetTerminalValues);
            }
            else
            {
                // get block settings
                TurretSetting settings = (block as IMyLargeMissileTurret).RetrieveTerminalValues();
                Logger.Instance.LogMessage("Settings For Block: " + block.EntityId + ": " + ((settings != null) ? settings.ToString() : "null"));
                // send settings to block
                block.GameLogic.GetAs <TurretSpotlight>().InitTerminalValues(settings);
            }
        }
Example #7
0
        public void InitTerminalValues(TurretSetting settings = null)
        {
            try
            {
                if (!m_init)
                {
                    CreateTerminalControls();
                    // load stored terminal data
                    LoadTerminalValues(m_turret, settings);

                    m_turret.ShowInInventory = false;

                    if (PlayerInput.Instance.isServer)
                    {
                        m_inventory = m_turret.GetInventory() as IMyInventory;

                        NeedsUpdate |= VRage.ModAPI.MyEntityUpdateEnum.EACH_100TH_FRAME;
                        PlayerInput.Instance.SaveTerminalValues(m_turret.EntityId);
                    }

                    m_turret.EnabledChanged    += OnEnabledChanged;
                    m_turret.IsWorkingChanged  += OnIsWorkingChanged;
                    m_turret.PropertiesChanged += OnPropertiesChanged;
                    if (PlayerInput.Instance.isServer)
                    {
                        m_turret.OnMarkForClose += OnMarkForClose;
                    }

                    m_init = true;

                    CheckAndAddLight();

                    //NeedsUpdate |= MyEntityUpdateEnum.EACH_FRAME;
                }
            }
            catch (Exception e)
            {
                // Do nothing
                Logger.Instance.LogMessage("Init Terminal Values Error: " + e.Message);
                Logger.Instance.LogMessage(e.StackTrace);
                NeedsUpdate |= VRage.ModAPI.MyEntityUpdateEnum.BEFORE_NEXT_FRAME;
            }
        }
Example #8
0
        public void StoreTerminalValues(IMyLargeMissileTurret turret)
        {
            var settings = m_TurretSettings.FirstOrDefault((x) => x.EntityId == turret.EntityId);

            if (settings == null)
            {
                settings          = new TurretSetting();
                settings.EntityId = turret.EntityId;
                m_TurretSettings.Add(settings);
            }
            settings.LightColor         = turret.GameLogic.GetAs <TurretSpotlight>().Light_Color;
            settings.LightRadius        = turret.GameLogic.GetAs <TurretSpotlight>().Light_Radius;
            settings.LightIntensity     = turret.GameLogic.GetAs <TurretSpotlight>().Light_Intensity;
            settings.LightOffset        = turret.GameLogic.GetAs <TurretSpotlight>().Light_Offset;
            settings.LightBlinkInterval = turret.GameLogic.GetAs <TurretSpotlight>().Light_Blink_Interval;
            settings.LightBlinkLength   = turret.GameLogic.GetAs <TurretSpotlight>().Light_Blink_Length;
            settings.LightBlinkOffset   = turret.GameLogic.GetAs <TurretSpotlight>().Light_Blink_Offset;
            settings.TurretAzimuth      = turret.GameLogic.GetAs <TurretSpotlight>().Turret_Azimuth;
            settings.TurretElevation    = turret.GameLogic.GetAs <TurretSpotlight>().Turret_Elevation;
        }
Example #9
0
        // Public Handles
        // Server Only
        public void SendTerminalValues(long EntityID)
        {
            if (isServer && isOnline)
            {
                // check for any uninitialized clients for this block
                bool  Send    = false;
                ulong steamId = 0;
                foreach (var entry in PreInitBlockSettings)
                {
                    // if this entry has this entity ID in it
                    if (entry.Value.ContainsKey(EntityID.ToString()))
                    {
                        // this is the client we need to send to
                        steamId = entry.Key;
                        Send    = true;
                        // break the loop
                        break;
                    }
                }

                // if we have a client ot send to
                if (Send)
                {
                    Logger.Instance.LogMessage("Block: " + EntityID + " Settings Need to be Sent.");
                    // collect data for sending
                    MyEntity blockEntity = MyAPIGateway.Entities.GetEntityById(EntityID) as MyEntity;
                    // get block settings
                    TurretSetting settings = (blockEntity as IMyLargeMissileTurret).RetrieveTerminalValues();

                    // send settings to client
                    SendActionToClient(blockEntity, 0, steamId, BlockAction.GetTerminalValues, settings);

                    // remove setting from data list
                    (PreInitBlockSettings[steamId]).Remove(EntityID.ToString());
                    if ((PreInitBlockSettings[steamId]).Count == 0)
                    {
                        PreInitBlockSettings.Remove(steamId);
                    }
                }
            }
        }
Example #10
0
 private void PerformClientAction(MyEntity blockEntity, long playerId, ulong steamId, BlockAction action, NetworkMessage data)
 {
     if (action == BlockAction.GetTerminalValues)
     {
         // decompile settings data
         TurretSetting settings = new TurretSetting();
         settings.LightColor         = new Color(data.ColorR, data.ColorG, data.ColorB, data.ColorA);
         settings.LightIntensity     = data.LightIntensity;
         settings.LightOffset        = data.LightOffset;
         settings.LightRadius        = data.LightRadius;
         settings.LightBlinkInterval = data.LightBlinkInterval;
         settings.LightBlinkLength   = data.LightBlinkLength;
         settings.LightBlinkOffset   = data.LightBlinkOffset;
         settings.TurretAzimuth      = data.TurretAzimuth;
         settings.TurretElevation    = data.TurretElevation;
         settings.Enabled            = data.Enabled;
         DoClientGetTerminalValues(blockEntity, settings);
     }
     else if (action == BlockAction.SetColor)
     {
         // decompile data
         Color color = Color.FromNonPremultiplied(data.ColorR, data.ColorG, data.ColorB, data.ColorA);
         DoClientSetColor(blockEntity, color);
     }
     else if (action == BlockAction.SetIntensity)
     {
         DoClientSetIntensity(blockEntity, data.LightIntensity);
     }
     else if (action == BlockAction.SetOffset)
     {
         DoClientSetOffset(blockEntity, data.LightOffset);
     }
     else if (action == BlockAction.SetRadius)
     {
         DoClientSetRadius(blockEntity, data.LightRadius);
     }
 }
Example #11
0
 private void DoClientGetTerminalValues(MyEntity blockEntity, TurretSetting settings)
 {
     // send settings to block
     blockEntity.GameLogic.GetAs <TurretSpotlight>().InitTerminalValues(settings);
 }
Example #12
0
        private void SendActionToClient(IMyEntity entityblock, long playerId, ulong steamId, BlockAction action, TurretSetting settings = null)
        {
            try
            {
                NetworkMessage msg = new NetworkMessage();
                msg.BlockEntityId = entityblock.EntityId;

                msg.PlayerId = playerId;
                msg.SteamId  = steamId;
                msg.Action   = (ushort)action;

                // compile block data
                if (settings != null)
                {
                    // send passed values
                    msg.ColorR             = settings.LightColor.R;
                    msg.ColorG             = settings.LightColor.G;
                    msg.ColorB             = settings.LightColor.B;
                    msg.ColorA             = settings.LightColor.A;
                    msg.LightIntensity     = settings.LightIntensity;
                    msg.LightOffset        = settings.LightOffset;
                    msg.LightRadius        = settings.LightRadius;
                    msg.LightBlinkInterval = settings.LightBlinkInterval;
                    msg.LightBlinkLength   = settings.LightBlinkLength;
                    msg.LightBlinkOffset   = settings.LightBlinkOffset;
                    msg.TurretAzimuth      = settings.TurretAzimuth;
                    msg.TurretElevation    = settings.TurretElevation;
                    msg.Enabled            = settings.Enabled;
                }

                var msgBytes = MyAPIGateway.Utilities.SerializeToBinary(msg);

                MyAPIGateway.Multiplayer.SendMessageTo(_SND_DATATOCLIENT, msgBytes, msg.SteamId, true);
            }
            catch (Exception ex)
            {
                Logger.Instance.LogMessage(ex.Message);
                Logger.Instance.LogMessage(ex.StackTrace);
            }
        }
Example #13
0
        private void SendToServer(IMyEntity entityblock, long playerID, BlockAction action, TurretSetting settings = null)
        {
            try
            {
                if (playerID == 0)
                {
                    return;
                }

                NetworkMessage msg = new NetworkMessage();
                msg.BlockEntityId = entityblock.EntityId;

                msg.PlayerId = playerID;
                msg.SteamId  = MyAPIGateway.Multiplayer.MyId;
                msg.Action   = (ushort)action;
                // compile block data
                if (settings != null)
                {
                    // send passed values
                    msg.ColorR             = settings.LightColor.R;
                    msg.ColorG             = settings.LightColor.G;
                    msg.ColorB             = settings.LightColor.B;
                    msg.ColorA             = settings.LightColor.A;
                    msg.LightIntensity     = settings.LightIntensity;
                    msg.LightOffset        = settings.LightOffset;
                    msg.LightRadius        = settings.LightRadius;
                    msg.LightBlinkInterval = settings.LightBlinkInterval;
                    msg.LightBlinkLength   = settings.LightBlinkLength;
                    msg.LightBlinkOffset   = settings.LightBlinkOffset;
                    msg.TurretAzimuth      = settings.TurretAzimuth;
                    msg.TurretElevation    = settings.TurretElevation;
                    msg.Enabled            = settings.Enabled;
                }

                Logger.Instance.LogMessage("Send message to server: " + msg.SteamId + " for block: " + msg.BlockEntityId + " Action: " + msg.Action);

                var msgBytes = MyAPIGateway.Utilities.SerializeToBinary(msg);

                MyAPIGateway.Multiplayer.SendMessageToServer(_RCV_FROMCLIENT, msgBytes, true);
            }
            catch (Exception ex)
            {
                Logger.Instance.LogMessage(ex.Message);
                Logger.Instance.LogMessage(ex.StackTrace);
            }
        }