public static MeNode ReplacePropeties(MeNode tree, Entity origin) { List <MeNode> leaves = new List <MeNode>(); foreach (MeNode leaf in tree.Leaves) { leaves.Add(ReplacePropeties(leaf, origin)); } MeNode node = null; if (tree.Value.Type == VariableType.String && origin.HasProperty(tree.Value.ToMeString())) { MeNode[] nodeLeaves = new MeNode[2] { new MeNode(origin), tree }; Operator prop = Definer.Instance().Operators[LConstants.PROP_OP]; node = new MeNode(new MeVariable() { Type = VariableType.Operator, Value = prop }); node.Leaves.AddRange(nodeLeaves); } else { node = new MeNode(tree.Value); } node.Leaves.AddRange(leaves); return(node); }
public static void StartUp(TestContext ctx) { Definer.Instance().Engine = Engine; DamageTypeTemplate trueDamage = new DamageTypeTemplate(Engine, null, null, null, null); trueDamage.Key = "T"; Engine.AddDamageType(trueDamage); }
public static TokenNode MakeTree(Token[] postfix) { Stack <TokenNode> nodeStack = new Stack <TokenNode>(); foreach (Token tok in postfix) { switch (tok.Type) { case TokenType.LeftParen: { nodeStack.Push(new TokenNode(tok)); break; } case TokenType.Operator: { TokenNode node = new TokenNode(tok); for (int i = 0; i < Definer.Instance().Operators[tok.Value].ParameterCount; ++i) { if (nodeStack.Count == 0 || nodeStack.Peek().Token.Type == TokenType.LeftParen) { throw new MeException("Parameter(s) missing for operator " + tok.Value + " ."); } node.Parameters.Add(nodeStack.Pop()); } nodeStack.Push(node); node.Parameters.Reverse(); break; } case TokenType.Function: { TokenNode node = new TokenNode(tok); while (nodeStack.Count != 0 && nodeStack.Peek().Token.Type != TokenType.LeftParen) { node.Parameters.Add(nodeStack.Pop()); } if (nodeStack.Count == 0) { throw new MeException("No parenthesis found for function " + tok.Value + " ."); } nodeStack.Pop(); node.Parameters.Reverse(); nodeStack.Push(node); break; } case TokenType.Variable: { nodeStack.Push(new TokenNode(tok)); break; } } } return(nodeStack.Pop()); }
public void OperatorTestCanExecute() { MeVariable[] vec = { 10, 11 }; MeVariable[] vec2 = { new MeVariable() { Value = "yass" }, 20 }; Assert.IsTrue(Definer.Instance().Operators[LConstants.PLUS_OP].CanExecute(vec)); Assert.IsFalse(Definer.Instance().Operators[LConstants.PLUS_OP].CanExecute(vec2)); }
public static void StartUp(TestContext ctx) { Engine = new GameEngine(new DiscordLogHelper(new ConsoleLogger())); Definer.Instance().Engine = Engine; MockPlayer = new MockEntity(Engine) { Name = "MOCK_PLAYER", Key = "MOCK_KEY" }; Engine.AddPlayer(MockPlayer); DamageTypeTemplate trueDamage = new DamageTypeTemplate(Engine, null, null, null, null); trueDamage.Key = "T"; Engine.AddDamageType(trueDamage); }
private static void ShuntOperators(List <Token> postfix, Stack <Token> opStack, Operator op) { Token nextTok = opStack.Count == 0 ? null : opStack.Peek(); while (nextTok != null && nextTok.Type == TokenType.Operator && ((op.LeftAsoc && op.Precedence <= Definer.Instance().Operators[nextTok.Value].Precedence) || (op.Precedence < Definer.Instance().Operators[nextTok.Value].Precedence)) ) { postfix.Add(opStack.Pop()); nextTok = opStack.Count == 0 ? null : opStack.Peek(); } }
public static void StartUp(TestContext ctx) { Definer.Instance().Engine = Engine; DamageTypeTemplate trueDamage = new DamageTypeTemplate(Engine, null, null, null, null); trueDamage.Key = "T"; Engine.AddDamageType(trueDamage); ResourceTemplate mana = new ResourceTemplate(); mana.Key = "MP"; ResourceTemplate hp = new ResourceTemplate(); hp.Key = Entity.HP_KEY; Engine.GetPropertyManager().AddResource(hp); Engine.GetPropertyManager().AddResource(mana); Engine.GetCoreManager().DefaultSkillThreat = GcConstants.Core.DEFAULT_THREAT; }
public static void StartUp(TestContext ctx) { Definer.Instance().Engine = Engine; DamageTypeTemplate trueDamage = new DamageTypeTemplate(Engine, null, null, null, null); trueDamage.Name = "true"; trueDamage.Key = "T"; Engine.AddDamageType(trueDamage); ResourceTemplate res = new ResourceTemplate() { Key = "MP" }; SkillCost nullCost = new SkillCost(res, TreeConverter.Build("0", Engine)); _testSkill = new SkillTemplate(); _testSkill.Type = SkillType.Cast; _testSkill.Key = "TEST_CAST"; SkillLevelTemplate testLevelTemplate = new SkillLevelTemplate(); testLevelTemplate.Cooldown = TreeConverter.Build("3", Engine); testLevelTemplate.Duration = TreeConverter.Build($"{LConstants.SourceKeyword}{LConstants.PROP_OP}INT", Engine); testLevelTemplate.Interruptible = TreeConverter.Build("true", Engine); testLevelTemplate.Formulas.Add(TreeConverter.Build($"{LConstants.HARM_F}({LConstants.TargetKeyword},{LConstants.SourceKeyword},{trueDamage.Key},10)", Engine)); testLevelTemplate.PushBack = TreeConverter.Build("true", Engine); testLevelTemplate.Cost = nullCost; _testSkill.ByLevel.Add(testLevelTemplate); Engine.GetSkillManager().AddSkill(_testSkill); BaseObject bDmg = new BaseObject() { Description = "", Key = "BASE_DMG", Name = "Base damage" }; Engine.GetPropertyManager().BaseValues.Add("BASE_DMG", bDmg); BaseObject intellect = new BaseObject() { Description = "", Key = "INT", Name = "Intellect" }; Engine.GetPropertyManager().Attributes.Add("INT", intellect); }
public static void StartUp(TestContext ctx) { CultureInfo ci = new CultureInfo("en-US"); Thread.CurrentThread.CurrentCulture = ci; Console.WriteLine("START UP"); Engine = new GameEngine(new DiscordLogHelper(new ConsoleLogger())); Definer.Instance().Engine = Engine; BasePlayer = new MockEntity(Engine) { Name = "MOCK_PLAYER", Key = "MOCK_KEY" }; Engine.AddPlayer(BasePlayer); DamageTypeTemplate trueDamage = new DamageTypeTemplate(Engine, null, null, null, null); trueDamage.Key = "T"; Engine.AddDamageType(trueDamage); }
public GameEngine(ILogHelper log) { Definer.Instance().Init(this); _propertyManager = new PropertyManager(); _propertyManager.Engine = this; _skillManager = new SkillManager(); _skillManager.Engine = this; _coreManager = new CoreManager(); _coreManager.Engine = this; _playerManager = new PlayerManager(); _damageTypeManager = new DamageTypeManager(); _damageTypeManager.Engine = this; _statusManager = new StatusManager(); _statusManager.Engine = this; _statManager = new StatManager(this); _playerManager.Engine = this; _classManager = new ClassManager(); _classManager.Engine = this; _duelManager = new DuelManager(); _duelManager.Engine = this; _log = log; Players = new Dictionary <string, Entity>(); Enemies = new Dictionary <string, Entity>(); Timer = new MockTimer(); Sanit = new Sanitizer(this); DeclaredVariables = new Dictionary <string, MeVariable>(); commandsQueue = new ConcurrentQueue <Command>(); _nextSave = Timer.GetFuture(GameConstants.SAVE_INTERVAL); }
public static TokenType GetType(string str) { if (Definer.Instance().IsFunction(str)) { return(TokenType.Function); } if (Definer.Instance().IsOperator(str)) { return(TokenType.Operator); } if (Definer.Instance().IsLeftParen(str)) { return(TokenType.LeftParen); } if (Definer.Instance().IsRightParen(str)) { return(TokenType.RightParen); } if (Definer.Instance().IsSeparator(str)) { return(TokenType.Separator); } return(TokenType.Variable); }
public Operator DefineOperator() { return(Utils.MakeOperator(LConstants.ASSIGN_OP, -1, true, (values, op) => { op.CheckParamCount(values.Length); string key = values[0].ToMeString(); MeVariable leftSide = Definer.Instance().Engine.GetVariable(key); MeVariable rightSide = values[1]; if (rightSide.Type == VariableType.String) { rightSide = Definer.Instance().Engine.GetVariable(rightSide.Value.ToString()); } if (leftSide == null) { Definer.Instance().Engine.AddVariable(key, rightSide); } else { Definer.Instance().Engine.SetVariable(key, rightSide); } return null; }, new Validator( (variables, operation) => true), 2)); }
public static void StartUp(TestContext ctx) { Definer.Instance().Engine = Engine; }
public static Token[] ToPostfix(Token[] infix) { List <Token> postFix = new List <Token>(); Stack <Token> opStack = new Stack <Token>(); Token lastFunction = null; Token prevTok = null; foreach (Token tok in infix) { switch (tok.Type) { case TokenType.Variable: { postFix.Add(tok); break; } case TokenType.Function: { opStack.Push(tok); lastFunction = tok; break; } case TokenType.Separator: { if (prevTok != null && prevTok.Type == TokenType.Operator) { throw new MeException("Missing parameter(s) for operator " + prevTok.Value + " ."); } while (opStack.Count != 0 && opStack.Peek().Type != TokenType.LeftParen) { postFix.Add(opStack.Pop()); } if (opStack.Count == 0) { if (lastFunction == null) { throw new MeException("Unexpected separator Key."); } else { throw new MeException("Error while parsing function " + lastFunction.Value + " ."); } } break; } case TokenType.Operator: { if (prevTok != null && (prevTok.Type == TokenType.Separator || prevTok.Type == TokenType.LeftParen)) { throw new MeException("Missing parameter(s) for operator " + tok.Value + " ."); } Operator op = Definer.Instance().Operators[tok.Value]; ShuntOperators(postFix, opStack, op); opStack.Push(tok); break; } case TokenType.LeftParen: { if (prevTok != null) { if (prevTok.Type == TokenType.Function) { postFix.Add(tok); } } opStack.Push(tok); break; } case TokenType.RightParen: { if (prevTok != null && prevTok.Type == TokenType.Operator) { throw new MeException("Missing parameter(s) for operator " + prevTok.Value + " ."); } while (opStack.Count != 0 && opStack.Peek().Type != TokenType.LeftParen) { postFix.Add(opStack.Pop()); } if (opStack.Count == 0) { throw new MeException("Mismatched parenthesis after" + prevTok.Value + " ."); } opStack.Pop(); if (opStack.Count != 0 && opStack.Peek().Type == TokenType.Function) { postFix.Add(opStack.Pop()); } break; } } prevTok = tok; } while (opStack.Count != 0) { Token tok = opStack.Pop(); if (tok.Type == TokenType.LeftParen || tok.Type == TokenType.RightParen) { throw new MeException("Mismatched parenthesis after" + prevTok.Value + " ."); } postFix.Add(tok); } return(postFix.ToArray()); }
public static void StartUp(TestContext context) { Engine.AddPlayer(MockPlayer); Definer.Instance().Engine = Engine; }
public static MeNode Build(MeNode parent, TokenNode node, IGameEngine engine) { MeNode newNode = null; switch (node.Token.Type) { case TokenType.Function: { newNode = new MeNode(new MeVariable() { Value = Definer.Instance().Functions[node.Token.Value], Type = VariableType.Function }); break; } case TokenType.Operator: { newNode = new MeNode(new MeVariable() { Value = Definer.Instance().Operators[node.Token.Value], Type = VariableType.Operator }); break; } case TokenType.Variable: { //first, try a number double result = 0; bool success = double.TryParse(node.Token.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out result); if (success) { newNode = new MeNode( new MeVariable() { Value = result, Type = VariableType.NumericValue }); break; } //try a boolean bool boolResult = false; success = bool.TryParse(node.Token.Value, out boolResult); if (success) { newNode = new MeNode(boolResult); break; } //try a placeholder if (node.Token.Value.StartsWith("$")) { newNode = new MeNode( new MeVariable() { Value = node.Token.Value, Type = VariableType.PlaceHolder }); break; } //try an entitiy Entity tryEntity = engine.GetEntityByKey(node.Token.Value); if (tryEntity != null) { newNode = new MeNode( new MeVariable() { Value = tryEntity, Type = VariableType.Entity }); break; } //try a damage typeTemplate DamageTypeTemplate tryDamageTypeTemplate = engine.GeDamageType(node.Token.Value); if (tryDamageTypeTemplate != null) { newNode = new MeNode( new MeVariable() { Value = tryDamageTypeTemplate, Type = VariableType.DamageType }); break; } /* * MeVariable tryVariable = engine.GetVariable(node.Token.Final); * if (tryVariable != null) * { * newNode = new MeNode(tryVariable); * break; * } */ //if nothing else is found, it must be a string newNode = new MeNode( new MeVariable() { Value = node.Token.Value, Type = VariableType.String }); break; } } foreach (TokenNode subNode in node.Parameters) { newNode.Leaves.Add(Build(newNode, subNode, engine)); } newNode.Parent = parent; return(newNode); }
public static void StartUp(TestContext ctx) { Definer.Instance().Engine = Engine; Engine.GetCoreManager().ExpFormula = TreeConverter.Build($"{LConstants.ExpPrevKeyword}*1.1+50*2^{LConstants.FLOOR_F}({LConstants.LevelKeyword}/5.0)", Engine); Engine.SetStartExp(StartExp); }
public static Token[] Tokenize(string expression) { List <Token> result = new List <Token>(); string sanitized = expression; string current = ""; bool inString = false; int i = 0; while (i < sanitized.Length) { char c = sanitized[i]; if (c == '"') { if (inString) { Token stringToken = new Token(current); result.Add(stringToken); current = ""; } inString = !inString; } else if (inString) { current += c; } else if (Definer.Instance().Ignore(c)) { } else if (!Definer.Instance().IsSpecialChar(c)) { current += c; } else if (c == '-') { if (current.Length != 0) { Token testToken = new Token(current); if (testToken.Type == TokenType.Variable) { result.Add(testToken); current = ""; } } if (result.Count == 0) { current = "-"; } else { Token prev = result.Last(); switch (prev.Type) { case TokenType.Function: throw new Exception( $"Found minus after function with no (, function:\"{prev.Value}\"."); case TokenType.Variable: case TokenType.RightParen: result.Add(new Token(char.ToString(c))); break; default: current = "-"; break; } } //eventually consider -= } else { if (current.Length != 0) { result.Add(new Token(current)); current = ""; } if (i < sanitized.Length - 1 && Definer.Instance().IsOperatorChar(c) && Definer.Instance().IsOperatorChar(sanitized[i + 1])) { string possibleOp = char.ToString(c) + sanitized[i + 1]; if (Definer.Instance().IsOperator(possibleOp)) { result.Add(new Token(possibleOp)); ++i; } } else { result.Add(new Token(char.ToString(c))); } } ++i; } if (current.Length != 0) { result.Add(new Token(current)); } return(result.ToArray()); }