Beispiel #1
0
 /// <summary>
 /// Load data from a file. Shall be called after mod is fully initialized.
 /// </summary>
 private void DoLoad(Builder_ArmsData data)
 {
     try
     {
         LoadSaveData(data);
     }
     catch (Exception ex)
     {
         Logger.AlwaysLog("Exception: " + ex, Rynchodon.Logger.severity.ERROR);
         Rynchodon.Logger.Notify("ARMS: failed to load data", 60000, Rynchodon.Logger.severity.ERROR);
     }
 }
Beispiel #2
0
        private Builder_ArmsData GetData()
        {
            m_fileMaster = new FileMaster("SaveDataMaster.txt", "SaveData - ", int.MaxValue);

            Builder_ArmsData data = null;

            string serialized;

            if (MyAPIGateway.Utilities.GetVariable(SaveXml, out serialized))
            {
                data = MyAPIGateway.Utilities.SerializeFromXML <Builder_ArmsData>(serialized);
                if (data != null)
                {
                    Logger.DebugLog("ARMS data was imbeded in the save file proper", Rynchodon.Logger.severity.DEBUG);
                    return(data);
                }
            }

            string identifier = LegacyIdentifier(true);

            if (identifier == null)
            {
                Logger.DebugLog("no identifier");
                return(data);
            }

            var reader = m_fileMaster.GetTextReader(identifier);

            if (reader != null)
            {
                Logger.DebugLog("loading from file: " + identifier);
                data = MyAPIGateway.Utilities.SerializeFromXML <Builder_ArmsData>(reader.ReadToEnd());
                reader.Close();
            }
            else
            {
                Logger.AlwaysLog("Failed to open file reader for " + identifier);
            }

            return(data);
        }
Beispiel #3
0
        /// <summary>
        /// Saves data to a variable.
        /// </summary>
        public override void SaveData()
        {
            if (!MyAPIGateway.Multiplayer.IsServer)
                return;

            try
            {
                // fetching data needs to happen on game thread as not every script has locks

                Builder_ArmsData data = new Builder_ArmsData();

                // network data

                Dictionary<long, RelayStorage.Builder_NetworkStorage> storages = new Dictionary<long, RelayStorage.Builder_NetworkStorage>();

                Registrar.ForEach<RelayNode>(node => {
                    // players never load properly
                    if (node.m_player != null)
                        return;
                    if (node.Storage != null && !storages.ContainsKey(node.Storage.PrimaryNode.EntityId))
                    {
                        RelayStorage.Builder_NetworkStorage bns = node.Storage.GetBuilder();
                        storages.Add(bns.PrimaryNode, bns);
                    }
                });
                data.AntennaStorage = storages.Values.ToArray();

                // disruption

                List<Disruption.Builder_Disruption> systemDisrupt = new List<Disruption.Builder_Disruption>();
                foreach (Disruption disrupt in Disruption.AllDisruptions)
                    systemDisrupt.Add(disrupt.GetBuilder());
                data.SystemDisruption = systemDisrupt.ToArray();

                // autopilot

                List<ShipAutopilot.Builder_Autopilot> buildAuto = new List<ShipAutopilot.Builder_Autopilot>();
                Registrar.ForEach<ShipAutopilot>(autopilot => {
                    ShipAutopilot.Builder_Autopilot builder = autopilot.GetBuilder();
                    if (builder != null)
                        buildAuto.Add(builder);
                });
                data.Autopilot = buildAuto.ToArray();

                //// programmable block

                //List<ProgrammableBlock.Builder_ProgrammableBlock> buildProgram = new List<ProgrammableBlock.Builder_ProgrammableBlock>();
                //Registrar.ForEach<ProgrammableBlock>(program => {
                //	ProgrammableBlock.Builder_ProgrammableBlock builder = program.GetBuilder();
                //	if (builder != null)
                //		buildProgram.Add(builder);
                //});
                //data.ProgrammableBlock = buildProgram.ToArray();

                //// text panel

                //List<TextPanel.Builder_TextPanel> buildPanel = new List<TextPanel.Builder_TextPanel>();
                //Registrar.ForEach<TextPanel>(panel => {
                //	TextPanel.Builder_TextPanel builder = panel.GetBuilder();
                //	if (builder != null)
                //		buildPanel.Add(builder);
                //});
                //data.TextPanel = buildPanel.ToArray();

                //// weapon

                //List<WeaponTargeting.Builder_WeaponTargeting> buildWeapon = new List<WeaponTargeting.Builder_WeaponTargeting>();
                //Action<WeaponTargeting> act = weapon => {
                //	WeaponTargeting.Builder_WeaponTargeting builder = weapon.GetBuilder();
                //	if (builder != null)
                //		buildWeapon.Add(builder);
                //};
                //Registrar.ForEach<FixedWeapon>(act);
                //Registrar.ForEach<Turret>(act);
                //data.Weapon = buildWeapon.ToArray();

                // entity values

                data.EntityValues = EntityValue.GetBuilders();

                MyAPIGateway.Utilities.SetVariable(SaveXml, MyAPIGateway.Utilities.SerializeToXML(data));

                if (m_fileMaster != null)
                {
                    string identifier = LegacyIdentifier();
                    if (identifier != null)
                        if (m_fileMaster.Delete(identifier))
                            m_logger.debugLog("file deleted: " + identifier);
                }
            }
            catch (Exception ex)
            {
                m_logger.alwaysLog("Exception: " + ex, Logger.severity.ERROR);
                Logger.notify("ARMS: failed to save data", 60000, Logger.severity.ERROR);
            }
        }
