public bool Push(StatusEffect statusEffect)
{
bool result = false;
int id = statusEffect.Id;
if (map.ContainsKey(id))
{
StatusEffect existedStatusEffect = map[id];
bool needReposition = existedStatusEffect.EndTime != statusEffect.EndTime;
if (!existedStatusEffect.ReachMaxNumStacks())
{
foreach (KeyValuePair <AttributeType, float> attribute in existedStatusEffect)
{
sumAttributes.Add(attribute.Key, -attribute.Value);
}
existedStatusEffect.Stack(statusEffect);
foreach (KeyValuePair <AttributeType, float> attribute in existedStatusEffect)
{
sumAttributes.Add(attribute.Key, attribute.Value);
}
result = true;
}
if (needReposition)
{
list.Remove(existedStatusEffect);
Insert(existedStatusEffect, current, list.Count - 1);
}
}
else
{
if (IsEmpty())
{
list.Add(statusEffect);
}
else
{
Insert(statusEffect, current, list.Count - 1);
}
map.Add(id, statusEffect);
foreach (KeyValuePair <AttributeType, float> attribute in statusEffect)
{
sumAttributes.Add(attribute.Key, attribute.Value);
}
result = true;
}
return(result);
}
// Returns attributes of gem in item.
public AttributeSet AttributesOf(Item gem, Item item)
{
AttributeSet attrs = new AttributeSet();
// Collect gem attributes and modifiers at gem level.
foreach (var prop in gem.Properties)
{
attrs.Add(prop.Attribute, new List <float>(prop.Value));
}
foreach (ItemMod mod in gem.Mods)
{
attrs.Add(mod.Attribute, new List <float>(mod.Value));
}
// Check if gem is in database.
if (GemIndex.ContainsKey(gem.Name))
{
Gem entry = GemIndex[gem.Name];
// Process +Level modifiers from item.
int plusLevel = 0;
foreach (ItemMod mod in item.Mods)
{
if (mod.Attribute == "+# to Level of Socketed Gems")
{
plusLevel += (int)mod.Value[0];
}
else
{
Match m = ReGemLevelKeyword.Match(mod.Attribute);
if (m.Success)
{
if (gem.Keywords.Contains(m.Groups[1].Value) ||
m.Groups[1].Value == "Elemental" && (gem.Keywords.Contains("Cold") || gem.Keywords.Contains("Fire") || gem.Keywords.Contains("Lightning")))
{
plusLevel += (int)mod.Value[0];
}
}
}
}
// Replace level-based attributes of gem (even without level bonus).
AttributeSet replace = entry.AttributesAtLevel(plusLevel + LevelOf(gem));
// Add quality-based attributes if Quality attributes are defined.
int quality = QualityOf(gem);
if (quality > 0)
{
replace.Add(entry.AttributesAtQuality(quality));
}
attrs.Replace(replace);
}
return(attrs);
}
public void addAttr(Document doc, SketchLine sl, SketchPoint sp, bool contstr)
{
VariableData vd = new VariableData(doc as Document);
UnitVector vec = sl.Geometry3d.Direction;
AttributeSet attSet = vd.AttribSetAdd(sp, "dir");
attSet.Add("X", ValueTypeEnum.kDoubleType, vec.X);
attSet.Add("Y", ValueTypeEnum.kDoubleType, vec.Y);
attSet.Add("Z", ValueTypeEnum.kDoubleType, vec.Z);
if (contstr)
{
string val = ut.getRefkey <SketchLine>(doc, sl, 0);
vd.AttribAdd <SketchPoint, string>(sp, "SL", val, ValueTypeEnum.kStringType);
}
}
// Return list group of this attack.
public ListGroup ToListGroup()
{
AttributeSet props = new AttributeSet();
props.Add(IsDamageOnUse() ? "Damage per Use: #" : "Damage per Second: #", new List <float> {
RoundHalfDownValue(DamagePerSecond(), 1)
});
if (Nature.Is(DamageSource.Attack))
{
props.Add("Chance to Hit: #%", new List <float> {
RoundValue(ChanceToHit(), 0)
});
props.Add("Attacks per Second: #", new List <float> {
RoundHalfDownValue(AttacksPerSecond(), 1)
});
}
else
{
props.Add("Casts per Second: #", new List <float> {
RoundHalfDownValue(AttacksPerSecond(), 1)
});
}
foreach (AttackSource source in Sources)
{
string sourcePrefix = source.Name.Length == 0 ? "" : source.Name + " ";
foreach (DamageType type in DamageTypes)
{
Damage damage = source.Deals.Find(d => d.Is(type));
if (damage != null)
{
props.Add(sourcePrefix + damage.ToAttribute(), damage.ToValue());
}
}
if (source.Nature.Is(DamageSource.Attack))
{
props.Add(sourcePrefix + "Accuracy Rating: #", new List <float> {
RoundValue(source.Accuracy, 0)
});
}
if (source.CriticalChance > 0)
{
// XXX: Different rounding style for spells and attacks. Really?
props.Add(sourcePrefix + "Critical Strike Chance: #%", new List <float> {
Nature.Is(DamageSource.Spell) ? RoundValue(source.CriticalChance, 1) : RoundHalfDownValue(source.CriticalChance, 1)
});
props.Add(sourcePrefix + "Critical Strike Multiplier: #%", new List <float> {
RoundValue(source.CriticalMultiplier, 0)
});
}
}
return(new ListGroup(Name + (IsUseable ? "" : " (Unuseable)"), props));
}
public void RemoveExisting_works()
{
var doc = tests.TestUtilities.CreatePartDocument();
//create the test AttributeSet
AttributeSet attributeSet = doc.AttributeSets.Add("testSet");
Inventor.Attribute attribute = attributeSet.Add("testAttribute", ValueTypeEnum.kStringType, "test string");
AttributeShim.RemoveAttribute(doc, "testSet", "testAttribute");
bool result = false;
foreach (Inventor.Attribute i in doc.AttributeSets["testSet"])
{
if (i.Name.Equals("testAttribute"))
{
result = true;
}
}
try
{
Assert.IsFalse(result);
}
finally { doc.Close(true); }
}
public Cfg ToCfg()
{
var result = new Cfg();
foreach (var prod in Productions)
{
if (!prod.Value.IsTerminal)
{
if (null != prod.Value.Expression)
{
var ll = prod.Value.Expression.ToDisjunctions(this, result);
foreach (var l in ll)
{
result.Rules.Add(new CfgRule(prod.Key, l));
}
}
else
{
result.Rules.Add(new CfgRule(prod.Key));
}
}
AttributeSet attrs = null;
if (0 < prod.Value.Attributes.Count)
{
attrs = new AttributeSet();
result.AttributeSets.Add(prod.Key, attrs);
foreach (var attr in prod.Value.Attributes)
{
attrs.Add(attr.Key, attr.Value);
}
}
}
return(result);
}
// Returns attributes of gem at specified level and quality.
public AttributeSet AttributesOf(string gemName, int level, int quality)
{
if (!IsIndexed)
{
throw new Exception("Gem Index not started");
}
if (!GemIndex.ContainsKey(gemName))
{
return(new AttributeSet());
}
Gem gem = GemIndex[gemName];
// Get level-based attributes.
AttributeSet attrs = gem.AttributesAtLevel(level);
// Add quality-based attributes if quality is 1 or above.
if (quality > 0)
{
attrs.Add(gem.AttributesAtQuality(quality));
}
return(attrs);
}
private Attribute <AttributeSet <NestedAttribute> > ConvertToSetOfNestedAttribute(
JToken jsonObject, JsonSerializer serializer)
{
var valueProperty = jsonObject["value"];
var nameProperty = jsonObject["name"];
var setAttr = new Attribute <AttributeSet <NestedAttribute> >();
var setOfNestedAttributes = new AttributeSet <NestedAttribute>();
foreach (var item in valueProperty.Children())
{
var attArr = item;
if (item.IsNestedAttributeObject())
{
attArr = item.First.Children().First();
}
var listOfAttrs = attArr.ToObject(typeof(List <Attribute>), serializer);
var nestedAttr = new NestedAttribute(new Attribute <List <Attribute> >()
{
Value = listOfAttrs as List <Attribute>
});
setOfNestedAttributes.Add(nestedAttr);
}
setAttr.Value = setOfNestedAttributes;
setAttr.Name = nameProperty.ToString();
return(setAttr);
}
public void RemoveExisting_works()
{
Inventor.Application app = ApplicationShim.Instance();
var path = app.DesignProjectManager.ActiveDesignProject.TemplatesPath;
Document doc = app.Documents.Add(DocumentTypeEnum.kPartDocumentObject, path + "Standard.ipt", true);
//create the test AttributeSet
AttributeSet attributeSet = doc.AttributeSets.Add("testSet");
Inventor.Attribute attribute = attributeSet.Add("testAttribute", ValueTypeEnum.kStringType, "test string");
AttributeShim.RemoveAttribute(doc, "testSet", "testAttribute");
bool result = false;
foreach (Inventor.Attribute i in doc.AttributeSets["testSet"])
{
if (i.Name.Equals("testAttribute"))
{
result = true;
}
}
try
{
Assert.IsFalse(result);
}
finally { doc.Close(true); }
}
public void AttribAdd <T>(string name, List <T> vals, ValueTypeEnum VT)
{
attSet = doc.AttributeSets.Add(name);
for (int i = 0; i < vals.Count; i++)
{
attSet.Add(name + i, VT, vals[i]);
}
attSet = null;
}
public File Parse(string fileAbsolutePath, UInt32 lastTagId = 0)
{
_lastTagId = lastTagId;
var attributeSet = new AttributeSet();
using (var file = System.IO.File.OpenRead(fileAbsolutePath)) {
//Preamble
var preamble = new byte[PREAMBLE_SIZE_BYTES];
file.Read(preamble, 0, preamble.Length);
//'DICM' Prefix
var prefixRaw = new byte[PREFIX_SIZE_BYTES];
file.Read(prefixRaw, 0, prefixRaw.Length);
string prefixUTF8 = Encoding.UTF8.GetString(prefixRaw, 0, prefixRaw.Length);
if (prefixUTF8.Equals(DICM_PREFIX, StringComparison.InvariantCultureIgnoreCase))
{
OnInfo?.Invoke(this, $"Found '{DICM_PREFIX}' prefix.");
}
else
{
OnWarning?.Invoke(this, $"Could not find '{DICM_PREFIX}' prefix.");
}
while (true)
{
try {
var pos = file.Position;
var newAttribute = ParseAttribute(file);
if (newAttribute == null)
{
OnWarning?.Invoke(this, $"Could not parse attribute at position: {pos}.");
continue;
}
attributeSet.Add(newAttribute.Tag.ID, newAttribute);
OnInfo?.Invoke(this, attributeSet.ToString());
if (_lastTagId > 0 && newAttribute.Tag.ID >= _lastTagId)
{
break;
}
}
catch (EndOfStreamException) {
break;
}
}
return(new File()
{
IsVRExplicit = _isExplicitVr,
Attributes = attributeSet
});
}
}
public void AttribAdd <T>(string name, T val, ValueTypeEnum VT)
{
attSets = doc.AttributeSets;
if (attSets.NameIsUsed[name])
{
AttribDelete(name);
}
attSet = attSets.Add(name); attSet.Add(name, VT, val);
attSet = null;
}
public void AttribAdd <T, TVal>(T ob, string name, TVal val, ValueTypeEnum VT)
{
AttributeSets attSets = InvDoc.Reflect.getProp <T, AttributeSets>(ob, "AttributeSets");
if (attSets.NameIsUsed[name])
{
AttribDelete(name);
}
attSet = attSets.Add(name); attSet.Add(name, VT, val);
attSet = null;
}
/// <summary>
/// create an attribute
/// this assumes a part document with some features is opened.
/// </summary>
/// <remarks></remarks>
public void AddAttribute()
{
// Get the selected edge. This assumes an edge is already selected.
Edge oEdge = (Edge)_InvApplication.ActiveDocument.SelectSet[1];
// Add an attribute set to the edge. If you only need to "name" the
// edge this is enough to find it later and you can skip the next step.
AttributeSet oAttribSet = oEdge.AttributeSets.Add("BoltEdge");
// Add an attribute to the set. This can be any information you
// want to associate with the edge.
oAttribSet.Add("BoltRadius", ValueTypeEnum.kDoubleType, 0.5);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static void CreateOccurrenceTag(AssemblyDocument AsmDocument, PartFeature PartFeature, ComponentOccurrence occurrence)
{
AttributeSet set = PartFeature.AttributeSets[_AttributeSet];
Byte[] contextData = set["ContextData"].Value as Byte[];
int keyContext = AsmDocument.ReferenceKeyManager.LoadContextFromArray(ref contextData);
Byte[] refKey = new byte[] { };
occurrence.GetReferenceKey(ref refKey, keyContext);
set.Add("OccurrenceRefKey", ValueTypeEnum.kByteArrayType, refKey);
PartDocument doc = PartFeature.Parent.Document as PartDocument;
set = doc.ComponentDefinition.AttributeSets[_AttributeSet];
string srcDocPath = set["SourcePartDoc"].Value as string;
PartDocument srcDoc = FeatureUtilities.Application.Documents.Open(srcDocPath, false) as PartDocument;
foreach (PartFeature feature in doc.ComponentDefinition.Features)
{
if (feature.AttributeSets.get_NameIsUsed(_AttributeSet))
{
AttributeSet setFeature = feature.AttributeSets[_AttributeSet];
string AsmFeature = setFeature["AsmFeature"].Value as string;
if (!setFeature.get_NameIsUsed("OccurrenceRefKey"))
{
ObjectCollection collec = srcDoc.AttributeManager.FindObjects(_AttributeSet, "AsmFeature", AsmFeature);
if (collec.Count > 0)
{
PartFeature srcFeature = collec[1] as PartFeature;
object val = srcFeature.AttributeSets[_AttributeSet]["OccurrenceRefKey"].Value;
setFeature.Add("OccurrenceRefKey", ValueTypeEnum.kByteArrayType, val);
}
}
}
}
srcDoc.Close(true);
}
public static AttributeSet Sum(params IAttributeCollection[] attributeSets)
{
AttributeSet attributeSet = new AttributeSet();
foreach (IAttributeCollection attributes in attributeSets)
{
foreach (KeyValuePair <AttributeType, float> attribute in attributes)
{
attributeSet.Add(attribute.Key, attribute.Value);
}
}
return(attributeSet);
}
// Returns all attributes of gem with defined values for specified level.
internal AttributeSet AttributesAtLevel(int level)
{
AttributeSet attrs = new AttributeSet();
foreach (var lookup in LevelIndex)
{
List <float> value = lookup.Value.ValueAt(level);
if (value != null)
{
attrs.Add(lookup.Key, new List <float>(value));
}
}
return(attrs);
}
// Returns all attributes of gem with defined values for specified quality.
internal AttributeSet AttributesAtQuality(int quality)
{
AttributeSet attrs = new AttributeSet();
foreach (var lookup in QualityIndex)
{
List <float> value = lookup.Value.ValueAt(quality);
if (value != null)
{
attrs.Add(lookup.Key, new List <float>(value));
}
}
return(attrs);
}
private IAttributeSet CreateAttributeSet(int ctrlId, string ctrlName,
string desc, Type boundType, IAttribute[] atts, object tag, IControlDescriptor ctrlDescriptor = null)
{
var attsSet = new AttributeSet(ctrlId, ctrlName, desc, boundType, tag, ctrlDescriptor);
if (atts?.Any() == true)
{
foreach (var att in atts)
{
attsSet.Add(att);
}
}
return(attsSet);
}
private IAttributeSet CreateAttributeSet(int ctrlId, string ctrlName,
string desc, Type boundType, IAttribute[] atts, object tag, MemberInfo boundMemberInfo = null)
{
var attsSet = new AttributeSet(ctrlId, ctrlName, desc, boundType, tag, boundMemberInfo);
if (atts?.Any() == true)
{
foreach (var att in atts)
{
attsSet.Add(att);
}
}
return(attsSet);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static void CreateDocTrackingTag(string srcFullFileName, PartDocument destDoc)
{
AttributeSet set = null;
try
{
set = destDoc.ComponentDefinition.AttributeSets[_AttributeSet];
set["SourcePartDoc"].Value = srcFullFileName;
}
catch
{
set = destDoc.ComponentDefinition.AttributeSets.Add(_AttributeSet, true);
set.Add("SourcePartDoc", ValueTypeEnum.kStringType, srcFullFileName);
}
}
private void createPart2()
{
// create a new part
PartDocument oDoc = (PartDocument)mApp.Documents.Add(DocumentTypeEnum.kPartDocumentObject);
PartComponentDefinition oDef = oDoc.ComponentDefinition;
TransientGeometry oTG = mApp.TransientGeometry;
// create sketch elements
PlanarSketch oSketch = oDef.Sketches.Add(oDef.WorkPlanes[3]);
oSketch.SketchLines.AddAsTwoPointRectangle(oTG.CreatePoint2d(-5, -5), oTG.CreatePoint2d(5, 5));
SketchPoint oSketchPt = oSketch.SketchPoints.Add(oTG.CreatePoint2d(0, 0));
Profile oProfile = oSketch.Profiles.AddForSolid();
// create a plate with a hole feature
ExtrudeDefinition oExtrudDef = oDef.Features.ExtrudeFeatures.CreateExtrudeDefinition(oProfile, PartFeatureOperationEnum.kJoinOperation);
oExtrudDef.SetDistanceExtent(1, PartFeatureExtentDirectionEnum.kPositiveExtentDirection);
ExtrudeFeature oExtrudeF = oDef.Features.ExtrudeFeatures.Add(oExtrudDef);
// Create an object collection for the hole center points.
ObjectCollection oHoleCenters = default(ObjectCollection);
oHoleCenters = mApp.TransientObjects.CreateObjectCollection();
oHoleCenters.Add(oSketchPt);
// create hole feature
HolePlacementDefinition oHPdef = (HolePlacementDefinition)oDef.Features.HoleFeatures.CreateSketchPlacementDefinition(oHoleCenters);
HoleFeature oHoleF = oDef.Features.HoleFeatures.AddDrilledByThroughAllExtent(oHPdef, "2", PartFeatureExtentDirectionEnum.kNegativeExtentDirection);
Face oFace = oHoleF.SideFaces[1];
AttributeSet oAttSet = default(AttributeSet);
Inventor.Attribute oAtt = null;
oAttSet = oFace.AttributeSets.Add("demoAttset");
oAtt = oAttSet.Add("demoAtt", ValueTypeEnum.kStringType, "namedEdge");
if (System.IO.File.Exists("c:\temp\test2.ipt"))
{
System.IO.File.Delete("c:\temp\test2.ipt");
}
oDoc.SaveAs("c:\\temp\\test2.ipt", false);
}
private Player(int id, int maxHp, int power, int dexterity, int wisdom)
{
this.id = id;
talents.Add(AttributeType.WalkSpeed_c0, 0.8f);
talents.Add(AttributeType.JumpPower_c0, 150);
talents.Add(AttributeType.MaxHp_c0, 10);
talents.Add(AttributeType.CriticalChance_cp0, 0.05f);
talents.Add(AttributeType.CriticalDamage_cp0, 1.5f);
talents.Add(AttributeType.BaseDamage_cp0, 1);
talents.Add(AttributeType.AttackSpeed_cp0, 1);
inventory = new Inventory();
inventory.Add(1, 1);
inventory.Add(2, 1);
inventory.Add(3, 1);
stats = new StatisticSystem(talents, inventory);
stats[StatisticType.Hp] = stats[StatisticType.MaxHp];
stats.onStatisticChange.AddListener(DispatchStatisticChangeEvents);
OnWalkSpeedChange = new EventOnDataChange2 <float>();
OnJumpPowerChange = new EventOnDataChange2 <float>();
OnHpChange = new EventOnDataChange2 <float>();
OnCriticalChanceChange = new EventOnDataChange2 <float>();
OnCriticalDamageChange = new EventOnDataChange2 <float>();
OnBaseDamageChange = new EventOnDataChange2 <float>();
OnAttackSpeedChange = new EventOnDataChange2 <float>();
playerClass = 0;
level = 1;
exp = 0;
neededExp = 100;
this.maxHp = maxHp;
this.power = power;
this.dexterity = dexterity;
this.wisdom = wisdom;
OnLevelChange = new EventOnDataChange1 <int>();
OnExpChange = new EventOnDataChange2 <int>();
OnNeededExpChange = new EventOnDataChange1 <int>();
OnPromotionChange = new EventOnDataChange1 <int>();
OnPowerChange = new EventOnDataChange1 <int>();
OnDexterityChange = new EventOnDataChange1 <int>();
OnWisdomChange = new EventOnDataChange1 <int>();
}
// requires: All slots in this are null or non-constants
// effects: Returns the non-null slots of this
internal AttributeSet GetNonNullSlots()
{
AttributeSet attributes = new AttributeSet(MemberPath.EqualityComparer);
foreach (ProjectedSlot projectedSlot in m_projectedSlots)
{
// null means 'unused' slot -- we ignore those
if (projectedSlot != null)
{
MemberProjectedSlot projectedVar = projectedSlot as MemberProjectedSlot;
Debug.Assert(projectedVar != null, "Projected slot must not be a constant");
attributes.Add(projectedVar.MemberPath);
}
}
return(attributes);
}
public void AttDoesExist_returnsTrue()
{
var doc = tests.TestUtilities.CreatePartDocument();
//create the test attribute
AttributeSet attributeSet = doc.AttributeSets.Add("testSet");
Attribute _ = attributeSet.Add("testAttribute", ValueTypeEnum.kStringType, "test string");
var result = AttributeShim.AttributeExists(doc, "testSet", "testAttribute");
try
{
Assert.IsTrue(result);
}
finally { doc.Close(true); }
}
public void GetExisting_works()
{
var doc = tests.TestUtilities.CreatePartDocument();
//create the test Attribute
var test = "test string";
AttributeSet attributeSet = doc.AttributeSets.Add("testSet");
Inventor.Attribute attribute = attributeSet.Add("testAttribute", ValueTypeEnum.kStringType, test);
var result = AttributeShim.GetAttributeValue(doc, "testSet", "testAttribute");
try
{
Assert.AreEqual(result, test);
}
finally { doc.Close(true); }
}
public void DoesExist_returnsTrue()
{
Inventor.Application app = ApplicationShim.Instance();
var path = app.DesignProjectManager.ActiveDesignProject.TemplatesPath;
Document doc = app.Documents.Add(DocumentTypeEnum.kPartDocumentObject, path + "Standard.ipt", true);
//create the test attribute
AttributeSet attributeSet = doc.AttributeSets.Add("testSet");
Attribute _ = attributeSet.Add("testAttribute", ValueTypeEnum.kStringType, "test string");
var result = AttributeShim.AttributeExists(doc, "testSet", "testAttribute");
try
{
Assert.IsTrue(result);
}
finally { doc.Close(true); }
}
/// <summary>
/// Performs a deep clone of the CFG
/// </summary>
/// <returns>A new CFG equal to this CFG</returns>
public Cfg Clone()
{
var result = new Cfg();
var ic = Rules.Count;
for (var i = 0; i < ic; ++i)
{
result.Rules.Add(Rules[i].Clone());
}
foreach (var attrs in AttributeSets)
{
var d = new AttributeSet();
result.AttributeSets.Add(attrs.Key, d);
foreach (var attr in attrs.Value)
{
d.Add(attr.Key, attr.Value);
}
}
return(result);
}
public void GetExisting_works()
{
Inventor.Application app = ApplicationShim.Instance();
var path = app.DesignProjectManager.ActiveDesignProject.TemplatesPath;
Document doc = app.Documents.Add(DocumentTypeEnum.kPartDocumentObject, path + "Standard.ipt", true);
//create the test Attribute
var test = "test string";
AttributeSet attributeSet = doc.AttributeSets.Add("testSet");
Inventor.Attribute attribute = attributeSet.Add("testAttribute", ValueTypeEnum.kStringType, test);
var result = AttributeShim.GetAttributeValue(doc, "testSet", "testAttribute");
try
{
Assert.AreEqual(result, test);
}
finally { doc.Close(true); }
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static void CreatePartFeatureTag(AssemblyDocument AsmDocument,
PartFeature AsmFeature,
PartFeature PartFeature,
ComponentOccurrence Occurrence)
{
if (PartFeature == null)
{
return;
}
AttributeSet set = PartFeature.AttributeSets.Add(_AttributeSet, true);
set.Add("AsmFile", ValueTypeEnum.kStringType, AsmDocument.FullFileName);
set.Add("AsmDoc", ValueTypeEnum.kStringType, AsmDocument.FullDocumentName);
set.Add("AsmIntName", ValueTypeEnum.kStringType, AsmDocument.InternalName);
set.Add("AsmFeature", ValueTypeEnum.kStringType, AsmFeature.Name);
Byte[] contextData = new byte[] { };
int keyContext = AsmDocument.ReferenceKeyManager.CreateKeyContext();
AsmDocument.ReferenceKeyManager.SaveContextToArray(keyContext, ref contextData);
set.Add("ContextData", ValueTypeEnum.kByteArrayType, contextData);
Byte[] featureRefKey = new byte[] { };
AsmFeature.GetReferenceKey(ref featureRefKey, keyContext);
set.Add("AsmFeatureRefKey", ValueTypeEnum.kByteArrayType, featureRefKey);
Byte[] occRefKey = new byte[] { };
Occurrence.GetReferenceKey(ref occRefKey, keyContext);
set.Add("OccurrenceRefKey", ValueTypeEnum.kByteArrayType, occRefKey);
}
// Return list group of this attack.
public ListGroup ToListGroup()
{
AttributeSet props = new AttributeSet();
props.Add(IsDamageOnUse() ? "Damage per Use: #" : "Damage per Second: #", new List<float> { RoundHalfDownValue(DamagePerSecond(), 1) });
if (Nature.Is(DamageSource.Attack))
{
props.Add("Chance to Hit: #%", new List<float> { RoundValue(ChanceToHit(), 0) });
props.Add("Attacks per Second: #", new List<float> { RoundHalfDownValue(AttacksPerSecond(), 1) });
}
else
props.Add("Casts per Second: #", new List<float> { RoundHalfDownValue(AttacksPerSecond(), 1) });
foreach (AttackSource source in Sources)
{
string sourcePrefix = source.Name.Length == 0 ? "" : source.Name + " ";
foreach (DamageType type in DamageTypes)
{
Damage damage = source.Deals.Find(d => d.Is(type));
if (damage != null)
props.Add(sourcePrefix + damage.ToAttribute(), damage.ToValue());
}
if (source.Nature.Is(DamageSource.Attack))
props.Add(sourcePrefix + "Accuracy Rating: #", new List<float> { RoundValue(source.Accuracy, 0) });
if (source.CriticalChance > 0)
{
// XXX: Different rounding style for spells and attacks. Really?
props.Add(sourcePrefix + "Critical Strike Chance: #%", new List<float> { Nature.Is(DamageSource.Spell) ? RoundValue(source.CriticalChance, 1) : RoundHalfDownValue(source.CriticalChance, 1) });
props.Add(sourcePrefix + "Critical Strike Multiplier: #%", new List<float> { RoundValue(source.CriticalMultiplier, 0) });
}
}
return new ListGroup(Name + (IsUseable ? "" : " (Unuseable)"), props);
}
// Initializes structures.
public static void Initialize(SkillTree skillTree, ItemAttributes itemAttrs)
{
Items = itemAttrs.Equip.ToList();
MainHand = new Weapon(WeaponHand.Main, Items.Find(i => i.Class == ItemClass.MainHand));
OffHand = new Weapon(WeaponHand.Off, Items.Find(i => i.Class == ItemClass.OffHand));
// If main hand weapon has Counts as Dual Wielding modifier, then clone weapon to off hand.
// @see http://pathofexile.gamepedia.com/Wings_of_Entropy
if (MainHand.Attributes.ContainsKey("Counts as Dual Wielding"))
OffHand = MainHand.Clone(WeaponHand.Off);
IsDualWielding = MainHand.IsWeapon() && OffHand.IsWeapon();
if (IsDualWielding)
{
// Set dual wielded bit on weapons.
MainHand.Hand |= WeaponHand.DualWielded;
OffHand.Hand |= WeaponHand.DualWielded;
}
IsWieldingShield = MainHand.Is(WeaponType.Shield) || OffHand.Is(WeaponType.Shield);
IsWieldingStaff = MainHand.Is(WeaponType.Staff);
Level = skillTree.Level;
if (Level < 1) Level = 1;
else if (Level > 100) Level = 100;
Global = new AttributeSet();
Tree = new AttributeSet(skillTree.SelectedAttributesWithoutImplicit);
Global.Add(Tree);
// Keystones.
Acrobatics = Tree.ContainsKey("#% Chance to Dodge Attacks. #% less Armour and Energy Shield, #% less Chance to Block Spells and Attacks");
AvatarOfFire = Tree.ContainsKey("Deal no Non-Fire Damage");
BloodMagic = Tree.ContainsKey("Removes all mana. Spend Life instead of Mana for Skills");
ChaosInoculation = Tree.ContainsKey("Maximum Life becomes #, Immune to Chaos Damage");
IronGrip = Tree.ContainsKey("The increase to Physical Damage from Strength applies to Projectile Attacks as well as Melee Attacks");
IronReflexes = Tree.ContainsKey("Converts all Evasion Rating to Armour. Dexterity provides no bonus to Evasion Rating");
NecromanticAegis = Tree.ContainsKey("All bonuses from an equipped Shield apply to your Minions instead of you");
ResoluteTechnique = Tree.ContainsKey("Never deal Critical Strikes");
VaalPact = Tree.ContainsKey("Life Leech applies instantly at #% effectiveness. Life Regeneration has no effect.");
ZealotsOath = Tree.ContainsKey("Life Regeneration applies to Energy Shield instead of Life");
Equipment = new AttributeSet();
foreach (ItemAttributes.Attribute attr in itemAttrs.NonLocalMods)
Equipment.Add(attr.TextAttribute, new List<float>(attr.Value));
if (NecromanticAegis && OffHand.IsShield())
{
// Remove all bonuses of shield from equipment set.
// @see http://pathofexile.gamepedia.com/Necromantic_Aegis
foreach (var attr in OffHand.Attributes)
Equipment.Remove(attr);
// Remove all bonuses from shield itself.
OffHand.Attributes.Clear();
}
Global.Add(Equipment);
CoreAttributes();
Implicit = new AttributeSet(SkillTree.ImplicitAttributes(Global, Level));
Global.Add(Implicit);
// Innate dual wielding bonuses.
// @see http://pathofexile.gamepedia.com/Dual_wielding
if (IsDualWielding)
{
Global["#% more Attack Speed"] = new List<float>() { 10 };
Global["#% more Physical Damage with Weapons"] = new List<float>() { 20 };
}
}
// requires: All slots in this are null or non-constants
// effects: Returns the non-null slots of this
internal AttributeSet GetNonNullSlots()
{
AttributeSet attributes = new AttributeSet(MemberPath.EqualityComparer);
foreach (ProjectedSlot projectedSlot in m_projectedSlots)
{
// null means 'unused' slot -- we ignore those
if (projectedSlot != null)
{
MemberProjectedSlot projectedVar = projectedSlot as MemberProjectedSlot;
Debug.Assert(projectedVar != null, "Projected slot must not be a constant");
attributes.Add(projectedVar.MemberPath);
}
}
return attributes;
}