void ReadXml_Tiles(XmlReader reader)
{
// We are in the "Tiles" element, so read elements until
// we run out of "Tile" nodes.
if (reader.ReadToDescendant("Tile"))
{
// We have at least one tile, so do something with it.
do
{
int x = int.Parse(reader.GetAttribute("X"));
int y = int.Parse(reader.GetAttribute("Y"));
tiles[x, y].ReadXml(reader);
} while (reader.ReadToNextSibling("Tile"));
}
}
internal static WidgetStyle ReadForegroundBackgroundColorNode(XmlReader reader, string nameOfNode)
{
WidgetStyle ret = null;
string fgColor = string.Empty;
string bgColor = string.Empty;
reader.ReadToNextSibling(nameOfNode);
while (reader.MoveToNextAttribute())
{
switch (reader.Name)
{
case ReadWidgetStyle.attr_fgColor:
fgColor = (reader.Value == null ? string.Empty : reader.Value);
break;
case ReadWidgetStyle.attr_bgColor:
bgColor = (reader.Value == null ? string.Empty : reader.Value);
break;
case XMLNameSpace:
break;
default:
if (reader.Name.Trim().Length > 0 && reader.Name != XMLComment)
{
logger.Warn("Parsing the XML child:'" + reader.Name + "' of '" + ReadLexerType.XMLName + "' is not implemented.");
}
break;
}
}
ret = new WidgetStyle(nameOfNode);
if (fgColor != string.Empty)
{
ret.fgColor = ReadWidgetStyle.SetColorFromString(ReadWidgetStyle.attr_fgColor, fgColor);
}
if (bgColor != string.Empty)
{
ret.bgColor = ReadWidgetStyle.SetColorFromString(ReadWidgetStyle.attr_bgColor, bgColor);
}
return(ret);
}
public void ReadXmlParams(XmlReader reader)
{
// X, Y, and objectType have already been set, and we should already
// be assigned to a tile. So just read extra data.
//movementCost = int.Parse( reader.GetAttribute("movementCost") );
if (reader.ReadToDescendant("Param"))
{
do
{
string k = reader.GetAttribute("name");
float v = float.Parse(reader.GetAttribute("value"));
furnParameters[k] = v;
} while (reader.ReadToNextSibling("Param"));
}
}
private void ResolveBuilders(XmlReader reader, Plugin plugin)
{
if (reader.Name == "builders")
{
reader.Read();
}
if (reader.Name != "builder")
{
return;
}
do
{
plugin.Builders.Add(reader.GetAttribute("type"), reader.GetAttribute("name"), plugin);
} while(reader.ReadToNextSibling("builder"));
}
public void HighScoreRead()
{
XmlReader reader = XmlReader.Create("Resources/HighScores.xml", null);
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Text)
{
string player1 = reader.ReadString();
reader.ReadToNextSibling("name2");
string player2 = reader.ReadString();
reader.ReadToFollowing("time");
string score = reader.ReadString();
Score s = new Score(player1, player2, score);
highScoreList.Add(s);
}
}
highScoreList.RemoveAt(highScoreList.Count - 1);
reader.Close();
//Checks for 10 highgscores
if (highScoreList.Count > 10)
{
highScoreList.RemoveAt(10);
}
if (Convert.ToInt32(highScoreList[highScoreList.Count - 1].score) <= timer)
{
for (int i = 0; i <= highScoreList.Count; i++)
{
if (Convert.ToInt32(highScoreList[i].score) <= timer)
{
Score s = new Score(InstructionScreen.bluePlayerName, InstructionScreen.orangePlayerName, Convert.ToString(timer));
highScoreList.Insert(i, s);
break;
}
}
}
if (highScoreList.Count > 10)
{
highScoreList.RemoveAt(10);
}
}
public void ReadXml(XmlReader reader)
{
do
{
reader.ReadStartElement("LogProperty");
//Create new LogDetailInfo object
var logDetail = new LogDetailInfo();
//Load it from the Xml
logDetail.ReadXml(reader);
//Add to the collection
Add(logDetail);
} while (reader.ReadToNextSibling("LogProperty"));
}
void ReadXml_Characters(XmlReader _reader)
{
//We are in the Characters element, read it's descendant elements named Character until we run out
if (_reader.ReadToDescendant("Character"))
{
do
{
//Read X and Y attributes of the Character element
int x = int.Parse(_reader.GetAttribute("X"));
int y = int.Parse(_reader.GetAttribute("Y"));
Character c = CreateCharacter(tiles[x, y]);
//Things like health set in c's ReadXml
c.ReadXml(_reader);
}while (_reader.ReadToNextSibling("Character"));
}
}
/// <summary>
/// Returns the list of all employees in the collection.
/// </summary>
/// <returns>The list of all employees.</returns>
public List <Employee> GetAllEmployees()
{
if (employees == null)
{
employees = new List <Employee>();
string dirPath = Path.GetDirectoryName(FilePath);
if (!Directory.Exists(dirPath))
{
Directory.CreateDirectory(dirPath);
}
if (!File.Exists(FilePath))
{
CreateEmptyXmlFile(FilePath);
}
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreWhitespace = true;
settings.IgnoreComments = true;
using (XmlReader xmlFileIn = XmlReader.Create(FilePath, settings))
{
try
{
if (xmlFileIn.ReadToDescendant("Employee"))
{
do
{
string employeeId = xmlFileIn.GetAttribute("EmployeeId");
xmlFileIn.ReadStartElement("Employee");
string fullName = xmlFileIn.ReadElementContentAsString();
Department department = (Department)Enum.Parse(typeof(Department),
xmlFileIn.ReadElementContentAsString());
DateTime weekStart = DateTime.Parse(xmlFileIn.ReadElementContentAsString());
decimal salary = xmlFileIn.ReadElementContentAsDecimal();
employees.Add(new Employee(employeeId, fullName, department, weekStart, salary));
} while (xmlFileIn.ReadToNextSibling("Employee"));
}
}
catch (Exception) { throw; }
}
}
return(employees);
}
private void GetRTDEConfigFromFile(string xmlKey, List <KeyValuePair <string, string> > rtdeConfiguration)
{
//List<KeyValuePair<string,string>> values = new List<KeyValuePair<string, string>>();
XmlReader xmlReader = XmlReader.Create(@"C:\SourceCode\ur-interface\URConnect\UniversalRobotsConnect\bin\Debug\Resources\rtde_configuration.xml");
xmlReader.ReadToFollowing(xmlKey);
if (xmlReader.ReadToDescendant("field"))
{
do
{
var name = xmlReader.GetAttribute("name");
var value = xmlReader.GetAttribute("type");
rtdeConfiguration.Add(new KeyValuePair <string, string>(name, value));
} while (xmlReader.ReadToNextSibling("field"));
}
//return rtdeConfiguration;
}
public static Parameter ReadXml(XmlReader reader)
{
Parameter paramGroup = new Parameter(reader.GetAttribute("name"));
XmlReader subReader = reader.ReadSubtree();
// Advance to the first inner element. Two reads are needed to ensure we don't get stuck on containing Element, or an EndElement
subReader.Read();
// In case the reader gets passed early, we descend to Params if it's not a Params or Param
if (subReader.Name != "Params" && subReader.Name != "Param")
{
subReader.ReadToDescendant("Params");
}
subReader.Read();
do
{
string k = subReader.GetAttribute("name");
// Sometimes the look will get stuck on a Whitespace or an EndElement and error, so continue to next loop if we encounter one
if (subReader.NodeType == XmlNodeType.Whitespace || subReader.NodeType == XmlNodeType.EndElement)
{
continue;
}
// Somewhat redundant check to make absolutely sure we're on an Element
if (subReader.NodeType == XmlNodeType.Element)
{
// An empty element is a singular Param such as <Param name="name" value="value />
if (subReader.IsEmptyElement)
{
string v = subReader.GetAttribute("value");
paramGroup[k] = new Parameter(k, v);
}
else
{
// This must be a group element, so we recurse and dive deeper
paramGroup[k] = Parameter.ReadXml(subReader);
}
}
}while (subReader.ReadToNextSibling("Param"));
subReader.Close();
return(paramGroup);
}
private string[] readFileElements(XmlReader reader, string tag)
{
List <string> fileNames = new List <string>();
if (reader.ReadToFollowing(tag))
{
if (reader.ReadToDescendant("file"))
{
do
{
string fname = reader.ReadString();
fileNames.Add(fname);
} while (reader.ReadToNextSibling("file"));
}
}
return(fileNames.ToArray());
}
//[Variation("If name not found, stop at end element of the subtree", Priority = 1)]
public void v4()
{
XmlReader DataReader = GetReader(new StringReader(_xmlStr));
PositionOnElement(DataReader, "elem");
int depth = DataReader.Depth;
TestLog.Compare(DataReader.ReadToNextSibling("abc"), false, "Reader returned true for an invalid name");
TestLog.Compare(DataReader.NodeType, XmlNodeType.EndElement, "Wrong node type");
TestLog.Compare(DataReader.Depth, depth - 1, "Wrong Depth");
while (DataReader.Read())
{
;
}
DataReader.Dispose();
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Reads a Module Definitions from an XmlReader
/// </summary>
/// <param name="reader">The XmlReader to use</param>
/// <history>
/// [cnurse] 01/17/2008 Created
/// </history>
/// -----------------------------------------------------------------------------
private void ReadModuleDefinitions(XmlReader reader)
{
reader.ReadStartElement("moduleDefinitions");
do
{
reader.ReadStartElement("moduleDefinition");
//Create new ModuleDefinition object
var moduleDefinition = new ModuleDefinitionInfo();
//Load it from the Xml
moduleDefinition.ReadXml(reader);
//Add to the collection
ModuleDefinitions.Add(moduleDefinition.FriendlyName, moduleDefinition);
} while (reader.ReadToNextSibling("moduleDefinition"));
}
private void LoadSubPossibilitiesFromXml(XmlReader xrdr, ICmPossibility owner, string sItemClassName)
{
Debug.Assert(owner != null);
if (xrdr.ReadToDescendant(sItemClassName))
{
do
{
string sGuid = xrdr.GetAttribute("guid");
xrdr.MoveToElement();
Guid guid = Guid.Empty;
if (!String.IsNullOrEmpty(sGuid))
{
guid = new Guid(sGuid);
}
ICmPossibility poss = null;
switch (sItemClassName)
{
case "CmPossibility":
poss = m_factPoss.Create(EnsureGuid(guid), owner);
break;
case "CmAnthroItem":
Debug.Assert(owner is ICmAnthroItem);
poss = m_factAnthro.Create(EnsureGuid(guid), owner as ICmAnthroItem) as ICmPossibility;
break;
case "CmSemanticDomain":
Debug.Assert(owner is ICmSemanticDomain);
poss = m_factSemDom.Create(EnsureGuid(guid), owner as ICmSemanticDomain) as ICmPossibility;
break;
case "PartOfSpeech":
Debug.Assert(owner is IPartOfSpeech);
poss = m_factPOS.Create(guid, (IPartOfSpeech)owner);
break;
default:
// TODO: implement the other subclasses of CmPossibility?
break;
}
Debug.Assert(poss != null);
ReadPossItem(xrdr.ReadSubtree(), poss, sItemClassName);
} while (xrdr.ReadToNextSibling(sItemClassName));
}
xrdr.Read(); // reads end element.
}
private void ReadXml_Wallet(XmlReader reader)
{
if (reader.ReadToDescendant("Currency"))
{
do
{
Currency c = new Currency
{
Name = reader.GetAttribute("Name"),
ShortName = reader.GetAttribute("ShortName"),
Balance = float.Parse(reader.GetAttribute("Balance"))
};
Wallet.Currencies[c.Name] = c;
}while (reader.ReadToNextSibling("Character"));
}
}
void ReadXml_Buildings(XmlReader reader)
{
Debug.Log("ReadXml_Buildings");
if (reader.ReadToDescendant("Building"))
{
do
{
int x = int.Parse(reader.GetAttribute("X"));
int z = int.Parse(reader.GetAttribute("Z"));
Building bld = PlaceBuilding(reader.GetAttribute("objectType"), tiles[x, z]);
//Debug.Log(bld.objectType);
bld.ReadXml(reader);
} while (reader.ReadToNextSibling("Building"));
}
}
/// <summary>
/// Reads a specific data tag from the xml document.
/// </summary>
/// <param name='reader'>
/// Reader.
/// </param>
private void ReadData(XmlReader reader)
{
//If these values are not being set,
//something is wrong.
string key = "ERROR";
string value = "ERROR";
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.Name == "name")
{
key = reader.Value;
}
}
}
//Move back to the element
reader.MoveToElement();
//Read the child nodes
if (reader.ReadToDescendant("value"))
{
do
{
//value = reader.ReadString();
value = reader.ReadElementContentAsString();
if (reader.Name.Equals("data"))
{
break;
}
}while (reader.ReadToNextSibling("value"));
}
//Add the raw values to the dictionary
textDataBase.Add(key, value);
//Add the localized parsed values to the localizedObjectDataBase
LocalizedObject newLocalizedObject = new LocalizedObject();
newLocalizedObject.ObjectType = LocalizedObject.GetLocalizedObjectType(key);
newLocalizedObject.TextValue = value;
localizedObjectDataBase.Add(LocalizedObject.GetCleanKey(key, newLocalizedObject.ObjectType), newLocalizedObject);
}
private void parseMapXML(string fileName)
{
XmlReader reader = XmlReader.Create(fileName);
while (reader.Read())
{
if (!reader.IsStartElement())
{
continue;
}
if (reader.Name != "terrain")
{
continue;
}
string terrainType = reader.GetAttribute("type");
Tile.TileType terrainEnum = (Tile.TileType)Enum.Parse(typeof(Tile.TileType), terrainType);
Tile currentTile;
reader.ReadToDescendant("coord");
do
{
reader.MoveToNextAttribute();
int X = Convert.ToInt32(reader.Value);
reader.MoveToNextAttribute();
int Y = Convert.ToInt32(reader.Value);
reader.MoveToNextAttribute();
int Z = Convert.ToInt32(reader.Value);
string ownerString = reader.GetAttribute("owner");
Player owner = null;
if (ownerString == "1")
{
owner = WoPR.players[0];
}
if (ownerString == "2")
{
owner = WoPR.players[1];
}
Debug.Print(X + " " + Y + " " + Z);
HexCoord position = new HexCoord(X, Y, Z);
/* CHANGED*/ currentTile = new Tile(WoPR, terrainEnum, position, owner);/* CHANGED*/
tiles.Add(position, currentTile);
} while (reader.ReadToNextSibling("coord"));
}
}
void ReadXml_Furnitures(XmlReader reader)
{
if (reader.ReadToDescendant("Furniture"))
{
do
{
int x = int.Parse(reader.GetAttribute("X"));
int y = int.Parse(reader.GetAttribute("Y"));
Furniture furniture = PlaceFurniture(reader.GetAttribute("FurnitureType"), tiles [x, y], false);
furniture.ReadXml(reader);
} while(reader.ReadToNextSibling("Furniture"));
foreach (var furniture in furnitures)
{
Room.DoRoomFloodFill(furniture.tile, true);
}
}
}
public static IList <PowerBuilderConfig> ReadConfigFile(String path)
{
IList <PowerBuilderConfig> configs = new List <PowerBuilderConfig>();
using (FileStream stream = new FileStream(path, FileMode.Open))
{
XmlReader reader = XmlReader.Create(stream);
reader.ReadToDescendant("PowerBuilderRunTime");
do
{
PowerBuilderConfig config = new PowerBuilderConfig();
ReadVersionNumber(config, reader);
ReadFiles(config, reader);
configs.Add(config);
} while (reader.ReadToNextSibling("PowerBuilderRunTime"));
}
return(configs);
}
void ReadXml_Furnitures(XmlReader reader)
{
int x = -1, y = -1, count = 0;
if (reader.ReadToDescendant("Furniture"))
{
do
{
x = int.Parse(reader.GetAttribute("X"));
y = int.Parse(reader.GetAttribute("Y"));
Furniture furn = PlaceFurniture(reader.GetAttribute("objectType"), tiles[x, y]);
furn.ReadXml(reader);
count++;
} while (reader.ReadToNextSibling("Furniture"));
}
Debug.Log("Read " + count + " furnitures.");
}
public void ReadXml(XmlReader reader)
{
//x & y already been set.
// X = int.Parse(reader.GetAttribute("X"));
// Y = int.Parse(reader.GetAttribute("Y"));
// objectType = reader.GetAttribute("objectType");
//movementCost = float.Parse(reader.GetAttribute("movementCost"));
if (reader.ReadToDescendant("Params"))
{
do
{
string k = reader.GetAttribute("Name");
float v = float.Parse(reader.GetAttribute("value"));
furnParameters.Add(k, v);
} while (reader.ReadToNextSibling("Params"));
}
}
private void ReadAvailableLanguagesResponse(Stream stream)
{
using (XmlReader reader = XmlReader.Create(stream))
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element &&
reader.Name == "ArrayOfstring" &&
reader.ReadToDescendant("string"))
{
do
{
availableLanguages.Add(reader.ReadString());
}while (reader.ReadToNextSibling("string"));
}
}
}
}
private RecipeCraft LoadRecipeCraft(XmlReader xmlReader)
{
int recipe_id = int.Parse(xmlReader.GetAttribute("recipe_id"));
int result_id = int.Parse(xmlReader.GetAttribute("result_id"));
int chance = int.Parse(xmlReader.GetAttribute("chance"));
RecipeCraft result = new RecipeCraft(recipe_id, result_id, chance);
if (xmlReader.ReadToDescendant("ingridien"))
{
do
{
int id = int.Parse(xmlReader.GetAttribute("id"));
int number = int.Parse(xmlReader.GetAttribute("number"));
result.AddIngridient(id, number);
} while (xmlReader.ReadToNextSibling("ingridien"));
}
return(result);
}
static Dictionary <int, string> BuildDictionary()
{
Dictionary <int, string> spellEffectNameDictionary = new Dictionary <int, string>();
XmlReader xmlReader = XmlReader.Create(
typeof(SpellEffectNameDictionary).Assembly.GetManifestResourceStream(typeof(SpellEffectNameDictionary), "SpellEffectNames.xml"),
new XmlReaderSettings()
{
IgnoreWhitespace = true,
IgnoreComments = true,
CloseInput = true,
ConformanceLevel = ConformanceLevel.Document,
});
xmlReader.Read();
xmlReader.ReadStartElement("SpellEffects");
while (xmlReader.NodeType == XmlNodeType.Element)
{
int id;
string name;
if (xmlReader.Name != "SpellEffect")
{
if (!xmlReader.ReadToNextSibling("SpellEffect"))
{
continue;
}
}
xmlReader.MoveToAttribute("Id");
xmlReader.ReadAttributeValue();
id = int.Parse(xmlReader.Value);
xmlReader.MoveToAttribute("Name");
xmlReader.ReadAttributeValue();
name = xmlReader.Value;
xmlReader.Skip();
spellEffectNameDictionary.Add(id, name);
}
xmlReader.ReadEndElement();
return(spellEffectNameDictionary);
}
/// <summary>
/// Initializes RoutingRule instance from its XML representation.
/// </summary>
/// <param name="reader">
/// The Xml reader stream from where Region instance is intialized.
/// </param>
public void ReadXml(XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
Endpoints = new Collection <string>();
if (reader.NodeType == XmlNodeType.Element &&
reader.LocalName == "RoutingRule")
{
string attr = reader.GetAttribute("name");
if (attr != null)
{
Name = attr;
}
attr = reader.GetAttribute("value");
if (attr != null)
{
Value = attr;
}
bool isEmpty = reader.IsEmptyElement;
reader.Read();
if (!isEmpty)
{
while (reader.NodeType != XmlNodeType.EndElement && !reader.EOF)
{
if (reader.LocalName == "Endpoint")
{
Endpoints.Add(reader.ReadElementContentAsString());
}
else
{
reader.ReadToNextSibling("Endpoint");
}
}
reader.Read();
}
}
}
private static void ParseIcons(
XmlReader reader, Dispatcher dispatcher,
IDictionary <string, ImageSource> icons)
{
while (reader.ReadToFollowing("UUID"))
{
var id = reader.ReadElementContentAsString();
if (reader.Name != "Data" &&
!reader.ReadToNextSibling("Data"))
{
continue;
}
var data = Convert.FromBase64String(
reader.ReadElementContentAsString());
BitmapImage image = null;
if (dispatcher.CheckAccess())
{
image = new BitmapImage();
image.SetSource(new MemoryStream(data));
}
else
{
var wait = new ManualResetEvent(false);
dispatcher.BeginInvoke(() =>
{
image = new BitmapImage();
image.SetSource(new MemoryStream(data));
wait.Set();
});
wait.WaitOne();
}
if (!icons.ContainsKey(id))
{
icons.Add(id, image);
}
}
}
static void ReadData(XmlReader reader, SortedDictionary <string, LocalizedObject> loadedLanguageDictionary)
{
string key = string.Empty;
string value = string.Empty;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.Name == "name")
{
key = reader.Value;
}
}
}
//Move back to the element
reader.MoveToElement();
//Read the child nodes
if (reader.ReadToDescendant("value"))
{
do
{
value = reader.ReadElementContentAsString();
}while (reader.ReadToNextSibling("value"));
}
//Add the localized parsed values to the localizedObjectDict
LocalizedObject newLocalizedObject = new LocalizedObject();
newLocalizedObject.ObjectType = LocalizedObject.GetLocalizedObjectType(key);
newLocalizedObject.TextValue = value;
if (newLocalizedObject.ObjectType != LocalizedObjectType.STRING && newLocalizedObject.TextValue != null && newLocalizedObject.TextValue.StartsWith("override="))
{
newLocalizedObject.OverrideLocalizedObject = true;
newLocalizedObject.OverrideObjectLanguageCode = newLocalizedObject.TextValue.Substring("override=".Length);
}
if (!loadedLanguageDictionary.ContainsKey(key))
{
loadedLanguageDictionary.Add(LocalizedObject.GetCleanKey(key, newLocalizedObject.ObjectType), newLocalizedObject);
}
}
// Handles the author getting
private string GetAuthor()
{
if (this.found)
{
//take our saved xmldocument and convert it to a stream
StringReader str = new StringReader(this.ToString());
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreComments = true;
settings.IgnoreWhitespace = true;
XmlDocument x = this.response;
XmlReader xmlIn = XmlReader.Create(str, settings);
string ret = "";
//So for some reason, on certain books in the isbndb page, the author elements don't exist.
//This code stops the program from crashing, and returns a blank value.
try {
if (xmlIn.ReadToDescendant("author_data"))
{
do
{
xmlIn.ReadStartElement("author_data");
xmlIn.ReadElementContentAsString();
ret += xmlIn.ReadElementContentAsString() + "; ";
} while (xmlIn.ReadToNextSibling("author_data"));
//remove the semicolon and space at the end
ret = ret.Substring(0, ret.Length - 2);
}
}
catch (InvalidOperationException) {
ret = "";
}
return(ret);
}
else
{
return("");
}
}
private HashSet <NATION> ParseNationsFromStream(Stream stream)
{
HashSet <NATION> nations = new HashSet <NATION>();
XmlReader reader = XmlReader.Create(stream);
reader.ReadToDescendant("NATIONS");
reader.ReadToDescendant("NATION");
do
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(reader.ReadOuterXml());
XElement nation = XElement.Load(doc.DocumentElement.CreateNavigator().ReadSubtree()); // convert xmlnode to xelement
nations.Add(BuildNation(nation));
}while (reader.ReadToNextSibling("NATION"));
reader.Close();
reader.Dispose();
return(nations);
}
public static QuestionGenerator CreateGeneratorFromXml(XmlReader reader)
{
bool used = reader.GetAttribute("Used").Equals("y");
if(!used) return null;
QuestionGenerator generator = new QuestionGenerator();
generator.m_tags = reader.GetAttribute("Tags").Split(';');
generator.m_type = (GeneratorType)System.Enum.Parse(typeof(GeneratorType), reader.GetAttribute("Type"));
generator.m_weight = System.Convert.ToSingle(reader.GetAttribute("Weight"));
generator.m_questionText = reader.GetAttribute("QuestionText");
generator.m_adjacentWithin = System.Convert.ToInt32(reader.GetAttribute("AdjacentWithin"));
generator.m_infoPrefix = reader.GetAttribute("InfoPrefix");
generator.m_infoSuffix = reader.GetAttribute("InfoSuffix");
bool preventDuplicates = generator.m_type == GeneratorType.SortedMultiset;
reader.ReadToDescendant("Answer");
do{
generator.AddAnswer(reader.GetAttribute("Text"), reader.GetAttribute("Value"), preventDuplicates);
}while(reader.ReadToNextSibling("Answer"));
return generator;
}
/// <summary>
/// Reads a specific data tag from the xml document.
/// </summary>
/// <param name='reader'>
/// Reader.
/// </param>
private void ReadData(XmlReader reader)
{
//If these values are not being set,
//something is wrong.
string key = "ERROR";
string value = "ERROR";
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.Name == "name")
{
key = reader.Value;
}
}
}
//Move back to the element
reader.MoveToElement();
//Read the child nodes
if (reader.ReadToDescendant("value"))
{
do
{
value = reader.ReadString();
}
while (reader.ReadToNextSibling("value"));
}
//Add the raw values to the dictionary
textDataBase.Add(key, value);
//Add the localized parsed values to the localizedObjectDataBase
LocalizedObject newLocalizedObject = new LocalizedObject();
newLocalizedObject.ObjectType = LocalizedObject.GetLocalizedObjectType(key);
newLocalizedObject.TextValue = value;
localizedObjectDataBase.Add(LocalizedObject.GetCleanKey(key,newLocalizedObject.ObjectType), newLocalizedObject);
}
protected void LoadPosition(XmlReader reader) {
reader.ReadToFollowing ("Position");
reader.ReadToDescendant ("x");
Vector3 loadedPosition = new Vector3 ();
loadedPosition.x = reader.ReadElementContentAsFloat ();
reader.ReadToNextSibling ("y");
loadedPosition.y = reader.ReadElementContentAsFloat ();
reader.ReadToNextSibling ("z");
loadedPosition.z = reader.ReadElementContentAsFloat ();
transform.position = loadedPosition;
reader.ReadEndElement ();
}
private void LoadEnemies(XmlReader reader) {
reader.ReadStartElement("Enemies");
GameObject enemy = null;
bool enemyToParse = reader.ReadToFollowing ("Enemy");
Debug.Log ("Started parsing enemies..." + enemyToParse);
do {
if(!enemyToParse)
break;
Debug.Log ("Found an enemy");
switch (reader.GetAttribute ("Type")) {
case "Bat":
enemy = Instantiate (prefabDictionary ["Bat"]);
break;
case "Blob":
enemy = Instantiate (prefabDictionary ["Blob"]);
break;
}
enemy.GetComponent<Enemy> ().Load (reader);
} while(reader.ReadToNextSibling("Enemy"));
}
/// <summary>
/// Loads the status.
/// </summary>
/// <param name="reader">Reader.</param>
protected override void LoadStatus (XmlReader reader)
{
base.LoadStatus (reader);
reader.ReadToNextSibling ("Mana");
mana.value = reader.ReadElementContentAsFloat ();
Debug.Log("Found Exp field: " + reader.ReadToNextSibling ("Exp"));
Debug.Log("Found level field: " + reader.ReadToNextSibling ("Level"));
GetComponent<Inventory> ().LoadInventory (reader);
reader.ReadEndElement ();
}
