public static int CalculateScore(this IScorable scorable) { var baseScore = scorable.Stars * 50 + scorable.Awesomes * 5 + scorable.AdminScore + 2; scorable.Score = baseScore / ((DateTime.UtcNow - scorable.CreateTime).Days + 1); return(scorable.Score); }
public override void Collided(ICollidable i_Collidable) { Bullet bullet = i_Collidable as Bullet; bool dispose = true; if (bullet != null) { if (TeamColor == Color.Blue) { dispose = randomCalculationIfIShouldDie(); } } else { IScorable iScorable = i_Collidable as IScorable; if (iScorable != null) { addScoresToMyShooter(iScorable); } } if (dispose) { IsAlive = false; Visible = false; } }
/// <summary> /// Try to simplify a list of scorables. /// </summary> /// <param name="scorables">The simplified list of scorables.</param> /// <param name="scorable">The single scorable representing the list, if possible.</param> /// <returns>True if it were possible to reduce the list of scorables to a single scorable, false otherwise.</returns> public static bool TryReduce <Item, Score>(ref IEnumerable <IScorable <Item, Score> > scorables, out IScorable <Item, Score> scorable) { // only if this is a fixed list of scorables, but never a lazy enumerable var list = scorables as IReadOnlyList <IScorable <Item, Score> >; if (list != null) { var itemCount = list.Count; int keepCount = 0; for (int index = 0; index < itemCount; ++index) { var item = list[index]; if (Keep(item)) { ++keepCount; } } // empty non-null list is null scorable if (keepCount == 0) { scorable = NullScorable <Item, Score> .Instance; return(true); } // single item non-null list is just that scorable else if (keepCount == 1) { for (int index = 0; index < itemCount; ++index) { var item = list[index]; if (Keep(item)) { scorable = item; return(true); } } } // non-null subset of that list is just those scorables else if (keepCount < itemCount) { var keep = new IScorable <Item, Score> [keepCount]; int keepIndex = 0; for (int index = 0; index < itemCount; ++index) { var item = list[index]; if (Keep(item)) { keep[keepIndex] = item; ++keepIndex; } } scorables = keep; } } scorable = null; return(false); }
TargetScore IScorable <Item, TargetScore> .GetScore(Item item, object state) { IScorable <Item, SourceScore> source = this.inner; var sourceScore = source.GetScore(item, state); var targetScore = this.selector(item, sourceScore); return(targetScore); }
public DispatchTests() { // TODO: not working //methods.Setup(m => m.ToString()).Returns("methods"); this.resolver = new ActivityResolver( new DictionaryResolver(new Dictionary <Type, object>() { { typeof(IActivity), this.activity }, { typeof(IMethods), this.methods.Object }, }, new NullResolver())); luisOne .Setup(l => l.BuildUri(It.IsAny <string>())) .Returns <string>(q => new UriBuilder() { Path = q }.Uri); luisOne .Setup(l => l.QueryAsync(It.IsAny <Uri>(), token)) .Returns <Uri, CancellationToken>(async(u, t) => { var text = u.LocalPath.Substring(1); return(luisOneByText[text]); }); luisTwo .Setup(l => l.BuildUri(It.IsAny <string>())) .Returns <string>(q => new UriBuilder() { Path = q }.Uri); luisTwo .Setup(l => l.QueryAsync(It.IsAny <Uri>(), token)) .Returns <Uri, CancellationToken>(async(u, t) => { var text = u.LocalPath.Substring(1); return(luisTwoByText[text]); }); Func <ILuisModel, ILuisService> make = model => { if (model.SubscriptionKey == KeyOne && model.ModelID == ModelOne) { return(luisOne.Object); } if (model.SubscriptionKey == KeyTwo && model.ModelID == ModelTwo) { return(luisTwo.Object); } throw new NotImplementedException(); }; this.scorable = new AttributeScorable(typeof(IMethods), make); }
protected virtual bool OnStage(FoldStage stage, IScorable <IResolver, object> scorable, IResolver item, object state, object score) { switch (stage) { case FoldStage.AfterFold: return(true); case FoldStage.StartPost: continueAfterPost = false; return(true); case FoldStage.AfterPost: return(continueAfterPost); default: throw new NotImplementedException(); } }
public override bool OnStageHandler(FoldStage stage, IScorable <Item, Score> scorable, Item item, object state, Score score) { switch (stage) { case FoldStage.AfterFold: return(OnFold(scorable, item, state, score)); case FoldStage.StartPost: return(true); case FoldStage.AfterPost: return(false); default: throw new NotImplementedException(); } }
public override async Task <Token <Item, Score> > PrepareAsync(Item item, CancellationToken token) { Score maximumScore = default(Score); object maximumState = null; IScorable <Item, Score> maximumScorable = null; foreach (var scorable in this.scorables) { var state = await scorable.PrepareAsync(item, token); if (scorable.HasScore(item, state)) { var score = scorable.GetScore(item, state); bool better; if (maximumScorable == null) { better = true; } else { var compare = this.comparer.Compare(score, maximumScore); better = compare > 0; } if (better) { maximumScore = score; maximumState = state; maximumScorable = scorable; if (!OnFold(scorable, item, state, score)) { break; } } } } if (maximumScorable != null) { return(new Token <Item, Score>() { Scorable = maximumScorable, State = maximumState }); } else { return(null); } }
/// <summary> /// Invoke the scorable calling protocol against a single scorable. /// </summary> public static async Task <bool> TryPostAsync <Item, Score>(this IScorable <Item, Score> scorable, Item item, CancellationToken token) { var state = await scorable.PrepareAsync(item, token); if (scorable.HasScore(item, state)) { var score = scorable.GetScore(item, state); await scorable.PostAsync(item, state, token); return(true); } return(false); }
/// <summary> /// True if the scorable is non-null, false otherwise. /// </summary> public static bool Keep <Item, Score>(IScorable <Item, Score> scorable) { // complicated because IScorable<Item, Score> is variant on generic parameter, // so generic type arguments of NullScorable<,> may not match generic type // arguments of IScorable<,> var type = scorable.GetType(); if (type.IsGenericType) { var definition = type.GetGenericTypeDefinition(); if (typeof(NullScorable <,>).IsAssignableFrom(definition)) { return(false); } } return(true); }
private bool OnFold(IScorable <Item, Score> scorable, Item item, object state, Score score) { if (this.comparer.Compare(score, this.traits.Minimum) < 0) { throw new ArgumentOutOfRangeException(nameof(score)); } var maximum = this.comparer.Compare(score, this.traits.Maximum); if (maximum > 0) { throw new ArgumentOutOfRangeException(nameof(score)); } else if (maximum == 0) { return(false); } return(true); }
public SelectScoreScorable(IScorable <Item, SourceScore> scorable, Func <Item, SourceScore, TargetScore> selector) : base(scorable) { SetField.NotNull(out this.selector, nameof(selector), selector); }
/// <summary> /// Project the item of a scorable using a lambda expression. /// </summary> public static IScorable <SourceItem, Score> SelectItem <SourceItem, TargetItem, Score>(this IScorable <TargetItem, Score> scorable, Func <SourceItem, TargetItem> selector) { return(new SelectItemScorable <SourceItem, TargetItem, Score>(scorable, selector)); }
/// <summary> /// Project the score of a scorable using a lambda expression. /// </summary> public static IScorable <Item, TargetScore> SelectScore <Item, SourceScore, TargetScore>(this IScorable <Item, SourceScore> scorable, Func <Item, SourceScore, TargetScore> selector) { return(new SelectScoreScorable <Item, SourceScore, TargetScore>(scorable, selector)); }
public static IScorable <Item, Score> WhereScore <Item, Score>(this IScorable <Item, Score> scorable, Func <Item, Score, bool> predicate) { return(new WhereScoreScorable <Item, Score>(scorable, predicate)); }
protected DelegatingScorable(IScorable <Item, Score> inner) { SetField.NotNull(out this.inner, nameof(inner), inner); }
public static IScorable <IResolver, double> Normalize(this IScorable <IResolver, Binding> scorable) { return(scorable.SelectScore((r, b) => 1.0)); }
public static IDialog <T> WithScorable <T, Score>(this IDialog <T> antecedent, IScorable <Score> scorable) { return(new WithScorableDialog <T, Score>(antecedent, scorable)); }
public static IScorable <IResolver, IntentRecommendation> When(this IScorable <IResolver, Binding> scorable, ILuisModel model, LuisIntentAttribute intent, ILuisService service = null) { service = service ?? new LuisService(model); return(new LuisIntentScorable <Binding, Binding>(service, model, intent, scorable)); }
public static IScorable <IResolver, double> Normalize(this IScorable <IResolver, Match> scorable) { return(scorable.SelectScore((r, m) => RegexMatchScorable.ScoreFor(m))); }
public override async Task PostAsync <T>(T item, CancellationToken cancellationToken = default(CancellationToken)) { Score maximumScore = default(Score); object maximumState = null; IScorable <Score> maximumScorable = null; Func <IScorable <Score>, Delegate, Task <bool> > UpdateAsync = async(scorable, frame) => { var state = await scorable.PrepareAsync(item, frame); Score score; if (scorable.TryScore(state, out score)) { if (this.comparer.Compare(score, this.traits.Minimum) < 0) { throw new ArgumentOutOfRangeException(nameof(score)); } if (this.comparer.Compare(score, this.traits.Maximum) > 0) { throw new ArgumentOutOfRangeException(nameof(score)); } var compare = this.comparer.Compare(score, maximumScore); if (maximumScorable == null || compare > 0) { maximumScore = score; maximumState = state; maximumScorable = scorable; if (this.comparer.Compare(score, this.traits.Maximum) == 0) { return(false); } } } return(true); }; bool more = true; foreach (var frame in this.Frames) { var scorable = frame.Target as IScorable <Score>; if (scorable != null) { more = await UpdateAsync(scorable, frame); if (!more) { break; } } } if (more) { foreach (var scorable in this.scorables) { more = await UpdateAsync(scorable, null); if (!more) { break; } } } if (maximumScorable != null) { await maximumScorable.PostAsync <T>(this.inner, item, maximumState); await base.PollAsync(); } else { await base.PostAsync <T>(item, cancellationToken); } }
public WithScorableDialog(IDialog <T> antecedent, IScorable <Item, Score> scorable) : base(scorable) { SetField.NotNull(out this.Antecedent, nameof(antecedent), antecedent); }
public ScoringDialogTask(IPostToBot inner, IDialogStack stack, IScorable <IActivity, Score> scorable) { SetField.NotNull(out this.inner, nameof(inner), inner); SetField.NotNull(out this.stack, nameof(stack), stack); SetField.NotNull(out this.scorable, nameof(scorable), scorable); }
public static IScorable <IResolver, double> Normalize(this IScorable <IResolver, IntentRecommendation> scorable) { return(scorable.SelectScore((r, i) => i.Score ?? 0)); }
public WithScorableDialog(IDialog <T> antecedent, IScorable <Score> scorable) { SetField.NotNull(out this.Antecedent, nameof(antecedent), antecedent); SetField.NotNull(out this.Scorable, nameof(scorable), scorable); }
public static IScorable <IResolver, Match> When(this IScorable <IResolver, Binding> scorable, Regex regex) { return(new RegexMatchScorable <Binding, Binding>(regex, scorable)); }
public RegexMatchScorable(Regex regex, IScorable <IResolver, InnerScore> inner) : base(inner) { SetField.NotNull(out this.regex, nameof(regex), regex); }
public WhereScoreScorable(IScorable <Item, Score> scorable, Func <Item, Score, bool> predicate) : base(scorable) { SetField.NotNull(out this.predicate, nameof(predicate), predicate); }
public LuisIntentScorable(ILuisService service, ILuisModel model, LuisIntentAttribute intent, IScorable <IResolver, InnerScore> inner) : base(inner) { SetField.NotNull(out this.service, nameof(service), service); SetField.NotNull(out this.model, nameof(model), model); SetField.NotNull(out this.intent, nameof(intent), intent); }
public SelectItemScorable(IScorable <InnerItem, Score> scorable, Func <OuterItem, InnerItem> selector) { SetField.NotNull(out this.scorable, nameof(scorable), scorable); SetField.NotNull(out this.selector, nameof(selector), selector); }