public override IEnumerable <ValidationMessage> Validate(IClassDefinition classDefinition) { if (classDefinition == null) { throw new ArgumentNullException(nameof(classDefinition)); } if (classDefinition.Constructors.Count > 1) { yield return(new ValidationMessage { LogLevel = LogLevel.Error, Message = "Class definitions on typescript only have one constructor" }); } foreach (var method in classDefinition.Methods) { if (classDefinition.Methods.Where(m => m.Name == method.Name).Count() > 1) { yield return(new ValidationMessage { LogLevel = LogLevel.Error, Message = string.Format("There is more than one method with name '{0}'", method.Name) }); } } var validations = base.Validate(classDefinition); foreach (var item in validations) { yield return(item); } }
public decimal CalculateRegen(IClassDefinition classInfo) { // var life = CalculateAmount(level, classType); var totalRegen = Convert.ToDouble(BasicRegen + BonusRegen); return(DecimalHelper.RoundToDecimals(totalRegen * Convert.ToDouble(1 + BonusRegenPercentage), 2)); }
public IFieldDefinition GetFieldDefinition(IClassDefinition classDef, string name) { var fd = classDef.GetField(name); if (fd == null) { var fieldNames = name.Split('.'); if (fieldNames.Length > 1) { var currentClassDef = classDef; for (var i = 0; i < fieldNames.Length; i++) { name = fieldNames[i]; fd = currentClassDef.GetField(name); if (i == fieldNames.Length - 1) { break; } if (fd == null) { throw new ArgumentException("Unknown field: " + name); } currentClassDef = LookupClassDefinition(fd.GetFactoryId(), fd.GetClassId(), currentClassDef.GetVersion()); if (currentClassDef == null) { throw new ArgumentException("Not a registered Portable field: " + fd); } } } } return fd; }
private static ISkillDamageStat CalculateSkillPowerPrimary(IClassDefinition classInfo) { var skillDamageStat = new DamageSkillStat(1, 1, 1); var fibonacciLine = new List <int> { 1, 2, 3, 5, 8, 13, 21, 34, 55 }; var squareRootLine = new List <int> { 1, 4, 9, 16, 25, 36, 49 }; var from = fibonacciLine.IndexOf(fibonacciLine.FirstOrDefault(c => c > classInfo.Level)); var skillBonus = Convert.ToInt32(Math.Sqrt(squareRootLine.IndexOf(squareRootLine.FirstOrDefault(c => c > classInfo.Level)))); if (classInfo.ClassType == ClassTypeEnum.Sorceress) { skillBonus += Convert.ToInt32(Math.Sqrt(1 + skillBonus)); } skillDamageStat.From = from; skillDamageStat.To = from + skillBonus; skillDamageStat.Level = classInfo.Level; return(skillDamageStat); }
private void RegisterClassDefinition(IClassDefinition cd, IDictionary <int, IClassDefinition> classDefMap, bool checkClassDefErrors) { for (var i = 0; i < cd.GetFieldCount(); i++) { var fd = cd.GetField(i); if (fd.GetFieldType() == FieldType.Portable || fd.GetFieldType() == FieldType.PortableArray) { var classId = fd.GetClassId(); IClassDefinition nestedCd; classDefMap.TryGetValue(classId, out nestedCd); if (nestedCd != null) { RegisterClassDefinition(nestedCd, classDefMap, checkClassDefErrors); _portableContext.RegisterClassDefinition(nestedCd); } else { if (checkClassDefErrors) { throw new HazelcastSerializationException( "Could not find registered ClassDefinition for class-id: " + classId); } } } } _portableContext.RegisterClassDefinition(cd); }
internal IClassDefinition Register(IClassDefinition cd) { if (cd == null) { return(null); } if (cd.GetFactoryId() != _factoryId) { throw new HazelcastSerializationException("Invalid factory-id! " + _factoryId + " -> " + cd); } if (cd is ClassDefinition) { var cdImpl = (ClassDefinition)cd; cdImpl.SetVersionIfNotSet(_portableContext.GetVersion()); } var versionedClassId = Bits.CombineToLong(cd.GetClassId(), cd.GetVersion()); var currentCd = _versionedDefinitions.GetOrAdd(versionedClassId, cd); if (Equals(currentCd, cd)) { return(cd); } if (currentCd is ClassDefinition) { if (!currentCd.Equals(cd)) { throw new HazelcastSerializationException( "Incompatible class-definitions with same class-id: " + cd + " VS " + currentCd); } return(currentCd); } _versionedDefinitions.AddOrUpdate(versionedClassId, cd, (key, oldValue) => cd); return(cd); }
public IFieldDefinition GetFieldDefinition(IClassDefinition classDef, string name) { var fd = classDef.GetField(name); if (fd == null) { var fieldNames = name.Split('.'); if (fieldNames.Length > 1) { var currentClassDef = classDef; for (var i = 0; i < fieldNames.Length; i++) { name = fieldNames[i]; fd = currentClassDef.GetField(name); if (i == fieldNames.Length - 1) { break; } if (fd == null) { throw new ArgumentException("Unknown field: " + name); } currentClassDef = LookupClassDefinition(fd.GetFactoryId(), fd.GetClassId(), currentClassDef.GetVersion()); if (currentClassDef == null) { throw new ArgumentException("Not a registered Portable field: " + fd); } } } } return(fd); }
private DefaultPortableReader CreateReader(IBufferObjectDataInput input, int factoryId, int classId, int version, int portableVersion) { int effectiveVersion = version; if (version < 0) { effectiveVersion = context.GetVersion(); } IClassDefinition cd = context.LookupClassDefinition(factoryId, classId, effectiveVersion); if (cd == null) { int begin = input.Position(); cd = context.ReadClassDefinition(input, factoryId, classId, effectiveVersion); input.Position(begin); } DefaultPortableReader reader; if (portableVersion == effectiveVersion) { reader = new DefaultPortableReader(this, input, cd); } else { reader = new MorphingPortableReader(this, input, cd); } return(reader); }
/// <summary> /// /// </summary> /// <param name="classDefinition"></param> /// <returns></returns> public virtual ValidationResult Validate(IClassDefinition classDefinition) { if (classDefinition == null) { throw new ArgumentNullException(nameof(classDefinition)); } var result = new ValidationResult(); if (string.IsNullOrEmpty(classDefinition.Name)) { result.ValidationMessages.Add(new ValidationMessage(LogLevel.Error, "There isn't name for class definition")); } foreach (var field in classDefinition.Fields) { if (classDefinition.Fields.Where(p => p.Name == field.Name).Count() > 1) { result.ValidationMessages.Add(new ValidationMessage(LogLevel.Error, string.Format("There is more than one field with name '{0}'", field.Name))); } } foreach (var property in classDefinition.Properties) { if (classDefinition.Properties.Where(p => p.Name == property.Name).Count() > 1) { result.ValidationMessages.Add(new ValidationMessage(LogLevel.Error, string.Format("There is more than one property with name '{0}'", property.Name))); } } return(result); }
internal IClassDefinition Lookup(int classId, int version) { var versionedClassId = Bits.CombineToLong(classId, version); IClassDefinition cd = null; _versionedDefinitions.TryGetValue(versionedClassId, out cd); return(cd); }
public static DamageSkillStat CalculateHitData(IClassDefinition classInfo) { var data = CalculateHitDamageLevels(classInfo).FirstOrDefault(x => x.Level == classInfo.Level); var selected = new DamageSkillStat(data.From, data.To, 0, 0, 0, 0); selected.Level = classInfo.Level; return(selected); }
internal FieldDefinition(IFieldSymbol symbol, IClassDefinition referencedClass) { Contract.Requires(symbol != null); Contract.Requires(referencedClass != null); this.Symbol = symbol; this.Sort = References.Sort; this.ReferencedClass = referencedClass; }
public ClassDefinition(IClassDefinition classDefinition) { this.classDefinition = classDefinition; this.ClassType = classDefinition.ClassType; this.ClassDescription = classDefinition.ClassDescription; this.Level = classDefinition.Level; this.AngelicPower = classDefinition.AngelicPower; this.DemonicPower = classDefinition.DemonicPower; this.AncestralPower = classDefinition.AncestralPower; }
/// <summary> /// Adds a <see cref="IPortable"/> class definition to be registered /// </summary> /// <param name="classDefinition"><see cref="IPortable"/> class definition</param> /// <returns>configured <see cref="SerializationConfig"/> for chaining</returns> public virtual SerializationConfig AddClassDefinition(IClassDefinition classDefinition) { if (GetClassDefinitions().Contains(classDefinition)) { throw new ArgumentException("IClassDefinition for class-id[" + classDefinition.GetClassId() + "] already exists!"); } GetClassDefinitions().Add(classDefinition); return(this); }
public virtual SerializationConfig AddClassDefinition(IClassDefinition classDefinition) { if (GetClassDefinitions().Contains(classDefinition)) { throw new ArgumentException("IClassDefinition for class-id[" + classDefinition.GetClassId() + "] already exists!"); } GetClassDefinitions().Add(classDefinition); return this; }
/// <exception cref="System.IO.IOException"/> internal void WriteInternal(IBufferObjectDataOutput output, IPortable p) { IClassDefinition cd = context.LookupOrRegisterClassDefinition(p); output.WriteInt(cd.GetVersion()); DefaultPortableWriter writer = new DefaultPortableWriter(this, output, cd); p.WritePortable(writer); writer.End(); }
public DamagePerHit(IClassDefinition classInfo) { var data = SpellCalculator.CalculateHitData(classInfo); this.MinValue = data.From; this.MaxValue = data.To; // TODO: Return IsMax when Maxxed !!! this.BonusMinValue = Math.Min(60, Convert.ToInt32(classInfo.AncestralPower / 2)); this.BonusMaxValue = Math.Min(120, classInfo.AncestralPower); }
public ClassDefinitionBuilder AddPortableField(string fieldName, IClassDefinition def) { Check(); if (def.GetClassId() == 0) { throw new ArgumentException("Portable class id cannot be zero!"); } _fieldDefinitions.Add(new FieldDefinition(_index++, fieldName, FieldType.Portable, def.GetFactoryId(), def.GetClassId())); return(this); }
public SelfEmpowerHitProc CalculateProcAmount(IClassDefinition classInfo) { var baseProcRate = DecimalHelper.RoundToDecimals((classInfo.ClassType == Enums.ClassTypeEnum.Barbarian ? 10 : 6) / 100, 3); var bonusProcRate = DecimalHelper.RoundToDecimals(0.66 * classInfo.DemonicPower * (classInfo.ClassType == Enums.ClassTypeEnum.Barbarian ? 0.6 : 0.5), 3); var procAmount = DecimalHelper.RoundToDecimals(Convert.ToDouble(baseProcRate + bonusProcRate), 2); var resourceReturnProc = new SelfEmpowerHitProc { ProcPercentage = 1, ProcAmount = procAmount, Duration = 0 }; return(resourceReturnProc); }
public static List <ISkillDamageStat> CalculateHitDamageLevels(IClassDefinition classInfo) { var sampleData = new List <ISkillDamageStat>(); for (int lvl = 1; lvl < 20; lvl++) { var data = CalculateSkillPowerPrimary(classInfo); sampleData.Add(data); } return(sampleData); }
/// <exception cref="System.IO.IOException"></exception> public void WriteNullPortable(string fieldName, int factoryId, int classId) { IClassDefinition nestedClassDef = context.LookupClassDefinition(factoryId, classId , context.GetVersion()); if (nestedClassDef == null) { throw new HazelcastSerializationException("Cannot write null portable without explicitly " + "registering class definition!"); } builder.AddPortableField(fieldName, nestedClassDef); }
/// <exception cref="System.IO.IOException"></exception> public void WritePortable(string fieldName, IPortable portable) { if (portable == null) { throw new HazelcastSerializationException("Cannot write null portable without explicitly " + "registering class definition!"); } int version = PortableVersionHelper.GetVersion(portable, context.GetVersion()); IClassDefinition nestedClassDef = CreateNestedClassDef(portable, new ClassDefinitionBuilder (portable.GetFactoryId(), portable.GetClassId(), version)); builder.AddPortableField(fieldName, nestedClassDef); }
public Life(IClassDefinition classInfo, CharacterClass classData) { var baseAmt = (classInfo.ClassType == ClassTypeEnum.Sorceress ? 45 : 55); BasicAmount = classData.HP + classInfo.Level * 1; BonusAmount = classInfo.AngelicPower * 4; TotalAmount = CalculateAmount(classInfo); var regenCoeff = DecimalHelper.RoundToDecimals(Math.Pow(Convert.ToDouble(1.05), classInfo.Level / 2), 3); BasicRegen = Math.Round(0.024m * classData.HPRegen, 3); var ratio = Math.Round((decimal)BonusAmount / classData.HP, 3); BonusRegen = Math.Round(regenCoeff * ratio, 2); TotalRegen = CalculateRegen(classInfo); }
public ClassDefinitionBuilder AddPortableField(string fieldName, IClassDefinition def) { if (def == null) { throw new ArgumentNullException(nameof(def)); } Check(); if (def.ClassId == 0) { throw new ArgumentException("Portable class id cannot be zero!"); } _fieldDefinitions.Add(new FieldDefinition(_index++, fieldName, FieldType.Portable, def.FactoryId, def.ClassId, def.Version)); return(this); }
/// <exception cref="System.IO.IOException" /> public DefaultPortableWriter(PortableSerializer serializer, IBufferObjectDataOutput @out, IClassDefinition cd) { this.serializer = serializer; this.@out = @out; this.cd = cd; writtenFields = new HashSet<string>(); //cd.GetFieldCount() begin = @out.Position(); // room for final offset @out.WriteZeroBytes(4); @out.WriteInt(cd.GetFieldCount()); offset = @out.Position(); // one additional for raw data var fieldIndexesLength = (cd.GetFieldCount() + 1)*Bits.IntSizeInBytes; @out.WriteZeroBytes(fieldIndexesLength); }
public Stamina(IClassDefinition classInfo, CharacterClass classData) { var baseAmt = classInfo.ClassType == ClassTypeEnum.Druid ? 60 : classInfo.ClassType == ClassTypeEnum.Barbarian ? 50 : 35; BasicAmount = classData.Stamina + classInfo.Level * 1; BonusAmount = classInfo.AncestralPower * 4; TotalAmount = CalculateAmount(classInfo); var regenCoeff = DecimalHelper.RoundToDecimals(Math.Pow(Convert.ToDouble(1.05), classInfo.Level / 2), 3); var classCoeff = Math.Round((classInfo.ClassType == ClassTypeEnum.Druid ? 0.050m : 0.040m) * baseAmt, 3); BasicRegen = Math.Round(classCoeff * classData.StaminaRegen, 3); var ratio = Math.Round((decimal)BonusAmount / classData.Stamina, 3); BonusRegen = Math.Round(regenCoeff * ratio, 2); TotalRegen = CalculateRegen(classInfo); }
/// <exception cref="System.IO.IOException" /> public DefaultPortableWriter(PortableSerializer serializer, IBufferObjectDataOutput @out, IClassDefinition cd) { this.serializer = serializer; this.@out = @out; this.cd = cd; writtenFields = new HashSet <string>(); //cd.GetFieldCount() begin = @out.Position(); // room for final offset @out.WriteZeroBytes(4); @out.WriteInt(cd.GetFieldCount()); offset = @out.Position(); // one additional for raw data var fieldIndexesLength = (cd.GetFieldCount() + 1) * Bits.IntSizeInBytes; @out.WriteZeroBytes(fieldIndexesLength); }
/// <exception cref="System.IO.IOException" /> public DefaultPortableWriter(PortableSerializer serializer, ObjectDataOutput @out, IClassDefinition cd) { _serializer = serializer; _out = @out; _cd = cd; _writtenFields = new HashSet <string>(); //cd.GetFieldCount() _begin = @out.Position; // room for final offset @out.WriteZeroBytes(4); @out.WriteInt(cd.GetFieldCount()); _offset = @out.Position; // one additional for raw data var fieldIndexesLength = (cd.GetFieldCount() + 1) * BytesExtensions.SizeOfInt; @out.WriteZeroBytes(fieldIndexesLength); }
public virtual IEnumerable <ValidationMessage> Validate(IClassDefinition classDefinition) { if (classDefinition == null) { throw new ArgumentNullException(nameof(classDefinition)); } if (string.IsNullOrEmpty(classDefinition.Name)) { yield return(new ValidationMessage { LogLevel = LogLevel.Error, Message = "There isn't name for class definition" }); } foreach (var field in classDefinition.Fields) { if (classDefinition.Fields.Where(p => p.Name == field.Name).Count() > 1) { yield return(new ValidationMessage { LogLevel = LogLevel.Error, Message = string.Format("There is more than one field with name '{0}'", field.Name) }); } } foreach (var property in classDefinition.Properties) { if (classDefinition.Properties.Where(p => p.Name == property.Name).Count() > 1) { yield return(new ValidationMessage { LogLevel = LogLevel.Error, Message = string.Format("There is more than one property with name '{0}'", property.Name) }); } } }
public IMemberDefinition GetMemberDefinition(uint hash) { if (this.Members.ContainsKey(hash) == true) { return(this.Members[hash]); } IClassDefinition current = this.Super; while (current != null) { var member = current.GetMemberDefinition(hash); if (member != null) { return(member); } current = current.Super; } return(null); }
public IClassDefinition GetClassDefinition(uint hash) { if (this.Children.ContainsKey(hash) == true) { return(this.Children[hash]); } IClassDefinition current = this.Super; while (current != null) { var def = current.GetClassDefinition(hash); if (def != null) { return(def); } current = current.Super; } return(this.Master.GetClassDefinition(hash)); }
public SelfEmpowerHitProc CalculateProcAmount(IClassDefinition classInfo) { var baseProcPerc = classInfo.ClassType == Enums.ClassTypeEnum.Barbarian ? 0.05m : 0.03m; var procPercAdditives = classInfo.AncestralPower * 0.55 + classInfo.AngelicPower * 0.11; var bonusMultiplier = 0.45 * (Math.Pow(1.04, procPercAdditives)); var bonusProcPerc = DecimalHelper.RoundToDecimals(bonusMultiplier * procPercAdditives / 100, 3); var baseProcRate = classInfo.ClassType == Enums.ClassTypeEnum.Barbarian ? 0.10m : 0.08m; var rateMultiplier = (Math.Pow(1.04, classInfo.DemonicPower / 4)); var bonusProcRate = DecimalHelper.RoundToDecimals((rateMultiplier * classInfo.AngelicPower * 1.25) / 4, 2); var basicDuration = 1; var bonusDuration = (classInfo.AngelicPower * 6.5) / 100; var procAmount = DecimalHelper.RoundToDecimals(Convert.ToDouble(baseProcRate + bonusProcRate), 2); var procPerc = Math.Min(0.45m, DecimalHelper.RoundToDecimals(Convert.ToDouble((baseProcPerc + bonusProcPerc)), 2)); var resourceReturnProc = new SelfEmpowerHitProc { ProcPercentage = procPerc * 100, ProcAmount = procAmount, Duration = DecimalHelper.RoundToDecimals(basicDuration * (1 + bonusDuration), 2) }; return(resourceReturnProc); }
public LifestealHitProc CalculateProcAmount(IClassDefinition classInfo) { var mainDps = new DamagePerHit(classInfo); var baseProcPerc = classInfo.ClassType == Enums.ClassTypeEnum.Barbarian ? 0.05m : 0.03m; var procPercAdditives = classInfo.AngelicPower * 0.125 + classInfo.AncestralPower * 0.55; var bonusMultiplier = 0.35 * (Math.Pow(1.04, procPercAdditives)); var bonusProcPerc = DecimalHelper.RoundToDecimals(bonusMultiplier * procPercAdditives / 100, 3); var baseProcRate = classInfo.ClassType == Enums.ClassTypeEnum.Barbarian ? 0.08m : 0.10m; var bonusProcRate = 0.66m * DecimalHelper.RoundToDecimals((classInfo.AngelicPower * 1.4) / 100, 3); var average = DecimalHelper.RoundToDecimals((mainDps.CalculateMinBase(classInfo) + mainDps.CalculateMaxBase(classInfo)) / 2, 3); var procAmountVal = DecimalHelper.RoundToDecimals(Convert.ToDouble(baseProcRate) + Convert.ToDouble(bonusProcRate), 3); var procAmount = DecimalHelper.RoundToDecimals(Convert.ToDouble(average) * Convert.ToDouble(procAmountVal), 2); var procPerc = Math.Min(0.45m, DecimalHelper.RoundToDecimals(Convert.ToDouble((baseProcPerc + bonusProcPerc)), 2)); var lifestealProc = new LifestealHitProc { ProcPercentage = procPerc * 100, ProcAmount = procAmount, Duration = 0 }; return(lifestealProc); }
public ISerializationServiceBuilder AddClassDefinition(IClassDefinition cd) { classDefinitions.Add(cd); return this; }
public IClassDefinition RegisterClassDefinition(IClassDefinition cd) { return GetClassDefContext(cd.GetFactoryId()).Register(cd); }
internal IClassDefinition Register(IClassDefinition cd) { if (cd == null) { return null; } if (cd.GetFactoryId() != _factoryId) { throw new HazelcastSerializationException("Invalid factory-id! " + _factoryId + " -> " + cd); } if (cd is ClassDefinition) { var cdImpl = (ClassDefinition)cd; cdImpl.SetVersionIfNotSet(_portableContext.GetVersion()); } var versionedClassId = Bits.CombineToLong(cd.GetClassId(), cd.GetVersion()); var currentCd = _versionedDefinitions.GetOrAdd(versionedClassId, cd); if (Equals(currentCd, cd)) { return cd; } if (currentCd is ClassDefinition) { if (!currentCd.Equals(cd)) { throw new HazelcastSerializationException( "Incompatible class-definitions with same class-id: " + cd + " VS " + currentCd); } return currentCd; } _versionedDefinitions.AddOrUpdate(versionedClassId, cd, (key, oldValue) => cd); return cd; }
public sxDocClass(IClassDefinition cd) { m_cd = cd; }
public ClassDefinitionBuilder AddPortableField(string fieldName, IClassDefinition def) { Check(); if (def.GetClassId() == 0) { throw new ArgumentException("Portable class id cannot be zero!"); } fieldDefinitions.Add(new FieldDefinition(index++, fieldName, FieldType.Portable, def.GetFactoryId(), def.GetClassId())); return this; }