public static MyObjectBuilder_Definitions LoadWorkshopPrefab(string archive, ulong?publishedItemId) { if (!File.Exists(archive) || publishedItemId == null) { return(null); } var subItem = MyGuiBlueprintScreen.m_subscribedItemsList.Find(item => item.PublishedFileId == publishedItemId); if (subItem == null) { return(null); } var extracted = MyZipArchive.OpenOnFile(archive); var stream = extracted.GetFile("bp.sbc").GetStream(); if (stream == null) { return(null); } MyObjectBuilder_Definitions objectBuilder = null; var success = MyObjectBuilderSerializer.DeserializeXML(stream, out objectBuilder); stream.Close(); extracted.Dispose(); if (success) { objectBuilder.ShipBlueprints[0].Description = subItem.Description; objectBuilder.ShipBlueprints[0].CubeGrids[0].DisplayName = subItem.Title; return(objectBuilder); } return(null); }
private static bool TryGetGridsFromDefinition(MyObjectBuilder_Definitions Definition, out IEnumerable <MyObjectBuilder_CubeGrid> Grids) { //Should be able to load shipdef and prefabs that people load/drag in Grids = new List <MyObjectBuilder_CubeGrid>(); if (Definition.Prefabs != null && Definition.Prefabs.Count() != 0) { foreach (var prefab in Definition.Prefabs) { Grids = Grids.Concat(prefab.CubeGrids); } return(true); } else if (Definition.ShipBlueprints != null && Definition.ShipBlueprints.Count() != 0) { foreach (var shipBlueprint in Definition.ShipBlueprints) { Grids = Grids.Concat(shipBlueprint.CubeGrids); } return(true); } else { Log.Error("Invalid Definition file!"); return(false); } }
public void LoadParticlesLibrary(string file) { if (file.Contains(".mwl")) { MyParticlesLibrary.Deserialize(file); } else { ProfilerShort.Begin("Verify Integrity"); MyDataIntegrityChecker.HashInFile(file); MyObjectBuilder_Definitions builder = null; ProfilerShort.BeginNextBlock("Parse"); MyObjectBuilderSerializer.DeserializeXML <MyObjectBuilder_Definitions>(file, out builder); if (builder == null || builder.ParticleEffects == null) { return; } else { MyParticlesLibrary.Close(); foreach (var classDef in builder.ParticleEffects) { MyParticleEffect effect = MyParticlesManager.EffectsPool.Allocate(); effect.DeserializeFromObjectBuilder(classDef); MyParticlesLibrary.AddParticleEffect(effect); } } //definitionBuilders.Add(new Tuple<MyObjectBuilder_Definitions, string>(builder, file)); ProfilerShort.End(); } }
public bool Save() { if (!Changed) { return(false); } if (!IsMutable) { return(false); } if (FileInfo == null) { return(false); } MyObjectBuilder_Definitions definitionsContainer = new MyObjectBuilder_Definitions(); if (m_definitionsContainerField == null) { throw new GameInstallationInfoException(GameInstallationInfoExceptionState.Invalid, "Failed to find matching definitions field in the given file."); } //Save the source data into the definitions container m_definitionsContainerField.SetValue(definitionsContainer, ExtractBaseDefinitions().ToArray()); //Save the definitions container out to the file SaveContentFile <MyObjectBuilder_Definitions, MyObjectBuilder_DefinitionsSerializer>(definitionsContainer, m_fileInfo); return(true); }
private bool SaveGridToFile(string path, string filename, List <MyObjectBuilder_CubeGrid> objectBuilders) { MyObjectBuilder_ShipBlueprintDefinition definition = MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_ShipBlueprintDefinition>(); definition.Id = new MyDefinitionId(new MyObjectBuilderType(typeof(MyObjectBuilder_ShipBlueprintDefinition)), filename); definition.CubeGrids = objectBuilders.Select(x => (MyObjectBuilder_CubeGrid)x.Clone()).ToArray(); /* Reset ownership as it will be different on the new server anyway */ foreach (MyObjectBuilder_CubeGrid cubeGrid in definition.CubeGrids) { foreach (MyObjectBuilder_CubeBlock cubeBlock in cubeGrid.CubeBlocks) { cubeBlock.Owner = 0L; cubeBlock.BuiltBy = 0L; } } MyObjectBuilder_Definitions builderDefinition = MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_Definitions>(); builderDefinition.ShipBlueprints = new MyObjectBuilder_ShipBlueprintDefinition[] { definition }; return(MyObjectBuilderSerializer.SerializeXML(path, false, builderDefinition)); }
public static bool SaveGrid(string path, string filename, bool keepOriginalOwner, bool keepProjection, List <MyObjectBuilder_CubeGrid> objectBuilders) { MyObjectBuilder_ShipBlueprintDefinition definition = MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_ShipBlueprintDefinition>(); definition.Id = new MyDefinitionId(new MyObjectBuilderType(typeof(MyObjectBuilder_ShipBlueprintDefinition)), filename); definition.CubeGrids = objectBuilders.Select(x => (MyObjectBuilder_CubeGrid)x.Clone()).ToArray(); /* Reset ownership as it will be different on the new server anyway */ foreach (MyObjectBuilder_CubeGrid cubeGrid in definition.CubeGrids) { foreach (MyObjectBuilder_CubeBlock cubeBlock in cubeGrid.CubeBlocks) { if (!keepOriginalOwner) { cubeBlock.Owner = 0L; cubeBlock.BuiltBy = 0L; } /* Remove Projections if not needed */ if (!keepProjection) { if (cubeBlock is MyObjectBuilder_ProjectorBase projector) { projector.ProjectedGrids = null; } } /* Remove Pilot and Components (like Characters) from cockpits */ if (cubeBlock is MyObjectBuilder_Cockpit cockpit) { cockpit.Pilot = null; if (cockpit.ComponentContainer != null) { var components = cockpit.ComponentContainer.Components; if (components != null) { for (int i = components.Count - 1; i >= 0; i--) { var component = components[i]; if (component.TypeId == "MyHierarchyComponentBase") { components.RemoveAt(i); continue; } } } } } } } MyObjectBuilder_Definitions builderDefinition = MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_Definitions>(); builderDefinition.ShipBlueprints = new MyObjectBuilder_ShipBlueprintDefinition[] { definition }; return(MyObjectBuilderSerializer.SerializeXML(path, false, builderDefinition)); }
public static MyObjectBuilder_Definitions SaveProgram(string path, MyObjectBuilder_Definitions definitions, long entityid, string program) { try { string backup = String.Format("{0}.bak", path); if (!File.Exists(backup)) { File.Copy(path, backup); } else { FileInfo source = new FileInfo(path); FileInfo dest = new FileInfo(path); if (source.LastWriteTime > dest.LastWriteTime) { File.Copy(path, backup, true); } } foreach (MyObjectBuilder_ShipBlueprintDefinition blueprints in definitions.ShipBlueprints) { foreach (MyObjectBuilder_CubeGrid cubegrid in blueprints.CubeGrids) { foreach (MyObjectBuilder_CubeBlock block in cubegrid.CubeBlocks) { if (block is MyObjectBuilder_MyProgrammableBlock) { if (block.EntityId == entityid) { MyObjectBuilder_MyProgrammableBlock prog = (MyObjectBuilder_MyProgrammableBlock)block; prog.Program = program; } } } } } MyObjectBuilderSerializer.SerializeXML(path, false, definitions); } catch (Exception ex) { string message = String.Format( "{0} ({1}){2}{2}{3}", "There was an error saving the blueprint", ex.Message, Environment.NewLine, ex.StackTrace ); System.Windows.MessageBox.Show( message, "SE Workbench", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Error ); } return(definitions); }
bool CopySelectedItemToClipboard() { if (!ValidateSelecteditem()) { return(false); } var path = ""; MyObjectBuilder_Definitions prefab = null; if ((m_selectedItem.UserData as MyBlueprintItemInfo).Type == MyBlueprintTypeEnum.LOCAL) { path = Path.Combine(m_localBlueprintFolder, m_selectedItem.Text.ToString(), "bp.sbc"); if (File.Exists(path)) { prefab = LoadPrefab(path); } } else if ((m_selectedItem.UserData as MyBlueprintItemInfo).Type == MyBlueprintTypeEnum.STEAM) { var id = (m_selectedItem.UserData as MyBlueprintItemInfo).PublishedItemId; path = Path.Combine(m_workshopBlueprintFolder, id.ToString() + m_workshopBlueprintSuffix); if (File.Exists(path)) { prefab = LoadWorkshopPrefab(path, id); } } else if ((m_selectedItem.UserData as MyBlueprintItemInfo).Type == MyBlueprintTypeEnum.SHARED) { return(false); } else if ((m_selectedItem.UserData as MyBlueprintItemInfo).Type == MyBlueprintTypeEnum.DEFAULT) { path = Path.Combine(m_defaultBlueprintFolder, m_selectedItem.Text.ToString(), "bp.sbc"); if (File.Exists(path)) { prefab = LoadPrefab(path); } } if (prefab != null) { if (MySandboxGame.Static.SessionCompatHelper != null) { MySandboxGame.Static.SessionCompatHelper.CheckAndFixPrefab(prefab); } return(CopyBlueprintPrefabToClipboard(prefab, m_clipboard)); } else { MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox( buttonType: MyMessageBoxButtonsType.OK, styleEnum: MyMessageBoxStyleEnum.Error, messageCaption: new StringBuilder("Error"), messageText: new StringBuilder("Failed to load the blueprint file.") )); return(false); } }
protected static void SavePrefabToFile(MyObjectBuilder_Definitions prefab, string name, bool replace = false, MyBlueprintTypeEnum type = MyBlueprintTypeEnum.LOCAL) { //if (name == null) //{ // name = MyUtils.StripInvalidChars(MyCubeBuilder.Static.Clipboard.CopiedGridsName); //} Debug.Assert(name != null, "Name cannot be null"); string file = ""; if (type == MyBlueprintTypeEnum.LOCAL) { file = Path.Combine(m_localBlueprintFolder, name); } else { file = Path.Combine(m_workshopBlueprintFolder, "temp", name); } string filePath = ""; int index = 1; try { if (!replace) { while (MyFileSystem.DirectoryExists(file)) { file = Path.Combine(m_localBlueprintFolder, name + "_" + index); index++; } if (index > 1) { name += new StringBuilder("_" + (index - 1)); } } filePath = file + "\\bp.sbc"; var success = MyObjectBuilderSerializer.SerializeXML(filePath, false, prefab); Debug.Assert(success, "falied to write blueprint to file"); if (!success) { MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox( buttonType: MyMessageBoxButtonsType.OK, styleEnum: MyMessageBoxStyleEnum.Error, messageCaption: new StringBuilder("Error"), messageText: new StringBuilder("There was a problem with saving blueprint") )); if (Directory.Exists(file)) { Directory.Delete(file, true); } } } catch (Exception e) { MySandboxGame.Log.WriteLine(String.Format("Failed to write prefab at file {0}, message: {1}, stack:{2}", filePath, e.Message, e.StackTrace)); } }
public int GetHashCode(object o) { var definitions = o as MyObjectBuilder_Definitions; if (definitions != null) { Def = definitions; } return(0); }
public static bool SaveGrid(string path, string filename, string ip, bool keepOriginalOwner, bool keepProjection, List <MyObjectBuilder_CubeGrid> objectBuilders) { MyObjectBuilder_ShipBlueprintDefinition definition = MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_ShipBlueprintDefinition>(); definition.Id = new MyDefinitionId(new MyObjectBuilderType(typeof(MyObjectBuilder_ShipBlueprintDefinition)), filename); definition.CubeGrids = objectBuilders.Select(x => (MyObjectBuilder_CubeGrid)x.Clone()).ToArray(); List <ulong> playerIds = new List <ulong>(); /* Reset ownership as it will be different on the new server anyway */ foreach (MyObjectBuilder_CubeGrid cubeGrid in definition.CubeGrids) { foreach (MyObjectBuilder_CubeBlock cubeBlock in cubeGrid.CubeBlocks) { if (!keepOriginalOwner) { cubeBlock.Owner = 0L; cubeBlock.BuiltBy = 0L; } /* Remove Projections if not needed */ if (!keepProjection) { if (cubeBlock is MyObjectBuilder_ProjectorBase projector) { projector.ProjectedGrids = null; } } /* Remove Pilot and Components (like Characters) from cockpits */ if (cubeBlock is MyObjectBuilder_Cockpit cockpit) { if (cockpit.Pilot != null) { var playersteam = cockpit.Pilot.PlayerSteamId; var player = PlayerUtils.GetIdentityByNameOrId(playersteam.ToString()); playerIds.Add(playersteam); ModCommunication.SendMessageTo(new JoinServerMessage(ip), playersteam); } } } } MyObjectBuilder_Definitions builderDefinition = MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_Definitions>(); builderDefinition.ShipBlueprints = new MyObjectBuilder_ShipBlueprintDefinition[] { definition }; foreach (var playerId in playerIds) { var player = PlayerUtils.GetIdentityByNameOrId(playerId.ToString()); player.Character.EnableBag(false); Sandbox.Game.MyVisualScriptLogicProvider.SetPlayersHealth(player.IdentityId, 0); player.Character.Delete(); } return(MyObjectBuilderSerializer.SerializeXML(path, false, builderDefinition)); }
private bool LoadBlueprint(string path) { bool success = false; MyObjectBuilder_Definitions blueprint = MyGuiBlueprintScreenBase.LoadPrefab(path); if (blueprint != null) { success = MyGuiBlueprintScreen.CopyBlueprintPrefabToClipboard(blueprint, m_clipboard); } OnBlueprintScreen_Closed(null); return(success); }
public static void SaveEnvironmentDefinition() { EnvironmentDefinition.SunProperties = SunProperties; EnvironmentDefinition.FogProperties = FogProperties; EnvironmentDefinition.SSAOSettings = SSAOSettings; EnvironmentDefinition.HBAOSettings = HBAOSettings; EnvironmentDefinition.PostProcessSettings = MyPostprocessSettingsWrapper.Settings; EnvironmentDefinition.ShadowSettings.CopyFrom(ShadowSettings); var save = new MyObjectBuilder_Definitions(); save.Environments = new MyObjectBuilder_EnvironmentDefinition[] { (MyObjectBuilder_EnvironmentDefinition)EnvironmentDefinition.GetObjectBuilder() }; save.Save(Path.Combine(MyFileSystem.ContentPath, "Data", "Environment.sbc")); }
/// <summary> /// Method to serialize a configuration file. /// </summary> /// <param name="definitions">The definition to serialize.</param> public void Serialize(MyObjectBuilder_Definitions definitions) { XmlWriterSettings settings = new XmlWriterSettings() { CloseOutput = true, Indent = true, ConformanceLevel = ConformanceLevel.Auto, NewLineHandling = NewLineHandling.Entitize }; XmlWriter writer = XmlWriter.Create(_configFileInfo.FullName, settings); MyObjectBuilder_DefinitionsSerializer serializer = (MyObjectBuilder_DefinitionsSerializer)Activator.CreateInstance(typeof(MyObjectBuilder_DefinitionsSerializer)); serializer.Serialize(writer,definitions); writer.Close(); }
public static MyObjectBuilder_Definitions LoadPrefab(string filePath) { MyObjectBuilder_Definitions loadedPrefab = null; if (MyFileSystem.FileExists(filePath)) { var success = MyObjectBuilderSerializer.DeserializeXML(filePath, out loadedPrefab); if (!success) { return(null); } } return(loadedPrefab); }
private static bool SaveGridToFile(string Path, string Name, IEnumerable <MyObjectBuilder_CubeGrid> GridBuilders) { MyObjectBuilder_ShipBlueprintDefinition definition = MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_ShipBlueprintDefinition>(); definition.Id = new MyDefinitionId(new MyObjectBuilderType(typeof(MyObjectBuilder_ShipBlueprintDefinition)), Name); definition.CubeGrids = GridBuilders.ToArray(); PrepareGridForSave(definition); MyObjectBuilder_Definitions builderDefinition = MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_Definitions>(); builderDefinition.ShipBlueprints = new MyObjectBuilder_ShipBlueprintDefinition[] { definition }; return(MyObjectBuilderSerializer.SerializeXML(Path, false, builderDefinition)); }
/// <summary> /// Method to serialize a configuration file. /// </summary> /// <param name="definitions">The definition to serialize.</param> public void Serialize(MyObjectBuilder_Definitions definitions) { XmlWriterSettings settings = new XmlWriterSettings() { CloseOutput = true, Indent = true, ConformanceLevel = ConformanceLevel.Auto, NewLineHandling = NewLineHandling.Entitize }; XmlWriter writer = XmlWriter.Create(_configFileInfo.FullName, settings); MyObjectBuilder_DefinitionsSerializer serializer = (MyObjectBuilder_DefinitionsSerializer)Activator.CreateInstance(typeof(MyObjectBuilder_DefinitionsSerializer)); serializer.Serialize(writer, definitions); writer.Close(); }
public void Load(FileInfo sourceFile) { m_fileInfo = sourceFile; //Get the definitions content from the file MyObjectBuilder_Definitions definitionsContainer = LoadContentFile <MyObjectBuilder_Definitions, MyObjectBuilder_DefinitionsSerializer>(m_fileInfo); if (m_definitionsContainerField == null) { throw new SEConfigurationException(SEConfigurationExceptionState.InvalidConfigurationFile, "Failed to find matching definitions field in the specified file."); } //Get the data from the definitions container MyObjectBuilder_Base[] baseDefinitions = (MyObjectBuilder_Base[])m_definitionsContainerField.GetValue(definitionsContainer); Load(baseDefinitions); }
private static bool SaveGridToFile(string SavePath, string GridName, IEnumerable <MyObjectBuilder_CubeGrid> GridBuilders) { MyObjectBuilder_ShipBlueprintDefinition definition = MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_ShipBlueprintDefinition>(); definition.Id = new MyDefinitionId(new MyObjectBuilderType(typeof(MyObjectBuilder_ShipBlueprintDefinition)), GridName); definition.CubeGrids = GridBuilders.ToArray(); //PrepareGridForSave(definition); MyObjectBuilder_Definitions builderDefinition = MyObjectBuilderSerializer.CreateNewObject <MyObjectBuilder_Definitions>(); builderDefinition.ShipBlueprints = new MyObjectBuilder_ShipBlueprintDefinition[] { definition }; Log.Warn("Saving grid @" + Path.Combine(SavePath, GridName + ".sbc")); return(MyObjectBuilderSerializer.SerializeXML(Path.Combine(SavePath, GridName + ".sbc"), false, builderDefinition)); }
private static MyBehaviorDefinition LoadBehaviorTreeFromFile(string path) { MyObjectBuilder_Definitions objectBuilder = null; MyObjectBuilderSerializer.DeserializeXML <MyObjectBuilder_Definitions>(path, out objectBuilder); if (((objectBuilder == null) || (objectBuilder.AIBehaviors == null)) || (objectBuilder.AIBehaviors.Length == 0)) { return(null); } MyObjectBuilder_BehaviorTreeDefinition builder = objectBuilder.AIBehaviors[0]; MyModContext modContext = new MyModContext(); modContext.Init("BehaviorDefinition", Path.GetFileName(path), null); MyBehaviorDefinition definition1 = new MyBehaviorDefinition(); definition1.Init(builder, modContext); return(definition1); }
private static MyBehaviorDefinition LoadBehaviorTreeFromFile(string path) { MyObjectBuilder_Definitions allDefinitions = null; MyObjectBuilderSerializer.DeserializeXML(path, out allDefinitions); if (allDefinitions != null && allDefinitions.AIBehaviors != null && allDefinitions.AIBehaviors.Length > 0) { var firstDef = allDefinitions.AIBehaviors[0]; // only one tree can be uploaded at one time MyBehaviorDefinition behaviorDefinition = new MyBehaviorDefinition(); MyModContext context = new MyModContext(); context.Init("BehaviorDefinition", Path.GetFileName(path)); behaviorDefinition.Init(firstDef, context); return(behaviorDefinition); } return(null); }
void OnSave(MyGuiControlButton button) { var ob = new MyObjectBuilder_Definitions(); var sounds = MyDefinitionManager.Static.GetSoundDefinitions(); ob.Sounds = new MyObjectBuilder_AudioDefinition[sounds.Count]; int i = 0; foreach (var sound in sounds) { ob.Sounds[i++] = (MyObjectBuilder_AudioDefinition)sound.GetObjectBuilder(); } var path = Path.Combine(MyFileSystem.ContentPath, @"Data\Audio.sbc"); MyObjectBuilderSerializer.SerializeXML(path, false, ob); }
public static bool CopyBlueprintPrefabToClipboard(MyObjectBuilder_Definitions prefab, MyGridClipboard clipboard, bool setOwner = true) { if (prefab.ShipBlueprints == null) { return(false); } var cubeGrids = prefab.ShipBlueprints[0].CubeGrids; if (cubeGrids == null || cubeGrids.Count() == 0) { return(false); } var localBB = MyCubeGridExtensions.CalculateBoundingSphere(cubeGrids[0]); var posAndOrient = cubeGrids[0].PositionAndOrientation.Value; var worldMatrix = MatrixD.CreateWorld(posAndOrient.Position, posAndOrient.Forward, posAndOrient.Up); var invertedNormalizedWorld = Matrix.Normalize(Matrix.Invert(worldMatrix)); var worldBB = localBB.Transform(worldMatrix); var dragVector = Vector3.TransformNormal((Vector3)(Vector3D)posAndOrient.Position - worldBB.Center, invertedNormalizedWorld); var dragDistance = localBB.Radius + 10f; //Reset ownership to local player if (setOwner) { foreach (var gridBuilder in cubeGrids) { foreach (var block in gridBuilder.CubeBlocks) { if (block.Owner != 0) { block.Owner = MySession.LocalPlayerId; } } } } clipboard.SetGridFromBuilders(cubeGrids, dragVector, dragDistance); clipboard.Deactivate(); return(true); }
/// <summary> /// Method to deserialize a configuration file. /// </summary> /// <returns>The deserialized definition.</returns> public MyObjectBuilder_Definitions Deserialize() { if (!_configFileInfo.Exists) { throw new SEConfigurationException(SEConfigurationExceptionState.InvalidFileInfo, "The file pointed by configFileInfo does not exists." + "\r\n" + "Cannot deserialize: " + _configFileInfo.FullName); } XmlReaderSettings settings = new XmlReaderSettings(); XmlReader reader = XmlReader.Create(_configFileInfo.FullName, settings); MyObjectBuilder_DefinitionsSerializer serializer = (MyObjectBuilder_DefinitionsSerializer)Activator.CreateInstance(typeof(MyObjectBuilder_DefinitionsSerializer)); if (!serializer.CanDeserialize(reader)) { throw new SEConfigurationException(SEConfigurationExceptionState.InvalidConfigurationFile, "The file pointed by configFileInfo cannot be deserialized: " + _configFileInfo.FullName); } MyObjectBuilder_Definitions definitions = (MyObjectBuilder_Definitions)serializer.Deserialize(reader); reader.Close(); return(definitions); }
/// <summary> /// Method to deserialize a configuration file. /// </summary> /// <returns>The deserialized definition.</returns> /// <exception cref="FileNotFoundException">Config file specified does not exist.</exception> /// <exception cref="PathTooLongException">The fully qualified path and file name is 260 or more characters.</exception> /// <exception cref="SecurityException">The caller does not have the required permission. </exception> /// <exception cref="TargetInvocationException">The constructor being called throws an exception. </exception> /// <exception cref="MethodAccessException">The caller does not have permission to call the specified constructor. </exception> /// <exception cref="MemberAccessException">Cannot create an instance of an <see langword="abstract"/> class, or this member was invoked with a late-binding mechanism. </exception> /// <exception cref="MissingMethodException">No matching public constructor was found.</exception> /// <exception cref="SerializationException">Unable to de-serialize file.</exception> public MyObjectBuilder_Definitions Deserialize() { if (!_configFileInfo.Exists) { throw new FileNotFoundException(string.Format("The file specified in configFileInfo does not exists.\r\nCannot deserialize: {0}", _configFileInfo.FullName), _configFileInfo.FullName); } XmlReaderSettings settings = new XmlReaderSettings(); XmlReader reader = XmlReader.Create(_configFileInfo.FullName, settings); MyObjectBuilder_DefinitionsSerializer serializer = (MyObjectBuilder_DefinitionsSerializer)Activator.CreateInstance(typeof(MyObjectBuilder_DefinitionsSerializer)); if (!serializer.CanDeserialize(reader)) { throw new SerializationException(string.Format("The file specified in configFileInfo cannot be deserialized: {0}", _configFileInfo.FullName)); } MyObjectBuilder_Definitions definitions = (MyObjectBuilder_Definitions)serializer.Deserialize(reader); reader.Close(); return(definitions); }
public void Load(FileInfo sourceFile) { m_fileInfo = sourceFile; //Get the definitions content from the file MyObjectBuilder_Definitions definitionsContainer = LoadContentFile <MyObjectBuilder_Definitions, MyObjectBuilder_DefinitionsSerializer>(m_fileInfo); if (m_definitionsContainerField == null) { throw new SEConfigurationException(SEConfigurationExceptionState.InvalidConfigurationFile, "Failed to find matching definitions field in the specified file."); } //Get the data from the definitions container T[] baseDefinitions = (T[])m_definitionsContainerField.GetValue(definitionsContainer); //Copy the data into the manager GetInternalData().Clear(); foreach (T definition in baseDefinitions) { NewEntry(definition); } }
private MyObjectBuilder_Definitions LoadAllDefinitionsZip(string stockContentPath, string zipModFile, ref Dictionary <string, ContentDataPath> contentData) { var zipFiles = ZipTools.ExtractZipContentList(zipModFile, null); var definitions = new MyObjectBuilder_Definitions(); if (!zipFiles.Any(f => Path.GetDirectoryName(f).Equals("Data", StringComparison.InvariantCultureIgnoreCase))) { return(definitions); } var files = zipFiles.Where(f => Path.GetDirectoryName(f).Equals("Data", StringComparison.InvariantCultureIgnoreCase) && Path.GetExtension(f).Equals(".sbc", StringComparison.InvariantCultureIgnoreCase)).ToArray(); foreach (var filePath in files) { MyObjectBuilder_Definitions stockTemp = null; try { using (var stream = ZipTools.ExtractZipFileToSteam(zipModFile, null, filePath)) { stockTemp = SpaceEngineersApi.ReadSpaceEngineersFile <MyObjectBuilder_Definitions>(stream); } } catch (Exception ex) { // ignore errors, keep on trucking just like SE. // write event log warning of any files not loaded. DiagnosticsLogging.LogWarning(string.Format(Res.ExceptionState_CorruptContentFile, filePath), ex); } if (stockTemp != null) { MergeDefinitions(ref definitions, stockTemp); } } LoadContent(stockContentPath, null, zipModFile, zipFiles, definitions, ref contentData); return(definitions); }
private void MergeDefinitions(ref MyObjectBuilder_Definitions baseDefinitions, MyObjectBuilder_Definitions newDefinitions) { var fields = newDefinitions.GetType().GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance); foreach (var field in fields) { var readValues = field.GetValue(newDefinitions); if (readValues != null) { var currentValues = field.GetValue(baseDefinitions); if (currentValues == null || !field.FieldType.IsArray) { field.SetValue(baseDefinitions, readValues); } else { // Merge together multiple values from seperate files. var newArray = ArrayHelper.MergeGenericArrays(currentValues, readValues); field.SetValue(baseDefinitions, newArray); } } } }
public void LoadParticlesLibrary(string file) { if (file.Contains(".mwl")) { MyParticlesLibrary.Deserialize(file); } else { MyDataIntegrityChecker.HashInFile(file); MyObjectBuilder_Definitions objectBuilder = null; MyObjectBuilderSerializer.DeserializeXML <MyObjectBuilder_Definitions>(file, out objectBuilder); if ((objectBuilder != null) && (objectBuilder.ParticleEffects != null)) { MyParticlesLibrary.Close(); foreach (MyObjectBuilder_ParticleEffect effect in objectBuilder.ParticleEffects) { MyParticleEffect local1 = MyParticlesManager.EffectsPool.Allocate(false); local1.DeserializeFromObjectBuilder(effect); MyParticlesLibrary.AddParticleEffect(local1); } } } }
private MyObjectBuilder_Definitions LoadAllDefinitions(string stockContentPath, string modContentPath, ref Dictionary <string, ContentDataPath> contentData) { var searchPath = Path.Combine(modContentPath, "Data"); var definitions = new MyObjectBuilder_Definitions(); if (!Directory.Exists(searchPath)) { return(definitions); } var files = Directory.GetFiles(searchPath, "*.sbc"); foreach (var filePath in files) { MyObjectBuilder_Definitions stockTemp = null; try { bool isCompressed; stockTemp = SpaceEngineersApi.ReadSpaceEngineersFile <MyObjectBuilder_Definitions>(filePath, out isCompressed); } catch (Exception ex) { // ignore errors, keep on trucking just like SE. // write event log warning of any files not loaded. DiagnosticsLogging.LogWarning(string.Format(Res.ExceptionState_CorruptContentFile, filePath), ex); } if (stockTemp != null) { MergeDefinitions(ref definitions, stockTemp); } } LoadContent(stockContentPath, modContentPath, null, null, definitions, ref contentData); return(definitions); }
public bool Save() { if (!this.Changed) { return(false); } if (!this.IsMutable) { return(false); } if (this.FileInfo == null) { return(false); } MyObjectBuilder_Definitions definitionsContainer = new MyObjectBuilder_Definitions(); if (m_definitionsContainerField == null) { throw new GameInstallationInfoException(GameInstallationInfoExceptionState.Invalid, "Failed to find matching definitions field in the given file."); } List <MyObjectBuilder_Base> baseDefs = new List <MyObjectBuilder_Base>(); foreach (var baseObject in GetInternalData().Values) { baseDefs.Add(baseObject.ObjectBuilder); } //Save the source data into the definitions container m_definitionsContainerField.SetValue(definitionsContainer, baseDefs.ToArray()); //Save the definitions container out to the file SaveContentFile <MyObjectBuilder_Definitions, MyObjectBuilder_DefinitionsSerializer>(definitionsContainer, m_fileInfo); return(true); }
public void CallLoadPrefab(WorkData workData) { m_prefab = LoadPrefab(m_path); CallOnPrefabLoaded(); }
public void CallLoadWorkshopPrefab(WorkData workData) { m_prefab = LoadWorkshopPrefab(m_path, m_id); CallOnPrefabLoaded(); }
internal void OnPrefabLoaded(MyObjectBuilder_Definitions prefab) { if (prefab != null) { if (MySandboxGame.Static.SessionCompatHelper != null) { MySandboxGame.Static.SessionCompatHelper.CheckAndFixPrefab(prefab); } if (CheckBlueprintForMods(prefab) == false) { MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox( buttonType: MyMessageBoxButtonsType.YES_NO, styleEnum: MyMessageBoxStyleEnum.Info, messageCaption: MyTexts.Get(MyCommonTexts.MessageBoxCaptionWarning), messageText: MyTexts.Get(MyCommonTexts.MessageBoxTextDoYouWantToPasteGridWithMissingBlocks), callback: result => { if (result == MyGuiScreenMessageBox.ResultEnum.YES) { if (CopyBlueprintPrefabToClipboard(prefab, m_clipboard)) { CloseScreen(); } } })); } else { if (CopyBlueprintPrefabToClipboard(prefab, m_clipboard)) CloseScreen(); } } else { MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox( buttonType: MyMessageBoxButtonsType.OK, styleEnum: MyMessageBoxStyleEnum.Error, messageCaption: new StringBuilder("Error"), messageText: new StringBuilder("Failed to load the blueprint file.") )); } }
public static void Publish(MyObjectBuilder_Definitions prefab, string blueprintName, Action<ulong> publishCallback = null) { string file = Path.Combine(m_localBlueprintFolder, blueprintName); string title = prefab.ShipBlueprints[0].CubeGrids[0].DisplayName; string description = prefab.ShipBlueprints[0].Description; ulong publishId = prefab.ShipBlueprints[0].WorkshopId; MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox( styleEnum: MyMessageBoxStyleEnum.Info, buttonType: MyMessageBoxButtonsType.YES_NO, messageCaption: new StringBuilder("Publish"), messageText: new StringBuilder("Do you want to publish this blueprint?"), callback: delegate(MyGuiScreenMessageBox.ResultEnum val) { if (val == MyGuiScreenMessageBox.ResultEnum.YES) { Action<MyGuiScreenMessageBox.ResultEnum, string[]> onTagsChosen = delegate(MyGuiScreenMessageBox.ResultEnum tagsResult, string[] outTags) { if (tagsResult == MyGuiScreenMessageBox.ResultEnum.YES) { MySteamWorkshop.PublishBlueprintAsync(file, title, description, publishId, outTags, SteamSDK.PublishedFileVisibility.Public, callbackOnFinished: delegate(bool success, Result result, ulong publishedFileId) { if (success) { if (publishCallback != null) publishCallback(publishedFileId); prefab.ShipBlueprints[0].WorkshopId = publishedFileId; SavePrefabToFile(prefab, blueprintName, true); MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox( styleEnum: MyMessageBoxStyleEnum.Info, messageText: MyTexts.Get(MyCommonTexts.MessageBoxTextWorldPublished), messageCaption: new StringBuilder("BLUEPRINT PUBLISHED"), callback: (a) => { MySteam.API.OpenOverlayUrl(string.Format("http://steamcommunity.com/sharedfiles/filedetails/?id={0}", publishedFileId)); })); } else { MyStringId error; switch (result) { case Result.AccessDenied: error = MyCommonTexts.MessageBoxTextPublishFailed_AccessDenied; break; default: error = MyCommonTexts.MessageBoxTextWorldPublishFailed; break; } MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox( messageText: MyTexts.Get(error), messageCaption: MyTexts.Get(MyCommonTexts.MessageBoxCaptionWorldPublishFailed))); } }); } }; if (MySteamWorkshop.BlueprintCategories.Length > 0) MyGuiSandbox.AddScreen(new MyGuiScreenWorkshopTags(MySteamWorkshop.WORKSHOP_BLUEPRINT_TAG, MySteamWorkshop.BlueprintCategories, null, onTagsChosen)); else onTagsChosen(MyGuiScreenMessageBox.ResultEnum.YES, new string[] { MySteamWorkshop.WORKSHOP_BLUEPRINT_TAG }); } })); }
protected static void SavePrefabToFile(MyObjectBuilder_Definitions prefab, string name, bool replace = false, MyBlueprintTypeEnum type = MyBlueprintTypeEnum.LOCAL) { //if (name == null) //{ // name = MyUtils.StripInvalidChars(MyCubeBuilder.Static.Clipboard.CopiedGridsName); //} Debug.Assert(name != null, "Name cannot be null"); string file = ""; if (type == MyBlueprintTypeEnum.LOCAL) { file = Path.Combine(m_localBlueprintFolder, name); } else { file = Path.Combine(m_workshopBlueprintFolder, "temp", name); } string filePath = ""; int index = 1; try { if (!replace) { while (MyFileSystem.DirectoryExists(file)) { file = Path.Combine(m_localBlueprintFolder, name + "_" + index); index++; } if (index > 1) { name += new StringBuilder("_" + (index - 1)); } } filePath = file + "\\bp.sbc"; var success = MyObjectBuilderSerializer.SerializeXML(filePath, false, prefab); Debug.Assert(success, "falied to write blueprint to file"); if (!success) { MyGuiSandbox.AddScreen(MyGuiSandbox.CreateMessageBox( buttonType: MyMessageBoxButtonsType.OK, styleEnum: MyMessageBoxStyleEnum.Error, messageCaption: new StringBuilder("Error"), messageText: new StringBuilder("There was a problem with saving blueprint") )); if (Directory.Exists(file)) Directory.Delete(file, true); } } catch (Exception e) { MySandboxGame.Log.WriteLine(String.Format("Failed to write prefab at file {0}, message: {1}, stack:{2}", filePath, e.Message, e.StackTrace)); } }
/// <summary> /// Method to serialize a configuration file. /// </summary> /// <param name="definitions">The definition to serialize.</param> public void Serialize(MyObjectBuilder_Definitions definitions) { MyObjectBuilderSerializer.SerializeXML( _configFileInfo.FullName, false, definitions ); }
public LoadPrefabData(MyObjectBuilder_Definitions prefab, string path, MyGuiBlueprintScreen blueprintScreen, ulong? id = null) { m_prefab = prefab; m_path = path; m_blueprintScreen = blueprintScreen; m_id = id; }
static bool CheckBlueprintForMods(MyObjectBuilder_Definitions prefab) { if (prefab.ShipBlueprints == null) return true; var cubeGrids = prefab.ShipBlueprints[0].CubeGrids; if (cubeGrids == null || cubeGrids.Length == 0) return true; foreach (var gridBuilder in cubeGrids) { foreach (var block in gridBuilder.CubeBlocks) { var defId = block.GetId(); MyCubeBlockDefinition blockDefinition = null; if (MyDefinitionManager.Static.TryGetCubeBlockDefinition(defId, out blockDefinition) == false) { return false; } } } return true; }
public virtual void CheckAndFixPrefab(MyObjectBuilder_Definitions prefab) { }
public static bool CopyBlueprintPrefabToClipboard(MyObjectBuilder_Definitions prefab, MyGridClipboard clipboard, bool setOwner = true) { if (prefab.ShipBlueprints == null) return false; var cubeGrids = prefab.ShipBlueprints[0].CubeGrids; if (cubeGrids == null || cubeGrids.Length == 0) return false; var localBB = MyCubeGridExtensions.CalculateBoundingSphere(cubeGrids[0]); var posAndOrient = cubeGrids[0].PositionAndOrientation.Value; var worldMatrix = MatrixD.CreateWorld(posAndOrient.Position, posAndOrient.Forward, posAndOrient.Up); var invertedNormalizedWorld = Matrix.Normalize(Matrix.Invert(worldMatrix)); var worldBB = localBB.Transform(worldMatrix); var dragVector = Vector3.TransformNormal((Vector3)(Vector3D)posAndOrient.Position - worldBB.Center, invertedNormalizedWorld); var dragDistance = localBB.Radius + 10f; //Reset ownership to local player if (setOwner) { foreach (var gridBuilder in cubeGrids) { foreach (var block in gridBuilder.CubeBlocks) { if (block.Owner != 0) { block.Owner = MySession.Static.LocalPlayerId; } } } } // Blueprint can have old (deprecated) fractured blocks, they have to be converted to fracture components. There is no version in blueprints. if (MyFakes.ENABLE_FRACTURE_COMPONENT) { for (int i = 0; i < cubeGrids.Length; ++i) { cubeGrids[i] = MyFracturedBlock.ConvertFracturedBlocksToComponents(cubeGrids[i]); } } clipboard.SetGridFromBuilders(cubeGrids, dragVector, dragDistance); clipboard.Deactivate(); return true; }