public void Equals_ForTwoEnumElementsOfSameValue_ReturnsTrueEvenForDiffrentDescription() { var firstEnumElement = new EnumElement<SimpleEnum>(SimpleEnum.TwentyOne, "description"); var secondEnumElement = new EnumElement<SimpleEnum>(SimpleEnum.TwentyOne, "diffrent description"); Assert.IsTrue(firstEnumElement.Equals(secondEnumElement)); }
private static T CreateItemFromRow <T>(DataRow row, IEnumerable <PropertyInfo> properties) where T : new() { var item = new T(); foreach (var property in properties.Where(p => !Attribute.IsDefined(p, typeof(NotMappedAttribute)))) { if (property.GetCustomAttributes(true) .Any(p => Attribute.IsDefined(property, typeof(MappedFromJsonField)))) { var jsonField = property.GetCustomAttribute <MappedFromJsonField>().JsonField; if (row[jsonField] != Convert.DBNull) { var jsonObject = JsonHelper.Deserialize((string)row[jsonField]); var value = JsonHelper.GetPropertyValue(jsonObject, property.Name, property.PropertyType); property.SetValue(item, value, null); } else { property.SetValue(item, null, null); } } else { var value = property.PropertyType.IsEnum ? EnumElement.ToEnum(property.PropertyType, row[property.Name]) : row[property.Name] == Convert.DBNull ? null : row[property.Name]; property.SetValue(item, value, null); } } return(item); }
public void SetRunaElement(EnumElement element) { Element = element; switch (element) { case EnumElement.Air: SkeletonAnimation.Skeleton.SetSkin("Runa de Ar"); SkeletonAnimation.Skeleton.SetSlotsToSetupPose(); break; case EnumElement.Earth: SkeletonAnimation.Skeleton.SetSkin("Runa de terra"); SkeletonAnimation.Skeleton.SetSlotsToSetupPose(); break; case EnumElement.Fire: SkeletonAnimation.Skeleton.SetSkin("Runas de fogo"); SkeletonAnimation.Skeleton.SetSlotsToSetupPose(); break; case EnumElement.Water: SkeletonAnimation.Skeleton.SetSkin("Runa de Agua"); SkeletonAnimation.Skeleton.SetSlotsToSetupPose(); break; case EnumElement.Light: SkeletonAnimation.Skeleton.SetSkin("Runa de Luz"); SkeletonAnimation.Skeleton.SetSlotsToSetupPose(); break; } }
/// <summary> /// Adds new enum value element. /// </summary> /// <param name="type">The enum type.</param> /// <param name="customBuildEntriesDelegate">The custom entries layout builder. Allows to hide existing or add different enum values to editor.</param> /// <param name="formatMode">The formatting mode.</param> /// <returns>The created element.</returns> public EnumElement Enum(Type type, EnumComboBox.BuildEntriesDelegate customBuildEntriesDelegate = null, EnumDisplayAttribute.FormatMode formatMode = EnumDisplayAttribute.FormatMode.Default) { var element = new EnumElement(type, customBuildEntriesDelegate, formatMode); OnAddElement(element); return(element); }
public void Equals_ForTwoEnumElementsOfDiffrentValue_ReturnsFalse() { var firstEnumElement = new EnumElement<SimpleEnum>(SimpleEnum.One, "description"); var secondEnumElement = new EnumElement<SimpleEnum>(SimpleEnum.TwentyOne, "description"); Assert.IsFalse(firstEnumElement.Equals(secondEnumElement)); }
/// <summary> /// Adds new enum value element. /// </summary> /// <param name="type">The enum type.</param> /// <param name="cusstomBuildEntriesDelegate">The custom entries layout builder. Allows to hide existing or add diffrent enum values to editor.</param> /// <returns>The created element.</returns> public EnumElement Enum(Type type, EnumElement.BuildEntriesDelegate cusstomBuildEntriesDelegate = null) { EnumElement element = new EnumElement(type, cusstomBuildEntriesDelegate); OnAddElement(element); return(element); }
public override List <Field> GetFieldsForLucene() { var fields = new List <Field>(); EnumElement enumElement = (EnumElement)programElement; fields.Add(new Field(SandoField.Namespace.ToString(), enumElement.Namespace.ToSandoSearchable(), Field.Store.YES, Field.Index.ANALYZED)); AddBodyField(fields, new Field(SandoField.Body.ToString(), enumElement.RawSource.ToSandoSearchable(), Field.Store.NO, Field.Index.ANALYZED)); fields.Add(new Field(SandoField.AccessLevel.ToString(), enumElement.AccessLevel.ToString().ToLower(), Field.Store.YES, Field.Index.NOT_ANALYZED)); AddBodyField(fields, new Field(SandoField.Body.ToString(), enumElement.Body.ToSandoSearchable(), Field.Store.NO, Field.Index.ANALYZED)); return(fields); }
public EnumType(Program program, EnumElement element) : base(program, new UserElementMixin(element)) { List <EnumMember> members = new List <EnumMember>(); foreach (var m in element.Members) { members.Add(new EnumMember(m)); } _members = members.ToImmutableList(); }
/// <inheritdoc /> public override void Initialize(LayoutElementsContainer layout) { if (HasDifferentTypes) { // No support for different enum types } else { element = layout.Enum(Values[0].GetType()); element.ValueChanged += OnValueChanged; } }
private void ShowEnums(Int32 level, String nodeText, String parentNodeText) { listView1.Items.Clear(); listView1.Columns.Clear(); if (level == 0 || level == 1) { listView1.Columns.Add("Name", -1, HorizontalAlignment.Left); listView1.Columns.Add("Description", -1, HorizontalAlignment.Left); listView1.Columns.Add("IntegerBased", -1, HorizontalAlignment.Left); listView1.Columns.Add("Template", -1, HorizontalAlignment.Left); IList list; if (level == 0) { list = enums; } else { list = new ArrayList(); list.Add(EnumElement.FindByName((ArrayList)enums, nodeText)); } foreach (EnumElement e in list) { ListViewItem lvi = new ListViewItem(e.Name); lvi.SubItems.Add(e.Description); lvi.SubItems.Add(e.IntegerBased.ToString()); lvi.SubItems.Add(e.Template); listView1.Items.Add(lvi); } } if (level == 2 && nodeText.Equals("values")) { listView1.Columns.Add("Name", -1, HorizontalAlignment.Left); listView1.Columns.Add("Code", -1, HorizontalAlignment.Left); listView1.Columns.Add("Description", -1, HorizontalAlignment.Left); EnumElement e = EnumElement.FindByName((ArrayList)enums, parentNodeText); foreach (EnumValueElement v in e.Values) { ListViewItem lvi = new ListViewItem(v.Name); lvi.SubItems.Add(v.Code); lvi.SubItems.Add(v.Description); listView1.Items.Add(lvi); } } }
public void ProgramElementReader_ReadProgramElementFromDocumentReturnValidEnumElementForValidDocument() { EnumElement element = SampleProgramElementFactory.GetSampleEnumElement(); Document document = DocumentFactory.Create(element).GetDocument(); EnumElement returnedElement = ConverterFromHitToProgramElement.Create(document).Convert() as EnumElement; Assert.IsNotNull(returnedElement, "returned class element is null!"); Assert.True(element.AccessLevel == returnedElement.AccessLevel, "AccessLevel is different!"); Assert.True(element.DefinitionLineNumber == returnedElement.DefinitionLineNumber, "DefinitionLineNumber is different!"); Assert.True(StandardizeFilePath(element.FullFilePath) == returnedElement.FullFilePath, "FullFilePath is different!"); Assert.True(element.Name == returnedElement.Name, "Name is different!"); Assert.True(element.Namespace == returnedElement.Namespace, "Namespace is different!"); Assert.True(element.ProgramElementType == returnedElement.ProgramElementType, "ProgramElementType is different!"); Assert.True(element.RawSource == returnedElement.RawSource, "Snippet is different!"); Assert.True("not stored in index" == returnedElement.Body, "Body is different"); }
private List <FieldDeclaration> DeclareFields(EnumElement enumeration, bool isBitmask, Dictionary <string, EnumMapping> enumLookup) { var result = new List <FieldDeclaration>(); if (enumeration != null) { if (isBitmask && !enumeration.Fields.Values.Any(x => x.Value == "0" && !x.IsBitmask)) { AddNoneField(result); } var fieldNameLookup = enumeration.Fields.Values.ToDictionary(x => x.VkName, x => this.nameFormatter.FormatName(enumeration, x, x.IsBitmask)); var fieldNameCount = fieldNameLookup.Values.GroupBy(x => x).ToDictionary(x => x.Key, x => x.Count()); foreach (var field in enumeration.Fields.Values) { var name = fieldNameLookup[field.VkName]; if (fieldNameCount[name] > 1) { name += field.ExtensionNamespace; } string value = field.Value; if (field.IsBitmask) { value = $"1 << {value}"; } result.Add(new FieldDeclaration { VkName = field.VkName, Name = name, Extension = field.ExtensionNamespace, Value = value }); enumLookup.Add(field.VkName, new EnumMapping(enumeration.VkName, name)); } } else { AddNoneField(result); } return(result); }
public string FormatName(EnumElement enumeration, EnumField value, bool isBitmask) { string digitsPrefix = JoinNameParts(enumeration.NameParts.TakeWhile(x => !digitsSuffix.Contains(x))); int skipAtEnd = isBitmask && digitsSuffix.Contains(value.NameParts.Last()) ? 1 : 0; string result = JoinNameParts(value.NameParts.Take(value.NameParts.Length - skipAtEnd)); if (!char.IsLetter(result[0])) { result = digitsPrefix + result; } return(result); }
private Runa createRuna(int column, int row) { int quantityOfAvailibleElements = Enum.GetValues(typeof(EnumElement)).Length; EnumElement element = (EnumElement)_random.Next(0, quantityOfAvailibleElements); GameObject runaPrefab = Instantiate(RunaPrefab); Runa runa = runaPrefab.GetComponent <Runa>(); runa.SetRunaElement(element); runa.SpotInKeyboard = new Vector2(column, row); setRunaPosition(runa, column, row, false); return(runa); }
internal EnumElement Restore() { var model = new EnumElement(this.FullName); model.Label = this.Label; model.Left = this.Left; model.Top = this.Top; model.Width = this.Width; model.Height = this.Height; foreach (var item in this.Items) { var modelItem = item.Restore(); model.Items.Add(modelItem); } return(model); }
public Ability(string Name, EnumAbilityStrength abilityStrength, EnumElement element, EnumAbilityType abilityType, EnumTargets targets, EnumTargetModifier targetModifier, EnumDuration duration) { this.Name = Name; this.abilityStrength = abilityStrength; this.element = element; this.abilityType = abilityType; this.targets = targets; this.targetModifier = targetModifier; this.duration = duration; this.RoundsLeft = (int)duration; Cost = (int)abilityStrength + 1 + (abilityType == EnumAbilityType.HEAL ? 2 : 1) + (int)targets + 1 + (targetModifier == EnumTargetModifier.RANDOM ? 1 : 2) + (int)duration; Damage = 10 * (int)abilityStrength; }
/// <inheritdoc /> public override void Initialize(LayoutElementsContainer layout) { var mode = EnumDisplayAttribute.FormatMode.Default; var attributes = Values.GetAttributes(); if (attributes?.FirstOrDefault(x => x is EnumDisplayAttribute) is EnumDisplayAttribute enumDisplay) { mode = enumDisplay.Mode; } if (HasDifferentTypes) { // No support for different enum types } else { element = layout.Enum(Values[0].GetType(), null, mode); element.ValueChanged += OnValueChanged; } }
internal static EnumElementXml ConvertToNode(EnumElement model) { var xml = new EnumElementXml(); xml.FullName = model.Name; xml.Label = model.Label; xml.Left = model.Left; xml.Top = model.Top; xml.Width = model.Width; xml.Height = model.Height; xml.Items = new EnumItemElementXml[model.Items.Count]; for (int i = 0, c = model.Items.Count; i < c; i++) { var property = model.Items[i]; var propertyXml = EnumItemElementXml.ConvertToNode(property); xml.Items[i] = propertyXml; } return(xml); }
internal static EnumElementXml ConvertToNode(EnumElement model) { var xml = new EnumElementXml(); xml.FullName = model.Name; xml.Label = model.Label; xml.Left = model.Left; xml.Top = model.Top; xml.Width = model.Width; xml.Height = model.Height; xml.Items = new EnumItemElementXml[model.Items.Count]; for (int i = 0, c = model.Items.Count; i < c; i++) { var property = model.Items[i]; var propertyXml = EnumItemElementXml.ConvertToNode(property); xml.Items[i] = propertyXml; } return xml; }
public void EnumParserTest() { SrcMLCSharpParser parser = new SrcMLCSharpParser(generator); var elements = parser.Parse("TestFiles\\ShortCSharpFile.txt"); bool hasEnum = false; foreach (var programElement in elements) { if (programElement as EnumElement != null) { EnumElement enumElem = (EnumElement)programElement; Assert.AreEqual(enumElem.Name, "LanguageEnum"); Assert.AreEqual(enumElem.DefinitionLineNumber, 7); Assert.AreEqual(enumElem.Namespace, "Sando.Parser"); Assert.AreEqual(enumElem.Body, "Java C CSharp"); Assert.AreEqual(enumElem.AccessLevel, AccessLevel.Public); Assert.True(enumElem.FullFilePath.EndsWith("TestFiles\\ShortCSharpFile.txt")); hasEnum = true; } } Assert.IsTrue(hasEnum); }
public void ParseUndefinedNameEnumTest() { bool hasEnum = false; var parser = new SrcMLCppParser(generator); var elements = parser.Parse("TestFiles\\PlayMp3Dlg.h.txt"); Assert.IsNotNull(elements); foreach (ProgramElement pe in elements) { if (pe is EnumElement) { EnumElement enumElem = (EnumElement)pe; Assert.AreEqual(enumElem.Name, ""); Assert.AreEqual(enumElem.DefinitionLineNumber, 30); Assert.AreEqual(enumElem.Body, "IDD IDD_PLAYMP3_DIALOG"); Assert.AreEqual(enumElem.AccessLevel, AccessLevel.Public); Assert.True(enumElem.FullFilePath.EndsWith("TestFiles\\PlayMp3Dlg.h.txt")); hasEnum = true; } } Assert.IsTrue(hasEnum); }
/// <inheritdoc /> public override void Initialize(LayoutElementsContainer layout) { var mode = EnumDisplayAttribute.FormatMode.Default; var attributes = Values.GetAttributes(); if (attributes?.FirstOrDefault(x => x is EnumDisplayAttribute) is EnumDisplayAttribute enumDisplay) { mode = enumDisplay.Mode; } if (HasDifferentTypes) { // No support for different enum types } else { var enumType = Values.Type.Type != typeof(object) || Values[0] == null?TypeUtils.GetType(Values.Type) : Values[0].GetType(); element = layout.Enum(enumType, null, mode); element.ComboBox.ValueChanged += OnValueChanged; } }
private List <FieldDeclaration> DeclareFields(EnumElement enumeration, bool isBitmask, Dictionary <string, EnumMapping> enumLookup) { var result = new List <FieldDeclaration>(); if (enumeration != null) { if (isBitmask && !enumeration.Fields.Values.Any(x => x.Value == "0" && !x.IsBitmask)) { AddNoneField(result); } foreach (var field in enumeration.Fields.Values) { var name = this.nameFormatter.FormatName(enumeration, field, field.IsBitmask); string value = field.Value; if (field.IsBitmask) { value = $"1 << {value}"; } result.Add(new FieldDeclaration { VkName = field.VkName, Name = name, Value = value }); enumLookup.Add(field.VkName, new EnumMapping(enumeration.VkName, name)); } } else { AddNoneField(result); } return(result); }
private void CreateSqlElementAssociations(ParserValidationDelegate vd) { // find and assign the foreign entity and EnumElement now that they are parsed foreach (DatabaseElement database in databases) { foreach (SqlEntityElement sqlEntity in database.SqlEntities) { foreach (ConstraintElement constraint in sqlEntity.Constraints) { if (constraint.ForeignEntity.Name.Length > 0) { SqlEntityElement entity = SqlEntityElement.FindByName(DatabaseElement.GetAllSqlEntities(databases), constraint.ForeignEntity.Name); if (entity != null) { constraint.ForeignEntity = (SqlEntityElement)entity.Clone(); } else { vd(ParserValidationArgs.NewError("ForeignEntity (" + constraint.ForeignEntity.Name + ") specified in constraint " + constraint.Name + " could not be found as an defined entity")); } } if (constraint.CheckEnum.Name.Length > 0) { EnumElement entity = EnumElement.FindByName(enumtypes as ArrayList, constraint.CheckEnum.Name); if (entity != null) { constraint.CheckEnum = (EnumElement)entity.Clone(); } else { vd(ParserValidationArgs.NewError("CheckEnum (" + constraint.CheckEnum.Name + ") specified in constraint " + constraint.Name + " could not be found as an defined entity")); } } } } } }
public void ParseCPPHeaderTest() { bool hasClass = false; bool hasEnum = false; var parser = new SrcMLCppParser(generator); var elements = parser.Parse("TestFiles\\Event.H.txt"); Assert.IsNotNull(elements); Assert.AreEqual(elements.Count, 8); foreach (ProgramElement pe in elements) { if (pe is ClassElement) { ClassElement classElem = (ClassElement)pe; Assert.AreEqual(classElem.Name, "Event"); Assert.AreEqual(classElem.DefinitionLineNumber, 12); Assert.AreEqual(classElem.AccessLevel, AccessLevel.Public); Assert.AreEqual(classElem.Namespace, String.Empty); Assert.True(classElem.FullFilePath.EndsWith("TestFiles\\Event.H.txt")); hasClass = true; } else if (pe is EnumElement) { EnumElement enumElem = (EnumElement)pe; Assert.AreEqual(enumElem.Name, "EventType"); Assert.AreEqual(enumElem.DefinitionLineNumber, 6); Assert.AreEqual(enumElem.Namespace, String.Empty); Assert.AreEqual(enumElem.Body, "SENSED_DATA_READY SENDING_DONE RECEIVING_DONE"); Assert.AreEqual(enumElem.AccessLevel, AccessLevel.Public); Assert.True(enumElem.FullFilePath.EndsWith("TestFiles\\Event.H.txt")); hasEnum = true; } } Assert.IsTrue(hasClass); Assert.IsTrue(hasEnum); }
private static int CalculateSpellForce(List <Runa> selectedRunas, AttributePoints playerAttributes) { EnumElement element = selectedRunas[0].Element; int elementForce = 0; if (element == EnumElement.Air) { elementForce = playerAttributes.Air; } else if (element == EnumElement.Earth) { elementForce = playerAttributes.Earth; } else if (element == EnumElement.Fire) { elementForce = playerAttributes.Fire; } else if (element == EnumElement.Light) { elementForce = playerAttributes.Light; } else if (element == EnumElement.Water) { elementForce = playerAttributes.Water; } var force = 0; var runasBuff = selectedRunas.Count(x => x.PoweredUp); var runasNormal = selectedRunas.Count(x => !x.PoweredUp); force = (int)(elementForce * (runasBuff * 5) * 1.5) + (elementForce * runasNormal * 5); return(force); }
public void Execute(IServiceCollection target) { var enums = new Dictionary <string, EnumElement>(); foreach (var vkEnum in this.xmlCache.GetVkXml().Element("registry").Elements("enums")) { string name = vkEnum.Attribute("name").Value; string type = vkEnum.Attribute("type")?.Value; string extension = null; string[] nameParts = name == "API Constants" ? new[] { name } : this.nameParser.GetNameParts(name, out extension); var newEnum = new EnumElement { VkName = name, Type = type, NameParts = nameParts, ExtensionNamespace = extension }; foreach (var vkField in vkEnum.Elements("enum")) { string fieldName = vkField.Attribute("name").Value; bool isBitmask = true; string value = vkField.Attribute("bitpos")?.Value; string comment = SimpleParser.NormaliseComment(vkField.Attribute("comment")?.Value); if (value == null) { isBitmask = false; value = vkField.Attribute("value")?.Value; // Special case for mapping C "unsigned long long" // (64-bit unsigned integer) to C# UInt64 if (value == "(~0ULL)") { value = "(~0UL)"; } value = value?.Trim('(', ')'); } IEnumerable <string> fieldNameParts = this.nameParser.ParseEnumField(fieldName, nameParts); newEnum.Fields.Add(fieldName, new EnumField { VkName = fieldName, NameParts = fieldNameParts.ToArray(), IsBitmask = isBitmask, Value = value, Comment = comment != null ? new List <string> { comment } : null }); } enums.Add(name, newEnum); } foreach (var vkExtension in this.xmlCache.GetVkXml() .Element("registry") .Element("extensions") .Elements("extension")) { int extensionNumber = int.Parse(vkExtension.Attribute("number").Value); string extensionName = vkExtension.Attribute("name").Value; var extensionNameParts = extensionName.Split('_'); string extensionSuffix = extensionNameParts[1].ToLower().FirstToUpper(); foreach (var vkExtensionEnum in vkExtension.Elements("require") .SelectMany(x => x.Elements("enum")) .Where(x => x.Attribute("extends") != null)) { string vkName = vkExtensionEnum.Attribute("name").Value; var extendedEnum = enums[vkExtensionEnum.Attribute("extends").Value]; int? value = null; bool isBitmask = false; if (vkExtensionEnum.Attribute("offset") != null) { int offset = int.Parse(vkExtensionEnum.Attribute("offset").Value); value = 1000000000 + 1000 * (extensionNumber - 1) + offset; } else if (vkExtensionEnum.Attribute("bitpos") != null) { value = int.Parse(vkExtensionEnum.Attribute("bitpos").Value); isBitmask = true; } else if (vkExtensionEnum.Attribute("value") != null) { value = int.Parse(vkExtensionEnum.Attribute("value").Value); } if (vkExtensionEnum.Attribute("dir")?.Value == "-") { value = -value; } var nameParts = this.nameParser.ParseEnumField(vkName, extendedEnum.NameParts); extendedEnum.Fields[vkName] = new EnumField { VkName = vkName, Value = value?.ToString(), NameParts = nameParts.ToArray(), IsBitmask = isBitmask, ExtensionNamespace = extensionSuffix }; } } foreach (var element in enums.Values) { target.AddSingleton(element); } }
public static CreateSpellType GetPreviewSpellType(EnumElement?comboStoneElement, EnumElement currentSelectedElement) { if (comboStoneElement == null) { return(CreateSpellType.Attack); } switch (comboStoneElement) { case EnumElement.Air: switch (currentSelectedElement) { case EnumElement.Air: return(CreateSpellType.Attack); case EnumElement.Earth: return(CreateSpellType.Attack); case EnumElement.Fire: return(CreateSpellType.Attack); case EnumElement.Water: return(CreateSpellType.FreezeTime); case EnumElement.Light: return(CreateSpellType.Time); default: throw new Exception("Combinação de elementos não encontrada"); } case EnumElement.Earth: switch (currentSelectedElement) { case EnumElement.Air: return(CreateSpellType.Attack); case EnumElement.Earth: return(CreateSpellType.Attack); case EnumElement.Fire: return(CreateSpellType.Attack); case EnumElement.Water: return(CreateSpellType.Attack); case EnumElement.Light: return(CreateSpellType.Protection); default: throw new Exception("Combinação de elementos não encontrada"); } case EnumElement.Fire: switch (currentSelectedElement) { case EnumElement.Air: return(CreateSpellType.Attack); case EnumElement.Earth: return(CreateSpellType.Attack); case EnumElement.Fire: return(CreateSpellType.Attack); case EnumElement.Water: return(CreateSpellType.Attack); case EnumElement.Light: return(CreateSpellType.Clear); default: throw new Exception("Combinação de elementos não encontrada"); } case EnumElement.Water: switch (currentSelectedElement) { case EnumElement.Air: return(CreateSpellType.FreezeTime); case EnumElement.Earth: return(CreateSpellType.Attack); case EnumElement.Fire: return(CreateSpellType.Attack); case EnumElement.Water: return(CreateSpellType.Attack); case EnumElement.Light: return(CreateSpellType.Health); default: throw new Exception("Combinação de elementos não encontrada"); } case EnumElement.Light: switch (currentSelectedElement) { case EnumElement.Air: return(CreateSpellType.Time); case EnumElement.Earth: return(CreateSpellType.Protection); case EnumElement.Fire: return(CreateSpellType.Clear); case EnumElement.Water: return(CreateSpellType.Health); case EnumElement.Light: return(CreateSpellType.Attack); default: throw new Exception("Combinação de elementos não encontrada"); } default: throw new Exception("Combinação de elementos não encontrada"); } }
public EnumDocument(EnumElement enumElement) : base(enumElement) { }
internal EnumElement Restore() { var model = new EnumElement(this.FullName); model.Label = this.Label; model.Left = this.Left; model.Top = this.Top; model.Width = this.Width; model.Height = this.Height; foreach (var item in this.Items) { var modelItem = item.Restore(); model.Items.Add(modelItem); } return model; }
public ConstantCollator(IEnumerable <EnumElement> enums, NameFormatter nameFormatter) { this.constantsEnum = enums.Single(x => x.VkName == "API Constants"); this.nameFormatter = nameFormatter; }
private static IEnumerable <String> ExtractEnumWords(EnumElement element) { return(GetDefaultLetterWords(element.Body)); }
public int BuffModify(int damage, EnumElement element) { if (element == this.element) if (this.buffType == EnumBuffType.DAMAGE) return (int)(damage * (double)abilityStrength); else return (int)(damage / (double)abilityStrength); else return damage; }
public static ISpell Create(EnumElement element, EnumElement?elementLastRuna, List <Runa> selectedRunas, Character origin, Character target, AttributePoints attributes) { EnumElement element1 = element; EnumElement?element2 = elementLastRuna; var prefabSpell = CreateSpellPrefab(); var force = CalculateSpellForce(selectedRunas, attributes); switch (element1) { case EnumElement.Air: switch (element2) { case EnumElement.Air: return(CreateAttackSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/AirSpell"), force, origin, target, true)); case EnumElement.Earth: return(CreateAttackSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/AirSpell"), force, origin, target, false)); case EnumElement.Fire: return(CreateBurnSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/BurnSpell"), force, attributes, origin, target)); case EnumElement.Water: return(CreateFreezeTimeSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/FreezeSpell"), attributes)); case EnumElement.Light: return(CreateTimeSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/AddTimeSpell"), attributes)); case null: return(CreateAttackSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/AirSpell"), force, origin, target, false)); default: return(null); } case EnumElement.Earth: switch (element2) { case EnumElement.Air: return(CreateAttackSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/EarthSpell"), force, origin, target, false)); case EnumElement.Earth: return(CreateAttackSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/EarthSpell"), force, origin, target, true)); case EnumElement.Fire: return(CreateLavaSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/LavaSpell"), force, attributes, origin, target)); case EnumElement.Water: return(CreateRootingSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/RootingSpell"), force, attributes, origin, target)); case EnumElement.Light: return(CreateProtectionSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/ProtectionSpell"), force, attributes, origin, target)); case null: return(CreateAttackSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/EarthSpell"), force, origin, target, false)); default: return(null); } case EnumElement.Fire: switch (element2) { case EnumElement.Air: return(CreateBurnSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/BurnSpell"), force, attributes, origin, target)); case EnumElement.Earth: return(CreateLavaSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/LavaSpell"), force, attributes, origin, target)); case EnumElement.Fire: return(CreateAttackSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/FireSpell"), force, origin, target, true)); case EnumElement.Water: return(CreateAttackSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/FireSpell"), force, origin, target, false)); case EnumElement.Light: return(CreateClearStatusSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/ClearStatusSpell"), origin)); case null: return(CreateAttackSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/FireSpell"), force, origin, target, false)); default: return(null); } case EnumElement.Water: switch (element2) { case EnumElement.Air: return(CreateFreezeTimeSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/FreezeSpell"), attributes)); case EnumElement.Earth: return(CreateRootingSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/RootingSpell"), force, attributes, origin, target)); case EnumElement.Fire: return(CreateAttackSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/WaterSpell"), force, origin, target, false)); case EnumElement.Water: return(CreateAttackSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/WaterSpell"), force, origin, target, true)); case EnumElement.Light: return(CreateHealthSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/CureSpell"), force, attributes, origin)); case null: return(CreateAttackSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/WaterSpell"), force, origin, target, false)); default: return(null); } case EnumElement.Light: switch (element2) { case EnumElement.Air: return(CreateTimeSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/AddTimeSpell"), attributes)); case EnumElement.Earth: return(CreateProtectionSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/ProtectionSpell"), force, attributes, origin, target)); case EnumElement.Fire: return(CreateClearStatusSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/ClearStatusSpell"), origin)); case EnumElement.Water: return(CreateHealthSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/CureSpell"), force, attributes, origin)); case EnumElement.Light: return(CreateAttackSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/LightSpell"), force, origin, target, false)); case null: return(CreateAttackSpell(prefabSpell, CustomResources.Load <Sprite>("Spells/LightSpell"), force, origin, target, false)); default: return(null); } default: return(null); } }
public UserElementMixin(EnumElement enumElement) : this(enumElement.Name, enumElement.Location, enumElement.Documentation, enumElement.Annotations) { }
public static ColoredString Element(EnumElement element) { Color elementColor; switch (element) { case EnumElement.COLD: elementColor = Color.DarkBlue; break; case EnumElement.FIRE: elementColor = Color.Blue; break; case EnumElement.HOLY: elementColor = Color.LightGoldenrodYellow; break; case EnumElement.LIGHTNING: elementColor = Color.Yellow; break; case EnumElement.PHYSICAL: elementColor = Color.Gray; break; case EnumElement.POISON: elementColor = Color.Green; break; case EnumElement.UNHOLY: elementColor = Color.Purple; break; default: elementColor = Color.Black; break; } return new ColoredString(elementColor, element.ToString()); }
public void Parse(String filename) { FileInfo file = new FileInfo(filename); if (!file.Exists) { throw new FileNotFoundException("Could not load config file", filename); } isValid = true; ValidateSchema(filename); doc = new XmlDocument(); Stream filestream = XIncludeReader.GetStream(filename); doc.Load(filestream); filestream.Close(); if (doc == null) { throw new InvalidOperationException("Could not parse xml document: " + filename); } // event handler for all of the ParseFromXml methods ParserValidationDelegate vd = new ParserValidationDelegate(ParserValidationEventHandler); XmlNode root = doc.DocumentElement["config"]; if (root != null) { this.options = new Configuration(root, vd); } else { this.options = new Configuration(); } sqltypes = SqlTypeElement.ParseFromXml(doc, vd); types = TypeElement.ParseFromXml(options, doc, vd); // parse generate/task information so that type registration will happen before other types are loaded generator = GeneratorElement.ParseFromXml(options, doc, vd); TaskElement.RegisterTypes(doc, options, generator.Tasks, types); // see if we want to generate collections for all entities XmlNodeList collectionElement = doc.DocumentElement.GetElementsByTagName("collections"); XmlNode collectionNode = collectionElement[0]; if (collectionNode.Attributes["generateall"] == null) { options.GenerateAllCollections = false; } else { options.GenerateAllCollections = Boolean.Parse(collectionNode.Attributes["generateall"].Value.ToString()); } // if the root directory is not specified, make it the directory the config file is loaded from if (options.RootDirectory.Equals(String.Empty)) { options.RootDirectory = file.DirectoryName + "\\"; } if (!options.RootDirectory.EndsWith("\\")) { options.RootDirectory += "\\"; } enumtypes = EnumElement.ParseFromXml(options, doc, sqltypes, types, vd); databases = DatabaseElement.ParseFromXml(options, doc, sqltypes, types, vd); entities = EntityElement.ParseFromXml(options, doc, sqltypes, types, DatabaseElement.GetAllSqlEntities(databases), vd); messages = MessageElement.ParseFromXml(options, doc, sqltypes, types, DatabaseElement.GetAllSqlEntities(databases), vd); reportExtractions = ReportExtractionElement.ParseFromXml(options, doc, sqltypes, types, entities, vd); ArrayList collectableClasses = new ArrayList(); ArrayList autoGenerateClasses = new ArrayList(); collectableClasses.AddRange(entities); collectableClasses.AddRange(reportExtractions); autoGenerateClasses.AddRange(entities); autoGenerateClasses.AddRange(reportExtractions); collections = CollectionElement.ParseFromXml(options, doc, sqltypes, types, vd, collectableClasses, autoGenerateClasses, (ArrayList)entities); CreateSqlElementAssociations(vd); CreateEntityElementAssociations(vd); Validate(vd); }