Beispiel #4
0
        private void LoadData()
        {
            if (m_data == null)
            {
                m_logger.debugLog("No data to load");
                return;
            }

            m_logger.alwaysLog("Save version: " + m_data.ModVersion, Logger.severity.INFO);

            // network

            Dictionary<Message.Builder_Message, Message> messages = new Dictionary<Message.Builder_Message, Message>();
            SerializableGameTime.Adjust = new TimeSpan(m_data.SaveTime);
            foreach (RelayStorage.Builder_NetworkStorage bns in m_data.AntennaStorage)
            {
                RelayNode node;
                if (!Registrar.TryGetValue(bns.PrimaryNode, out node))
                {
                    m_logger.alwaysLog("Failed to get node for: " + bns.PrimaryNode, Logger.severity.WARNING);
                    continue;
                }
                RelayStorage store = node.Storage;
                if (store == null) // probably always true
                {
                    node.ForceCreateStorage();
                    store = node.Storage;
                    if (store == null)
                    {
                        m_logger.debugLog("failed to create storage for " + node.LoggingName, Logger.severity.ERROR);
                        continue;
                    }
                }

                foreach (LastSeen.Builder_LastSeen bls in bns.LastSeenList)
                {
                    LastSeen ls = new LastSeen(bls);
                    if (ls.IsValid)
                        store.Receive(ls);
                    else
                        m_logger.debugLog("failed to create a valid last seen from builder for " + bls.EntityId, Logger.severity.WARNING);
                }

                m_logger.debugLog("added " + bns.LastSeenList.Length + " last seen to " + store.PrimaryNode.LoggingName, Logger.severity.DEBUG);

                foreach (Message.Builder_Message bm in bns.MessageList)
                {
                    Message msg;
                    if (!messages.TryGetValue(bm, out msg))
                    {
                        msg = new Message(bm);
                        messages.Add(bm, msg);
                    }
                    else
                    {
                        m_logger.debugLog("found linked message", Logger.severity.TRACE);
                    }
                    if (msg.IsValid)
                        store.Receive(msg);
                    else
                        m_logger.debugLog("failed to create a valid message from builder for " + bm.DestCubeBlock, Logger.severity.WARNING);
                }

                m_logger.debugLog("added " + bns.MessageList.Length + " message to " + store.PrimaryNode.LoggingName, Logger.severity.DEBUG);
            }

            // system disruption

            foreach (Disruption.Builder_Disruption bd in m_data.SystemDisruption)
            {
                Disruption disrupt;
                switch (bd.Type)
                {
                    case "AirVentDepressurize":
                        disrupt = new AirVentDepressurize();
                        break;
                    case "CryoChamberMurder":
                        disrupt = new CryoChamberMurder();
                        break;
                    case "DisableTurret":
                        disrupt = new DisableTurret();
                        break;
                    case "DoorLock":
                        disrupt = new DoorLock();
                        break;
                    case "EMP":
                        disrupt = new EMP();
                        break;
                    case "GravityReverse":
                        disrupt = new GravityReverse();
                        break;
                    case "JumpDriveDrain":
                        disrupt = new JumpDriveDrain();
                        break;
                    case "MedicalRoom":
                        disrupt = new MedicalRoom();
                        break;
                    case "TraitorTurret":
                        disrupt = new TraitorTurret();
                        break;
                    default:
                        m_logger.alwaysLog("Unknown disruption: " + bd.Type, Logger.severity.WARNING);
                        continue;
                }
                disrupt.Start(bd);
            }

            // autopilot

            if (m_data.Autopilot != null)
                foreach (ShipAutopilot.Builder_Autopilot ba in m_data.Autopilot)
                {
                    ShipAutopilot autopilot;
                    if (Registrar.TryGetValue(ba.AutopilotBlock, out autopilot))
                        autopilot.Resume = ba;
                    else
                        m_logger.alwaysLog("failed to find autopilot block " + ba.AutopilotBlock, Logger.severity.WARNING);
                }

            // programmable block

            if (m_data.ProgrammableBlock != null)
                foreach (ProgrammableBlock.Builder_ProgrammableBlock bpa in m_data.ProgrammableBlock)
                {
                    ProgrammableBlock pb;
                    if (Registrar.TryGetValue(bpa.BlockId, out pb))
                        pb.ResumeFromSave(bpa);
                    else
                        m_logger.alwaysLog("failed to find programmable block " + bpa.BlockId, Logger.severity.WARNING);
                }

            // text panel

            if (m_data.TextPanel != null)
                foreach (TextPanel.Builder_TextPanel btp in m_data.TextPanel)
                {
                    TextPanel panel;
                    if (Registrar.TryGetValue(btp.BlockId, out panel))
                        panel.ResumeFromSave(btp);
                    else
                        m_logger.alwaysLog("failed to find text panel " + btp.BlockId, Logger.severity.WARNING);
                }

            // weapon

            if (m_data.Weapon != null)
                foreach (WeaponTargeting.Builder_WeaponTargeting bwt in m_data.Weapon)
                {
                    WeaponTargeting targeting;
                    if (WeaponTargeting.TryGetWeaponTargeting(bwt.WeaponId, out targeting))
                        targeting.ResumeFromSave(bwt);
                    else
                        m_logger.alwaysLog("failed to find weapon " + bwt.WeaponId, Logger.severity.WARNING);
                }

            // entity values

            if (m_data.EntityValues != null)
                EntityValue.ResumeFromSave(m_data.EntityValues);

            m_data = null;
        }
