public RihaNode place(RihaNode[] parameters) { RihaNode par = parameters[parameters.Length - 1]; RihaNode[] getZero = new RihaNode[] { new RihaNode(ValueType.number, 0) }; RihaNode[] getOne = new RihaNode[] { new RihaNode(ValueType.number, 1) }; string name = par.get(getZero).GetString(); RihaNode tileLocation = par.get(getOne); Buildable building = GameData.GetBuilding(name); if (building != null) { float x = (float)tileLocation.get(getZero).GetValue(); float z = (float)tileLocation.get(getOne).GetValue(); Tile t = GameController.island.GetTileByWorldCoords(x, z); GameController.playerController.SetBuilding(building); GameController.playerController.Build(t); return(new RihaNode(ValueType.boolean, true)); } return(new RihaNode(ValueType.boolean, false)); }
public RihaNode set(RihaNode[] parameters) { RihaNode p = parameters[parameters.Length - 1]; this.value = p.value; this.type = p.GetNodeType(); return(this); }
override protected void Execute() { RihaNode variable = this.parameters[0]; ValueType type = GetValueType(words[3]); variable.SetType(type); RihaCompiler.AddToMemory(words[1], variable); }
void ExecuteAction(List <string> actions) { actions.Reverse(); List <RihaNode> finishedActionsReturns = new List <RihaNode>(); foreach (string action in actions) { string[] words = SplitWords(action).ToArray(); object isAction = EvaluateAction(action, words, finishedActionsReturns); if (isAction == null) { RihaNode functionNode = IsFunction(action, words); if (functionNode != null) { string[] functions = words[0].Split('.'); string methodName = (functionNode.GetNodeType() == ValueType.GLOBAL) ? "GlobalCall" : functions[1].ToLower(); MethodInfo functionMethod = functionNode.GetType().GetMethod(methodName); if (functionMethod != null) { object[] parameters; if ((functionNode.GetNodeType() == ValueType.GLOBAL)) { parameters = new object[] { functions[1].ToLower(), finishedActionsReturns.ToArray(), }; } else { parameters = new object[] { finishedActionsReturns.ToArray(), }; } RihaNode returnValue = (RihaNode)functionMethod.Invoke(functionNode, parameters); finishedActionsReturns.Add(returnValue); } } else { MethodInfo actionMethod = this.GetType().GetMethod(words[0].ToLower()); if (actionMethod != null) { object[] parameters = new object[] { action, words, finishedActionsReturns.ToArray() }; actionMethod.Invoke(this, parameters); } } } else { finishedActionsReturns.Add(isAction == null ? null : (RihaNode)isAction); } } }
public void import(string action, string[] words, RihaNode[] previuseActionResult) { //Patern set [varible_key] as [variable_type]; string setPattern = @"\s*import\s*"; if (MatchesRegex(action, setPattern)) { RihaNode varible = previuseActionResult[previuseActionResult.Length - 1]; } }
public void size(string action, string[] words, RihaNode[] previuseActionResult) { string printPattern = @"\s*size\s+of\s*"; if (MatchesRegex(action, printPattern)) { RihaNode node = previuseActionResult[previuseActionResult.Length - 1]; codeOutput += node.GetSize() + "\n"; Debug.Log(node.GetSize()); } }
public void print(string action, string[] words, RihaNode[] previuseActionResult) { string printPattern = @"\s*print\s*"; if (MatchesRegex(action, printPattern)) { RihaNode node = previuseActionResult[previuseActionResult.Length - 1]; string value = node.GetString(); codeOutput += value + "\n"; } }
public RihaNode bigger_than(RihaNode[] parameters) { bool ret = false; RihaNode comperisonNode = parameters[parameters.Length - 1]; if (comperisonNode.GetSize() < GetSize()) { ret = true; } return(new RihaNode(ValueType.boolean, ret)); }
public RihaNode equal_type(RihaNode[] parameters) { bool ret = false; RihaNode comperisonNode = parameters[parameters.Length - 1]; if (comperisonNode.GetNodeType() == GetNodeType()) { ret = true; } return(new RihaNode(ValueType.boolean, ret)); }
public RihaNode GlobalCall(string method, RihaNode[] par) { MethodInfo functionMethod = value.GetType().GetMethod(method); if (functionMethod != null) { object[] parameters = new object[] { par }; RihaNode returnValue = (RihaNode)functionMethod.Invoke(value, parameters); return(returnValue); } return(null); }
public RihaNode less_than(RihaNode[] parameters) { bool ret = false; RihaNode comperisonNode = parameters[parameters.Length - 1]; if (comperisonNode.GetSize() > GetSize()) { ret = true; } Debug.Log(ret); return(new RihaNode(ValueType.boolean, ret)); }
public void set(string action, string[] words, RihaNode[] previuseActionResult) { //Patern set [varible_key] as [variable_type]; string setPattern = @"\s*set\s+\w+\s+as\s+\w+\s*"; if (MatchesRegex(action, setPattern)) { RihaNode varible = previuseActionResult[previuseActionResult.Length - 1]; ValueType type = GetValueType(words[3]); varible.SetType(type); variableMemory.Add(words[1], varible); } }
public void add(string action, string[] words, RihaNode[] previuseActionResult) { string addPattern = @"\s*add\s+to\s+\w+\s*"; if (MatchesRegex(action, addPattern)) { string variableKey = words[2]; if (variableMemory.ContainsKey(variableKey)) { RihaNode varibale = variableMemory[variableKey]; varibale.Add(previuseActionResult[previuseActionResult.Length - 1]); } } }
public void Add(RihaNode addNode) { if (type == ValueType.number) { float add = addNode.GetNodeType() == ValueType.number ? RihaNode.GetNumeric(addNode.GetValue()) : 0; float newValue = RihaNode.GetNumeric(value) + add; value = newValue.ToString(); } else if (type == ValueType.text) { value += addNode.GetString(); } else if (type == ValueType.array) { ((List <RihaNode>)value).Add(addNode); } }
public void scope(string action, string[] words, RihaNode[] previuseActionResult) { string setPattern = @"\s*scope\s+\w+\s*"; if (MatchesRegex(action, setPattern)) { RihaNode value = previuseActionResult[previuseActionResult.Length - 1]; ScopeType type = GetScopeType(words[1]); if (type == ScopeType.check && value.GetNodeType() == ValueType.boolean || type == ScopeType.loop && value.GetNodeType() == ValueType.number) { scopes.Add(new RihaScope() { type = type, parameter = value, startLine = lineNumber }); } } }
object EvaluateAction(string action, string[] words, List <RihaNode> pevActions) { // Is number: float n; bool isNumeric = float.TryParse(action, out n); if (isNumeric) { return(new RihaNode(ValueType.number, n)); } if (words.Length == 1) { if (words[0] == "GLOBAL") { if (globals.ContainsKey(pevActions.Last().GetString())) { return(globals[pevActions.Last().GetString()]); } } //Is boolean else if (words[0].ToLower() == "true") { return(new RihaNode(ValueType.boolean, true)); } else if (words[0].ToLower() == "false") { return(new RihaNode(ValueType.boolean, false)); } else if (words[0].ToLower() == "null") { return(new RihaNode(ValueType.tmp, null)); } // NULL } //Is varibale if (variableMemory.ContainsKey(words[0])) { return(variableMemory[words[0]]); } //Is array string arrayPattern = @"\[.*\]"; List <string> arrayGroups = GroupMatch(action, arrayPattern); if (arrayGroups != null) { string arrayless = arrayGroups[0].Substring(1, arrayGroups[0].Length - 2); string[] elements = arrayless.Split(','); List <RihaNode> array = new List <RihaNode>(); foreach (string element in elements) { string[] elementWords = SplitWords(element).ToArray(); RihaNode variable = (RihaNode)EvaluateAction(element, elementWords, null); array.Add(variable); } return(new RihaNode(ValueType.array, array)); } //Is text: string textPattern = @"\"".*?\"""; List <string> textGroups = GroupMatch(action, textPattern); if (textGroups != null) { string qouteless = textGroups[0].Substring(1, textGroups[0].Length - 2); return(new RihaNode(ValueType.text, qouteless)); } return(null); }
public static void AddToMemory(string key, RihaNode value) { RihaCompiler.variableMemory.Add(key, value); }