public Relation(int id, int idFirst, int idSecond, TypeRelation type) { this.Id = id; this.IdFirst = idFirst; this.IdSecond = idSecond; this.Type = type; }
public RelationSavingEngine( IServiceProvider serviceProvider, InformationRessource informationRessource, PropertyInfo propertyRelation, RelationshipJsonApiAttribute relationshipJApiAttribute, object idRessourceParent) { this._serviceProvider = serviceProvider; this._informationRessource = informationRessource; this._relationProperty = propertyRelation; this._idRessourceParent = idRessourceParent; (PropertyInfo foreignKeyProperty, ForeignKeyJsonApiAttribute foreignKeyAttribute) = AttributeRelationsHandling.FindForeignKeyPropertyAndAttribute(this._informationRessource.TypeRessource, this._relationProperty.Name); if (foreignKeyProperty == null && foreignKeyAttribute == null) { throw new JsonApiArchitectureException($"ForeignKeyJsonApi manquant pour {this._relationProperty.Name} dans {this._informationRessource.TypeRessource.Name}, ajouter[ForeignKeyJsonApi (RelationName = nameof({this._relationProperty.Name}))]"); } this._foreignKeyProperty = foreignKeyProperty; this._typeRelation = relationshipJApiAttribute is HasManyJsonApiAttribute ? TypeRelation.Many : TypeRelation.One; this.SaveRelations(); }
internal List <TypeRelation> GetRelations(Type serviceType, Type[] genericParms, bool isDetect = false) { var relations = this.typeRelations.Where(_ => { if (_.BuildFlag == false) { return(false); } if (_.ServiceType == serviceType) { return(true); } if (serviceType.IsConstructedGenericType) { var outType = serviceType.GetGenericTypeDefinition(); if (_.ServiceType == outType) { return(true); } } return(false); }).Select(p => { if (p.ImplementType.IsGenericType && p.ImplementType.ContainsGenericParameters) { Type newType = null; Type newServiceType = null; if (genericParms == null) { newType = p.ImplementType.MakeGenericType(serviceType.GetGenericArguments()); newServiceType = serviceType; } else { newType = p.ImplementType.MakeGenericType(genericParms); newServiceType = serviceType.MakeGenericType(genericParms); } var relation = new TypeRelation(newServiceType, newType, p.Lifetime); if (isDetect == false) { this.TryAddServiceType(newServiceType); this.typeRelations.Add(relation); } return(relation); } else { return(p); } }).ToList(); relations.Reverse(); return(relations); }
/// <summary> /// 查找最精确的输入类型和类型转换方法。 /// </summary> /// <param name="method">类型转换方法。</param> /// <param name="inputRelation">实际输入类型到方法输入类型间的关系。</param> /// <param name="outputRelation">实际输出类型到方法输出类型间的关系。</param> private void GetBestConversion(UserConversionMethod method, TypeRelation inputRelation, TypeRelation outputRelation) { Contract.Requires(method != null); // 更新最优输入和输出类型。 UpdateBestType(method.InputType, inputRelation, true, ref bestInputType, ref bestInputRelation); UpdateBestType(method.OutputType, outputRelation, false, ref bestOutputType, ref bestOutputRelation); if (method.InputType == bestInputType && method.OutputType == bestOutputType) { bestMethod.Value = method; } }
public float calculateTypeMultiplier(int moveId, Pokemon a, Pokemon d, ref TypeRelation relation) { relation = TypeRelation.Null; float multiplier = 1; MoveData moveData = Fi.data.getMoveData(moveId); //If the move is the same type as the pokemon if ((PokemonType)moveData.typeId == a.type1 || (PokemonType)moveData.typeId == a.type2) { multiplier *= 1.5f; } float typeMultiplier = Fi.data.getTypeRelationMultiplier(a.type1, d.type1); if (typeMultiplier == 2) { relation = TypeRelation.Good; } else if (typeMultiplier == 0.5) { relation = TypeRelation.Bad; } else { relation = TypeRelation.Neutral; } if (d.type2 != PokemonType.Null) { typeMultiplier *= Fi.data.getTypeRelationMultiplier(a.type1, d.type2); relation = TypeRelation.Neutral; } if (a.type2 != PokemonType.Null) { typeMultiplier *= Fi.data.getTypeRelationMultiplier(a.type2, d.type1); relation = TypeRelation.Neutral; if (d.type2 != PokemonType.Null) { typeMultiplier *= Fi.data.getTypeRelationMultiplier(a.type2, d.type2); } } return(multiplier); }
/// <summary> /// 根据serviceType创建新的依赖关系 /// </summary> /// <param name="serviceType"></param> /// <param name="isDedect"></param> /// <returns></returns> internal TypeRelation MakeGeneric(Type serviceType, bool isDedect = false) { var outType = serviceType.GetGenericTypeDefinition(); var relation = this.typeRelations.First(p => p.ServiceType == outType); var result = new TypeRelation(serviceType, relation.ImplementType.MakeGenericType(serviceType.GenericTypeArguments), relation.Lifetime); if (isDedect == false) { this.typeRelations.Insert(0, result); this.TryAddServiceType(serviceType); } return(result); }
/// <summary> /// Gets multiplier for specific type from relations. /// </summary> /// <param name="types">Type relations.</param> /// <param name="type">Type to find.</param> /// <returns>Multiplier of the type relationship.</returns> public static double GetMultiplier(TypeRelation types, string type) { if (types.Strong.ContainsKey(type)) { return(types.Strong[type]); } else if (types.Weak.ContainsKey(type)) { return(types.Weak[type]); } else { return(1.0); } }
public XLink(int sourceTypeId, int sourceObjectId, int targetTypeId, int targetObjectId, TypeRelation relation) { if (sourceTypeId <= 0) throw new ArgumentOutOfRangeException("sourceTypeId", "Value must be greater than zero."); if (sourceObjectId <= 0) throw new ArgumentOutOfRangeException("sourceObjectId", "Value must be greater than zero."); if (targetTypeId <= 0) throw new ArgumentOutOfRangeException("targetTypeId", "Value must be greater than zero."); if (targetObjectId <= 0) throw new ArgumentOutOfRangeException("targetObjectId", "Value must be greater than zero."); Relation = relation; TargetObjectId = targetObjectId; TargetTypeId = targetTypeId; SourceObjectId = sourceObjectId; SourceTypeId = sourceTypeId; }
/// <summary> /// Calculates all of the relevant Stats of a Pokémon. This /// includes the Forms, Moves, League IVs, Type interactions, and weather boosts. /// </summary> /// <param name="pokemon">Reference to a Pokémon.</param> public void GetPokemonStats(ref Pokemon pokemon) { if (pokemon != null) { TypeRelation typeRelations = GetTypeDefenseRelations(pokemon.Type); pokemon.Weakness = typeRelations.Weak.Keys.ToList(); pokemon.Resistance = typeRelations.Strong.Keys.ToList(); pokemon.Weather = GetWeather(pokemon.Type); pokemon.FastMove = POGODBConnector.GetPokemonMoves(ReformatName(pokemon.Name), Global.FAST_MOVE_CATEGORY); pokemon.ChargeMove = POGODBConnector.GetPokemonMoves(ReformatName(pokemon.Name), Global.CHARGE_MOVE_CATEGORY, pokemon.Shadow); pokemon.CPMax = CPCalculator.CalcCPPerLevel( pokemon.Attack, pokemon.Defense, pokemon.Stamina, Global.MAX_IV, Global.MAX_IV, Global.MAX_IV, Global.MAX_XL_LEVEL); } }
/// <summary> /// 更新最优的输入/输出类型。 /// </summary> /// <param name="methodType">类型转换方法的输入/输出类型。</param> /// <param name="relation">实际输入类型与方法输入/输出类型间的关系。</param> /// <param name="relationJudge">方法输入/输出类型和最优类型间的关系判定。</param> /// <param name="bestType">当前的最优类型。</param> /// <param name="bestRelation">当前最优类型与实际输入/输出类型间的关系。</param> private void UpdateBestType(Type methodType, TypeRelation relation, bool relationJudge, ref Type bestType, ref TypeRelation bestRelation) { // 当前选择更差。 if (relation > bestRelation) { return; } // 当前选择更优,或者当前选择与最佳选择相同,但最佳选择没有类型填充。 if (relation < bestRelation || bestType == null) { bestType = methodType; bestRelation = relation; bestMethod.Reset(); return; } ConversionType ctype = ConversionFactory.GetStandardConversion(methodType, bestType); if (ctype == ConversionType.None) { // 找不到类型转换关系,令最佳选择前进至下一级别,并清除类型填充。 bestType = null; bestRelation--; bestMethod.Reset(); return; } if (ctype.IsImplicit() == relationJudge) { // 当前选择被最优选择包含。 if (bestRelation == TypeRelation.Second) { bestType = methodType; bestMethod.Reset(); } } else if (bestRelation == TypeRelation.Thirt) { // 当前选择包含最优选择。 bestType = methodType; bestMethod.Reset(); } }
void SingleAttack(Character attacker, Character opponent) { TypeRelation relation = Types.GetRelation(attacker.Type, opponent.Type); opponent.EnemyAwareness &= Types.GetPossibleTypes(attacker.Type, relation); float multiplier = relation == TypeRelation.Neutral ? 1 : (relation == TypeRelation.Advantage ? 2 : 0.5f); Character.Status hp = opponent.HitPoints; hp.Remaining -= (int)Math.Round(multiplier * attacker.Strength); opponent.HitPoints = hp; if (!opponent.Alive) { opponent.Parent.Active = false; if (opponent is Hero && !((Hero)opponent).AlliedUnitInRoom(opponent.Tile.Room)) { opponent.Tile.Room.UpdateGraphics(Room.Visibility.Darkened); attacker.GetComponent <SpriteRenderer>().Active = false; } } }
public RelationsPropertyEngine( IServiceProvider serviceProvider, IQueryService queryService, InformationRessource informationRessource, PropertyInfo propertyRelation, RelationshipJsonApiAttribute relationshipJApiAttribute, string _relationPath, int depth) { this._serviceProvider = serviceProvider; this._queryService = queryService; this._informationRessource = informationRessource; this._relationProperty = propertyRelation; this._relationAttribute = relationshipJApiAttribute; this._depth = depth; this._relationPath = _relationPath; (PropertyInfo foreignKeyProperty, ForeignKeyJsonApiAttribute foreignKeyAttribute) = AttributeRelationsHandling.FindForeignKeyPropertyAndAttribute(this._informationRessource.TypeRessource, this._relationProperty.Name); if (foreignKeyProperty == null && foreignKeyAttribute == null) { throw new JsonApiArchitectureException($"ForeignKeyJsonApi manquant pour {this._relationProperty.Name} dans {this._informationRessource.TypeRessource.Name}, ajouter[ForeignKeyJsonApi (RelationName = nameof({this._relationProperty.Name}))]"); } this._identifiantRelationProperty = AttributeHandling.GetIdProperty(typeof(T)); if (this._identifiantRelationProperty == null) { throw new JsonApiArchitectureException($"Ajouter [IdJsonApi] sur {typeof(T).Name}"); } this._foreignKeyProperty = foreignKeyProperty; this._foreignKeyAttribute = foreignKeyAttribute; this._typeRelation = this._relationAttribute is HasManyJsonApiAttribute ? TypeRelation.Many : TypeRelation.One; this.GetRelations(); }
public static CombatType GetPossibleTypes(CombatType attacker, TypeRelation result) { if (result == TypeRelation.Neutral) { return(attacker); } switch (attacker) { case CombatType.Lizard: return(result == TypeRelation.Advantage ? CombatType.Spock | CombatType.Paper : CombatType.Scissors | CombatType.Rock); case CombatType.Paper: return(result == TypeRelation.Advantage ? CombatType.Rock | CombatType.Spock : CombatType.Scissors | CombatType.Lizard); case CombatType.Rock: return(result == TypeRelation.Advantage ? CombatType.Scissors | CombatType.Lizard : CombatType.Paper | CombatType.Spock); case CombatType.Scissors: return(result == TypeRelation.Advantage ? CombatType.Paper | CombatType.Lizard : CombatType.Rock | CombatType.Spock); case CombatType.Spock: return(result == TypeRelation.Advantage ? CombatType.Scissors | CombatType.Rock : CombatType.Paper | CombatType.Lizard); default: throw new InvalidOperationException("This will never happen."); } }
protected sbyte ScoreHero(Hero hero) { sbyte score = 0; foreach (CombatType type in Enum.GetValues(typeof(CombatType))) { if (hero.EnemyAwareness.HasFlag(type)) { TypeRelation result = Types.GetRelation(Monster.Type, type); if (result == TypeRelation.Advantage) { score++; } if (result == TypeRelation.Disadvantage) { score--; } } } return(score); }
public async Task Type([Summary("(Optional) Get information about this type.")] string type1 = null, [Summary("(Optional) Get information about this secondary type.")] string type2 = null) { if (type1 == null) { StringBuilder sb = new StringBuilder(); sb.AppendLine($"{Global.NONA_EMOJIS["bug_emote"]} Bug"); sb.AppendLine($"{Global.NONA_EMOJIS["dark_emote"]} Dark"); sb.AppendLine($"{Global.NONA_EMOJIS["dragon_emote"]} Dragon"); sb.AppendLine($"{Global.NONA_EMOJIS["electric_emote"]} Electric"); sb.AppendLine($"{Global.NONA_EMOJIS["fairy_emote"]} Fairy"); sb.AppendLine($"{Global.NONA_EMOJIS["fighting_emote"]} Fighting"); sb.AppendLine($"{Global.NONA_EMOJIS["fire_emote"]} Fire"); sb.AppendLine($"{Global.NONA_EMOJIS["flying_emote"]} Flying"); sb.AppendLine($"{Global.NONA_EMOJIS["ghost_emote"]} Ghost"); sb.AppendLine($"{Global.NONA_EMOJIS["grass_emote"]} Grass"); sb.AppendLine($"{Global.NONA_EMOJIS["ground_emote"]} Ground"); sb.AppendLine($"{Global.NONA_EMOJIS["ice_emote"]} Ice"); sb.AppendLine($"{Global.NONA_EMOJIS["normal_emote"]} Normal"); sb.AppendLine($"{Global.NONA_EMOJIS["poison_emote"]} Poison"); sb.AppendLine($"{Global.NONA_EMOJIS["psychic_emote"]} Psychic"); sb.AppendLine($"{Global.NONA_EMOJIS["rock_emote"]} Rock"); sb.AppendLine($"{Global.NONA_EMOJIS["steel_emote"]} Steel"); sb.AppendLine($"{Global.NONA_EMOJIS["water_emote"]} Water"); EmbedBuilder embed = new EmbedBuilder(); embed.AddField($"Pokémon Types:", sb.ToString()); embed.WithColor(Global.EMBED_COLOR_DEX_RESPONSE); embed.WithFooter("Pokémon have 1 or 2 types. Moves always have 1 type."); await ReplyAsync(embed : embed.Build()); } else { List <string> types = new List <string> { type1 }; if (type2 != null && !type1.Equals(type2, StringComparison.OrdinalIgnoreCase)) { types.Add(type2); } if (!CheckValidType(type1) || (types.Count == 2 && !CheckValidType(type2))) { await ResponseMessage.SendErrorMessage(Context.Channel, "type", $"{(!CheckValidType(type1) ? type1 : type2)} is not a valid type."); } else { string title = $"{type1}"; if (types.Count == 2) { title += $", {type2}"; } string description = Global.NONA_EMOJIS[$"{type1}_emote"]; if (types.Count == 2) { description += Global.NONA_EMOJIS[$"{type2}_emote"]; } TypeRelation? type1AttackRelations = (types.Count == 2) ? null : (TypeRelation?)Connections.Instance().GetTypeAttackRelations(type1); TypeRelation defenseRelations = Connections.Instance().GetTypeDefenseRelations(types); List <string> weather = Connections.Instance().GetWeather(types); EmbedBuilder embed = new EmbedBuilder(); string fileName = GENERIC_IMAGE; embed.WithTitle($"Type {title.ToUpper()}"); embed.WithDescription(description); embed.WithThumbnailUrl($"attachment://{fileName}"); embed.AddField("Weather Boosts:", FormatWeatherList(weather), false); if (type1AttackRelations.HasValue) { embed.AddField($"Super Effective against:", FormatTypeList(type1AttackRelations.Value.Strong), false); embed.AddField($"Not Very Effective against:", FormatTypeList(type1AttackRelations.Value.Weak), false); } embed.AddField($"Weaknesses:", FormatTypeList(defenseRelations.Weak), false); embed.AddField($"Resistances:", FormatTypeList(defenseRelations.Strong), false); embed.WithColor(Global.EMBED_COLOR_DEX_RESPONSE); Connections.CopyFile(fileName); await Context.Channel.SendFileAsync(fileName, embed : embed.Build()); Connections.DeleteFile(fileName); } } }
/// <summary> /// Computes the union type of {@code this} and {@code other}, meaning {@code union extends this} and /// {@code union extends other}. /// The union function may return null if no union type could be created due conflicting /// primitive types. /// </summary> /// <param name="other">other type</param> /// <param name="memory">types already used</param> /// <returns>union type </returns> public XType Union(XType other, HashSet <XType> memory) { TypeRelation rel = this.CompareTo(other); if (rel == TypeRelation.EXTENDS || rel == TypeRelation.EQUAL) { return(this); } else if (rel == TypeRelation.SUPER) { return(other); } XType ret = new XType(); memory.Add(this); outer: foreach (XCapability c0 in this.Capabilities) { if (c0.ComplexType == null || !memory.Contains(c0.ComplexType)) { foreach (XCapability c1 in other.Capabilities) { // the same member? if (c0.Name.CompareTo(c1.Name) != TypeRelation.NONE) { XCapability c2 = new XCapability(); c2.Name = c0.Name; // both complex types? if ((c0.ComplexType != null) && (c1.ComplexType != null)) { c2.ComplexType = c0.ComplexType.Union(c1.ComplexType, memory); if (c2.ComplexType == null) { return(null); // can't union the types } } else { if (c0.ValueType == c1.ValueType) { c2.ValueType = c0.ValueType; } else { return(null); // can't union the types } } switch (Utils.CompareCardinality(c0.Cardinality, c1.Cardinality)) { case TypeRelation.EXTENDS: case TypeRelation.EQUAL: c2.Cardinality = c0.Cardinality; break; case TypeRelation.SUPER: c2.Cardinality = c1.Cardinality; break; default: break; } ret.Capabilities.Add(c2); goto outer; } } // not found in c1 ret.Capabilities.Add(c0); } } outer2: foreach (XCapability c1 in other.Capabilities) { foreach (XCapability c0 in this.Capabilities) { if (c0.ComplexType == null || !memory.Contains(c0.ComplexType)) { if (c0.Name.CompareTo(c1.Name) != TypeRelation.NONE) { goto outer2; } } } ret.Capabilities.Add(c1); } memory.Remove(this); return(ret); }
private void DeleteTypeRelation(TypeRelation type) { Options.TypesRelation.Remove(type); }
/// <summary> /// 根据依赖关系生成对象 /// </summary> /// <param name="serviceProvider"></param> /// <param name="typeRelation"></param> /// <returns></returns> internal static object GetServiceByRelation(this IServiceProvider serviceProvider, TypeRelation typeRelation) { if (serviceProvider is ServiceProvider sp) { return(sp.GetServiceByRelation(typeRelation)); } else { return(null); } }
/// <summary> /// 查找最精确的输入类型和类型转换方法。 /// </summary> /// <param name="method">类型转换方法。</param> /// <param name="inputRelation">实际输入类型到方法输入类型间的关系。</param> /// <param name="outputRelation">实际输出类型到方法输出类型间的关系。</param> private void GetBestConversion(UserConversionMethod method, TypeRelation inputRelation, TypeRelation outputRelation) { Contract.Requires(method != null); // 更新最优输入和输出类型。 UpdateBestType(method.InputType, inputRelation, true, ref bestInputType, ref bestInputRelation); UpdateBestType(method.OutputType, outputRelation, false, ref bestOutputType, ref bestOutputRelation); if (method.InputType == bestInputType && method.OutputType == bestOutputType) { bestMethod.Value = method; } }
/// <summary> /// 更新最优的输入/输出类型。 /// </summary> /// <param name="methodType">类型转换方法的输入/输出类型。</param> /// <param name="relation">实际输入类型与方法输入/输出类型间的关系。</param> /// <param name="relationJudge">方法输入/输出类型和最优类型间的关系判定。</param> /// <param name="bestType">当前的最优类型。</param> /// <param name="bestRelation">当前最优类型与实际输入/输出类型间的关系。</param> private void UpdateBestType(Type methodType, TypeRelation relation, bool relationJudge, ref Type bestType, ref TypeRelation bestRelation) { // 当前选择更差。 if (relation > bestRelation) { return; } // 当前选择更优,或者当前选择与最佳选择相同,但最佳选择没有类型填充。 if (relation < bestRelation || bestType == null) { bestType = methodType; bestRelation = relation; bestMethod.Reset(); return; } ConversionType ctype = ConversionFactory.GetStandardConversion(methodType, bestType); if (ctype == ConversionType.None) { // 找不到类型转换关系,令最佳选择前进至下一级别,并清除类型填充。 bestType = null; bestRelation--; bestMethod.Reset(); return; } if (ctype.IsImplicit() == relationJudge) { // 当前选择被最优选择包含。 if (bestRelation == TypeRelation.Second) { bestType = methodType; bestMethod.Reset(); } } else if (bestRelation == TypeRelation.Thirt) { // 当前选择包含最优选择。 bestType = methodType; bestMethod.Reset(); } }
/// <summary> /// Récupere la liste des couples propriétés / attributes (HasOneJsonApiAttribute et/ou HasManyJsonApiAttribute) pour un type /// </summary> /// <param name="type">Type sur lequel chercher</param> /// <param name="typeRelation">Type de relation recherché, par défaut TypeRelation.None = Tous les relations</param> public static IEnumerable <Tuple <PropertyInfo, RelationshipJsonApiAttribute> > GetRelationshipProperties(Type type, TypeRelation typeRelation = TypeRelation.None) { Type typeAttribute; if (typeRelation == TypeRelation.One) { typeAttribute = typeof(HasOneJsonApiAttribute); } else if (typeRelation == TypeRelation.Many) { typeAttribute = typeof(HasManyJsonApiAttribute); } else if (typeRelation == TypeRelation.ManyToMany) { typeAttribute = typeof(HasManyToManyJsonApiAttribute); } else { typeAttribute = typeof(RelationshipJsonApiAttribute); } foreach (PropertyInfo prop in type.GetProperties()) { var attr = (RelationshipJsonApiAttribute)prop.GetCustomAttribute(typeAttribute); if (attr != null) { yield return(new Tuple <PropertyInfo, RelationshipJsonApiAttribute>(prop, attr)); } } }
/// <summary> /// Runs the counter simulation against a boss using raiders. /// </summary> /// <param name="boss">Boss to fight against.</param> /// <param name="raiders">Raiders used to attack the boss.</param> /// <returns>Counter calculation results.</returns> public static CounterCalcResults RunSim(Pokemon boss, List <Pokemon> raiders) { CounterCalcResults results = new CounterCalcResults(); for (int mode = 0; mode < 2; mode++) { List <Counter> counters = new List <Counter>(); TypeRelation bossTypes = Connections.Instance().GetTypeDefenseRelations(boss.Type); foreach (Pokemon raider in raiders) { if (raider.Released && (mode == REGULAR_COUNTER_INDEX && !raider.Name.Contains("Mega ") || (mode == SPECIAL_COUNTER_INDEX && (raider.Shadow || raider.Name.Contains("Mega ")))) ) { List <Counter> allCounters = new List <Counter>(); TypeRelation raiderTypes = Connections.Instance().GetTypeDefenseRelations(raider.Type); foreach (Move raiderFast in raider.FastMove) { foreach (Move raiderCharge in raider.ChargeMove) { if ((!raiderCharge.Name.Equals(Global.SHADOW_MOVES.ElementAt(Global.PURIFIED_INDEX).Name, StringComparison.OrdinalIgnoreCase) && !raiderCharge.Name.Equals(Global.SHADOW_MOVES.ElementAt(Global.SHADOW_INDEX).Name, StringComparison.OrdinalIgnoreCase)) || (raiderCharge.Name.Equals(Global.SHADOW_MOVES.ElementAt(Global.PURIFIED_INDEX).Name, StringComparison.OrdinalIgnoreCase) && mode == REGULAR_COUNTER_INDEX) || (raiderCharge.Name.Equals(Global.SHADOW_MOVES.ElementAt(Global.SHADOW_INDEX).Name, StringComparison.OrdinalIgnoreCase) && mode == SPECIAL_COUNTER_INDEX)) { SimPokemon raiderSim = new SimPokemon { Number = raider.Number, Name = raider.Name, Fast = raiderFast, Charge = raiderCharge, FastEffect = TypeCalculator.GetMultiplier(bossTypes, raiderFast.Type), ChargeEffect = TypeCalculator.GetMultiplier(bossTypes, raiderCharge.Type), FastStab = raider.Type.Contains(raiderFast.Type) ? STAB_MULTIPLIER : 1.0, ChargeStab = raider.Type.Contains(raiderCharge.Type) ? STAB_MULTIPLIER : 1.0, StadowAtkMul = mode == SPECIAL_COUNTER_INDEX && raider.Shadow ? SHADOW_ATK_MUL : 1.0, StadowDefMul = mode == SPECIAL_COUNTER_INDEX && raider.Shadow ? SHADOW_DEF_MUL : 1.0, AtkStat = (int)((raider.Attack + Global.MAX_IV) * Global.DISCRETE_CPM[Global.MAX_REG_LEVEL - 1]), DefStat = (int)((raider.Defense + Global.MAX_IV) * Global.DISCRETE_CPM[Global.MAX_REG_LEVEL - 1]), StamStat = (int)((raider.Stamina + Global.MAX_IV) * Global.DISCRETE_CPM[Global.MAX_REG_LEVEL - 1]) }; SimPokemon bossSim = new SimPokemon { Number = boss.Number, Name = boss.Name, StadowAtkMul = 1.0, StadowDefMul = 1.0, AtkStat = (int)((boss.Attack + Global.MAX_IV) * Global.DISCRETE_CPM[Global.MAX_REG_LEVEL - 1]), DefStat = (int)((boss.Defense + Global.MAX_IV) * Global.DISCRETE_CPM[Global.MAX_REG_LEVEL - 1]), StamStat = (int)((boss.Stamina + Global.MAX_IV) * Global.DISCRETE_CPM[Global.MAX_REG_LEVEL - 1]) }; double x = 0.0; double y = 0.0; double moveSets = 1; List <Move> bossFastMoves = boss.FastMove.Where(m => !m.IsLegacy).ToList(); List <Move> bossChargeMoves = boss.ChargeMove.Where(m => !m.IsLegacy).ToList(); if (boss.Defense == 0 || bossFastMoves.Count + bossChargeMoves.Count == 0) { if (boss.Defense == 0) { bossSim.DefStat = DEFAULT_DEF; } x = (0.5 * raiderSim.Fast.PvEEnergy) + (0.5 * raiderSim.Charge.PvEEnergy); y = DEFAULT_DPS / (double)raiderSim.DefStat; } else { moveSets = boss.FastMove.Count * boss.ChargeMove.Count; foreach (Move bossFast in bossFastMoves) { bossSim.Fast = bossFast; bossSim.FastEffect = TypeCalculator.GetMultiplier(raiderTypes, bossFast.Type); bossSim.FastStab = boss.Type.Contains(bossFast.Type) ? STAB_MULTIPLIER : 1.0; foreach (Move bossCharge in bossChargeMoves) { if (!bossCharge.Name.Equals(Global.SHADOW_MOVES.ElementAt(Global.PURIFIED_INDEX).Name, StringComparison.OrdinalIgnoreCase) && !bossCharge.Name.Equals(Global.SHADOW_MOVES.ElementAt(Global.SHADOW_INDEX).Name, StringComparison.OrdinalIgnoreCase)) { bossSim.Charge = bossCharge; bossSim.ChargeEffect = TypeCalculator.GetMultiplier(raiderTypes, bossCharge.Type); bossSim.ChargeStab = boss.Type.Contains(bossCharge.Type) ? STAB_MULTIPLIER : 1.0; DPSInput inputs = CalcDPSInput(bossSim, raiderSim); x += inputs.X; y += inputs.Y; } } } } allCounters.Add(CalcDps(bossSim, raiderSim, x / moveSets, y / moveSets)); } } } if (allCounters.Count != 0) { counters.Add(allCounters.OrderByDescending(x => x.Rating).First()); } } } if (mode == REGULAR_COUNTER_INDEX) { results.Regular = counters.OrderByDescending(x => x.Rating).ThenBy(x => x.Name).Take(RESULTS).ToList(); } else { results.Special = counters.OrderByDescending(x => x.Rating).ThenBy(x => x.Name).Take(RESULTS).ToList(); } } return(results); }
/// <summary> /// 查找合适的用户自定义类型转换方法。 /// </summary> /// <returns>合适的用户自定义类型转换方法,如果不存在则为 <c>null</c>。</returns> public MethodInfo FindConversion() { UserConversions convs = GetUserConversions(inputType); if (convs != null) { Contract.Assume(convs.ConvertToIndex >= 0); for (int i = convs.ConvertToIndex; i < convs.Methods.Length; i++) { UserConversionMethod method = convs.Methods[i]; ConversionType ctype = ConversionFactory.GetStandardConversion(outputType, method.OutputType); if (ctype == ConversionType.None) { continue; } TypeRelation inputRelation = (method.InputType == inputType) ? TypeRelation.Best : TypeRelation.Second; TypeRelation outputRelation = TypeRelation.Best; if (ctype >= ConversionType.ExplicitNumeric) { outputRelation = TypeRelation.Second; } else if (ctype > ConversionType.Identity) { outputRelation = TypeRelation.Thirt; } GetBestConversion(method, inputRelation, outputRelation); } } convs = GetUserConversions(outputType); if (convs != null) { for (int i = 0; i < convs.ConvertToIndex; i++) { UserConversionMethod method = convs.Methods[i]; ConversionType ctype = ConversionFactory.GetStandardConversion(method.InputType, inputType); if (ctype == ConversionType.None) { continue; } TypeRelation outputRelation = (method.OutputType == outputType) ? TypeRelation.Best : TypeRelation.Second; TypeRelation inputRelation = TypeRelation.Best; if (ctype >= ConversionType.ExplicitNumeric) { inputRelation = TypeRelation.Second; } else if (ctype > ConversionType.Identity) { inputRelation = TypeRelation.Thirt; } GetBestConversion(method, inputRelation, outputRelation); } } if (bestMethod.IsUnique) { return(bestMethod.Value.Method); } if (bestMethod.IsAmbig) { throw CommonExceptions.AmbiguousUserDefinedConverter(inputType, outputType); } return(null); }