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());
}
}