Beispiel #5
0
        private void GetData()
        {
            m_fileMaster = new FileMaster("SaveDataMaster.txt", "SaveData - ", int.MaxValue);

            string serialized;
            if (MyAPIGateway.Utilities.GetVariable(SaveXml, out serialized))
            {
                m_data = MyAPIGateway.Utilities.SerializeFromXML<Builder_ArmsData>(serialized);
                if (m_data != null)
                {
                    m_logger.debugLog("ARMS data was imbeded in the save file proper", Logger.severity.DEBUG);
                    return;
                }
            }

            string identifier = LegacyIdentifier();
            if (identifier == null)
            {
                m_logger.debugLog("no identifier");
                return;
            }

            var reader = m_fileMaster.GetTextReader(identifier);
            if (reader != null)
            {
                m_logger.debugLog("loading from file: " + identifier);
                m_data = MyAPIGateway.Utilities.SerializeFromXML<Builder_ArmsData>(reader.ReadToEnd());
                reader.Close();
            }
            else
                m_logger.alwaysLog("Failed to open file reader for " + identifier);
        }
Beispiel #6
0
        [OnWorldSave(Order = int.MaxValue)]         // has to be last, obviously
        private static void SaveData()
        {
            if (!MyAPIGateway.Multiplayer.IsServer)
            {
                return;
            }

            try
            {
                // fetching data needs to happen on game thread as not every script has locks

                Builder_ArmsData data = new Builder_ArmsData();

                data.SaveTime    = Globals.ElapsedTimeTicks;
                data.ArmsVersion = Settings.ServerSettings.CurrentVersion;

                // network data

                Dictionary <long, RelayStorage.Builder_NetworkStorage> storages = new Dictionary <long, RelayStorage.Builder_NetworkStorage>();

                Registrar.ForEach <RelayNode>(node => {
                    if (node.Block != null && node.Storage != null && !storages.ContainsKey(node.Storage.PrimaryNode.EntityId))
                    {
                        RelayStorage.Builder_NetworkStorage bns = node.Storage.GetBuilder();
                        if (bns != null)
                        {
                            storages.Add(bns.PrimaryNode, bns);
                        }
                    }
                });
                data.AntennaStorage = storages.Values.ToArray();

                // disruption

                List <Disruption.Builder_Disruption> systemDisrupt = new List <Disruption.Builder_Disruption>();
                foreach (Disruption disrupt in Disruption.AllDisruptions)
                {
                    systemDisrupt.Add(disrupt.GetBuilder());
                }
                data.SystemDisruption = systemDisrupt.ToArray();

                // autopilot

                List <ShipAutopilot.Builder_Autopilot> buildAuto = new List <ShipAutopilot.Builder_Autopilot>();
                Registrar.ForEach <ShipAutopilot>(autopilot => {
                    ShipAutopilot.Builder_Autopilot builder = autopilot.GetBuilder();
                    if (builder != null)
                    {
                        buildAuto.Add(builder);
                    }
                });
                data.Autopilot = buildAuto.ToArray();

                // Sync

                data.Sync = ASync.GetBuilder();

                MyAPIGateway.Utilities.SetVariable(SaveXml, MyAPIGateway.Utilities.SerializeToXML(data));

                if (Instance.m_fileMaster != null)
                {
                    string identifier = Instance.LegacyIdentifier(false);
                    if (identifier != null)
                    {
                        if (Instance.m_fileMaster.Delete(identifier))
                        {
                            Rynchodon.Logger.DebugLog("file deleted: " + identifier);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Rynchodon.Logger.AlwaysLog("Exception: " + ex, Rynchodon.Logger.severity.ERROR);
                Rynchodon.Logger.Notify("ARMS: failed to save data", 60000, Rynchodon.Logger.severity.ERROR);
            }
        }
Beispiel #7
0
        private void LoadSaveData(Builder_ArmsData data)
        {
            if (data == null)
            {
                Logger.DebugLog("No data to load");
                return;
            }

#pragma warning disable 612, 618
            if (Comparer <Version> .Default.Compare(data.ArmsVersion, default(Version)) == 0)
            {
                Logger.DebugLog("Old version: " + data.ModVersion);
                data.ArmsVersion = new Version(data.ModVersion);
            }
#pragma warning restore 612, 618

            Logger.AlwaysLog("Save version: " + data.ArmsVersion, Rynchodon.Logger.severity.INFO);

            // relay

            Dictionary <Message.Builder_Message, Message> messages = MyAPIGateway.Multiplayer.IsServer ? new Dictionary <Message.Builder_Message, Message>() : null;
            SerializableGameTime.Adjust = new TimeSpan(data.SaveTime);
            foreach (RelayStorage.Builder_NetworkStorage bns in data.AntennaStorage)
            {
                RelayNode node;
                if (!Registrar.TryGetValue(bns.PrimaryNode, out node))
                {
                    Logger.AlwaysLog("Failed to get node for: " + bns.PrimaryNode, Rynchodon.Logger.severity.WARNING);
                    continue;
                }
                RelayStorage store = node.Storage;
                if (store == null)                 // probably always true
                {
                    node.ForceCreateStorage();
                    store = node.Storage;
                    if (store == null)
                    {
                        Logger.AlwaysLog("failed to create storage for " + node.DebugName, Rynchodon.Logger.severity.ERROR);
                        continue;
                    }
                }

                foreach (LastSeen.Builder_LastSeen bls in bns.LastSeenList)
                {
                    LastSeen ls = new LastSeen(bls);
                    if (ls.IsValid)
                    {
                        store.Receive(ls);
                    }
                    else
                    {
                        Logger.AlwaysLog("failed to create a valid last seen from builder for " + bls.EntityId, Rynchodon.Logger.severity.WARNING);
                        if (m_failedLastSeen == null)
                        {
                            m_failedLastSeen = new CachingDictionary <long, CachingList <LastSeen.Builder_LastSeen> >();
                            UpdateManager.Register(100, RetryLastSeen);
                        }
                        CachingList <LastSeen.Builder_LastSeen> list;
                        if (!m_failedLastSeen.TryGetValue(bns.PrimaryNode, out list))
                        {
                            list = new CachingList <LastSeen.Builder_LastSeen>();
                            m_failedLastSeen.Add(bns.PrimaryNode, list, true);
                        }
                        list.Add(bls);
                        list.ApplyAdditions();
                    }
                }

                Logger.DebugLog("added " + bns.LastSeenList.Length + " last seen to " + store.PrimaryNode.DebugName, Rynchodon.Logger.severity.DEBUG);

                // messages in the save file belong on the server
                if (messages == null)
                {
                    continue;
                }

                foreach (Message.Builder_Message bm in bns.MessageList)
                {
                    Message msg;
                    if (!messages.TryGetValue(bm, out msg))
                    {
                        msg = new Message(bm);
                        messages.Add(bm, msg);
                    }
                    else
                    {
                        Logger.DebugLog("found linked message", Rynchodon.Logger.severity.TRACE);
                    }
                    if (msg.IsValid)
                    {
                        store.Receive(msg);
                    }
                    else
                    {
                        Logger.AlwaysLog("failed to create a valid message from builder for " + bm.DestCubeBlock + "/" + bm.SourceCubeBlock, Rynchodon.Logger.severity.WARNING);
                    }
                }

                Logger.DebugLog("added " + bns.MessageList.Length + " message to " + store.PrimaryNode.DebugName, Rynchodon.Logger.severity.DEBUG);
            }

            // past this point, only synchronized data
            if (!MyAPIGateway.Multiplayer.IsServer)
            {
                data = null;
                return;
            }

            // system disruption

            foreach (Disruption.Builder_Disruption bd in data.SystemDisruption)
            {
                Disruption disrupt;
                switch (bd.Type)
                {
                case "AirVentDepressurize":
                    disrupt = new AirVentDepressurize();
                    break;

                case "CryoChamberMurder":
                    disrupt = new CryoChamberMurder();
                    break;

                case "DisableTurret":
                    disrupt = new DisableTurret();
                    break;

                case "DoorLock":
                    disrupt = new DoorLock();
                    break;

                case "EMP":
                    disrupt = new EMP();
                    break;

                case "GravityReverse":
                    disrupt = new GravityReverse();
                    break;

                case "JumpDriveDrain":
                    disrupt = new JumpDriveDrain();
                    break;

                case "MedicalRoom":
                    disrupt = new MedicalRoom();
                    break;

                case "TraitorTurret":
                    disrupt = new TraitorTurret();
                    break;

                default:
                    Logger.AlwaysLog("Unknown disruption: " + bd.Type, Rynchodon.Logger.severity.WARNING);
                    continue;
                }
                disrupt.Start(bd);
            }

            // autopilot

            if (data.Autopilot != null)
            {
                foreach (ShipAutopilot.Builder_Autopilot ba in data.Autopilot)
                {
                    ShipAutopilot autopilot;
                    if (Registrar.TryGetValue(ba.AutopilotBlock, out autopilot))
                    {
                        autopilot.ResumeFromSave(ba);
                    }
                    else
                    {
                        Logger.AlwaysLog("failed to find autopilot block " + ba.AutopilotBlock, Rynchodon.Logger.severity.WARNING);
                    }
                }
            }

            // programmable block

            if (data.ProgrammableBlock != null)
            {
                foreach (ProgrammableBlock.Builder_ProgrammableBlock bpa in data.ProgrammableBlock)
                {
                    ProgrammableBlock pb;
                    if (Registrar.TryGetValue(bpa.BlockId, out pb))
                    {
                        pb.ResumeFromSave(bpa);
                    }
                    else
                    {
                        Logger.AlwaysLog("failed to find programmable block " + bpa.BlockId, Rynchodon.Logger.severity.WARNING);
                    }
                }
            }

            // text panel

            if (data.TextPanel != null)
            {
                foreach (TextPanel.Builder_TextPanel btp in data.TextPanel)
                {
                    TextPanel panel;
                    if (Registrar.TryGetValue(btp.BlockId, out panel))
                    {
                        panel.ResumeFromSave(btp);
                    }
                    else
                    {
                        Logger.AlwaysLog("failed to find text panel " + btp.BlockId, Rynchodon.Logger.severity.WARNING);
                    }
                }
            }

            // weapon

            if (data.Weapon != null)
            {
                foreach (WeaponTargeting.Builder_WeaponTargeting bwt in data.Weapon)
                {
                    WeaponTargeting targeting;
                    if (WeaponTargeting.TryGetWeaponTargeting(bwt.WeaponId, out targeting))
                    {
                        targeting.ResumeFromSave(bwt);
                    }
                    else
                    {
                        Logger.AlwaysLog("failed to find weapon " + bwt.WeaponId, Rynchodon.Logger.severity.WARNING);
                    }
                }
            }

            // entity values

            if (data.EntityValues != null)
            {
                UpgradeEntityValue.Load(data.EntityValues);
            }

            // sync

            if (data.Sync != null)
            {
                ASync.SetBuilder(data.Sync);
            }

            data = null;
        }