public void testSerializationAndDeserialization() { // set up board Board board = new Board(5, 5, 4); for (int i = 0; i < 4; i++) { board.SetBombState(i, 0, 0, true); } board.SetBombState(0, 0, 0, false); board.SetBombState(2, 2, 2, false); board[0, 1, 2].Highlighted = true; // serialize Board string json = GameSerializer.serialize(new GameRepresentation(board, new PlayerStats())); // deserialize again and check if the values are still the same GameRepresentation grep = GameSerializer.deserialize(json); Assert.AreEqual(grep.board[0, 1, 2].PosX, 0); Assert.AreEqual(grep.board[0, 1, 2].PosY, 1); Assert.AreEqual(grep.board[0, 1, 2].PosZ, 2);// Assert.AreEqual(grep.board[0, 0, 0].IsBomb, false, "huh..."); Assert.AreEqual(grep.board[1, 0, 0].IsBomb, true, "hmm..."); Assert.AreEqual(grep.board[2, 2, 2].IsBomb, false, "heh."); Assert.AreEqual(grep.board[0, 1, 2].Highlighted, true, "huh..."); }
public void ExportGame() { var builder = new PackageBuilder() { Id = Game.Id.ToString(), Description = Game.Description, ProjectUrl = new Uri(Game.GameUrl), Version = new NuGetVersion(Game.Version), Title = Game.Name, IconUrl = new Uri(Game.IconUrl), }; foreach (var a in Game.Authors) { builder.Authors.Add(a); } foreach (var t in Game.Tags) { builder.Authors.Add(t); } var g = new GameSerializer(); g.Serialize(Game); var feedPath = Path.Combine(GamePath, Game.Name + '-' + Game.Version + ".nupkg"); var filestream = File.Open(feedPath, FileMode.Create, FileAccess.ReadWrite, FileShare.None); builder.Save(filestream); filestream.Flush(true); filestream.Close(); }
public GameObject Load(LevelResAsset lightmapAsset) { GameObject result = null; if (lightmapAsset != null) { if (!(lightmapAsset.levelDom != null)) { return(null); } TextAsset levelDom = lightmapAsset.levelDom; BinaryDomDocument document = new BinaryDomDocument(levelDom.bytes); result = GameSerializer.Load(document); int num = lightmapAsset.lightmapFar.Length; LightmapData[] array = new LightmapData[num]; for (int i = 0; i < num; i++) { array[i] = new LightmapData { lightmapFar = lightmapAsset.lightmapFar[i], lightmapNear = lightmapAsset.lightmapNear[i] }; } LightmapSettings.lightmaps = array; } return(result); }
private static void InitComponets(BinaryNode domNode, GameObject go) { Component[] components = go.GetComponents(typeof(Component)); for (int i = 0; i < domNode.GetChildNum(); i++) { BinaryNode child = domNode.GetChild(i); if (!(child.GetName() != "Cop")) { string nodeAttr = GameSerializer.GetNodeAttr(child, "Type"); Component x = null; for (int j = 0; j < components.Length; j++) { if (!GameSerializer.isNull(components[j])) { string pureType = GameSerializer.GetPureType(components[j].GetType().ToString()); if (pureType.Equals(nodeAttr)) { x = components[j]; break; } } } if (x == null) { x = go.AddComponent(GameSerializer.GetType(nodeAttr)); } } } }
public void LoadGame(FileInfo path) { NeedsSave = false; _workingDirectory = path.Directory; var files = WorkingDirectory.GetFiles("*.*", SearchOption.AllDirectories); foreach (var file in files) { var asset = ViewModelLocator.AssetsTabViewModel.LoadAsset(file); if (file.FullName == path.FullName) { // registers the game definition asset var gameSerializer = new GameSerializer(); Game = (Game)gameSerializer.Deserialize(path.FullName); Asset = new AssetController(AssetType.Xml); asset.LockName = true; asset.IsReserved = true; Asset.SelectedAsset = asset; Asset.PropertyChanged += AssetUpdated; { }; } } }
public void ObjectDeserialize(ref object o, BinaryNode node) { byte[] binaryAttribute = GameSerializer.GetBinaryAttribute(node, "Value"); Quaternion quaternion = (Quaternion)o; UnityBasetypeSerializer.BytesToQuaternion(ref quaternion, binaryAttribute); o = quaternion; }
public void ObjectDeserialize(ref object o, BinaryNode node) { byte[] binaryAttribute = GameSerializer.GetBinaryAttribute(node, "Value"); Rect rect = (Rect)o; UnityBasetypeSerializer.BytesToRect(ref rect, binaryAttribute); o = rect; }
public void ObjectDeserialize(ref object o, BinaryNode node) { byte[] binaryAttribute = GameSerializer.GetBinaryAttribute(node, "Value"); Matrix4x4 matrix = (Matrix4x4)o; UnityBasetypeSerializer.BytesToMatrix4x4(ref matrix, binaryAttribute); o = matrix; }
public void ObjectDeserialize(ref object o, BinaryNode node) { byte[] binaryAttribute = GameSerializer.GetBinaryAttribute(node, "Value"); Bounds bounds = (Bounds)o; UnityBasetypeSerializer.BytesToBounds(ref bounds, binaryAttribute); o = bounds; }
public void ComponentDeserialize(Component cmp, BinaryNode node) { SphereCollider sphereCollider = cmp as SphereCollider; sphereCollider.center = UnityBasetypeSerializer.BytesToVector3(GameSerializer.GetBinaryAttribute(node, "center")); sphereCollider.radius = UnityBasetypeSerializer.BytesToFloat(GameSerializer.GetBinaryAttribute(node, "radius")); sphereCollider.isTrigger = bool.Parse(GameSerializer.GetAttribute(node, "trigger")); }
public void ObjectDeserialize(ref object o, BinaryNode node) { byte[] binaryAttribute = GameSerializer.GetBinaryAttribute(node, "Value"); Color color = (Color)o; UnityBasetypeSerializer.BytesToColor(ref color, binaryAttribute); o = color; }
public void ComponentDeserialize(Component cmp, BinaryNode node) { BoxCollider collider = cmp as BoxCollider; collider.center = UnityBasetypeSerializer.BytesToVector3(GameSerializer.GetBinaryAttribute(node, "center")); collider.size = UnityBasetypeSerializer.BytesToVector3(GameSerializer.GetBinaryAttribute(node, "size")); collider.isTrigger = bool.Parse(GameSerializer.GetAttribute(node, "trigger")); }
public void ObjectDeserialize(ref object o, BinaryNode node) { byte[] binaryAttribute = GameSerializer.GetBinaryAttribute(node, "Value"); Vector2 vector = default(Vector2); UnityBasetypeSerializer.BytesToVector2(ref vector, binaryAttribute); o = vector; }
public static void DeleteSave() { var path = GameSerializer.GetPath(); if (File.Exists(path)) { File.Delete(path); } }
private static void LoadRecursionTwice(GameObject parentGo, BinaryNode domNode, GameObject go) { if (domNode == domNode.OwnerDocument.Root) { GameSerializer.LoadComponets(domNode, go); int num = -1; for (int i = 0; i < domNode.GetChildNum(); i++) { BinaryNode child = domNode.GetChild(i); if (child.GetName() == "CHD") { num++; GameObject gameObject = go.transform.GetChild(num).gameObject; if (!(gameObject == null)) { GameSerializer.LoadRecursionTwice(null, child, gameObject); } } } } else { BinaryNode parentNode = domNode.ParentNode; for (int j = 0; j < parentNode.GetChildNum(); j++) { BinaryNode child2 = parentNode.GetChild(j); if (!(child2.GetName() != "CHD")) { string attribute = GameSerializer.GetAttribute(child2, "ON"); if (!(attribute != go.name)) { GameSerializer.LoadComponets(child2, go); if (child2.GetChildNum() > 0 && go.transform.childCount > 0) { BinaryNode child3 = child2.GetChild(0); for (int k = 0; k < go.transform.childCount; k++) { GameObject gameObject2 = go.transform.GetChild(k).gameObject; GameSerializer.LoadRecursionTwice(null, child3, gameObject2); } } domNode = child2; } } } } string nodeAttr = GameSerializer.GetNodeAttr(domNode, "DIS"); if (nodeAttr != null) { go.SetActive(false); } else { go.SetActive(true); } }
public void ComponentDeserialize(Component o, BinaryNode node) { AstarPath astarPath = (AstarPath)o; astarPath.astarData = new AstarData(); astarPath.astarData.cacheStartup = bool.Parse(GameSerializer.GetNodeAttr(node, this.XML_ATTR_CACHE_AT_START_UP)); ((AstarPath)o).logPathResults = PathLog.OnlyErrors; astarPath.astarData.data_cachedStartup = node.GetValue(); astarPath.astarData.cacheStartup = true; }
public void ComponentDeserialize(Component cmp, BinaryNode node) { CapsuleCollider capsuleCollider = cmp as CapsuleCollider; capsuleCollider.center = UnityBasetypeSerializer.BytesToVector3(GameSerializer.GetBinaryAttribute(node, "center")); capsuleCollider.radius = UnityBasetypeSerializer.BytesToFloat(GameSerializer.GetBinaryAttribute(node, "radius")); capsuleCollider.height = UnityBasetypeSerializer.BytesToFloat(GameSerializer.GetBinaryAttribute(node, "height")); capsuleCollider.direction = UnityBasetypeSerializer.BytesToInt(GameSerializer.GetBinaryAttribute(node, "dir")); capsuleCollider.isTrigger = bool.Parse(GameSerializer.GetAttribute(node, "trigger")); }
public void ObjectDeserialize(ref object o, BinaryNode node) { IList list = (IList)o; int childNum = node.GetChildNum(); for (int i = 0; i < childNum; i++) { list.Add(GameSerializer.GetObject(node.GetChild(i))); } }
public void BuildPgn_TestVariousPositionsAndVariations(PgnFormatterVariationTestCase testCase) { Console.WriteLine(testCase.ExpectedPgn); var expected = string.Format(testCase.ExpectedPgn, options.NewLineIndicator); GameSerializer gs = new GameSerializer(new PGNFormatterOptions()); var actual = gs.SerializeToString(testCase.Game); Console.WriteLine(actual); Assert.AreEqual(expected, actual, testCase.ToString()); }
public SerializableGameViewModel([NotNull] GameConfig config) { Assert.IsNotNull(config); _serializer = new GameSerializer(); var model = _serializer.TryLoad(); ViewModel = GameViewModel.Create(config, model); Observable.Timer(TimeSpan.FromSeconds(30)) .Subscribe(_ => Save()); }
private Guid GetGameId() { var xmlPath = Details.Path; var serializer = new GameSerializer(); var game = (Game)serializer.Deserialize(xmlPath); return(game.Id); }
public void ComponentDeserialize(Component o, BinaryNode node) { RectTransform rectTransform = o as RectTransform; rectTransform.localScale = new Vector3(float.Parse(GameSerializer.GetAttribute(node, "SX")), float.Parse(GameSerializer.GetAttribute(node, "SY")), float.Parse(GameSerializer.GetAttribute(node, "SZ"))); rectTransform.localRotation = new Quaternion(float.Parse(GameSerializer.GetAttribute(node, "RX")), float.Parse(GameSerializer.GetAttribute(node, "RY")), float.Parse(GameSerializer.GetAttribute(node, "RZ")), float.Parse(GameSerializer.GetAttribute(node, "RW"))); rectTransform.anchorMin = new Vector2(float.Parse(GameSerializer.GetAttribute(node, "anchorMinX")), float.Parse(GameSerializer.GetAttribute(node, "anchorMinY"))); rectTransform.anchorMax = new Vector2(float.Parse(GameSerializer.GetAttribute(node, "anchorMaxX")), float.Parse(GameSerializer.GetAttribute(node, "anchorMaxY"))); rectTransform.offsetMin = new Vector2(float.Parse(GameSerializer.GetAttribute(node, "offsetMinX")), float.Parse(GameSerializer.GetAttribute(node, "offsetMinY"))); rectTransform.offsetMax = new Vector2(float.Parse(GameSerializer.GetAttribute(node, "offsetMaxX")), float.Parse(GameSerializer.GetAttribute(node, "offsetMaxY"))); }
private void saveExecute() { string playerSaveFile = Path.Combine(dataDir, "players.elo"); List <PlayerSerializer> pSerials = PlayerSerializer.SerializeList(Players); Serializer <PlayerSerializer> .Save(pSerials, playerSaveFile); string gameSaveFile = Path.Combine(dataDir, "games.elo"); List <GameSerializer> gSerials = GameSerializer.SerializeList(History.GameHistory); Serializer <GameSerializer> .Save(gSerials, gameSaveFile); }
/// <summary> /// Initializes the object and all control elements of the game. /// </summary> private GameObjectManager() { teamMgr = new TeamManager(); fightMgr = new FightManager(); objectCreator = new ObjectCreator(); moveMgr = new MoveManager(); groupMgr = new GroupManager(); propertyMgr = new PropertyManager(); hitTest = new HitTest(); solarSystemMgr = new SolarSystemManager(); gameSerializer = new GameSerializer(); }
private static void LoadComponets(BinaryNode domNode, GameObject go) { for (int i = 0; i < domNode.GetChildNum(); i++) { BinaryNode child = domNode.GetChild(i); if (!(child.GetName() != "Cop")) { string nodeAttr = GameSerializer.GetNodeAttr(child, "Type"); Component component = go.GetComponent(nodeAttr); if (!(component == null)) { string nodeAttr2 = GameSerializer.GetNodeAttr(child, "DIS"); if (nodeAttr2 != null && component is Behaviour) { Behaviour behaviour = (Behaviour)component; behaviour.enabled = false; } ICustomizedComponentSerializer componentSerlizer = GameSerializer.GetComponentSerlizer(component.GetType()); if (componentSerlizer != null) { componentSerlizer.ComponentDeserialize(component, child); } else { MemberInfo[] members = component.GetType().GetMembers(); for (int j = 0; j < members.Length; j++) { if (GameSerializer.IsMINeedExport(members[j])) { BinaryNode binaryNode = child.SelectSingleNode(members[j].get_Name()); if (binaryNode != null) { object @object = GameSerializer.GetObject(binaryNode); try { if (@object != null) { GameSerializer.SetMIValue(members[j], component, @object); } } catch (Exception var_11_F4) { } } } } } } } } }
public void GameCanBeSerializedAndDeserialized() { var gs = new GameSerializer(); var h = new GameHistory(new[] { BoardState.ClassicInitialState }, Array.Empty <Turn>()); string s = gs.Serialize(h, Color.White); Assert.Contains("King", s); Assert.Contains("White", s); var(dh, _) = gs.Deserialize(s); Assert.Equal((Figure.Pawn, Color.White), dh.States.Single()[Cell.At('E', 2)]); }
public bool Load(string name) { Debug.Log("Loading to {name}"); Clear(); bool res = GameSerializer.Load(name, (Vector3 pos) => CreateNode(pos), (GameObject f, GameObject t) => CreateEdge(f, t)); current = graph.GetRoot(); Start(); return(res); }
public bool SerializeXmlAssets() { try { var gameTempPath = Path.Combine(ViewModelLocator.AssetsTabViewModel.AssetTempDirectory.FullName, Guid.NewGuid().ToString() + ".xml"); var gameSerializer = new GameSerializer(); gameSerializer.OutputPath = gameTempPath; gameSerializer.Serialize(Game); Asset.SelectedAsset.SafeFile = new FileInfo(gameTempPath); var setSerializer = new SetSerializer() { Game = Game }; foreach (SetModel set in ViewModelLocator.SetTabViewModel.Items) { var setTempPath = Path.Combine(ViewModelLocator.AssetsTabViewModel.AssetTempDirectory.FullName, Guid.NewGuid().ToString() + ".xml"); setSerializer.OutputPath = setTempPath; setSerializer.Serialize(set._set); set.Asset.SelectedAsset.SafeFile = new FileInfo(setTempPath); } var scriptSerializer = new GameScriptSerializer(Game.Id) { Game = Game }; foreach (ScriptItemModel script in ViewModelLocator.ScriptsTabViewModel.Scripts) { scriptSerializer.OutputPath = script.Asset.SafePath; scriptSerializer.Serialize(script._script); } var proxyTempPath = Path.Combine(ViewModelLocator.AssetsTabViewModel.AssetTempDirectory.FullName, Guid.NewGuid().ToString() + ".xml"); var proxySerializer = new ProxyGeneratorSerializer(Game.Id) { Game = Game }; proxySerializer.OutputPath = proxyTempPath; proxySerializer.Serialize(ViewModelLocator.ProxyTabViewModel._proxydef); ViewModelLocator.ProxyTabViewModel.Asset.SelectedAsset.SafeFile = new FileInfo(proxyTempPath); return(true); } catch { return(false); } }
/// <summary> /// Allows the game to perform any initialization it needs to before starting to run. /// This is where it can query for any required services and load any non-graphic /// related content. Calling base.Initialize will enumerate through any components /// and initialize them as well. /// </summary> protected override void Initialize() { // TODO: Add your initialization logic here graphics.PreferredBackBufferWidth = 800; graphics.PreferredBackBufferHeight = 600; RasterizerState customState = new RasterizerState(); graphics.GraphicsDevice.RasterizerState = customState; graphics.ApplyChanges(); ComponentRecord.RegisterAttribute <Sprite>("Sprite"); ComponentRecord.RegisterAttribute <AnimatedSprite>("AnimatedSprite"); ComponentRecord.RegisterAttribute <Transform>("Transform"); ComponentRecord.RegisterAttribute <GUIButton>("GUIButton"); ComponentRecord.RegisterAttribute <GUILabel>("GUILabel"); ComponentRecord.RegisterAttribute <GUITextBox>("GUITextBox"); ComponentRecord.RegisterAttribute <GUIImage>("GUIImage"); ComponentRecord.RegisterAttribute <AABBCollider>("AABBCollider"); ComponentRecord.RegisterAttribute <SATCollider>("SATCollider"); ComponentRecord.RegisterAttribute <CharacterController>("CharacterController"); Debug.InitializeDebug(GraphicsDevice, this); DebugConsole.DebugConsoleInit(this, graphics); GameSerializer.Init(this); GameScript.InitGameScript(); Transform.UpdateGraphicsSize(graphics); InputManager.InitInputManager(this); Camera.InitCamera(graphics); GUILabel.Initialize(this); Exiting += new EventHandler <EventArgs>((object obj, EventArgs args) => { Debug.CloseDebug(); }); DebugConsole.RegisterCommand("reset", (string[] args) => { reset(); }); w = new World(); this.IsMouseVisible = true; base.Initialize(); }
public void ComponentDeserialize(Component cmp, BinaryNode node) { Camera camera = (Camera)cmp; camera.clearFlags = (CameraClearFlags)int.Parse(GameSerializer.GetNodeAttr(node, "clear_flags")); camera.cullingMask = int.Parse(GameSerializer.GetNodeAttr(node, "cullingMask")); camera.fieldOfView = float.Parse(GameSerializer.GetNodeAttr(node, "fieldOfView")); camera.nearClipPlane = float.Parse(GameSerializer.GetNodeAttr(node, "nearClipPlane")); camera.farClipPlane = float.Parse(GameSerializer.GetNodeAttr(node, "farClipPlane")); camera.pixelRect = UnityBasetypeSerializer.StringToRect(GameSerializer.GetNodeAttr(node, "pixelRect")); camera.rect = UnityBasetypeSerializer.StringToRect(GameSerializer.GetNodeAttr(node, "rect")); camera.depth = float.Parse(GameSerializer.GetNodeAttr(node, "depth")); camera.renderingPath = (RenderingPath)int.Parse(GameSerializer.GetNodeAttr(node, "renderingPath")); camera.useOcclusionCulling = bool.Parse(GameSerializer.GetNodeAttr(node, "useOcclusionCulling")); camera.hdr = bool.Parse(GameSerializer.GetNodeAttr(node, "hdr")); }
private void toPGNToolStripMenuItem1_Click(object sender, EventArgs e) { // Prompt for where to save file if (saveDiag.ShowDialog() == DialogResult.OK) { // Open stream and serializer StreamWriter stream = new StreamWriter(new FileStream(saveDiag.FileName, FileMode.Append)); GameSerializer s = new GameSerializer(); try { // Format, write and close s.ToStream(new PGNSerializer(), this.game, stream); } catch (Exception ex) { MessageBox.Show(ex.Message); } } }