private static void PlayerControllerGameTick_Postfix(PlayerController __instance, long time) { if (!UIRoot.instance.uiGame.globemap.active) { return; // Only modify behaviour when the globe map is open } bool moveCameraConflict = VFInput.rtsMoveCameraConflict; bool mineCameraConflict = VFInput.rtsMineCameraConflict; if (VFInput._rtsMove.onDown) { dragBeginMousePosition = Input.mousePosition; hit = Physics.Raycast(Camera.main.ScreenPointToRay(dragBeginMousePosition), out hitInfo, 800f, 8720, QueryTriggerInteraction.Collide); } // Check if the player moved the mouse a significant distance indicating they want to drag the camera, not move the character. else if (VFInput._rtsMove.onUp && ((double)(dragBeginMousePosition - Input.mousePosition).sqrMagnitude < 800.0)) { if (hit) { GameMain.data.mainPlayer.Order(OrderNode.MoveTo(hitInfo.point), (bool)VFInput._multiOrdering); RTSTargetGizmo.Create(hitInfo.point); hit = false; } } }
private bool Add(SymbolicConstant <T> lower, SymbolicConstant <T> upper) { if (LessThan(upper, lower) == true) { // Cycle! return(false); } if (lower.Equals(upper)) { return(true); } if (!_Orders.TryGetValue(lower, out var lowerNode)) { lowerNode = new OrderNode(lower); _Orders.Add(lower, lowerNode); } if (!_Orders.TryGetValue(upper, out var upperNode)) { upperNode = new OrderNode(upper); _Orders.Add(upper, upperNode); } upperNode.Previous.Add(lowerNode); lowerNode.Next.Add(upperNode); return(true); }
/// <summary> /// load the client information from the .csv file /// </summary> public static void LoadClients() { string filePath = Path.Combine(Application.persistentDataPath, clientsTreeFile); if (File.Exists(filePath)) { string[] Nodes = File.ReadAllLines(filePath); foreach (var nodeData in Nodes) { string[] node = nodeData.Split(','); string ClientName = node[0]; string OrdersString = null; if (node.Length > 1) { OrdersString = node[1]; } List <CartItem> OrderedItems = new List <CartItem>(); if (!string.IsNullOrEmpty(OrdersString)) { string[] Orders = OrdersString.Split('&'); foreach (var order in Orders) { if (!string.IsNullOrEmpty(order)) { string[] orderInfo = order.Split(';'); CartItem item = new CartItem(); item.NodeItem = GameManager.Instance.ItemsTreeRoot.SearchTree(orderInfo[0]).Key; item.Price = float.Parse(orderInfo[1]); item.Quantity = int.Parse(orderInfo[2]); item.Discount = int.Parse(orderInfo[3]); OrderedItems.Add(item); } } } if (GameManager.Instance.ItemsTreeRoot.SearchTree(ClientName) == null) { OrderNode newOrder = new OrderNode(ClientName, OrderedItems); Node <OrderNode> newNode = new Node <OrderNode>(newOrder); GameManager.Instance.OrdersTreeRoot.RootTree.Left = GameManager.Instance.OrdersTreeRoot.AddToTree(GameManager.Instance.OrdersTreeRoot.RootTree.Left, newNode); } else { continue; } } } else { var textFile = Resources.Load <TextAsset>("ClientsData"); File.AppendAllText(filePath, textFile.ToString()); LoadClients(); } }
/// <summary> /// add the client from the input fields to the binary tree /// </summary> public void AddClients() { OrderNode client = new OrderNode(clientNameInput.text); Node <OrderNode> clientNode = new Node <OrderNode>(client); GameManager.Instance.OrdersTreeRoot.RootTree.Left = GameManager.Instance.OrdersTreeRoot.AddToTree(GameManager.Instance.OrdersTreeRoot.RootTree.Left, clientNode); Dropdown.OptionData newClient = new Dropdown.OptionData(); newClient.text = client.Name; GameManager.Instance.UIManagerComponent.ClientsSelection.options.Add(newClient); GameManager.Instance.RefreshNodes(); GameManager.Instance.UIManagerComponent.ClientsSelection.value = 0; clientNameInput.text = ""; }
/// <summary> /// refresh the information about the clients from the dropdown menu /// </summary> /// <param name="node"></param> public void RefreshClientsDropdown(Node <OrderNode> node) { if (node != null) { Dropdown.OptionData newClient = new Dropdown.OptionData(); OrderNode nodeName = (OrderNode)(NodeKey)node.Key; newClient.text = nodeName.Name; ClientsSelection.options.Add(newClient); ClientsSelection.value = 0; if (node.Right != null) { RefreshClientsDropdown(node.Right); } if (node.Left != null) { RefreshClientsDropdown(node.Left); } } }
private OrderNode GetOrCreateRootNode(List <OrderNode> roots, int order) { OrderNode root = null; for (var j = 0; j < roots.Count; j++) { if (roots[j].Order == order) { root = roots[j]; break; } } if (root == null) { // Nodes are guaranteed to be in order because the entries are in order. root = new OrderNode(order); roots.Add(root); } return(root); }
public void OrderBy(String name, bool ascent) { FieldInfo f = QueryImpl.lookupField(cls, name); OrderNode node; if (f == null) { MethodInfo m = QueryImpl.lookupMethod(cls, name, QueryImpl.defaultProfile); if (m == null) { throw new CodeGeneratorException("No such field " + name + " in class " + cls); } else { node = new OrderNode(m); } } else { node = new OrderNode(f); } node.ascent = ascent; if (query.order == null) { query.order = node; } else { OrderNode last; for (last = query.order; last.next != null; last = last.next) { ; } last.next = node; } }
public void OrderBy(String name, bool ascent) { FieldInfo f = QueryImpl.lookupField(cls, name); OrderNode node; if (f == null) { MethodInfo m = QueryImpl.lookupMethod(cls, name, QueryImpl.defaultProfile); if (m == null) { throw new CodeGeneratorException("No such field " + name + " in class " + cls); } else { node = new OrderNode(m); } } else { node = new OrderNode(f); } node.ascent = ascent; if (query.order == null) { query.order = node; } else { OrderNode last; for (last = query.order; last.next != null; last = last.next); last.next = node; } }
//TODO: Add support as we can. protected override DevicePlanNode InternalPrepare(Schema.DevicePlan plan, PlanNode planNode) { if (planNode is BaseTableVarNode) { BaseTableVarNode node = (BaseTableVarNode)planNode; node.CursorType = CursorType.Dynamic; node.RequestedCursorType = plan.Plan.CursorContext.CursorType; node.CursorCapabilities = CursorCapability.Navigable | CursorCapability.BackwardsNavigable | CursorCapability.Searchable | CursorCapability.Updateable; node.CursorIsolation = plan.Plan.CursorContext.CursorIsolation; node.Order = Compiler.OrderFromKey(plan.Plan, Compiler.FindClusteringKey(plan.Plan, node.TableVar)); return(new DevicePlanNode(node)); } else if ((planNode is OrderNode) && (planNode.Nodes[0] is BaseTableVarNode) && (plan.Plan.CursorContext.CursorType != CursorType.Static)) { OrderNode node = (OrderNode)planNode; BaseTableVarNode tableVarNode = (BaseTableVarNode)planNode.Nodes[0]; bool isSupported = false; foreach (Schema.Key key in tableVarNode.TableVar.Keys) { var tableOrder = Compiler.OrderFromKey(plan.Plan, key); if (node.RequestedOrder.Equivalent(tableOrder)) { node.PhysicalOrder = tableOrder; node.ScanDirection = ScanDirection.Forward; isSupported = true; break; } else if (node.RequestedOrder.Equivalent(new Schema.Order(tableOrder, true))) { node.PhysicalOrder = tableOrder; node.ScanDirection = ScanDirection.Backward; isSupported = true; break; } } if (!isSupported) { foreach (Schema.Order order in tableVarNode.TableVar.Orders) { //We support one column (or one column plus a single-column key ordered in the same direction). if (order.Columns.Count > 1) { break; } if (node.RequestedOrder.Equivalent(order)) { node.PhysicalOrder = order; node.ScanDirection = ScanDirection.Forward; isSupported = true; break; } else if (node.RequestedOrder.Equivalent(new Schema.Order(order, true))) { node.PhysicalOrder = order; node.ScanDirection = ScanDirection.Backward; isSupported = true; break; } var rowIdKey = tableVarNode.TableVar.Keys.MinimumSubsetKey(tableVarNode.TableVar.Columns); var tableOrder = Compiler.OrderFromKey(plan.Plan, rowIdKey); //If we have a rowId key... Add it to the ordering and see if we match if (rowIdKey.Columns.Count == 1 && tableOrder.Columns.Count == 1) { Order newOrder = new Order(order); newOrder.Columns.Add(tableOrder.Columns[0]); if (node.RequestedOrder.Equivalent(newOrder)) { node.PhysicalOrder = newOrder; node.ScanDirection = ScanDirection.Forward; isSupported = true; break; } else if (node.RequestedOrder.Equivalent(new Schema.Order(newOrder, true))) { node.PhysicalOrder = newOrder; node.ScanDirection = ScanDirection.Backward; isSupported = true; break; } } } } if (!isSupported) { //Support every ordering... Use nestedFilterCursor to emulate support... node.PhysicalOrder = node.RequestedOrder; node.ScanDirection = ScanDirection.Forward; isSupported = true; } if (isSupported) { node.Order = new Schema.Order(); node.Order.MergeMetaData(node.RequestedOrder.MetaData); node.Order.IsInherited = false; Schema.OrderColumn orderColumn; Schema.OrderColumn newOrderColumn; for (int index = 0; index < node.PhysicalOrder.Columns.Count; index++) { orderColumn = node.PhysicalOrder.Columns[index]; newOrderColumn = new Schema.OrderColumn ( node.TableVar.Columns[orderColumn.Column], node.ScanDirection == ScanDirection.Forward ? orderColumn.Ascending : !orderColumn.Ascending ); newOrderColumn.Sort = orderColumn.Sort; newOrderColumn.IsDefaultSort = orderColumn.IsDefaultSort; Error.AssertWarn(newOrderColumn.Sort != null, "Sort is null"); node.Order.Columns.Add(newOrderColumn); } if (!node.TableVar.Orders.Contains(node.Order)) { node.TableVar.Orders.Add(node.Order); } node.CursorType = CursorType.Dynamic; node.RequestedCursorType = plan.Plan.CursorContext.CursorType; node.CursorCapabilities = CursorCapability.Navigable | CursorCapability.BackwardsNavigable | CursorCapability.Searchable | (plan.Plan.CursorContext.CursorCapabilities & CursorCapability.Updateable); node.CursorIsolation = plan.Plan.CursorContext.CursorIsolation; return(new DevicePlanNode(node)); } } else if (planNode is CreateTableVarBaseNode) { plan.Plan.CheckRight(GetRight(Schema.RightNames.CreateStore)); return(new DevicePlanNode(planNode)); } else if (planNode is AlterTableNode) { //Don't support altering tables in V1 //plan.Plan.CheckRight(GetRight(Schema.RightNames.AlterStore)); //AlterTableNode alterTableNode = (AlterTableNode)planNode; //if (alterTableNode.AlterTableStatement.CreateColumns.Count > 0) // throw new RuntimeException(RuntimeException.Codes.UnimplementedCreateCommand, "Columns in a memory device"); //if (alterTableNode.AlterTableStatement.DropColumns.Count > 0) // throw new RuntimeException(RuntimeException.Codes.UnimplementedDropCommand, "Columns in a memory device"); //return new DevicePlanNode(planNode); } else if (planNode is DropTableNode) { plan.Plan.CheckRight(GetRight(Schema.RightNames.DropStore)); return(new DevicePlanNode(planNode)); } plan.IsSupported = false; return(null); }
private CommandNode ResolveCommand(XmlElement element) { var cmd = new CommandNode(); foreach (XmlNode item in element.ChildNodes) { if (item.Name == "var" || item.NodeType == XmlNodeType.Comment) { continue; } if (item.NodeType == XmlNodeType.Text) { cmd.Nodes.Add(new TextNode { Value = item.Value }); } else if (item.NodeType == XmlNodeType.Element && (item.Name == "where" || item.Name == "order-by")) { INodeList nodeList; if (item.Name == "where") { nodeList = new WhereNode(); } else { nodeList = new OrderNode(); } foreach (XmlNode iitem in item.ChildNodes) { if (iitem.NodeType == XmlNodeType.Text) { nodeList.Nodes.Add(new TextNode { Value = iitem.Value }); } else if (iitem.NodeType == XmlNodeType.Element && iitem.Name == "if") { var test = iitem.Attributes["test"].Value; var value = string.IsNullOrEmpty(iitem.InnerText) ? (iitem.Attributes["value"]?.Value ?? string.Empty) : iitem.InnerText; nodeList.Nodes.Add(new IfNode { Test = test, Value = value }); } } cmd.Nodes.Add(nodeList); } else if (item.NodeType == XmlNodeType.Element && item.Name == "if") { var test = item.Attributes["test"].Value; var value = string.IsNullOrEmpty(item.InnerText) ? (item.Attributes["value"]?.Value ?? string.Empty) : item.InnerText; cmd.Nodes.Add(new IfNode { Test = test, Value = value }); } } return(cmd); }
protected void TranslateOrderNode(CatalogDevicePlan devicePlan, CatalogDevicePlanNode devicePlanNode, OrderNode orderNode) { TranslatePlanNode(devicePlan, devicePlanNode, orderNode.SourceNode); if (devicePlan.IsSupported) { orderNode.CursorType = orderNode.SourceNode.CursorType; orderNode.RequestedCursorType = orderNode.SourceNode.RequestedCursorType; orderNode.CursorCapabilities = orderNode.SourceNode.CursorCapabilities; orderNode.CursorIsolation = orderNode.SourceNode.CursorIsolation; } }
protected override DevicePlanNode InternalPrepare(Schema.DevicePlan plan, PlanNode planNode) { if (planNode is BaseTableVarNode) { BaseTableVarNode node = (BaseTableVarNode)planNode; PrepareTableNode(plan, node); node.Order = Compiler.OrderFromKey(plan.Plan, Compiler.FindClusteringKey(plan.Plan, node.TableVar)); return(new DevicePlanNode(node)); } else if ((planNode is OrderNode) && (planNode.Nodes[0] is BaseTableVarNode) && (plan.Plan.CursorContext.CursorType != CursorType.Static)) { OrderNode node = (OrderNode)planNode; BaseTableVarNode tableVarNode = (BaseTableVarNode)planNode.Nodes[0]; Schema.Order tableOrder; bool isSupported = false; foreach (Schema.Key key in tableVarNode.TableVar.Keys) { tableOrder = Compiler.OrderFromKey(plan.Plan, key); if (node.RequestedOrder.Equivalent(tableOrder)) { node.PhysicalOrder = tableOrder; node.ScanDirection = ScanDirection.Forward; isSupported = true; break; } else if (node.RequestedOrder.Equivalent(new Schema.Order(tableOrder, true))) { node.PhysicalOrder = tableOrder; node.ScanDirection = ScanDirection.Backward; isSupported = true; break; } } if (!isSupported) { foreach (Schema.Order order in tableVarNode.TableVar.Orders) { if (node.RequestedOrder.Equivalent(order)) { node.PhysicalOrder = order; node.ScanDirection = ScanDirection.Forward; isSupported = true; break; } else if (node.RequestedOrder.Equivalent(new Schema.Order(order, true))) { node.PhysicalOrder = order; node.ScanDirection = ScanDirection.Backward; isSupported = true; break; } } } if (isSupported) { node.Order = new Schema.Order(); node.Order.MergeMetaData(node.RequestedOrder.MetaData); node.Order.IsInherited = false; Schema.OrderColumn orderColumn; Schema.OrderColumn newOrderColumn; for (int index = 0; index < node.PhysicalOrder.Columns.Count; index++) { orderColumn = node.PhysicalOrder.Columns[index]; newOrderColumn = new Schema.OrderColumn ( node.TableVar.Columns[orderColumn.Column], node.ScanDirection == ScanDirection.Forward ? orderColumn.Ascending : !orderColumn.Ascending ); newOrderColumn.Sort = orderColumn.Sort; newOrderColumn.IsDefaultSort = orderColumn.IsDefaultSort; Error.AssertWarn(newOrderColumn.Sort != null, "Sort is null"); node.Order.Columns.Add(newOrderColumn); } if (!node.TableVar.Orders.Contains(node.Order)) { node.TableVar.Orders.Add(node.Order); } PrepareTableNode(plan, node); PrepareTableNode(plan, tableVarNode); return(new DevicePlanNode(node)); } } else if (planNode is CreateTableVarBaseNode) { plan.Plan.CheckRight(GetRight(Schema.RightNames.CreateStore)); return(new DevicePlanNode(planNode)); } else if (planNode is AlterTableNode) { plan.Plan.CheckRight(GetRight(Schema.RightNames.AlterStore)); AlterTableNode alterTableNode = (AlterTableNode)planNode; if (alterTableNode.AlterTableStatement.CreateColumns.Count > 0) { throw new RuntimeException(RuntimeException.Codes.UnimplementedCreateCommand, "Columns in a memory device"); } if (alterTableNode.AlterTableStatement.DropColumns.Count > 0) { throw new RuntimeException(RuntimeException.Codes.UnimplementedDropCommand, "Columns in a memory device"); } return(new DevicePlanNode(planNode)); } else if (planNode is DropTableNode) { plan.Plan.CheckRight(GetRight(Schema.RightNames.DropStore)); return(new DevicePlanNode(planNode)); } plan.IsSupported = false; return(null); }
public OrderTable(OrderNode node, Program program) : base(node, program) { }
//Execute is what actually returns a value? Plan is executed which return a scan. protected override object InternalExecute(Program program, PlanNode planNode) { if (planNode is BaseTableVarNode) { FastoreCursor scan = new FastoreCursor(program, _db, (BaseTableVarNode)planNode); try { scan.Open(); return(scan); } catch { scan.Dispose(); throw; } } else if (planNode is OrderNode) { OrderNode orderNode = (OrderNode)planNode; if (orderNode.Order.Columns.Count == 1) { FastoreCursor scan = new FastoreCursor(program, _db, (BaseTableVarNode)planNode.Nodes[0]); try { scan.Key = orderNode.PhysicalOrder; scan.Direction = orderNode.ScanDirection; scan.Node.Order = orderNode.Order; scan.Open(); return(scan); } catch { scan.Dispose(); throw; } } else { FastoreStackedCursor scan = new FastoreStackedCursor(program, _db, orderNode.Order, orderNode.PhysicalOrder, (BaseTableVarNode)planNode.Nodes[0]); try { scan.Open(); return(scan); } catch { scan.Dispose(); throw; } } } else if (planNode is CreateTableVarBaseNode) { EnsureFastoreTable(((CreateTableVarBaseNode)planNode).GetTableVar()); return(null); } else if (planNode is AlterTableNode) { // TODO: Memory device alter table support return(null); } else if (planNode is DropTableNode) { Schema.TableVar tableVar = ((DropTableNode)planNode).Table; FastoreTables tables = GetTables(tableVar.Scope); lock (tables) { int tableIndex = tables.IndexOf(tableVar); if (tableIndex >= 0) { FastoreTable nativeTable = tables[tableIndex]; nativeTable.Drop(program.ValueManager); tables.RemoveAt(tableIndex); } } return(null); } else { throw new DeviceException(DeviceException.Codes.InvalidExecuteRequest, Device.Name, planNode.ToString()); } }