// Adds two numbers. public static CalcValue BinPlusNumbers(CalcObject left, CalcObject right, CLLocalStore vars, CLContextProvider context) { CalcNumber numLeft = left as CalcNumber; CalcNumber numRight = right as CalcNumber; return(new CalcNumber(numLeft + numRight)); }
// Returns the left raised to the power of the right. public static CalcValue BinPowerNumbers(CalcObject left, CalcObject right, CLLocalStore vars, CLContextProvider context) { CalcNumber numLeft = left as CalcNumber; CalcNumber numRight = right as CalcNumber; return(new CalcNumber((decimal)Math.Pow((double)(numLeft.Value), (double)(numRight.Value)))); }
/// <summary>Runs the Operator on two operands.</summary> /// <param name="left">The left operand.</param> /// <param name="right">The right operand.</param> /// <param name="vars">The local variable storage.</param> /// <param name="context">An object representing context.</param> public CalcValue Run(CalcObject left, CalcObject right, CLLocalStore vars = null, CLContextProvider context = null) { // If the operator is value-based, we'll automatically convert expressions. if (ValueBasedLeft) { left = left.GetValue(vars, context); } if (ValueBasedRight) { right = right.GetValue(vars, context); } // Now get the func. CLBinaryOperatorFunc func = this[left.GetType(), right.GetType()]; // If it's null, we'll throw an exception. if (func == null) { throw new CLException( "Binary operator " + Symbol + " doesn't support parameters " + left.GetType().Name + " and " + right.GetType().Name ); } // Now let's run it. return(func(left, right, vars, context)); }
private static CalcValue BinRepeat(CalcObject left, CalcObject right, CLLocalStore vars, CLContextProvider context) { List <CalcValue> ret = new List <CalcValue>(); CalcNumber numRight = (CalcNumber)right; int count = (int)numRight.Value; CalcObject _i = null; if (vars.ContainsVar("_i")) { _i = vars["_i"]; } for (int i = 0; i < count; i++) { vars["_i"] = new CalcNumber(i); ret.Add(left.GetValue(vars, context)); } if (_i != null) { vars["_i"] = _i; } return(new CalcList(ret.ToArray())); }
// Concatenates two strings. public static CalcValue BinPlusStrings(CalcObject left, CalcObject right, CLLocalStore vars, CLContextProvider context) { CalcString strLeft = left as CalcString; CalcString strRight = right as CalcString; return(new CalcString(strLeft + strRight)); }
public string TestLine(string line, CLLocalStore vars, CLContextProvider context, string expected) { // We'll parse the line as usual CalcObject obj1 = CLInterpreter.Interpret(line); string code2 = obj1.ToCode(); CalcObject obj3 = CLInterpreter.Interpret(code2); string code4 = obj3.ToCode(); // Make sure things look right Assert.AreEqual(code2, code4); // Now get the value out of it CalcValue val5 = obj3.GetValue(vars, context); string code6 = val5.ToCode(); CalcObject obj7 = CLInterpreter.Interpret(code6); string code8 = val5.ToCode(); CalcValue val9 = obj7.GetValue(vars, context); // Make sure things still look right Assert.AreEqual(code6, code8); Assert.AreEqual(val5, val9); // Now we should also make sure the values reported are as expected. Assert.AreEqual(code8, expected); // And we'll return the final value so it can be used later! return(code8); }
// Returns the string, reversed. public static CalcValue PreMinusString(CalcObject param, CLLocalStore vars, CLContextProvider context) { CalcString strParam = param as CalcString; char[] chars = strParam.Value.ToCharArray(); Array.Reverse(chars); return(new CalcString(new string(chars))); }
// Gets the parameter at a given index in the params list as a value. public static CalcValue ValueAt(CalcObject[] pars, int index, string name, CLLocalStore vars, CLContextProvider context) { if (pars.Length <= index) { throw new CLException($"{name} parameter {index} was not specified."); } CalcValue val = pars[index].GetValue(vars, context); return(val); }
public static CalcValue SignFunction(CalcObject[] pars, CLLocalStore vars, CLContextProvider context) { if (pars.Length == 0) { throw new CLException("{!sign} requires a number."); } CalcNumber num = NumberAt(pars, 0, "!sign", vars, context); return(new CalcNumber(Math.Sign(num))); }
// Returns the natural logarithm of the parameter. public static CalcValue LogFunction(CalcObject[] pars, CLLocalStore vars, CLContextProvider context) { if (pars.Length == 0) { throw new CLException("{!log} requires a number."); } CalcNumber num = NumberAt(pars, 0, "!floor", vars, context); return(new CalcNumber((decimal)Math.Log((double)num.Value))); }
public override CalcValue GetValue(CLLocalStore vars = null, CLContextProvider context = null) { vars ??= new CLLocalStore(); context ??= new CLContextProvider(); CalcObject obj = GetObject(vars, context); vars = new CLLocalStore(Params); return(obj.GetValue(vars, context)); }
public static CalcValue PostFactNumber(CalcObject param, CLLocalStore vars, CLContextProvider context) { CalcNumber num = param as CalcNumber; int o = 1; for (int i = 2; i < num.Value; i++) { o *= i; } return(new CalcNumber(o)); }
// Returns a number with magnitude x and sign of y public static CalcValue CopySignFunction(CalcObject[] pars, CLLocalStore vars, CLContextProvider context) { if (pars.Length < 2) { throw new CLException("{!copysign} requires two numbers."); } CalcNumber x = NumberAt(pars, 0, "!copysign", vars, context); CalcNumber y = NumberAt(pars, 1, "!copysign", vars, context); return(new CalcNumber((decimal)Math.CopySign((double)x.Value, (double)y.Value))); }
private static DiceDie FunctionDie(CalcObject[] pars, CLLocalStore vars, CLContextProvider context) { if (pars.Length < 2) { throw new CLException("{!die} requires two params: A number and a value."); } CalcNumber num = NumberAt(pars, 0, "!die", vars, context); CalcValue val = pars[1].GetValue(); return(new DiceDie(num.Value, val)); }
// Returns the list, with all its elements negated. public static CalcValue PreMinusList(CalcObject param, CLLocalStore vars, CLContextProvider context) { CalcList lstParam = param as CalcList; CalcValue[] lstRet = new CalcValue[lstParam.Count]; for (int i = 0; i < lstRet.Length; i++) { lstRet[i] = PrefixMinus.Run(lstParam[i], vars, context); } return(new CalcList(lstRet)); }
// Gets the parameter at a given index in the params list as a number. public static CalcNumber NumberAt(CalcObject[] pars, int index, string name, CLLocalStore vars, CLContextProvider context) { if (pars.Length <= index) { throw new CLException(name + " parameter " + index + " was not specified."); } CalcValue val = pars[index].GetValue(vars, context); if (!(val is CalcNumber num)) { throw new CLCastException(name + " parameter " + index + " must be a number."); } return(num); }
public override CalcValue GetValue(CLLocalStore vars = null, CLContextProvider context = null) { vars ??= new CLLocalStore(); context ??= new CLContextProvider(); CalcValue[] ret = new CalcValue[_list.Length]; for (int i = 0; i < _list.Length; i++) { ret[i] = _list[i].GetValue(vars); } return(new CalcList(ret)); }
// Returns the minimum value out of the list. public static CalcValue MinFunction(CalcObject[] pars, CLLocalStore vars, CLContextProvider context) { if (pars.Length == 0) { throw new CLException("{!min} requires numbers."); } decimal min = Decimal.MaxValue; for (int i = 0; i < pars.Length; i++) { CalcNumber num = NumberAt(pars, i, "!min", vars, context); min = Math.Min(min, num.Value); } return(new CalcNumber(min)); }
// Returns the quotient of a list's items over a number. public static CalcValue BinDivideList(CalcObject left, CalcObject right, CLLocalStore vars, CLContextProvider context) { CalcList lstLeft = left as CalcList; CalcNumber numRight = right as CalcNumber; // We will *not* do string checking here // It's entirely possible someone writes a string divider and this function will use it. CalcValue[] lstRet = new CalcValue[lstLeft.Count]; for (int i = 0; i < lstRet.Length; i++) { lstRet[i] = BinaryDivide.Run(lstLeft[i], numRight, vars, context); } return(new CalcList(lstRet)); }
// Returns the minimum value out of the list. public static CalcValue MinMagnitudeFunction(CalcObject[] pars, CLLocalStore vars, CLContextProvider context) { if (pars.Length == 0) { throw new CLException("{!minmagnitude} requires numbers."); } decimal min = (decimal)Decimal.MinValue; for (int i = 0; i < pars.Length; i++) { CalcNumber num = NumberAt(pars, i, "!minmagnitude", vars, context); if (Math.Abs(num.Value) < min) { min = num; } } return(new CalcNumber(min)); }
// Concatenates two lists. public static CalcValue BinPlusLists(CalcObject left, CalcObject right, CLLocalStore vars, CLContextProvider context) { CalcList lstLeft = left as CalcList; CalcList lstRight = right as CalcList; CalcValue[] lstRet = new CalcValue[lstLeft.Count + lstRight.Count]; int i; for (i = 0; i < lstLeft.Count; i++) { lstRet[i] = lstLeft[i]; } for (int j = 0; j < lstRight.Count; j++) { lstRet[i + j] = lstRight[j]; } return(new CalcList(lstRet)); }
// Multiplies a string by a number. public static CalcValue BinTimesString(CalcObject left, CalcObject right, CLLocalStore vars, CLContextProvider context) { CalcString strLeft = left as CalcString; CalcNumber numRight = right as CalcNumber; int count = (int)numRight; if (count < 0) { throw new CLException("Strings cannot be repeated negative times."); } string strRet = ""; for (int i = 0; i < count; i++) { strRet += strLeft; } return(new CalcString(strRet)); }
/// <summary>Runs the Operator on two operands.</summary> /// <param name="param">The right operand.</param> /// <param name="vars">The local variable storage.</param> /// <param name="context">An object representing context.</param> public CalcValue Run(CalcObject param, CLLocalStore vars = null, CLContextProvider context = null) { // If the operator is value-based, we'll automatically convert expressions. if (ValueBased) { param = param.GetValue(vars, context); } // Now get the func. CLUnaryOperatorFunc func = this[param.GetType()]; // If it's null, we'll throw an exception. if (func == null) { throw new CLException( "Binary operator " + Symbol + " doesn't support parameter " + param.GetType().Name ); } // Now let's run it. return(func(param, vars, context)); }
public override CalcValue GetValue(CLLocalStore vars = null, CLContextProvider context = null) { vars ??= new CLLocalStore(); context ??= new CLContextProvider(); if (Operator is CLBinaryOperator bin) { return(bin.Run(Left, Right, vars, context)); } else if (Operator is CLPrefixOperator pre) { return(pre.Run(Right, vars, context)); } else if (Operator is CLPostfixOperator post) { return(post.Run(Left, vars, context)); } else { throw new InvalidCastException("Operators must be binary, prefix, or postfix."); } }
// Multiplies a list by a number. public static CalcValue BinTimesList(CalcObject left, CalcObject right, CLLocalStore vars, CLContextProvider context) { CalcList lstLeft = left as CalcList; CalcNumber numRight = right as CalcNumber; // If it has a string, we'll just repeat the list multiple times. if (lstLeft.HasString()) { int count = (int)numRight; if (count < 0) { throw new CLException("Lists cannot be repeated negative times."); } CalcValue[] lstRet = new CalcValue[lstLeft.Count * count]; for (int i = 0; i < count; i++) { for (int j = 0; j < lstLeft.Count; j++) { lstRet[i * lstLeft.Count + j] = lstLeft[j]; } } return(new CalcList(lstRet)); } else { // Otherwise we'll multiply everything by the number. CalcValue[] lstRet = new CalcValue[lstLeft.Count]; for (int i = 0; i < lstRet.Length; i++) { lstRet[i] = BinaryTimes.Run(lstLeft[i], numRight, vars, context); } return(new CalcList(lstRet)); } }
private static CalcValue KeepDropNumber(CalcList list, int count, bool keep, bool highest, CLLocalStore vars) { // Shortcuts if (list.Count == 0) { vars["_d"] = new CalcList(new CalcValue[0]); return(list); } if (count >= list.Count) { if (keep) { vars["_d"] = new CalcList(new CalcValue[0]); return(list); } else { vars["_d"] = list; return(new CalcList(new CalcValue[0])); } } else if (count <= 0) { if (keep) { vars["_d"] = list; return(new CalcList(new CalcValue[0])); } else { vars["_d"] = new CalcList(new CalcValue[0]); return(list); } } // The long way int found = 0; bool[] action = new bool[list.Count]; decimal next = highest ? decimal.MinValue : decimal.MaxValue; decimal current = next; decimal[] values = new decimal[list.Count]; for (int i = 0; i < list.Count; i++) { // Get value of list item CalcValue val = list[i]; CalcNumber num = val as CalcNumber; if (num == null) { num = ListToNum(val); } values[i] = num.Value; } while (found < count) { for (int i = 0; i < list.Count && found < count; i++) { // If this is already one we found, skip it if (action[i]) { continue; } // Otherwise, if it's the next value, grab it if (values[i] == current) { action[i] = true; found++; } // Otherwise, check to see if it can be the next value if (highest) { next = Math.Max(next, values[i]); } else { next = Math.Min(next, values[i]); } } current = next; next = highest ? decimal.MinValue : decimal.MaxValue; } // Now make the outputs CalcValue[] fits = new CalcValue[count]; CalcValue[] noFits = new CalcValue[list.Count - count]; // Split the values into the two lists int fitCount = 0; int noFitCount = 0; for (int i = 0; i < list.Count; i++) { if (action[i]) { fits[fitCount++] = list[i]; } else { noFits[noFitCount++] = list[i]; } } if (keep) { vars["_d"] = new CalcList(noFits); return(new CalcList(fits)); } else { vars["_d"] = new CalcList(fits); return(new CalcList(noFits)); } }
private static CalcValue CompUntil(CalcObject left, CLComparison comp, CalcObject right, CLLocalStore vars, CLContextProvider context) { int limit = int.MaxValue; DiceContext dc = null; // We need to get the limits if they've been set if (context.ContainsDerived(typeof(DiceContext), out Type actualDiceContext)) { dc = (DiceContext)(context.Get(actualDiceContext)); limit = Math.Min(dc.PerRollLimit, dc.PerFunctionLimit - dc.PerFunctionUsed); if (limit == 0) { throw new LimitedDiceException(); } } CalcNumber numLeft = null; CalcList lstLeft = null; bool list = false; CalcNumber numRight = (CalcNumber)right; // Now figure out how many sides each die has... int sides = 0; // (Are we using a list or a number for the sides?) if (left is CalcNumber) { numLeft = (CalcNumber)left; sides = (int)(numLeft.Value); } else if (left is CalcList) { lstLeft = (CalcList)left; sides = lstLeft.Count; list = true; } // ... and ensure it's at least one. if (sides < 1) { throw new CLException("Dice must have at least one side."); } // Now we can roll the dice! List <CalcValue> lstRet = new List <CalcValue>(); Random rand = null; if (context.ContainsDerived(typeof(Random), out Type actualRandom)) { rand = (Random)(context.Get(actualRandom)); } else { rand = new Random(); } CalcList output = null; Type actual = null; for (int i = 0; i < limit; i++) { // First determine the value int choice = rand.Next(sides); CalcNumber value = null; if (list) { CalcValue val = lstLeft[choice]; if (val is CalcList valList) { value = new DiceDie(valList.Sum(), lstLeft); } else if (val is CalcNumber valNum) { value = new DiceDie(valNum.Value, lstLeft); } } else { value = new DiceDie(choice + 1, new CalcNumber(sides)); } // See if it satisfies the comparison if (comp.CompareFunction(value.Value, numRight.Value)) { vars["_u"] = value; output = new CalcList(lstRet.ToArray()); // Add to roll history if (context.ContainsDerived(typeof(List <(string, CalcList)>), out actual)) { List <(string, CalcList)> history = (List <(string, CalcList)>)context.Get(actual); history.Add(($"{left.ToCode()}u{comp.PostfixSymbol}{right.ToCode()}", output)); history.Add(($"Killed above roll:", ValToList(value))); } // also remember to actually UPDATE the limits! (╯°□°)╯︵ ┻━┻ if (dc != null) { dc.PerFunctionUsed += i + 1; } return(output); } else { lstRet.Add(value); } } vars["_u"] = new CalcNumber(0); output = new CalcList(lstRet.ToArray()); // Add to roll history if (context.ContainsDerived(typeof(List <(string, CalcList)>), out actual)) { List <(string, CalcList)> history = (List <(string, CalcList)>)context.Get(actual); history.Add(($"{left.ToCode()}u{comp.PostfixSymbol}{right.ToCode()}", output)); } // also remember to actually UPDATE the limits! (╯°□°)╯︵ ┻━┻ if (dc != null) { dc.PerFunctionUsed += limit; } return(output); }
private static CalcValue CompRerolls(CalcObject left, CLComparison comp, CalcObject right, CLLocalStore vars, CLContextProvider context, bool keep = false, bool recurse = false) { CalcList lstLeft = (CalcList)left; CalcNumber numRight = (CalcNumber)right; List <CalcValue> output = new List <CalcValue>(); DiceContext dc = null; int limit = 0; int limitUsed = 0; // We need to get the limits if they've been set if (context.ContainsDerived(typeof(DiceContext), out Type actualDiceContext)) { dc = (DiceContext)(context.Get(actualDiceContext)); limit = Math.Min(dc.PerRollLimit, dc.PerFunctionLimit - dc.PerFunctionUsed); if (limit == 0) { throw new LimitedDiceException(); } } // Go through the list foreach (CalcValue val in lstLeft) { decimal value; if (val is CalcNumber valNum) { value = valNum.Value; } else if (val is CalcList valList) { value = valList.Sum(); } else { throw new CLException("Re-rolls only work with numeric values."); } // If it's a value we need to re-roll if (comp.CompareFunction(value, numRight.Value)) { // Keep the original value ("x" and "xr" operators) if (keep) { output.Add(val); } // Now make another value (or recurse) bool redo = true; // Now figure out how many sides each die has... int sides = 0; bool list = false; CalcValue dSides; CalcList lstSides = null; if (val is DiceDie die) { dSides = die.Sides; // (Are we using a list or a number for the sides?) if (dSides is CalcNumber nSides) { sides = (int)(nSides.Value); } else if (dSides is CalcList lSides) { lstSides = lSides; sides = lSides.Count; list = true; } } else { decimal valValue = 0; if (val is CalcNumber nVal) { valValue = nVal.Value; } else if (val is CalcList lVal) { valValue = lVal.Sum(); } else { throw new CLException("Reroll only works with numeric values."); } if (valValue < 0) { valValue *= -1; } sides = (valValue <= 6) ? 6 : (valValue <= 20) ? 20 : (valValue <= 100) ? 100 : (valValue <= 1000) ? 1000 : (valValue <= 10000) ? 10000 : (valValue <= 100000) ? 100000 : (valValue <= 1000000) ? 1000000 : (valValue <= 10000000) ? 10000000 : (valValue <= 100000000) ? 100000000 : (valValue <= 1000000000) ? 1000000000 : 2147483647; dSides = new CalcNumber(sides); } // Now we can roll the dice! Random rand = null; if (context.ContainsDerived(typeof(Random), out Type actualRandom)) { rand = (Random)(context.Get(actualRandom)); } else { rand = new Random(); } while (redo && limitUsed < limit) { int choice = rand.Next(sides); limitUsed++; decimal cValue = 0; if (list) { CalcValue cVal = lstSides[choice]; if (cVal is CalcNumber cNum) { cValue = cNum.Value; output.Add(new DiceDie(cValue, lstSides)); } else if (cVal is CalcList cList) { cValue = cList.Sum(); output.Add(new DiceDie(cValue, lstSides)); } } else { cValue = choice + 1; output.Add(new DiceDie(cValue, new CalcNumber(sides))); } // recursion? if (recurse) { redo = comp.CompareFunction(cValue, numRight.Value); } else { redo = false; } } } else { // The reroll comparison wasn't satisfied output.Add(val); } } return(new CalcList(output.ToArray())); }
private static CalcValue KeepDropProxy(CalcObject left, CalcObject right, bool keep, bool highest, CLLocalStore vars) { return(KeepDropNumber((CalcList)left, (int)((CalcNumber)right).Value, keep, highest, vars)); }
private static CalcValue KeepCompare(CalcObject left, CLComparison comp, CalcObject right, CLLocalStore vars) { CalcList lstLeft = (CalcList)left; CalcNumber numRight = (CalcNumber)right; List <CalcValue> kept = new List <CalcValue>(); List <CalcValue> dropped = new List <CalcValue>(); foreach (CalcValue val in lstLeft) { if (comp.CompareFunction(ValueOf(val), numRight.Value)) { kept.Add(val); } else { dropped.Add(val); } } vars["_d"] = new CalcList(dropped.ToArray()); return(new CalcList(kept.ToArray())); }