Example

Krythic

Dec 13th, 2021

1,195

Never

Add comment

Not a member of Pastebin yet? Sign Up, it unlocks many cool features!

C# 15.16 KB | None | 0 0

raw download clone embed print report

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Xml;
using VoidwalkerEngine.Framework.Game.Systems.GameItems;
using VoidwalkerEngine.Framework.Game.Systems.GameItems.Affixes;
using VoidwalkerEngine.Framework.Game.Systems.GameItems.Enchanting;
using VoidwalkerEngine.Framework.Game.Systems.GameItems.Templates;
using VoidwalkerEngine.Framework.Game.Systems.StatusEffects;
using VoidwalkerEngine.Framework.Logic;
using VoidwalkerEngine.Framework.Maths;
using VoidwalkerEngine.Framework.Parsers;
using VoidwalkerEngine.Framework.Utilities;
namespace VoidwalkerEngine.Framework.Collections
{
public class GameDatabase
{
public List<StatusEffect> StatusEffects { get; set; }
public List<Enchantment> Enchantments { get; set; }
public Dictionary<string, GameItem> GameItems { get; set; }
public List<EpicItemTemplate> EpicItemTemplates { get; set; }
public List<DynamicMagicAffix> MagicAffixes { get; set; }
public GameDatabase()
{
this.StatusEffects = new List<StatusEffect>();
this.Enchantments = new List<Enchantment>();
this.GameItems = new Dictionary<string, GameItem>();
this.EpicItemTemplates = new List<EpicItemTemplate>();
this.MagicAffixes = new List<DynamicMagicAffix>();
}
public List<GameItem> FindGameItems(GameItemType type)
{
List<GameItem> results = new List<GameItem>();
foreach (GameItem item in this.GameItems.Values)
{
if (item != null && item.ItemType == type)
{
results.Add(item);
}
}
return results;
}
public List<Enchantment> GetEnchantments(List<string> identifiers)
{
List<Enchantment> results = new List<Enchantment>();
foreach (string identifier in identifiers)
{
Enchantment enchant = GetEnchantment(identifier);
if (enchant != null)
{
results.Add(enchant);
}
}
return results;
}
public Enchantment GetEnchantment(string identifier)
{
foreach (Enchantment enchantment in Enchantments)
{
if (enchantment.Identifier.Equals(identifier))
{
return enchantment;
}
}
return null;
}
public void Load(string path)
{
if (path != null && File.Exists(path))
{
byte[] fileData = File.ReadAllBytes(path);
/**
* Check to see if the database is an encrypted format.
* And if it is, move to decrypt it using the database
* encryption password.
*/
if (path.EndsWith(".bin"))
{
VoidwalkerCipher decryptionCipher = new VoidwalkerCipher("Krythic");
decryptionCipher.DecryptBytes(fileData);
}
// Check database xml header to make sure it's valid
if (VoidwalkerSerialization.IsValidXmlHeader(fileData))
{
MemoryStream stream = new MemoryStream(fileData);
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreComments = true;
XmlReader reader = XmlReader.Create(stream, settings);
while (reader.Read())
{
string localName = reader.LocalName;
switch (localName)
{
case "GameItem":
ParseGameItem(reader);
break;
case "DynamicMagicAffix":
ParseMagicAffix(reader);
break;
default:
break;
}
}
}
else
{
throw new System.Exception("Database file is corrupted; text is not valid xml!");
}
}
}
/// <summary>
/// Current API Keywords:
/// Weapons, Chestwear, Footwear, Handwear, Headwear, Rings, Amulets
/// </summary>
/// <param name="name"></param>
/// <param name="value"></param>
/// <param name="constraints"></param>
public void ParseGameItemConstraint(string name, string value, List<GameItemType> constraints)
{
switch (name)
{
case "Weapons":
if (Boolean.Parse(value))
{
constraints.AddRange(new GameItemType[] {
GameItemType.OneHandedSword, GameItemType.OneHandedMace, GameItemType.OneHandedAxe,
GameItemType.TwoHandedSword, GameItemType.TwoHandedMace, GameItemType.TwoHandedAxe,
GameItemType.Bow, GameItemType.Dagger, GameItemType.Fist, GameItemType.Staff, GameItemType.Wand,
});
}
break;
case "Chestwear":
if (Boolean.Parse(value))
{
constraints.AddRange(new GameItemType[] {
GameItemType.LightChestwear, GameItemType.MediumChestwear, GameItemType.HeavyChestwear,
});
}
break;
case "Footwear":
if (Boolean.Parse(value))
{
constraints.AddRange(new GameItemType[] {
GameItemType.LightFootwear, GameItemType.MediumFootwear, GameItemType.HeavyFootwear,
});
}
break;
case "Handwear":
if (Boolean.Parse(value))
{
constraints.AddRange(new GameItemType[] {
GameItemType.LightHandwear, GameItemType.MediumHandwear, GameItemType.HeavyHandwear,
});
}
break;
case "Headwear":
if (Boolean.Parse(value))
{
constraints.AddRange(new GameItemType[] {
GameItemType.LightHeadwear, GameItemType.MediumHeadwear, GameItemType.HeavyHeadwear,
});
}
break;
case "Rings":
if (Boolean.Parse(value))
{
constraints.Add(GameItemType.Ring);
}
break;
case "Amulets":
if (Boolean.Parse(value))
{
constraints.Add(GameItemType.Amulet);
}
break;
case "HeldItems":
if (Boolean.Parse(value))
{
constraints.AddRange(new GameItemType[] {
GameItemType.Shield, GameItemType.Phylactery, GameItemType.Focus,
GameItemType.Tome, GameItemType.Quiver, GameItemType.Instrument
});
}
break;
default:
Console.WriteLine("Unknown GameItemType Constraint keyword: '" + name + "'");
break;
}
}
public void ParseMagicAffix(XmlReader reader)
{
DynamicMagicAffix affix = new DynamicMagicAffix();
if (reader.HasAttributes)
{
int attributeCount = reader.AttributeCount;
for (int i = 0; i < attributeCount; i++)
{
reader.MoveToNextAttribute();
string attributeName = reader.Name;
switch (attributeName)
{
case "Name":
affix.Name = reader.Value;
break;
case "AffixType":
affix.AffixType = VoidwalkerParser.ParseAffixType(reader.Value);
break;
case "Property":
affix.Property = VoidwalkerParser.ParseGamePropertyType(reader.Value);
break;
case "Level":
affix.Level = Int32.Parse(reader.Value);
break;
case "ValueRange":
affix.ValueRange = Range.Parse(reader.Value, '-', Range.Empty);
break;
case "RangeMin":
affix.RangeMin = Range.Parse(reader.Value, '-', Range.Empty);
break;
case "RangeMax":
affix.RangeMax = Range.Parse(reader.Value, '-', Range.Empty);
break;
case "Constraints":
affix.Constraints = VoidwalkerParser.ParseGameItemConstraints(reader.Value);
break;
case "Weight":
affix.Weight = Int32.Parse(reader.Value);
break;
default:
break;
}
}
if (affix != null)
{
this.MagicAffixes.Add(affix);
}
}
while (reader.Read() && !reader.LocalName.Equals("DynamicMagicAffix"))
{
string localName = reader.LocalName;
switch (localName)
{
case "Constraints":
if (affix.Constraints == null)
{
affix.Constraints = new List<GameItemType>();
}
if (reader.HasAttributes)
{
int attributeCount = reader.AttributeCount;
for (int i = 0; i < attributeCount; i++)
{
reader.MoveToNextAttribute();
string attributeName = reader.Name;
ParseGameItemConstraint(attributeName, reader.Value, affix.Constraints);
}
}
break;
default:
break;
}
}
}
public void ParseGameItem(XmlReader reader)
{
GameItem gameItem = new GameItem();
if (reader.HasAttributes)
{
int attributeCount = reader.AttributeCount;
for (int i = 0; i < attributeCount; i++)
{
reader.MoveToNextAttribute();
string attributeName = reader.Name;
switch (attributeName)
{
case "ID":
gameItem.Identifier = reader.Value;
break;
case "ItemType":
gameItem.ItemType = VoidwalkerParser.ParseGameItemType(reader.Value);
break;
case "Rarity":
gameItem.Rarity = VoidwalkerParser.ParseItemRarity(reader.Value);
break;
case "Header":
gameItem.Header = reader.Value;
break;
case "BaseName":
gameItem.BaseName = reader.Value;
break;
case "BaseDamage":
gameItem.BaseDamage = Int32.Parse(reader.Value);
break;
case "BaseDurability":
gameItem.BaseDurability = Int32.Parse(reader.Value);
break;
case "BaseSellPrice":
gameItem.BaseSellPrice = Int32.Parse(reader.Value);
break;
default:
break;
}
}
}
/**
* Parse for Content
*/
while (reader.Read() && !reader.LocalName.Equals("GameItem"))
{
string localName = reader.LocalName;
switch (localName)
{
case "GameItemProperty":
if (gameItem.Properties == null)
{
gameItem.Properties = new List<GameItemProperty>();
}
if (reader.HasAttributes)
{
GameItemProperty property = new GameItemProperty();
int attributeCount = reader.AttributeCount;
for (int i = 0; i < attributeCount; i++)
{
reader.MoveToNextAttribute();
string attributeName = reader.Name;
switch (attributeName)
{
case "Property":
property.Property = VoidwalkerParser.ParseGamePropertyType(reader.Value);
break;
case "Value":
property.Value = Int32.Parse(reader.Value, NumberStyles.AllowLeadingSign);
break;
case "Range":
property.Range = Range.Parse(reader.Value, '-', Range.Empty);
break;
default:
break;
}
}
gameItem.Properties.Add(property);
}
break;
default:
break;
}
}
this.GameItems.Add(gameItem.Identifier, gameItem);
}
}
}

Add Comment

Please, Sign In to add comment