public override void VisitOther(Pred pred)
{
VisitCode(pred, pred.PreAction);
VisitCode(pred, pred.PostAction);
if (pred.VarLabel != null)
ProperLabels[pred.VarLabel] = ProperLabels.TryGetValue(pred.VarLabel, false) | pred.ResultSaver == null;
}
private static void AutoKillsteal()
{
if (!Spells._q.IsReadyPerfectly() || ObjectManager.Player.IsDead || !Config.CanqKS)
{
return;
}
var qMana = ObjectManager.Player.Spellbook.GetSpell(SpellSlot.Q).ManaCost;
foreach (var enemy in HeroManager.Enemies.Where(e => !e.IsDead))
{
if (enemy.IsKillableAndValidTarget(Spells._q.GetDamage(enemy), Spells._q.DamageType, Spells._q.Range))
{
if (!enemy.IsKillableAndValidTarget(Spells._w.GetDamage(enemy), Spells._w.DamageType, SebbyLib.Orbwalking.GetRealAutoAttackRange(ObjectManager.Player)) || !Spells._w.IsReadyPerfectly())
{
if (ObjectManager.Player.Distance(enemy) >= SebbyLib.Orbwalking.GetRealAutoAttackRange(ObjectManager.Player) ||
!Spells._w.IsReadyPerfectly() ||
CardSelector.Status != SelectStatus.Selecting ||
CardSelector.Status != SelectStatus.Selected)
{
Pred.CastSebbyPredict(Spells._q, enemy, Spells._q.MinHitChance);
}
}
}
}
}
public override object Execute(Reasoner reasoner, Unifier un, ITerm[] args)
{
CheckArguments(args);
Agent ag = reasoner.GetAgent();
Pred inc = new Pred(ns, "include");
inc.AddTerms(args);
//-Cosas Java???
//-Sí Peterrr, cÓsas Naz* ¡digo! cÓsas Java
Agent result = ((Include)DirectiveProcessor.GetDirective("include")).Process(inc, ag, null);
ag.ImportComponents(result);
ag.AddInitialBelsInBB();
ag.AddInitialDesiresInReasoner();
if (args.Length > 1 && args[1].IsVar())
{
return(un.Unifies(args[1], inc.GetTerm(1)));
}
else
{
return(true);
}
}
public async Task <IActionResult> Edit(int id, [Bind("SifPred,KratPred,NazPred,SifOrgjed,UpisanoStud,BrojSatiTjedno")] Pred pred)
{
if (id != pred.SifPred)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(pred);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PredExists(pred.SifPred))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["SifOrgjed"] = new SelectList(_context.Orgjed, "SifOrgjed", "NazOrgjed", pred.SifOrgjed);
return(View(pred));
}
public BEHControl(BehCF act, Pred persistent, int priorty, ICancellee cT)
{
action = act;
persist = persistent;
priority = priorty;
this.cT = cT;
}
public static void ContramapTest()
{
var pred = Pred.Create((int x) => x > 5).ContraMap((IEnumerable <int> x) => x.Count()).ToPredicate();
Assert.False(pred.Run(new int[] { 1, 2, 3, 4 }));
Assert.True(pred.Run(new int[] { 1, 2, 3, 4, 5, 6 }));
}
protected static Rule Rule(string name, Pred contents, Symbol mode = null, int k = 0)
{
var rule = Pred.Rule(name, contents, (mode ?? Start) == Start, mode == Token, k);
if (mode == Private)
rule.IsPrivate = true;
return rule;
}
public static ITerm AddAnnotToList(ITerm l, DefaultTerm source)
{
if (l.IsList())
{
IListTerm result = new ListTermImpl();
foreach (ITerm lTerm in (IListTerm)l)
{
ITerm t = AddAnnotToList(lTerm, source);
if (t != null)
{
result.Add(t);
}
}
return(result);
}
else if (l.IsLiteral())
{
Literal result = ((Literal)l).ForceFullLiteralImpl().Copy();
//Create the source annots
Literal ts = Pred.CreateSource(source).AddAnnots(result.GetAnnots("source"));
result.DelSources();
result.AddAnnots(ts);
return(result);
}
else
{
return(l);
}
}
public BulletControl(SBCF act, Pred persistent, int priority, ICancellee cT)
{
action = act;
persist = persistent;
this.priority = priority;
this.cT = cT;
}
public override Agent Process(Pred directive, Agent outerContent, Agent innerContent)
{
if (outerContent == null)
{
return(null);
}
try
{
string id = ((IStringTerm)directive.GetTerm(0)).GetString();
if (directive.GetArity() == 1)
{
// it is implemented in java
//outerContent.AddFunction((Class<ArithFunction>)Class.forName(id));
outerContent.AddFunction(Type.GetType(id));
}
else if (directive.GetArity() == 3)
{
// is is implemented in AS
int arity = (int)((INumberTerm)directive.GetTerm(1)).Solve();
string predicate = ((IStringTerm)directive.GetTerm(2)).GetString();
outerContent.AddFunction(id, arity, predicate);
}
}
catch (Exception e)
{
}
return(null);
}
public Rule(LNode basis, Symbol name, Pred pred, bool isStartingRule = true)
{
Basis = basis; Pred = pred; Name = name;
IsStartingRule = isStartingRule;
EndOfRule = new EndOfRule(this);
if (basis != null && basis.Calls(S.Fn) && basis.ArgCount >= 3)
ReturnType = basis.Args[0];
}
public void Can_assign_a_func_to_a_pred()
{
Func <int, bool> f = i => i > 0;
Pred <int> greaterThanZero = f;
Assert.True(greaterThanZero.Func(1));
}
public override void Clear()
{
if (Pred != null)
{
Pred.MarkUncomplited();
}
base.Clear();
}
/// <summary>
/// Create a sound effect.
/// </summary>
/// <param name="sfx">Sound effect</param>
/// <param name="cond">Filter condition</param>
/// <returns></returns>
public static BehCFc SFX(string sfx, Pred cond)
{
return(new BehCFc(b => {
if (cond(b.rBPI))
{
SFXService.Request(sfx);
}
}, BM.BulletControl.P_RUN));
}
/// <summary>
/// Add to the time of objects.
/// </summary>
/// <param name="by">Delta time</param>
/// <param name="cond">Filter condition</param>
/// <returns></returns>
public static BehCFc DT(float by, Pred cond)
{
return(new BehCFc(b => {
if (cond(b.rBPI))
{
b.SetTime(b.rBPI.t + by);
}
}, BM.BulletControl.P_MOVE_1));
}
/// <summary>
/// Add to the y-position of bullets. Useful for teleporting around the sides.
/// </summary>
/// <param name="by">Delta position</param>
/// <param name="cond">Filter condition</param>
/// <returns></returns>
public static BehCFc DY(float by, Pred cond)
{
return(new BehCFc(b => {
if (cond(b.rBPI))
{
b.rBPI.loc.y += by;
}
}, BM.BulletControl.P_MOVE_2));
}
/// <summary>
/// Flip the Y-velocity of bullets.
/// Use <see cref="FlipXGT"/>, etc instead for flipping against walls.
/// </summary>
/// <param name="cond">Filter condition</param>
/// <returns></returns>
public static BehCFc FlipY(Pred cond)
{
return(new BehCFc(b => {
if (cond(b.rBPI))
{
b.FlipVelY();
}
}, BM.BulletControl.P_MOVE_3));
}
/// <summary>
/// Destroy bullets.
/// </summary>
/// <param name="cond">Filter condition</param>
/// <returns></returns>
public static BehCFc Cull(Pred cond)
{
return(new BehCFc(b => {
if (cond(b.rBPI))
{
b.InvokeCull();
}
}, BM.BulletControl.P_CULL));
}
public void Can_access_the_contained_func()
{
var isOdd = Pred <int> .MakeFrom(i => i % 2 != 0);
var isOddDelegate = isOdd.Func;
Assert.False(isOddDelegate(0));
Assert.True(isOddDelegate(-1));
}
/// <summary>
/// Set the time of bullets.
/// </summary>
/// <param name="time">Time to set</param>
/// <param name="cond">Filter condition</param>
/// <returns></returns>
public static BehCFc Time(float time, Pred cond)
{
return(new BehCFc(b => {
if (cond(b.rBPI))
{
b.SetTime(time);
}
}, BM.BulletControl.P_MOVE_1));
}
public override void Handle(Post post)
{
BindScope boundScope = new BindScope(Context, post);
if (Pred.Calc(boundScope).Bool)
{
post.XData.Matches = true;
base.Handle(post);
}
}
/// <summary>
/// Change the bullets into a softcull-type bullet rather than destroying them directly.
/// </summary>
/// <param name="target">New style</param>
/// <param name="cond">Filter condition</param>
/// <returns></returns>
public static BehCFc Softcull(string target, Pred cond)
{
return(new BehCFc(b => {
if (cond(b.rBPI))
{
b.SpawnSimple(target);
b.InvokeCull();
}
}, BM.BulletControl.P_CULL));
}
public override void Execute()
{
var predRear = Pred.Substring(Pred.Length - 1, 1);
var succRear = Succ.Substring(Succ.Length - 1, 1);
if ((succRear.Equals("1")) && (predRear.Equals("0")))
{
Counter++;
}
}
public static BehCFc FlipYLT(BPY wall, Pred cond)
{
return(new BehCFc(b => {
var bpi = b.rBPI;
if (bpi.loc.y < wall(bpi) && cond(bpi))
{
b.rBPI.FlipSimple(true, wall(bpi));
b.FlipVelY();
}
}, BM.BulletControl.P_MOVE_3));
}
public static LCF FlipYLT(float wall, Pred cond)
{
return(b => {
if (b.bpi.loc.y < wall && cond(b.bpi))
{
b.FlipBPIAndDeltaSimple(true, wall);
b.path.FlipY();
b.intersectStatus = SelfIntersectionStatus.CHECK_THIS_AND_NEXT;
}
});
}
private bool VisitAndReplace(ref Pred p)
{
Debug.Assert(Replacement == null);
p.Call(this);
if (Replacement != null) {
p = Replacement;
Replacement = null;
return true;
}
return false;
}
new public void Visit(Pred pred)
{
if (pred.PreAction != null && !_recognizerMode)
AddUserAction(pred.PreAction);
var old = _currentPred;
_currentPred = pred;
pred.Call(this);
_currentPred = old;
if (pred.PostAction != null && !_recognizerMode)
AddUserAction(pred.PostAction);
}
public void EvalPredZero()
{
// Arrange
var s = new Pred(new Zero());
// Act
var term = Eval(s);
// Assert
Assert.IsType <Zero>(term);
}
/// <summary>
/// Ctor
/// </summary>
internal LstInternal(IEnumerable <A> items, Pred <A> pred)
{
hashCode = 0;
if (items is Lst <A> )
{
var lst = (Lst <A>)items;
root = lst.Value.Root;
}
else
{
root = new ListItem <A>(0, 0, null, default, null);
public override void Execute()
{
var predRear = Pred.Substring(Pred.Length - 1, 1);
var succRear = Succ.Substring(Succ.Length - 1, 1);
var predHorz = Pred.Substring(0, Pred.Length - 1);
var succHorz = Succ.Substring(0, Succ.Length - 1);
if (predRear.Equals("1") && succRear.Equals("1") && !predHorz.Equals(succHorz))
{
Counter++;
}
}
public Node Pred()
{
Expect(Token.PRED);
Expect(Token.COROPEN);
var p = new Pred()
{
Exp()
};
Expect(Token.CORCLOSE);
return(p);
}
public void CanUsePredicates()
{
var source = new[] { 1, 2, 3, 4, 5 };
var isEven = new Pred <int>(x => x % 2 == 0);
var isOdd = isEven.Invert();
var isOddOr2 = isOdd.Or(x => x == 2);
var count = source.Where(isOddOr2).Count();
Assert.AreEqual(4, count);
}
public void CanUsePredicates()
{
var source = new[] { 1, 2, 3, 4, 5 };
var isEven = new Pred<int>(x => x%2 == 0);
var isOdd = isEven.Invert();
var isOddOr2 = isOdd.Or(x => x == 2);
var count = source.Where(isOddOr2).Count();
Assert.AreEqual(4, count);
}
public async Task <IActionResult> Create([Bind("SifPred,KratPred,NazPred,SifOrgjed,UpisanoStud,BrojSatiTjedno")] Pred pred)
{
if (ModelState.IsValid)
{
_context.Add(pred);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["SifOrgjed"] = new SelectList(_context.Orgjed, "SifOrgjed", "NazOrgjed", pred.SifOrgjed);
return(View(pred));
}
public LstInternal <A> InsertRange(int index, IEnumerable <A> items, Pred <A> pred)
{
if (items == null)
{
return(this);
}
if (index < 0 || index > Root.Count)
{
throw new IndexOutOfRangeException();
}
return(Wrap(ListModuleM.InsertMany(Root, items, index, pred)));
}
/// <summary>
/// Ctor
/// </summary>
internal LstInternal(IEnumerable <A> items, Pred <A> pred)
{
hashCode = 0;
root = ListItem <A> .Empty;
if (items is Lst <A> )
{
var lst = (Lst <A>)items;
root = lst.Value.Root;
}
else
{
root = ListModuleM.InsertMany(root, items, 0, pred);
}
}
void VisitCode(Pred pred, LNode code)
{
if (code == null) return;
code.ReplaceRecursive(node => {
if (node.Calls(S.Substitute, 1)) {
var arg = node.Args[0];
PredsUsingSubstitution.Add(pred);
if (arg.IsId && _rules.ContainsKey(arg.Name))
RulesReferenced.Add(_rules[arg.Name]);
else
OtherReferences[arg] = 0;
}
return null; // search only, no replace
});
}
public Pred Do(Pred pred, LNode postAction)
{
pred.PostAction = Pred.MergeActions(pred.PostAction, postAction);
return pred;
}
public override void VisitOther(Pred pred)
{
LNode basis = pred.Basis;
if (pred.VarLabel != null) {
basis = null;
MaybeCreateVariableFor(pred, pred.VarLabel, _codeGen.TerminalType);
}
// If code blocks refer to this predicate's label or basis node, tally
// the reference and create a variable decl for it if we haven't yet.
// TODO: bug here: LNode equality depends on trivia.
// Should we change default definition of LNode equality?
int predCounter;
if (_data.OtherReferences.TryGetValueSafe(basis, out predCounter)) {
_data.OtherReferences[basis] = predCounter + 1;
MaybeCreateVariableFor(pred, PickVarNameForLNode(basis), _codeGen.TerminalType);
}
}
public Pred Act(string pre, Pred pred, string post)
{
if (pre != null) pred.PreAction = F.Id(pre);
if (post != null) pred.PostAction = F.Id(post);
return pred;
}
protected static Pred AddSet(string varName, Pred pred) { return Pred.AddSet(varName, pred); }
void VisitWithNewTarget(Pred toBeVisited, WList<LNode> target)
{
var old = _target;
_target = target;
Visit(toBeVisited);
_target = old;
}
public B(Pred checkFunc)
{
_checkFunction = checkFunc;
}
protected static Alts Opt(Pred contents, bool? greedy = null) { return Pred.Opt(contents, greedy); }
protected static Alts Star(Pred contents, bool? greedy = null) { return Pred.Star(contents, greedy); }
private void MaybeCreateVariableFor(Pred pred, Symbol varName, LNode primType)
{
if (pred.ResultSaver != null)
return;
if (primType == null) {
primType = F.Object;
_sink.Write(Severity.Error, pred, Localize.From("The type of this expression is unknown (did you set LLLPG's 'terminalType' option?)"));
}
LNode type = primType, oldType;
if (pred.VarIsList)
type = _codeGen.GetListType(primType);
if (!_newVarInitializers.ContainsKey(varName))
_newVarInitializers[varName] = Pair.Create(type, _codeGen.MakeInitializedVarDecl(primType, pred.VarIsList, varName));
else if (!(oldType = _newVarInitializers[varName].A).Equals(type))
_sink.Write(Severity.Error, pred, Localize.From(
"Type mismatch: Variable '{0}' was generated earlier with type {1}, but this predicate expects {2}.",
varName, oldType, type));
pred.ResultSaver = Pred.GetStandardResultSaver(F.Id(varName),
pred.VarIsList ? S.AddSet : S.Assign);
}
public void ApplyPrematchData(Pred pred, DList<Prematched> path)
{
_path = path;
_index = 0;
_reachedInnerAlts = false;
pred.Call(this);
}
public void Visit(Pred pred) { pred.Call(this); }
public OperPredAndRuleBuilder(Policy policy, Pred<HttpOperationDescription> pred)
{
_ruleSet = policy.Add(pred);
}
protected static Seq Plus(Pred contents, bool? greedy = null) { return Pred.Plus(contents, greedy); }
public OperRuleSet(Pred<HttpOperationDescription> pred)
{
_operPred = pred;
}
public virtual void VisitOther(Pred pred) { }
protected static AndPred AndNot(Pred test) { return Pred.AndNot(test); }
public OperRuleSet Add(Pred<HttpOperationDescription> p)
{
var ruleSet = new OperRuleSet(p);
_ruleSets.Add(ruleSet);
return ruleSet;
}
protected static Pred SetVar(string varName, Pred pred) { return Pred.SetVar(varName, pred); }
protected static Gate Gate(Pred predictor, Pred match) { return new Gate(null, predictor, match); }
public static OperPredAndRuleBuilder IfInRoles(this OperRuleBuilder rb, Pred<IPrincipal> p)
{
return rb.DefinePredicate(new PrincipalPredOperationHandler(p));
}
