public void ReadLayout(string xmlText) { xmlr = new PT_XMLReader(); xmlr.Parse(xmlText); xml = xmlr.xml["xml"] [0]; multiplier.x = float.Parse(xml["multiplier"][0].att("x")); multiplier.y = float.Parse(xml["multiplier"][0].att("y")); SlotDef tSD; PT_XMLHashList slotsX = xml["slot"]; for (int i = 0; i < slotsX.Count; i++) { tSD = new SlotDef(); if (slotsX[i].HasAtt("type")) { tSD.type = slotsX[i].att("type"); } else { tSD.type = "slot"; } tSD.x = float.Parse(slotsX[i].att("x")); tSD.y = float.Parse(slotsX[i].att("y")); tSD.layerID = int.Parse(slotsX[i].att("layer")); tSD.layerName = sortingLayerNames[tSD.layerID]; switch (tSD.type) { case "slot": tSD.faceUp = (slotsX[i].att("faceup") == "1"); tSD.id = int.Parse(slotsX[i].att("id")); if (slotsX[i].HasAtt("hiddenby")) { string[] hiding = slotsX[i].att("hiddenby").Split(','); foreach (string s in hiding) { tSD.hiddenBy.Add(int.Parse(s)); } } slotDefs.Add(tSD); break; case "drawpile": tSD.stagger.x = float.Parse(slotsX[i].att("xstagger")); drawPile = tSD; break; case "discardpile": discardPile = tSD; break; } } }
public void ReadLayout(string xmlText) { xmlr = new PT_XMLReader(); xmlr.Parse(xmlText); xml = xmlr.xml["xml"][0]; multiplier.x = float.Parse(xml["multiplier"][0].att("x")); multiplier.y = float.Parse(xml["multiplier"][0].att("y")); SlotDef tSD; PT_XMLHashList slotsX = xml["slot"]; for (int i = 0; i < slotsX.Count; i++) { tSD = new SlotDef(); if (slotsX[i].HasAtt("type")) { tSD.type = slotsX[i].att("type"); } else { tSD.type = "slot"; } tSD.x = float.Parse(slotsX[i].att("x")); tSD.y = float.Parse(slotsX[i].att("y")); tSD.pos = new Vector3(tSD.x * multiplier.x, tSD.y * multiplier.y, 0); // Sorting Layers tSD.layerID = int.Parse(slotsX[i].att("layer")); tSD.layerName = tSD.layerID.ToString(); switch (tSD.type) { case "slot": break; case "drawpile": tSD.stagger.x = float.Parse(slotsX[i].att("xstagger")); drawPile = tSD; break; case "discardpile": discardPile = tSD; break; case "target": target = tSD; break; case "hand": tSD.player = int.Parse(slotsX[i].att("player")); tSD.rot = float.Parse(slotsX[i].att("rot")); slotDefs.Add(tSD); break; } } }
public void ReadLayout(string xmlText) { xmlr = new PT_XMLReader(); xmlr.Parse(xmlText); xml = xmlr.xml["xml"][0]; multiplier.x = float.Parse(xml["multiplier"][0].att("x")); multiplier.y = float.Parse(xml["multiplier"][0].att("y")); SlotDefMatching tSD; PT_XMLHashList slotsX = xml["slot"]; for (int i = 0; i < slotsX.Count; i++) { tSD = new SlotDefMatching(); if (slotsX[i].HasAtt("type")) { tSD.type = slotsX[i].att("type"); } else { tSD.type = "slot"; } tSD.x = float.Parse(slotsX[i].att("x")); tSD.y = float.Parse(slotsX[i].att("y")); tSD.pos = new Vector3(tSD.x * multiplier.x, tSD.y * multiplier.y, 0); tSD.layerID = int.Parse(slotsX[i].att("layer")); tSD.layerName = tSD.layerID.ToString(); switch (tSD.type) { case "slot": tSD.id = int.Parse(slotsX[i].att("id")); tSD.faceUp = (slotsX[i].att("faceup") == "1"); if (tSD.id <= 25) { cardGroupOne.Add(tSD); } else { cardGroupTwo.Add(tSD); } break; case "matchesP1": playerOneMatches = tSD; break; case "matchesP2": playerTwoMatches = tSD; break; } } }
public void ReadLayout(string xmlText){ //bring in the XML and set a shortcut reference to it as xml xmlr = new PT_XMLReader (); xmlr.Parse (xmlText); xml = xmlr.xml ["xml"] [0]; //set up multiplier multiplier.x = float.Parse(xml["multiplier"][0].att("x")); multiplier.y = float.Parse(xml["multiplier"][0].att("y")); SlotDef tSD; PT_XMLHashList slotsX = xml ["slot"]; for (int i = 0; i < slotsX.Count; i++) { tSD = new SlotDef (); if (slotsX [i].HasAtt ("type")) tSD.type = slotsX [i].att ("type"); else tSD.type = "slot"; //parse various values into floats to assign them to the temporary slot definition tSD.x = float.Parse (slotsX [i].att ("x")); tSD.y = float.Parse (slotsX [i].att ("y")); tSD.pos = new Vector3 (tSD.x * multiplier.x, tSD.y * multiplier.y, 0); //layer sorting //layers are assigned numerical values 1-10 tSD.layerID = int.Parse(slotsX[i].att("layer")); tSD.layerName = tSD.layerID.ToString (); //converts layer number to a string switch (tSD.type) { case "slot": break; case "drawpile": tSD.stagger.x = float.Parse (slotsX [i].att ("xstagger")); drawPile = tSD; break; case "discardpile": discardPile = tSD; break; case "target": target = tSD; break; case "hand": tSD.player = int.Parse (slotsX [i].att ("player")); tSD.rot = float.Parse (slotsX [i].att ("rot")); slotDefs.Add (tSD); break; }//end of switch(tSD.type) }//end of for i }//end of ReadLayout(string xmlText)
private void Awake() { S = this; GameObject tAnc = new GameObject("TileAnchor"); tileAnchor = tAnc.transform; roomsXMLR = new PT_XMLReader(); roomsXMLR.Parse(roomsText.text); roomsXML = roomsXMLR.xml["xml"][0]["room"]; BuildRoom(roomNumber); }
public void ReadLayout(string xmlText) { this.XmlReader = new PT_XMLReader(); this.XmlReader.Parse(xmlText); this.Xml = this.XmlReader.xml["xml"][0]; this.Multiplier.x = float.Parse(this.Xml["multiplier"][0].att("x")); this.Multiplier.y = float.Parse(this.Xml["multiplier"][0].att("y")); SlotDef tSlotDef; PT_XMLHashList slotsX = this.Xml["slot"]; for (var i = 0; i < slotsX.Count; i++) { tSlotDef = new SlotDef { Type = slotsX[i].HasAtt("type") ? slotsX[i].att("type") : "slot", X = float.Parse(slotsX[i].att("x")), Y = float.Parse(slotsX[i].att("y")), LayerId = int.Parse(slotsX[i].att("layer")) }; tSlotDef.LayerName = this.SortingLayerNames[tSlotDef.LayerId]; switch (tSlotDef.Type) { case "slot": tSlotDef.FaceUp = (slotsX[i].att("faceup") == "1"); tSlotDef.Id = int.Parse(slotsX[i].att("id")); if (slotsX[i].HasAtt("hiddenby")) { string[] hiding = slotsX[i].att("hiddenby").Split(','); foreach (var s in hiding) { tSlotDef.HiddenBy.Add(int.Parse(s)); } } this.SlotDefs.Add(tSlotDef); break; case "drawpile": tSlotDef.Stagger.x = float.Parse(slotsX[i].att("xstagger")); this.DrawPile = tSlotDef; break; case "discardpile": this.DiscardPile = tSlotDef; break; } } }
void Awake() { S = this; // Set the Singleton for LayoutTiles // Make a new GameObject to be the TileAnchor (the parent transform of // all Tiles). This keeps Tiles tidy in the Hierarchy pane. GameObject tAnc = new GameObject("TileAnchor"); tileAnchor = tAnc.transform; // Read the XML roomsXMLR = new PT_XMLReader(); // Create a PT_XMLReader roomsXMLR.Parse(roomsText.text); // Parse the Rooms.xml file roomsXML = roomsXMLR.xml["xml"][0]["room"]; // Pull all the <room>s // Build the 0th Room BuildRoom(roomNumber); }
public void Set(string key, PT_XMLHashList val) { int ndx = Index(key); if (ndx != -1) { nodesList[ndx] = val; } else { keys.Add(key); nodesList.Add(val); } }
void Awake() { S = this; // Задаём синглтон // Создаём новый ио чтобы быть якорем для всех плит // сохранит нашу иерархию чистой GameObject tAnc = new GameObject("TileAnchor"); tileAnchor = tAnc.transform; // Читаем XML roomsXMLR = new PT_XMLReader(); // Создаём считыватель roomsXMLR.Parse(roomsText.text); // Передаём Rooms.xml roomsXML = roomsXMLR.xml["xml"][0]["room"]; // Достаём все комнаты }
// Set the hashtable value of a certain key, the value is a hashlist public void Set(string key, PT_XMLHashList val) { int ndx = Index(key); if (ndx != -1) { nodesList[ndx] = val; // If there is an index as the key, set the value of the nodesList[idx] as the value } else { keys.Add(key); // If there is no such index, add this key as the index nodesList.Add(val); // And add this value into the List. since it is the last value and the last key, //so there are corresponded with each other too. } }
public void ReadDeck(string deckXMLText){ xmlr = new PT_XMLReader (); xmlr.Parse (deckXMLText); string s = "xml[0] decorator[0]"; s += "type=" + xmlr.xml ["xml"] [0] ["decorator"] [0].att ("type"); s += " x=" + xmlr.xml ["xml"] [0] ["decorator"] [0].att ("x"); s += " y=" + xmlr.xml ["xml"] [0] ["decorator"] [0].att ("y"); s += "scale=" + xmlr.xml ["xml"] [0] ["decorator"] [0].att ("scale"); //print (s); decorators = new List<Decorator>(); PT_XMLHashList xDecos = xmlr.xml ["xml"] [0] ["decorator"]; Decorator deco; for (int i = 0; i<xDecos.Count; i++) { deco = new Decorator (); deco.type = xDecos [i].att ("type"); //set bool flip based on text being 1 or not 1 deco.flip = (xDecos [i].att ("flip") == "1"); //floats parsed from attribute strings deco.scale = float.Parse (xDecos [i].att ("scale")); deco.loc.x = float.Parse (xDecos [i].att ("x")); deco.loc.y = float.Parse (xDecos [i].att ("y")); deco.loc.z = float.Parse (xDecos [i].att ("z")); decorators.Add (deco); } cardDefs = new List<CardDefinition> (); PT_XMLHashList xCardDefs = xmlr.xml ["xml"] [0] ["card"]; for(int i = 0; i<xCardDefs.Count; i++) { CardDefinition cDef = new CardDefinition(); cDef.rank = int.Parse(xCardDefs[i].att("rank")); //get hashlist of all pips PT_XMLHashList xPipe = xCardDefs[i]["pip"]; if(xPips != null){ for(int j=0; j<xPips.Count;j++){ deco = new Decorator(); deco.type = "pip"; deco.flip = (xPips[j].att("flip") == "1"); deco.loc.x = float.Parse (xPips[j].att ("x")); deco.loc.y = float.Parse (xPips[j].att ("y")); deco.loc.z = float.Parse (xPips[j].att ("z")); if(xPips.[j].HasAtt("scale")){
void Start() { S = this; //Singleton for LayoutTiles //Make a new GameObject to be the TileAnchor (the parent transform of all Tiles). To keep Tiles tidy in the hierarchy pane GameObject tAnc = new GameObject("TileAnchor"); tileAnchor = tAnc.transform; //Read the XML roomsXMLR = new PT_XMLReader(); //Create a PT_XMLReader, which is lighter-weight that what's on .NET roomsXMLR.Parse(roomsText.text); //Parse the Rooms.xml file roomsXML = roomsXMLR.xml["xml"][0]["room"]; //Pull all the <room>s //Build the 0th room BuildRoom(roomNumber); }
//Methods void Start() { S = this; //Make tile anchor GameObject tAnc = new GameObject("TileAnchor"); tileAnchor = tAnc.transform; //Read room xml roomsXMLR = new PT_XMLReader(); roomsXMLR.Parse(roomsText.text); roomsXML = roomsXMLR.xml ["xml"] [0] ["room"]; //Build 0th room BuildRoom(roomNumber); }
private void Start() { S = this; //Make a new GameObject to be the TileAnchor (the parent transform of all tiles). //This keeps Tiles tidy in the Hierarchy pane; GameObject tAnc = new GameObject("TileAnchor"); tileAnchor = tAnc.transform; //Read the XML roomsXMLR = new PT_XMLReader(); roomsXMLR.Parse(roomsText.text); roomsXML = roomsXMLR.xml["xml"][0]["room"]; // Get all the <rooms>s //Build the 0 room BuildRoom(roomNumber); }
public void ReadDeck(string deckXMLText) { xmlr = new PT_XMLReader(); xmlr.Parse(deckXMLText); PrintDebugMsg(deckXMLText); string s = "xml[0] decorator[0] "; s += " type = " + xmlr.xml["xml"][0]["decorator"][0].att("type"); s += " x = " + xmlr.xml["xml"][0]["decorator"][0].att("x"); s += " y = " + xmlr.xml["xml"][0]["decorator"][0].att("y"); s += " scale = " + xmlr.xml["xml"][0]["decorator"][0].att("scale"); PrintDebugMsg(s); decorators = new List <Decorator>(); PT_XMLHashList xDecos = xmlr.xml["xml"][0]["decorator"]; Decorator deco; for (int i = 0; i < xDecos.Count; i++) { deco = new Decorator(); deco.type = xDecos[i].att("type"); deco.flip = xDecos[i].att("flip") == "1"; deco.scale = float.Parse(xDecos[i].att("scale")); deco.loc.x = float.Parse(xDecos[i].att("x")); deco.loc.y = float.Parse(xDecos[i].att("y")); deco.loc.z = float.Parse(xDecos[i].att("z")); decorators.Add(deco); } cardDefs = new List <CardDefinition>(); PT_XMLHashList xCardDefs = xmlr.xml["xml"][0]["card"]; for (int i = 0; i < xCardDefs.Count; i++) { CardDefinition cDef = new CardDefinition(); cDef.rank = int.Parse(xCardDefs[i].att("rank")); PT_XMLHashList xPips = xCardDefs[i]["pip"]; if (xCardDefs[i].HasAtt("face")) { cDef.face = xCardDefs[i].att("face"); } cardDefs.Add(cDef); } }
public void NewPips(Decorator deco) { //read pip locations for the card cardDefs = new List <CardDefinition>(); PT_XMLHashList xCardDefs = xmlr.xml["xml"][0]["style"][1]["card"]; // Debug.Log("xCardDefs count: " + xCardDefs.Count); for (int i = 0; i < xCardDefs.Count; i++) { //create new card def CardDefinition cDef = new CardDefinition(); //parse cDef.rank = int.Parse(xCardDefs[i].att("rank")); //grab PT_XMLHashList xPips = xCardDefs[i]["pip"]; if (xPips != null) { for (int j = 0; j < xPips.Count; j++) { deco = new Decorator(); //pips on the card are handled via the decorator deco.type = "pip"; deco.flip = (xPips[j].att("flip") == "1"); deco.loc.x = float.Parse(xPips[j].att("x")); deco.loc.y = float.Parse(xPips[j].att("y")); deco.loc.z = float.Parse(xPips[j].att("z")); if (xPips[j].HasAtt("scale")) { deco.scale = float.Parse(xPips[j].att("scale")); } cDef.pips.Add(deco); } } if (xCardDefs[i].HasAtt("face")) { cDef.face = xCardDefs[i].att("face"); } cardDefs.Add(cDef); } }
// ReadDeck parses the XML file passed to it into CardDefinitions public void ReadDeck(string lootDeckXMLText) { xmlr = new PT_XMLReader(); // Create a new PT_XMLReader xmlr.Parse(lootDeckXMLText); // Use that PT_XMLReader to parse DeckXML // Read skull locations for each card number cardDefs = new List <CardDefinition>(); // Init the List of Cards // Grab an PT_XMLHashList of all the <card>s in the XML file PT_XMLHashList xCardDefs = xmlr.xml["xml"][0]["card"]; for (int i = 0; i < xCardDefs.Count; i++) { // For each of the <card>s // Create a new CardDefinition CardDefinition cDef = new CardDefinition(); // Parse the attribute values and add them to cDef cDef.value = int.Parse(xCardDefs[i].att("value")); } }
private void Awake() { //为LayoutTiles设置Singleton值 S = this; //创建一个新的GameObject为TileAnchor GameObject tAnc = new GameObject("TileAnchor"); tileAnchor = tAnc.transform; //读取XML //创建一个PT_XMLReader对象 roomsXMLR = new PT_XMLReader(); //解析Rooms.xml文件 roomsXMLR.Parse(roomsText.text); //导出所有<room> roomsXML = roomsXMLR.xml["xml"][0]["room"]; //建立第0个room BuildRoom(roomNumber); }
static public void LoadShots() { shots = new List <Shot> (); if (!PlayerPrefs.HasKey(prefsName)) { return; } string shotsXML = PlayerPrefs.GetString(prefsName); PT_XMLReader xmlr = new PT_XMLReader(); xmlr.Parse(shotsXML); PT_XMLHashList hl = xmlr.xml["xml"] [0] ["shot"]; for (int i = 0; i < hl.Count; i++) { PT_XMLHashtable ht = hl[i]; Shot sh = ParseShotXML(ht); shots.Add(sh); } }
// ReadDeck parses the XML file passed to it into Card Definitions public void ReadDeck(string deckXMLText) { xmlr = new PT_XMLReader(); xmlr.Parse(deckXMLText); // print a test line string s = "xml[0] decorator [0] "; s += "type=" + xmlr.xml ["xml"] [0] ["decorator"] [0].att("type"); s += " x=" + xmlr.xml ["xml"] [0] ["decorator"] [0].att("x"); s += " y=" + xmlr.xml ["xml"] [0] ["decorator"] [0].att("y"); s += " scale=" + xmlr.xml ["xml"] [0] ["decorator"] [0].att("scale"); print(s); //Read decorators for all cards // these are the small numbers/suits in the corners decorators = new List <Decorator>(); // grab all decorators from the XML file PT_XMLHashList xDecos = xmlr.xml["xml"][0]["decorator"]; Decorator deco; for (int i = 0; i < xDecos.Count; i++) { // for each decorator in the XML, copy attributes and set up location and flip if needed deco = new Decorator(); deco.type = xDecos[i].att("type"); deco.flip = (xDecos[i].att("flip") == "1"); // too cute by half - if it's 1, set to 1, else set to 0 deco.scale = float.Parse(xDecos[i].att("scale")); deco.loc.x = float.Parse(xDecos[i].att("x")); deco.loc.y = float.Parse(xDecos[i].att("y")); deco.loc.z = float.Parse(xDecos[i].att("z")); decorators.Add(deco); } // read pip locations for each card rank // read the card definitions, parse attribute values for pips cardDefs = new List <CardDefinition>(); PT_XMLHashList xCardDefs = xmlr.xml["xml"][0]["card"]; for (int i = 0; i < xCardDefs.Count; i++) { // for each carddef in the XML, copy attributes and set up in cDef CardDefinition cDef = new CardDefinition(); cDef.rank = int.Parse(xCardDefs[i].att("rank")); PT_XMLHashList xPips = xCardDefs[i]["pip"]; if (xPips != null) { for (int j = 0; j < xPips.Count; j++) { deco = new Decorator(); deco.type = "pip"; deco.flip = (xPips[j].att("flip") == "1"); // too cute by half - if it's 1, set to 1, else set to 0 deco.loc.x = float.Parse(xPips[j].att("x")); deco.loc.y = float.Parse(xPips[j].att("y")); deco.loc.z = float.Parse(xPips[j].att("z")); if (xPips[j].HasAtt("scale")) { deco.scale = float.Parse(xPips[j].att("scale")); } cDef.pips.Add(deco); } // for j } // if xPips // if it's a face card, map the proper sprite // foramt is ##A, where ## in 11, 12, 13 and A is letter indicating suit if (xCardDefs[i].HasAtt("face")) { cDef.face = xCardDefs[i].att("face"); } cardDefs.Add(cDef); } // for i < xCardDefs.Count } // ReadDeck
// ReadDeck parses the XML file passed to it into CardDefinitions public void ReadDeck(string deckXMLText) { xmlr = new PT_XMLReader(); // Create a new PT_XMLReader xmlr.Parse(deckXMLText); // Use that PT_XMLReader to parse DeckXML // The following prints a test line to show you how xmlr can be used. // For more information read about XML in the Useful Concepts Appendix string s = "xml[0] decorator[0] "; s += "type=" + xmlr.xml["xml"][0]["decorator"][0].att("type"); s += " x=" + xmlr.xml["xml"][0]["decorator"][0].att("x"); s += " y=" + xmlr.xml["xml"][0]["decorator"][0].att("y"); s += " scale=" + xmlr.xml["xml"][0]["decorator"][0].att("scale"); //print(s); // Comment out this line, since we're done with the test // Read decorators for all Cards decorators = new List <Decorator>(); // Init the List of Decorators // Grab an PT_XMLHashList of all <decorator>s in the XML file PT_XMLHashList xDecos = xmlr.xml["xml"][0]["decorator"]; Decorator deco; for (int i = 0; i < xDecos.Count; i++) { // For each <decorator> in the XML deco = new Decorator(); // Make a new Decorator // Copy the attributes of the <decorator> to the Decorator deco.type = xDecos[i].att("type"); // bool deco.flip is true if the text of the flip attribute is "1" deco.flip = (xDecos[i].att("flip") == "1"); // a // floats need to be parsed from the attribute strings deco.scale = float.Parse(xDecos[i].att("scale")); // Vector3 loc initializes to [0,0,0], so we just need to modify it deco.loc.x = float.Parse(xDecos[i].att("x")); deco.loc.y = float.Parse(xDecos[i].att("y")); deco.loc.z = float.Parse(xDecos[i].att("z")); // Add the temporary deco to the List decorators decorators.Add(deco); } // Read pip locations for each card number cardDefs = new List <CardDefinition>(); // Init the List of Cards // Grab an PT_XMLHashList of all the <card>s in the XML file PT_XMLHashList xCardDefs = xmlr.xml["xml"][0]["card"]; for (int i = 0; i < xCardDefs.Count; i++) { // For each of the <card>s // Create a new CardDefinition CardDefinition cDef = new CardDefinition(); // Parse the attribute values and add them to cDef cDef.rank = int.Parse(xCardDefs[i].att("rank")); // Grab an PT_XMLHashList of all the <pip>s on this <card> PT_XMLHashList xPips = xCardDefs[i]["pip"]; if (xPips != null) { for (int j = 0; j < xPips.Count; j++) { // Iterate through all the <pip>s deco = new Decorator(); // <pip>s on the <card> are handled via the Decorator Class deco.type = "pip"; deco.flip = (xPips[j].att("flip") == "1"); deco.loc.x = float.Parse(xPips[j].att("x")); deco.loc.y = float.Parse(xPips[j].att("y")); deco.loc.z = float.Parse(xPips[j].att("z")); if (xPips[j].HasAtt("scale")) { deco.scale = float.Parse(xPips[j].att("scale")); } cDef.pips.Add(deco); } } // Face cards (Jack, Queen, & King) have a face attribute if (xCardDefs[i].HasAtt("face")) { cDef.face = xCardDefs[i].att("face"); // b } cardDefs.Add(cDef); } }
// Readdeck parses the XML file passed to it into CardDefinitions public void ReadDeck(string deckXMLText) { xmlr = new PT_XMLReader(); // Create a new PT_XMLReader xmlr.Parse(deckXMLText); // Use that PT_XMLReader to parse DeckXML //This prints a test line to show you how xmlr can be used. string s = "xml[0] decorator[0] "; s += "type=" + xmlr.xml ["xml"] [0] ["decorator"] [0].att("type"); s += " x=" + xmlr.xml ["xml"] [0] ["decorator"] [0].att("x"); s += " y=" + xmlr.xml ["xml"] [0] ["decorator"] [0].att("y"); s += " scale" + xmlr.xml ["xml"] [0] ["decorator"] [0].att("scale"); // print (s); // Commented out as this is just for testing //Read decorators for all Cards decorators = new List <Decorator> (); //Init the List of Decorators //Grab a PT_XMLHashList of all <decorator>s in the XML file PT_XMLHashList xDecos = xmlr.xml ["xml"] [0] ["decorator"]; Decorator deco; for (int i = 0; i < xDecos.Count; i++) { // For each <decorator> in the XML deco = new Decorator(); // Make a new Decorator //Copy the attributes of the <decorator> to the Decorator deco.type = xDecos [i].att("type"); // Set the bool flip based on whetherthe text of the attribute is "1" or something else. // This is an atrypical but perfectly fine use of the == comparison operator. // It will return a true or false, which will be assigned to deco.flip deco.flip = (xDecos [i].att("flip") == "1"); // floats need to be parsed from the attribute strings deco.scale = float.Parse(xDecos [i].att("scale")); // Vector3 loc initializes to [0,0,0], so we just need to modify it deco.loc.x = float.Parse(xDecos [i].att("x")); deco.loc.y = float.Parse(xDecos [i].att("y")); deco.loc.z = float.Parse(xDecos [i].att("z")); // Add the temporary deco to the List decorators decorators.Add(deco); } // Read pip locations for each card number cardDefs = new List <CardDefinition> (); // Init the List of Cards // Grab a PT_XMLHashList of all the <card>s in the XML file PT_XMLHashList xCardDefs = xmlr.xml ["xml"] [0] ["card"]; for (int i = 0; i < xCardDefs.Count; i++) { // For each of the <card>s // Create a new CardDefinition CardDefinition cDef = new CardDefinition(); // Parse the attribute values and add them to cDef cDef.rank = int.Parse(xCardDefs [i].att("rank")); // Grab a PT_XMLHastlist of all the <pip>s on this <card> PT_XMLHashList xPips = xCardDefs [i] ["pip"]; if (xPips != null) { for (int j = 0; j < xPips.Count; j++) { //Iterate through all the <pip>s deco = new Decorator(); // <pip>s on the <card> are handled via the Decorator Class deco.type = "pip"; deco.flip = (xPips [j].att("flip") == "1"); deco.loc.x = float.Parse(xPips [j].att("x")); deco.loc.y = float.Parse(xPips [j].att("y")); deco.loc.z = float.Parse(xPips [j].att("z")); if (xPips [j].HasAtt("scale")) { deco.scale = float.Parse(xPips [j].att("scale")); } cDef.pips.Add(deco); } } // Face cards (Jack, Queen, & King) have a face attribute // cDef.face is the base name of the face card Sprite // e.g., FaceCard_11 is the base name for the Jack face Sprites // the Jack of CLubs is FaceCard_11C, hearts is FaceCard_11H, etc. if (xCardDefs [i].HasAtt("face")) { cDef.face = xCardDefs [i].att("face"); } cardDefs.Add(cDef); } }
//把xml文件编译后传递到CarDefinitions中 public void ReadDeck(string deckXMLText) { xmlr = new PT_XMLReader(); xmlr.Parse(deckXMLText); //用PT_XMLReader脚本的Parse方法读xml string s = "xml[0] decorator[0] "; s += "type=" + xmlr.xml["xml"][0]["decorator"][0].att("type"); s += " x=" + xmlr.xml["xml"][0]["decorator"][0].att("x"); s += " y=" + xmlr.xml["xml"][0]["decorator"][0].att("y"); s += " scale=" + xmlr.xml["xml"][0]["decorator"][0].att("scale"); // print(s); //read decorators for all Cards decorators = new List <Decorator>(); PT_XMLHashList xDecos = xmlr.xml["xml"][0]["decorator"]; //得到全部“decorator”下的信息 Decorator deco; //声明其中一个<decorator> //对于xml中的每个<decorator>, 这个项目中为Count=4 for (int i = 0; i < xDecos.Count; i++) { deco = new Decorator(); //deco储存每一个decorator中的信息 deco.type = xDecos[i].att("type"); deco.flip = (xDecos[i].att("flip") == "1"); //true if flip att is "1" deco.scale = float.Parse(xDecos[i].att("scale")); deco.loc.x = float.Parse(xDecos[i].att("x")); deco.loc.y = float.Parse(xDecos[i].att("y")); deco.loc.z = float.Parse(xDecos[i].att("z")); decorators.Add(deco); } //read图案排列图形,xml文件中的所有<card> cardDefs = new List <CardDefinition>(); PT_XMLHashList xCardDefs = xmlr.xml["xml"][0]["card"]; //得到全部<card>下的信息 for (int i = 0; i < xCardDefs.Count; i++) { CardDefinition cDef = new CardDefinition(); cDef.rank = int.Parse(xCardDefs[i].att("rank")); PT_XMLHashList xPips = xCardDefs[i]["pip"]; //"pip"不是xml中的att if (xPips != null) //针对1-10 { for (int j = 0; j < xPips.Count; j++) { deco = new Decorator(); deco.type = "pip"; deco.flip = (xPips[j].att("flip") == "1"); deco.loc.x = float.Parse(xPips[j].att("x")); deco.loc.y = float.Parse(xPips[j].att("y")); deco.loc.z = float.Parse(xPips[j].att("z")); if (xPips[j].HasAtt("scale")) //针对1 { deco.scale = float.Parse(xPips[j].att("scale")); } cDef.pips.Add(deco); } } if (xCardDefs[i].HasAtt("face")) //针对JQK,“face”是此xml中的att { cDef.face = xCardDefs[i].att("face"); } cardDefs.Add(cDef); } }
// This function is called to read in the LayoutXML.xml file public void ReadLayout(string xmlText) { xmlr = new PT_XMLReader(); xmlr.Parse(xmlText); // The XML is parsed xml = xmlr.xml["xml"][0]; // And xml is set as a shortcut to the XML // Read in the multiplier, which sets card spacing multiplier.x = float.Parse(xml["multiplier"][0].att("x")); multiplier.y = float.Parse(xml["multiplier"][0].att("y")); // Read in the slots SlotDef tSD; // slotsX is used as a shortcut to all the <slot>s PT_XMLHashList slotsX = xml["slot"]; for (int i = 0; i < slotsX.Count; i++) { tSD = new SlotDef(); // Create a new SlotDef instance if (slotsX[i].HasAtt("type")) { // If this <slot> has a type attribute parse it tSD.type = slotsX[i].att("type"); } else { // If not, set its type to "slot" tSD.type = "slot"; } // Various attributes are parsed into numerical values tSD.x = float.Parse(slotsX[i].att("x")); tSD.y = float.Parse(slotsX[i].att("y")); tSD.pos = new Vector3(tSD.x * multiplier.x, tSD.y * multiplier.y, 0); // Sorting Layers tSD.layerID = int.Parse(slotsX[i].att("layer")); // In this game, the Sorting Layers are named 1, 2, 3, ...through 10 // This converts the number of the layerID into a text layerName tSD.layerName = tSD.layerID.ToString(); // The layers are used to make sure that the correct cards are // on top of the others. In Unity 2D, all of our assets are // effectively at the same Z depth, so sorting layers are used // to differentiate between them. // pull additional attributes based on the type of each <slot> switch (tSD.type) { case "slot": // ignore slots that are just of the "slot" type break; case "drawpile": // The drawPile xstagger is read but not actually used in Bartok tSD.stagger.x = float.Parse(slotsX[i].att("xstagger")); drawPile = tSD; break; case "discardpile": discardPile = tSD; break; case "target": // The target card has a different layer from discardPile target = tSD; break; case "hand": // Information for each player's hand tSD.player = int.Parse(slotsX[i].att("player")); tSD.rot = float.Parse(slotsX[i].att("rot")); slotDefs.Add(tSD); break; } } }
// This function is called to read in the LayoutXML.xml file public void ReadLayout(string xmlText) { xmlr = new PT_XMLReader(); xmlr.Parse(xmlText); // The XML is parsed xml = xmlr.xml["xml"][0]; // And xml is set as a shortcut to the XML //Read in the multiplier, which sets card spacing multiplier.x = float.Parse(xml["multiplier"][0].att("x")); multiplier.y = float.Parse(xml["multiplier"][0].att("y")); //Read in the slots SlotDef tSD; //slotsX is used as a shortcut to all the <slot>s PT_XMLHashList slotsX = xml["slot"]; print(sortingLayerNames.Length); for (int i = 0; i < slotsX.Count; i++) { tSD = new SlotDef(); // Create a new SlotDef instance if (slotsX[i].HasAtt("type")) { // If this <slot> has a type attribute parse it tSD.type = slotsX[i].att("type"); } else { // If not, set its type to "slot"; it's a card in the rows tSD.type = "slot"; } // Various attributes are parsed into numerical values tSD.x = float.Parse(slotsX[i].att("x")); tSD.y = float.Parse(slotsX[i].att("y")); tSD.layerID = int.Parse(slotsX[i].att("layer")); //This converts the number of the layerID into a text layerName tSD.layerName = sortingLayerNames[tSD.layerID]; switch (tSD.type) { //pull additional attributes based on the type of this <slot> case "slot": tSD.faceUp = (slotsX[i].att("faceup") == "1"); tSD.id = int.Parse(slotsX[i].att("id")); if (slotsX[i].HasAtt("hiddenby")) { string[] hiding = slotsX[i].att("hiddenby").Split(','); foreach (string s in hiding) { tSD.hiddenBy.Add(int.Parse(s)); } } slotDefs.Add(tSD); break; case "drawpile": tSD.stagger.x = float.Parse(slotsX[i].att("xstagger")); drawPile = tSD; break; case "discardpile": discardPile = tSD; break; } } }
// ReadDeck parses the XML file passed to it into CardDefinitions public void ReadDeck(string deckXMLText) { // Create a new PT_XMLReader xmlr = new PT_XMLReader(); // Use that PT_XMLReader to parse DeckXML xmlr.Parse(deckXMLText); // This prints a test line to show you how xmlr can be used // For more information read about the XML in the Useful Concept Appendix string s = "xml[0] decorator[0]"; s += "type=" + xmlr.xml["xml"][0]["decorator"][0].att("type"); s += " x=" + xmlr.xml["xml"][0]["decorator"][0].att("x"); s += " y=" + xmlr.xml["xml"][0]["decorator"][0].att("y"); s += " scale=" + xmlr.xml["xml"][0]["decorator"][0].att("scale"); //print(s); // Comment out this line, since we are done with the test // Read decorators for all Cards // Init the list of decorators decorators = new List <Decorator>(); // Grab a PT_XMLHashList of all <decorator>s in the XML file PT_XMLHashList decoHashList = xmlr.xml["xml"][0]["decorator"]; // Initialize the decorators in the xml and add them into the decorators list. Decorator deco; // For each decorator to work, we need four variables: the type of the suit/letter as string, // the location of the suit/letter as vector3, the size as float, and whether it is flipped as bool for (int i = 0; i < decoHashList.Count; i++) { // Make a new decorator deco = new Decorator(); // Find the four variable attribution of the [i] element string type = decoHashList[i].att("type"); Vector3 location = new Vector3(); location.x = float.Parse(decoHashList[i].att("x")); location.y = float.Parse(decoHashList[i].att("y")); location.z = float.Parse(decoHashList[i].att("z")); float size = float.Parse(decoHashList[i].att("scale")); bool flipped = (decoHashList[i].att("flip") == "1"); // Assign them to the new decorator deco.flip = flipped; deco.loc = location; deco.scale = size; deco.type = type; // Add them to the new decorator list decorators.Add(deco); } // Read pip location for each card number // Init the List of the Cards cardDefs = new List <CardDefinition>(); // Grab a PT_XMLHashList of all the <card>s in the XML file PT_XMLHashList xCardDefs = xmlr.xml["xml"][0]["card"]; // For each cardDefinition, we need 3 infos, the rank of a int number // the face if it is a faced card, and a list of decorators as pip for (int i = 0; i < xCardDefs.length; i++) { // Make a new cardDef CardDefinition cardDef = new CardDefinition(); // Find the variables of the [i] element as a card definition cardDef.rank = int.Parse(xCardDefs[i].att("rank")); // Iterate through all the pips in the hashlist and creates decorators // After initialize the new decorators with data, // add them into the pip list of the cardDef PT_XMLHashList xPips = xCardDefs[i]["pip"]; if (xPips != null) { for (int j = 0; j < xPips.length; j++) { // Make a new decorator for use Decorator decorator = new Decorator(); // type, location, scale and flip decorator.type = "pip"; decorator.loc.x = float.Parse(xPips[j].att("x")); decorator.loc.y = float.Parse(xPips[j].att("y")); decorator.loc.z = float.Parse(xPips[j].att("z")); if (xPips[i].HasAtt("scale")) { decorator.scale = float.Parse(xPips[i].att("scale")); } decorator.flip = (xPips[j].att("flip") == "1"); // add them into the pip list of the cardDef cardDef.pips.Add(decorator); } } // Face cards (Jack, Queen, & King) have a face attribute // cDef.face is the best name of the face Sprite // e.g., FaceCard_11 is the base name for the Jack face Sprites // the Jack of Clubs is FaceCard_11C, hearts is FaceCard_11H, etc. if (xCardDefs[i].HasAtt("face")) { cardDef.face = xCardDefs[i].att("face"); } cardDefs.Add(cardDef); } }
// ReadDeck parses the XML file passed to it into Card Definitions public void ReadDeck(string deckXMLText) { xmlr = new PT_XMLReader(); xmlr.Parse(deckXMLText); string s = "xml[0] decorator [0] "; s += "type=" + xmlr.xml["xml"][0]["decorator"][0].att("type"); s += " x=" + xmlr.xml["xml"][0]["decorator"][0].att("x"); s += " y=" + xmlr.xml["xml"][0]["decorator"][0].att("y"); s += " scale=" + xmlr.xml["xml"][0]["decorator"][0].att("scale"); print(s); //Read decorators for all cards decorators = new List <Decorator>(); PT_XMLHashList xDecos = xmlr.xml["xml"][0]["decorator"]; Decorator deco; for (int i = 0; i < xDecos.Count; i++) { // for each decorator in the XML, copy attributes and set up location and flip if needed deco = new Decorator(); deco.type = xDecos[i].att("type"); deco.flip = (xDecos[i].att("flip") == "1"); deco.scale = float.Parse(xDecos[i].att("scale")); deco.loc.x = float.Parse(xDecos[i].att("x")); deco.loc.y = float.Parse(xDecos[i].att("y")); deco.loc.z = float.Parse(xDecos[i].att("z")); decorators.Add(deco); } cardDefs = new List <CardDefinition>(); PT_XMLHashList xCardDefs = xmlr.xml["xml"][0]["card"]; for (int i = 0; i < xCardDefs.Count; i++) { // for each carddef in the XML, copy attributes and set up in cDef CardDefinition cDef = new CardDefinition(); cDef.rank = int.Parse(xCardDefs[i].att("rank")); PT_XMLHashList xPips = xCardDefs[i]["pip"]; if (xPips != null) { for (int j = 0; j < xPips.Count; j++) { deco = new Decorator(); deco.type = "pip"; deco.flip = (xPips[j].att("flip") == "1"); // too cute by half - if it's 1, set to 1, else set to 0 deco.loc.x = float.Parse(xPips[j].att("x")); deco.loc.y = float.Parse(xPips[j].att("y")); deco.loc.z = float.Parse(xPips[j].att("z")); if (xPips[j].HasAtt("scale")) { deco.scale = float.Parse(xPips[j].att("scale")); } cDef.pips.Add(deco); } } if (xCardDefs[i].HasAtt("face")) { cDef.face = xCardDefs[i].att("face"); } cardDefs.Add(cDef); } // for i < xCardDefs.Count } // ReadDeck
// Loot calls this method to read in the LootLayoutXML.xml file public void ReadLayout(string xmlText) { xmlr = new PT_XMLReader(); xmlr.Parse(xmlText); // The XML is parsed xml = xmlr.xml["xml"][0]; // And xml is set as a shortcut to the XML // Read in the multiplier, which sets card spacing multiplier.x = float.Parse(xml["multiplier"][0].att("x")); multiplier.y = float.Parse(xml["multiplier"][0].att("y")); // Read in the slots SlotDef tSD; // slotsX is used as a shortcut to all the <slot>s PT_XMLHashList slotsX = xml["slot"]; for (int i = 0; i < slotsX.Count; i++) { tSD = new SlotDef(); // Create a new SlotDef instance if (slotsX[i].HasAtt("type")) { // If this <slot> has a type attribute parse it tSD.type = slotsX[i].att("type"); } else { // If not, set its type to "slot"; it's a card in the rows tSD.type = "slot"; } // Various attributes are parsed into numerical values tSD.x = float.Parse(slotsX[i].att("x")); tSD.y = float.Parse(slotsX[i].att("y")); tSD.pos = new Vector3(tSD.x * multiplier.x, tSD.y * multiplier.y, 0); // Sorting Layers tSD.layerID = int.Parse(slotsX[i].att("layer")); tSD.layerName = tSD.layerID.ToString(); // pull additional attributes based on the type of each <slot> switch (tSD.type) { case "slot": // ignore slots that are just of the "slot" type break; case "drawpile": tSD.stagger.x = float.Parse(slotsX[i].att("xstagger")); drawPile = tSD; break; case "discardpile": discardPile = tSD; break; case "target": target = tSD; break; case "hand": tSD.player = int.Parse(slotsX[i].att("player")); tSD.rot = float.Parse(slotsX[i].att("rot")); slotDefs.Add(tSD); break; case "merchant": merchant = tSD; break; case "pirate": tSD.player = int.Parse(slotsX[i].att("player")); break; } } }
// This function parses a single tag and calls Parse() if it encounters subtags string ParseTag(string eS, PT_XMLHashtable eH) { // search for "<" int ndx = eS.IndexOf("<"); int end, end1, end2, end3; if (ndx == -1) { // It's possible that this is just a string (e.g. <someTagTheStringIsInside>string</someTagTheStringIsInside>) end3 = eS.IndexOf(">"); // This closes a standard tag; look for the closing tag if (end3 == -1) { // In that case, we just need to add an @ key/value to the hashtable eS = eS.Trim(); // I think this is redundant //eH["@"] = eS; eH.text = eS; } return(""); // We're done with this tag } // Ignore this if it is just an XML header (e.g. <?xml version="1.0"?>) if (eS[ndx + 1] == '?') { // search for the closing tag of this header int ndx2 = eS.IndexOf("?>"); string header = eS.Substring(ndx, ndx2 - ndx + 2); //eH["@XML_Header"] = header; eH.header = header; return(eS.Substring(ndx2 + 2)); } // Ignore this if it is an XML comment (e.g. <!-- Comment text -->) if (eS[ndx + 1] == '!') { // search for the closing tag of this header int ndx2 = eS.IndexOf("-->"); string comment = eS.Substring(ndx, ndx2 - ndx + 3); if (SHOW_COMMENTS) { Debug.Log("XMl Comment: " + comment); } //eH["@XML_Header"] = header; return(eS.Substring(ndx2 + 3)); } // Find the end of the tag name // For the next few comments, this is what happens when this character is the first one found after the beginning of the tag end1 = eS.IndexOf(" ", ndx); // This means that we'll have attributes end2 = eS.IndexOf("/", ndx); // Immediately closes the tag, end3 = eS.IndexOf(">", ndx); // This closes a standard tag; look for the closing tag if (end1 == -1) { end1 = int.MaxValue; } if (end2 == -1) { end2 = int.MaxValue; } if (end3 == -1) { end3 = int.MaxValue; } end = Mathf.Min(end1, end2, end3); string tag = eS.Substring(ndx + 1, end - ndx - 1); // search for this tag in eH. If it's not there, make it if (!eH.ContainsKey(tag)) { eH[tag] = new PT_XMLHashList(); } // Create a hashtable to contain this tag's information PT_XMLHashList arrL = eH[tag] as PT_XMLHashList; //int thisHashIndex = arrL.Count; PT_XMLHashtable thisHash = new PT_XMLHashtable(); arrL.Add(thisHash); // Pull the attributes string string atts = ""; if (end1 < end3) { try { atts = eS.Substring(end1, end3 - end1); } catch (System.Exception ex) { Debug.LogException(ex); Debug.Log("break"); } } // Parse the attributes, which are all guaranteed to be strings string att, val; int eqNdx, spNdx; while (atts.Length > 0) { atts = atts.Trim(); eqNdx = atts.IndexOf("="); if (eqNdx == -1) { break; } //att = "@"+atts.Substring(0,eqNdx); att = atts.Substring(0, eqNdx); spNdx = atts.IndexOf(" ", eqNdx); if (spNdx == -1) // This is the last attribute and doesn't have a space after it { val = atts.Substring(eqNdx + 1); if (val[val.Length - 1] == '/') // If the trailing / from /> was caught, remove it { val = val.Substring(0, val.Length - 1); } atts = ""; } else // This attribute has a space after it { val = atts.Substring(eqNdx + 1, spNdx - eqNdx - 2); atts = atts.Substring(spNdx); } val = val.Trim('\"'); //thisHash[att] = val; // All attributes have to be unique, so this should be okay. thisHash.attSet(att, val); } // Pull the subs, which is everything contained by this tag but exclusing the tags on either side (e.g. <tag att="hi">.....subs.....</tag>) string subs = ""; string leftoverString = ""; // singleLine means this doesn't have a separate closing tag (e.g. <tag att="hi" />) bool singleLine = (end2 == end3 - 1); // ? true : false; if (!singleLine) // This is a multiline tag (e.g. <tag> .... </tag>) // find the closing tag { int close = eS.IndexOf("</" + tag + ">"); // TODO: Should this do something more if there is no closing tag? if (close == -1) { Debug.Log("XMLReader ERROR: XML not well formed. Closing tag </" + tag + "> missing."); return(""); } subs = eS.Substring(end3 + 1, close - end3 - 1); leftoverString = eS.Substring(eS.IndexOf(">", close) + 1); } else { leftoverString = eS.Substring(end3 + 1); } subs = subs.Trim(); // Call Parse if this contains subs if (subs.Length > 0) { Parse(subs, thisHash); } // Trim and return the leftover string leftoverString = leftoverString.Trim(); return(leftoverString); }
void Start() { S = this; // Set the Singleton for LayoutTiles // Make a new GameObject to be the TileAnchor (the parent transform of // all Tiles). This keeps Tiles tidy in the Hierarchy pane. GameObject tAnc = new GameObject("TileAnchor"); tileAnchor = tAnc.transform; Utils.tr("..........",tileAnchor); // Read the XML levelsXMLR = new PT_XMLReader(); // Create a PT_XMLReader levelsXMLR.Parse(levelText.text); // Parse the Rooms.xml file levelsXML = levelsXMLR.xml["xml"][0]["level"]; // Pull all the <room>s BuildLevel (ApplicationModel.XMLlevel); }
// This function parses a single tag and calls Parse() if it encounters subtags string ParseTag(string eS, PT_XMLHashtable eH) { // search for "<" int ndx = eS.IndexOf("<"); int end, end1, end2, end3; if (ndx == -1) { // It's possible that this is just a string (e.g. <someTagTheStringIsInside>string</someTagTheStringIsInside>) end3 = eS.IndexOf(">"); // This closes a standard tag; look for the closing tag if (end3 == -1) { // In that case, we just need to add an @ key/value to the hashtable eS = eS.Trim(); // I think this is redundant //eH["@"] = eS; eH.text = eS; } return(""); // We're done with this tag } // Ignore this if it is just an XML header (e.g. <?xml version="1.0"?>) if (eS[ndx+1] == '?') { // search for the closing tag of this header int ndx2 = eS.IndexOf("?>"); string header = eS.Substring(ndx, ndx2-ndx+2); //eH["@XML_Header"] = header; eH.header = header; return(eS.Substring(ndx2+2)); } // Ignore this if it is an XML comment (e.g. <!-- Comment text -->) if (eS[ndx+1] == '!') { // search for the closing tag of this header int ndx2 = eS.IndexOf("-->"); string comment = eS.Substring(ndx, ndx2-ndx+3); if (SHOW_COMMENTS) Debug.Log("XMl Comment: "+comment); //eH["@XML_Header"] = header; return(eS.Substring(ndx2+3)); } // Find the end of the tag name // For the next few comments, this is what happens when this character is the first one found after the beginning of the tag end1 = eS.IndexOf(" ", ndx); // This means that we'll have attributes end2 = eS.IndexOf("/", ndx); // Immediately closes the tag, end3 = eS.IndexOf(">", ndx); // This closes a standard tag; look for the closing tag if (end1 == -1) end1 = int.MaxValue; if (end2 == -1) end2 = int.MaxValue; if (end3 == -1) end3 = int.MaxValue; end = Mathf.Min(end1, end2, end3); string tag = eS.Substring(ndx+1, end-ndx-1); // search for this tag in eH. If it's not there, make it if (!eH.ContainsKey(tag)) { eH[tag] = new PT_XMLHashList(); } // Create a hashtable to contain this tag's information PT_XMLHashList arrL = eH[tag] as PT_XMLHashList; //int thisHashIndex = arrL.Count; PT_XMLHashtable thisHash = new PT_XMLHashtable(); arrL.Add(thisHash); // Pull the attributes string string atts = ""; if (end1 < end3) { try { atts = eS.Substring(end1, end3-end1); } catch(System.Exception ex) { Debug.LogException(ex); Debug.Log("break"); } } // Parse the attributes, which are all guaranteed to be strings string att, val; int eqNdx, spNdx; while (atts.Length > 0) { atts = atts.Trim(); eqNdx = atts.IndexOf("="); if (eqNdx == -1) break; //att = "@"+atts.Substring(0,eqNdx); att = atts.Substring(0,eqNdx); spNdx = atts.IndexOf(" ",eqNdx); if (spNdx == -1) { // This is the last attribute and doesn't have a space after it val = atts.Substring(eqNdx+1); if (val[val.Length-1] == '/') { // If the trailing / from /> was caught, remove it val = val.Substring(0,val.Length-1); } atts = ""; } else { // This attribute has a space after it val = atts.Substring(eqNdx+1, spNdx - eqNdx - 2); atts = atts.Substring(spNdx); } val = val.Trim('\"'); //thisHash[att] = val; // All attributes have to be unique, so this should be okay. thisHash.attSet(att, val); } // Pull the subs, which is everything contained by this tag but exclusing the tags on either side (e.g. <tag att="hi">.....subs.....</tag>) string subs = ""; string leftoverString = ""; // singleLine means this doesn't have a separate closing tag (e.g. <tag att="hi" />) bool singleLine = (end2 == end3-1);// ? true : false; if (!singleLine) { // This is a multiline tag (e.g. <tag> .... </tag>) // find the closing tag int close = eS.IndexOf("</"+tag+">"); // TODO: Should this do something more if there is no closing tag? if (close == -1) { Debug.Log("XMLReader ERROR: XML not well formed. Closing tag </"+tag+"> missing."); return(""); } subs = eS.Substring(end3+1, close-end3-1); leftoverString = eS.Substring( eS.IndexOf(">",close)+1 ); } else { leftoverString = eS.Substring(end3+1); } subs = subs.Trim(); // Call Parse if this contains subs if (subs.Length > 0) { Parse(subs, thisHash); } // Trim and return the leftover string leftoverString = leftoverString.Trim(); return(leftoverString); }
public void ReadDeck(string deckXMLText) { xlmr = new PT_XMLReader(); xlmr.Parse(deckXMLText); string s = "xml[0] decorator[0]"; s += "type=" + xlmr.xml["xml"][0]["decorator"][0].att("type"); s += "type=" + xlmr.xml["xml"][0]["decorator"][0].att("x"); s += "type=" + xlmr.xml["xml"][0]["decorator"][0].att("y"); s += "type=" + xlmr.xml["xml"][0]["decorator"][0].att("scale"); //print(s); decorators = new List <Decorator>(); PT_XMLHashList xDecos = xlmr.xml["xml"][0]["decorator"]; Decorator deco; for (int i = 0; i < xDecos.Count; i++) { deco = new Decorator(); deco.type = xDecos[i].att("type"); deco.flip = (xDecos[i].att("flip") == "1"); deco.scale = float.Parse(xDecos[i].att("scale")); deco.loc.x = float.Parse(xDecos[i].att("x")); deco.loc.y = float.Parse(xDecos[i].att("y")); deco.loc.z = float.Parse(xDecos[i].att("z")); decorators.Add(deco); } cardDefs = new List <CardDefinition>(); PT_XMLHashList xCardDefs = xlmr.xml["xml"][0]["card"]; for (int i = 0; i < xCardDefs.Count; i++) { CardDefinition cDef = new CardDefinition(); cDef.rank = int.Parse(xCardDefs[i].att("rank")); PT_XMLHashList xPips = xCardDefs[i]["pip"]; if (xPips != null)//if not face card { for (int j = 0; j < xPips.Count; j++) { deco = new Decorator(); deco.type = "pip"; deco.flip = (xPips[j].att("flip") == "1"); deco.loc.x = float.Parse(xPips[j].att("x")); deco.loc.y = float.Parse(xPips[j].att("y")); deco.loc.z = float.Parse(xPips[j].att("z")); if (xPips[j].HasAtt("scale")) { deco.scale = float.Parse(xPips[j].att("scale")); } cDef.pips.Add(deco); } } if (xCardDefs[i].HasAtt("face"))//face cards { cDef.face = xCardDefs[i].att("face"); } cardDefs.Add(cDef); } }//end of read deck