public static void Struts(INodeInformation target, IEngineer3 engineer)
{
if (!target.Effects.Contains(NodeEffect.Struts))
{
engineer.Struts(target);
}
}
public static void Scaffold(INodeInformation target, IEngineer6 engineer)
{
if (!target.Effects.Contains(NodeEffect.Scaffold))
{
engineer.Scaffold(target);
}
}
public List <SqlConnectionInfo> GetAllServers()
{
try
{
List <SqlConnectionInfo> servers = new List <SqlConnectionInfo>();
foreach (IExplorerHierarchy srvHerarchy in GetExplorerHierarchies())
{
IServiceProvider provider = srvHerarchy.Root as IServiceProvider;
if (provider != null)
{
INodeInformation containedItem = provider.GetService(typeof(INodeInformation)) as INodeInformation;
servers.Add(containedItem.Connection as SqlConnectionInfo);
}
}
return(servers);
}
catch (Exception ex)
{
log.Error("ObjectExplorer manager failed:" + ex.Message, ex);
throw;
}
}
public static MenuItemAbstract CreateMenuItem(INodeInformation node)
{
MenuItemAbstract menuItem = null;
switch (node.Parent.InvariantName)
{
case "Databases":
if (!IsDBMenuAdded)
{
menuItem = new SqlDBMenuItem();
IsDBMenuAdded = true;
}
break;
case "UserTables":
if (!IsTableMenuAdded)
{
menuItem = new SqlTableMenuItem();
IsTableMenuAdded = true;
}
break;
case "Columns":
if (!IsColumnMenuAdded)
{
menuItem = new SqlColumnMenuItem();
IsColumnMenuAdded = true;
}
break;
default:
return(null);
}
return(menuItem);
}
/// <summary>
/// Get urn from underlying node information
/// </summary>
/// <param name="service">INodeInformation of object explorer item</param>
/// <returns>Urn of node</returns>
public Urn GetServiceUrn(INodeInformation service)
{
Urn urn = null;
if (service != null)
{
urn = new Urn(service.Context);
}
return(urn);
}
public INodeInformation GetNodeInformation(TreeNode node)
{
INodeInformation result = null;
if (node is IServiceProvider serviceProvider)
{
result = (serviceProvider.GetService(typeof(INodeInformation)) as INodeInformation);
}
return(result);
}
/// <summary>
/// Gets context string of node
/// </summary>
/// <param name="node">TreeNode item from view</param>
/// <returns>Context path</returns>
public string GetNodeContext(TreeNode node)
{
INodeInformation ni = GetNodeInformation(node);
if (ni != null)
{
return(ni.Context);
}
return(string.Empty);
}
/// <summary>
/// Gets node information from underlying type of tree node view
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
/// <remarks>Copy of private method in ObjectExplorerService</remarks>
private INodeInformation GetNodeInformation(TreeNode node)
{
INodeInformation result = null;
IServiceProvider serviceProvider = node as IServiceProvider;
if (serviceProvider != null)
{
result = (serviceProvider.GetService(typeof(INodeInformation)) as INodeInformation);
}
return(result);
}
/// <summary>
/// Gets urn path from tree node view
/// </summary>
/// <param name="node">TreeNode item</param>
/// <returns>urn path of the object explorer node from tree node view</returns>
public string GetNodeUrnPath(TreeNode node)
{
string urnPath = string.Empty;
INodeInformation service = GetNodeInformation(node);
if (service != null)
{
urnPath = service.UrnPath;
}
return(urnPath);
}
/// <summary>
/// Gets node information from underlying type of tree node view
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public INodeInformation GetNodeInformation(TreeNode node)
{
INodeInformation service = null;
IServiceProvider provider = node as IServiceProvider;
if (provider != null)
{
service = provider.GetService(typeof(INodeInformation)) as INodeInformation;
}
return(service);
}
/// <summary>
/// Gets node information from underlying type of tree node view
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
/// <remarks>Copy of private method in ObjectExplorerService</remarks>
private Microsoft.SqlServer.Management.UI.VSIntegration.ObjectExplorer.INodeInformation GetNodeInformation(TreeNode node)
{
INodeInformation result = null;
IServiceProvider serviceProvider = node as IServiceProvider;
if (serviceProvider != null)
{
result = (serviceProvider.GetService(typeof(INodeInformation)) as INodeInformation);
//debug_message("NodeInformation\n UrnPath:{0}\n Name:{1}\n InvariantName:{2}\n Context:{3}\n NavigationContext:{4}", ni.UrnPath, ni.Name, ni.InvariantName, ni.Context, ni.NavigationContext);
}
return(result);
}
/// <summary>
/// Gets node information from underlying type of tree node view
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
/// <remarks>Copy of private method in ObjectExplorerService</remarks>
private INodeInformation GetNodeInformation(TreeNode node)
{
INodeInformation result = null;
IServiceProvider serviceProvider = node as IServiceProvider;
if (serviceProvider != null)
{
result = (serviceProvider.GetService(typeof(INodeInformation)) as INodeInformation);
//debug_message("NodeInformation\n UrnPath:{0}\n Name:{1}\n InvariantName:{2}\n Context:{3}\n NavigationContext:{4}", ni.UrnPath, ni.Name, ni.InvariantName, ni.Context, ni.NavigationContext);
}
return(result);
}
private void RefreshTree()
{
INodeInformation node = Connect.ObjectExplorerSelectedNode;
if (node != null)
{
// Set focus on "Tables" tree node
Connect.ObjectExplorer.SynchronizeTree(node.Parent);
// Refresh = F5
SendKeys.Send("{F5}");
}
}
/// <summary>
/// Gets connection string from tree node view item
/// </summary>
/// <param name="node">TreeNode view item</param>
/// <returns>Connection string of the tree node item</returns>
public string GetConnectionString(TreeNode node)
{
INodeInformation service = GetNodeInformation(node);
Urn urn = GetServiceUrn(service);
//System.Diagnostics.Debug.Print(service.Connection.ConnectionString);
SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(service.Connection.ConnectionString);
builder.InitialCatalog = urn.GetAttribute("Name", "Database");
return(builder.ToString());
}
private void Provider_SelectionChanged(object sender, NodesChangedEventArgs args)
{
INavigationContextProvider provider = (INavigationContextProvider)sender;
INodeInformation node = (args.ChangedNodes.Count > 0 ? args.ChangedNodes[0] : null);
if (_tableMenu == null &&
_tableRegex.IsMatch(node.Context))
{
_tableMenu = (HierarchyObject)node.GetService(typeof(IMenuHandler));
MenuItem item = new MenuItem();
_tableMenu.AddChild(string.Empty, item);
}
}
public void lvl2_claimable_parent_claimable()
{
INodeInformation lvl2node = GetNodeInformation(new List<NodeEffect>(), new Dictionary<NodeExit, INodeInformation>(), 2, 3, 4, true, _owner2);
Dictionary<NodeExit, INodeInformation> lvl1Exits = new Dictionary<NodeExit, INodeInformation> { { new NodeExit(), lvl2node } };
_lvl1Node = GetNodeInformation(new List<NodeEffect>(), lvl1Exits, 1, 2, 3, true, _owner2);
var exits = new Dictionary<NodeExit, INodeInformation> { { NodeExit.Alpha, _lvl1Node } };
INodeInformation nodeInformation = GetNodeInformation(new List<NodeEffect>(), exits, 0, 1, 2, false, myPlayer);
IAgentUpdateInfo agentUpdate = GetAgentUpdate(nodeInformation);
var result = MoveSkills.GreedyMoveToFirstClaimable(agentUpdate, _agent);
nodeInformation.AssertWasCalled(x => x.RouteTo(nodeInformation, _lvl1Node.Layer, _lvl1Node.Row, _lvl1Node.Column));
}
public static void SelectNode(IObjectExplorerService explorerService, HierarchyTreeNode node)
{
IServiceProvider provider = node as IServiceProvider;
if (provider != null)
{
INodeInformation containedItem = provider.GetService(typeof(INodeInformation)) as INodeInformation;
if (containedItem != null)
{
explorerService.SynchronizeTree(containedItem);
}
}
}
public static INodeInformation FindParentNode(INodeInformation node, string searchUrnPath)
{
do
{
if (node.UrnPath == searchUrnPath)
{
return(node);
}
node = node.Parent;
} while (node != null);
return(null);
}
private void SelectNode(HierarchyTreeNode node)
{
IServiceProvider provider = node as IServiceProvider;
if (provider != null)
{
INodeInformation containedItem = provider.GetService(typeof(INodeInformation)) as INodeInformation;
if (containedItem != null)
{
IObjectExplorerService objExplorer = GetObjectExplorer();
objExplorer.SynchronizeTree(containedItem);
}
}
}
/// <summary>
/// Adds new nodes and move items between them
/// </summary>
/// <param name="node"></param>
void ReorganizeFolders(TreeNode node)
{
logger.LogStart(System.Reflection.MethodBase.GetCurrentMethod().Name);
try
{
if (node != null && node.Parent != null)
{
INodeInformation ni = _objectExplorerExtender.GetNodeInformation(node);
if (ni != null && !string.IsNullOrEmpty(ni.UrnPath))
{
//MessageBox.Show(ni.UrnPath);
switch (ni.UrnPath)
{
case "Server/Database/UserTablesFolder":
_objectExplorerExtender.ReorganizeNodes(node, "FolderEdit", "Table");
break;
case "Server/Database/StoredProceduresFolder":
case "Server/Database/Table-valuedFunctionsFolder":
case "Server/Database/Scalar-valuedFunctionsFolder":
_objectExplorerExtender.ReorganizeNodes(node, "FunctionFun", string.Empty);
break;
case "Server/DatabasesFolder":
//TODO: _objectExplorerExtender.ReorganizeDbNodes(node, "FolderEdit", string.Empty, GetDictionary());
break;
default:
break;
}
}
}
}
catch (Exception ex)
{
if (System.Diagnostics.Debugger.IsAttached)
{
MessageBox.Show(ex.ToString());
}
else
{
MessageBox.Show(ex.ToString());
}
}
logger.LogEnd(System.Reflection.MethodBase.GetCurrentMethod().Name);
}
public static IReadOnlyCollection <ObjectExplorerServer> GetServersConnection(IObjectExplorerService explorerService)
{
List <ObjectExplorerServer> servers = new List <ObjectExplorerServer>();
var hierarchies = FollowPropertyPath(explorerService, "Tree.Hierarchies") as IEnumerable <KeyValuePair <string, IExplorerHierarchy> >;
foreach (KeyValuePair <string, IExplorerHierarchy> srvHierarchy in hierarchies)
{
IServiceProvider provider = srvHierarchy.Value.Root as IServiceProvider;
if (provider != null)
{
INodeInformation nodeInformation = provider.GetService(typeof(INodeInformation)) as INodeInformation;
servers.Add(new ObjectExplorerServer(nodeInformation, srvHierarchy.Value));
}
}
return(servers);
}
private void OpenTable(HierarchyTreeNode node, SqlConnectionInfo connection)
{
var t = Type.GetType("Microsoft.SqlServer.Management.UI.VSIntegration.ObjectExplorer.OpenTableHelperClass,ObjectExplorer", true, true);
var mi = t.GetMethod("EditTopNRows", BindingFlags.Static | BindingFlags.Public);
var ncT = Type.GetType("Microsoft.SqlServer.Management.UI.VSIntegration.ObjectExplorer.NodeContext,ObjectExplorer", true, true);
IServiceProvider provider = node as IServiceProvider;
INodeInformation containedItem = provider.GetService(typeof(INodeInformation)) as INodeInformation;
var inst = Activator.CreateInstance(ncT, containedItem);
if (inst == null)
{
throw new Exception("Cannot create type" + ncT.ToString());
}
mi.Invoke(null, new Object[] { containedItem, 200 });
}
/// <summary>
/// Gets the connection string from a node
/// </summary>
/// <param name="node">The node.</param>
/// <returns></returns>
private string GetConnectionString(TreeNode node)
{
INodeInformation service = null;
IServiceProvider provider = node as IServiceProvider;
if (provider != null)
{
service = provider.GetService(typeof(INodeInformation)) as INodeInformation;
}
Urn urn = new Urn(service.Context);
System.Diagnostics.Debug.Print(service.Connection.ConnectionString);
SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(service.Connection.ConnectionString);
builder.InitialCatalog = urn.GetAttribute("Name", "Database");
return(builder.ToString());
}
private void Provider_SelectionChanged(object sender, NodesChangedEventArgs args)
{
Connect.ViewsSelected = false;
INodeInformation node = Connect.ObjectExplorerSelectedNode;
if (node != null)
{
System.Diagnostics.Debug.WriteLine(node.UrnPath);
System.Diagnostics.Debug.WriteLine(node.Name);
System.Diagnostics.Debug.WriteLine(node.Context);
// Mobile Device connections not supported
if (node.Connection.ServerName.StartsWith("Mobile Device\\", StringComparison.Ordinal))
{
// short circuit
node = null;
}
}
if (node != null && _serverMenu == null &&
urnPath == node.UrnPath)
{
_serverMenu = (HierarchyObject)node.GetService(typeof(IMenuHandler));
_serverMenu.AddChild(string.Empty, new ToolStripSeparatorMenuItem());
DatabaseMenuItem item = new DatabaseMenuItem();
_serverMenu.AddChild(string.Empty, item);
ServerMenuItem serveritem = new ServerMenuItem();
_serverMenu.AddChild(string.Empty, serveritem);
}
if (node != null && _tableMenu == null &&
tableUrnPath == node.UrnPath)
{
_tableMenu = (HierarchyObject)node.GetService(typeof(IMenuHandler));
_tableMenu.AddChild(string.Empty, new ToolStripSeparatorMenuItem());
EditTableMenuItem itemE = new EditTableMenuItem();
_tableMenu.AddChild(string.Empty, itemE);
_tableMenu.AddChild(string.Empty, new ToolStripSeparatorMenuItem());
ScriptTableMenuItem item = new ScriptTableMenuItem();
_tableMenu.AddChild(string.Empty, item);
_tableMenu.AddChild(string.Empty, new ToolStripSeparatorMenuItem());
ImportTableMenuItem item2 = new ImportTableMenuItem();
_tableMenu.AddChild(string.Empty, item2);
_tableMenu.AddChild(string.Empty, new ToolStripSeparatorMenuItem());
RenameTableMenuItem item3 = new RenameTableMenuItem();
_tableMenu.AddChild(string.Empty, item3);
}
if (node != null && _indexMenu == null && indexUrnPath == node.UrnPath)
{
_indexMenu = (HierarchyObject)node.GetService(typeof(IMenuHandler));
_indexMenu.AddChild(string.Empty, new ToolStripSeparatorMenuItem());
ScriptIndexMenuItem itemI = new ScriptIndexMenuItem();
_indexMenu.AddChild(string.Empty, itemI);
}
if (node != null && _viewMenu == null &&
viewUrnPath == node.UrnPath)
{
_viewMenu = (HierarchyObject)node.GetService(typeof(IMenuHandler));
_viewMenu.AddChild(string.Empty, new ToolStripSeparatorMenuItem());
EditTableMenuItem itemV = new EditTableMenuItem();
_viewMenu.AddChild(string.Empty, itemV);
}
// Set this each time
if (node != null && viewUrnPath == node.UrnPath)
{
Connect.ViewsSelected = true;
}
}
private bool TryClaim(INodeInformation node)
{
return this.Claim(node).Result == NodeResultType.Success;
}
public virtual ITargetNodeResult MockMove(IAgent self, INodeInformation target) {
ITargetNodeResult ret;
var okTarget = (NodeInformation)target;
var selfAgentUpdateInfo = this.Agents[self];
var okSelfAgentUpdateInfo = (AgentUpdateInfo)selfAgentUpdateInfo;
var currentNode = (from n in target.Exits.Values
let a = n.AllAgents.Where(ag => ag.Id == selfAgentUpdateInfo.Id).FirstOrDefault()
where null != a
select n).FirstOrDefault();
this.WaitToNextTick(self);
if (null == currentNode) {
ret = new TargetNodeResult {
AffectedNode = null,
Result = NodeResultType.FailedOutOfRange,
Cooldown = 1,
LastsFor = 1,
Warmup = 1,
Message = "MOCK: Target node is not nesting with current node of agent."
};
}
else {
var okCurrentNode = (NodeInformation)currentNode;
okCurrentNode.AllAgentsList.Remove(selfAgentUpdateInfo);
okTarget.AllAgentsList.Add(selfAgentUpdateInfo);
okSelfAgentUpdateInfo.NodePrevious = currentNode;
okSelfAgentUpdateInfo.Node = target;
ret = new TargetNodeResult {
AffectedNode = null,
Result = NodeResultType.Success,
Cooldown = 1,
LastsFor = 1,
Warmup = 1,
Message = "Success mock move."
};
}
this.Trace(self, TraceType.Information
, "MOCK-Move!"
, "Self={", self, "}"
, "Target={", target, "}"
, "Result={", ret, "}");
return ret;
}
public virtual ITargetNodeResult MockClaim(IAgent self, INodeInformation target) {
ITargetNodeResult ret;
var selfAgentInfo = (AgentInfo)self;
if (selfAgentInfo.Node == target) {
if (target.Owner.Id == selfAgentInfo.Owner.Id) {
ret = new TargetNodeResult {
AffectedNode = target,
Result = NodeResultType.FailedInvalidTarget,
Cooldown = 1,
LastsFor = 1,
Warmup = 1,
Message = "Failed (invalid-target: claim own node) mock claim."
};
}
else {
ret = new TargetNodeResult {
AffectedNode = target,
Result = NodeResultType.Success,
Cooldown = 1,
LastsFor = 1,
Warmup = 1,
Message = "Success mock claim."
};
}
}
else {
ret = new TargetNodeResult {
AffectedNode = target,
Result = NodeResultType.FailedOutOfRange,
Cooldown = 1,
LastsFor = 1,
Warmup = 1,
Message = "Failed (out-of-range) mock claim."
};
}
this.WaitToNextTick(self);
if (ret.Result == NodeResultType.Success) {
var mockTarget = (NodeInformation)target;
mockTarget.Owner = selfAgentInfo.Owner;
}
this.Trace(self, TraceType.Information
, "MOCK-Claim!"
, "Self={", self, "}"
, "Target={", target, "}"
, "Result={", ret, "}");
return ret;
}
public static bool TryClaim(INodeInformation node, IAgent agent)
{
return !node.IsClaimable || ItsClaimableTryClaim(node, agent);
}
public static void Struts(INodeInformation node, IEngineer3 engineer)
{
if (!node.Effects.Contains(NodeEffect.Struts))
engineer.Struts(node);
}
public NodeExit RouteTo(INodeInformation origin, int destinationLayer, int destinationRow, int destinationColumn) {
throw new NotImplementedException();
}
private static string Id(INodeInformation p0)
{
return p0.Row +";" + p0.Layer +";" + p0.Column;
}
private static bool ClaimThis(INodeInformation node, Guid agentId)
{
return node.IsClaimable
&& !node.Effects.Contains(NodeEffect.Struts)
&& (HasNodeOwner(node, agentId));
}
internal static bool HasNodeOwner(INodeInformation x, Guid agentId)
{
return (x.Owner != null
&& x.Owner.Id != agentId);
}
public void Tick(IAgentUpdateInfo agentUpdate)
{
bool unitTestApplied = false;
if (agentUpdate.Effects != null)
{
foreach (AgentEffect effect in agentUpdate.Effects)
{
if (effect.Equals(AgentEffect.UnitTest))
{
unitTestApplied = true;
}
}
}
if (!unitTestApplied)
{
this.UnitTest();
}
else
{
deck.Trace("UnitTest effect already applied. Will not extend ...", TraceType.Verbose);
}
if (currentNode == null)
{
deck.Trace("Current node was initialised for this agent!", TraceType.Verbose);
currentNode = agentUpdate.Node;
visited.Add(currentNode);
}
if (currentNode != null)
{
foreach (IAgentInfo agent in currentNode.OtherAgents)
{
this.Attack(agent);
}
}
if (currentNode != null && !currentNode.Owner.Equals(agentUpdate.Owner))
{
if (currentNode.IsClaimable)
{
this.Claim(currentNode);
}
else
{
deck.Trace("Agent met unclaimable node!", TraceType.Verbose);
}
}
else
{
deck.Trace("No current node or already owned by this agent!", TraceType.Warning);
}
if (walker == null)
{
if (currentNode != null)
{
walker = currentNode.Exits.Values.GetEnumerator();
}
else
{
deck.Trace("Walker not initialised! Current node was not set.", TraceType.Critical);
}
}
else
{
if (!walker.MoveNext() && currentNode != null)
{
walker = currentNode.Exits.Values.GetEnumerator();
}
else
{
deck.Trace("Agent is probably stuck on a single node!", TraceType.Critical);
}
}
if (walker != null)
{
INodeInformation nextNode = walker.Current;
while (nextNode == null)
{
if(!walker.MoveNext() && currentNode != null)
{
walker = currentNode.Exits.Values.GetEnumerator();
}
else
{
deck.Trace("Agent is probably stuck on a single node!", TraceType.Critical);
break;
}
}
if (nextNode != null)
{
this.Move(nextNode);
currentNode = nextNode;
}
else
{
deck.Trace("Next node is null - will not move anywher!", TraceType.Error);
}
}
}
private static string GetNodeEnemiesInfo(INodeInformation node, string nodeEnemiesInfo)
{
return string.Format("{0}{1}:{2}:{3}={4}, ", nodeEnemiesInfo, node.Row, node.Column, node.Layer, node.OpposingAgents.Count());
}
public static ITargetNodeResult Virus(this IPirate5 self, INodeInformation target) {
var dlg = VirusDelegate;
if (null != dlg) { return dlg(self, target); }
return IPirate5SkillExtensions.Virus(self, target);
}
public void Tick(IAgentUpdateInfo agentUpdate)
{
bool unitTestApplied = false;
if (agentUpdate.Effects != null)
{
foreach (AgentEffect effect in agentUpdate.Effects)
{
if (effect.Equals(AgentEffect.UnitTest))
{
unitTestApplied = true;
}
}
}
if (!unitTestApplied)
{
this.UnitTest();
}
else
{
deck.Trace("UnitTest effect already applied. Will not extend ...", TraceType.Verbose);
}
if (currentNode == null)
{
deck.Trace("Current node was initialised for this agent!", TraceType.Verbose);
currentNode = agentUpdate.Node;
visited.Add(currentNode);
}
if (currentNode != null)
{
foreach (IAgentInfo agent in currentNode.OtherAgents)
{
this.Attack(agent);
}
}
if (currentNode != null && !currentNode.Owner.Equals(agentUpdate.Owner))
{
if (currentNode.IsClaimable)
{
this.Claim(currentNode);
}
else
{
deck.Trace("Agent met unclaimable node!", TraceType.Verbose);
}
}
else
{
deck.Trace("No current node or already owned by this agent!", TraceType.Warning);
}
if (walker == null)
{
if (currentNode != null)
{
walker = currentNode.Exits.Values.GetEnumerator();
}
else
{
deck.Trace("Walker not initialised! Current node was not set.", TraceType.Critical);
}
}
else
{
if (!walker.MoveNext() && currentNode != null)
{
walker = currentNode.Exits.Values.GetEnumerator();
}
else
{
deck.Trace("Agent is probably stuck on a single node!", TraceType.Critical);
}
}
if (walker != null)
{
INodeInformation nextNode = walker.Current;
while (nextNode == null)
{
if (!walker.MoveNext() && currentNode != null)
{
walker = currentNode.Exits.Values.GetEnumerator();
}
else
{
deck.Trace("Agent is probably stuck on a single node!", TraceType.Critical);
break;
}
}
if (nextNode != null)
{
this.Move(nextNode);
currentNode = nextNode;
}
else
{
deck.Trace("Next node is null - will not move anywher!", TraceType.Error);
}
}
}
public static bool TryClaim(INodeInformation node, IAgent agent)
{
return agent.Claim(node).Result == NodeResultType.Success;
}
private static bool ItsClaimableTryClaim(INodeInformation node, IAgent agent)
{
return agent.Claim(node).Result == NodeResultType.Success;
}
public void two_target_claimable_2nd_with_owner()
{
IPlayer nodeOwner = MockRepository.GenerateMock<IPlayer>();
nodeOwner.Stub(x => x.Id).Return(Guid.NewGuid());
nodeOwner.Stub(x => x.DisplayHandle).Return("nodeowner");
var lvl2Node = GetNodeInformation(new List<NodeEffect>(), new Dictionary<NodeExit, INodeInformation>(), 2, 3, 4, true, nodeOwner);
_lvl1Node = GetNodeInformation(new List<NodeEffect>(), new Dictionary<NodeExit, INodeInformation>(), 1, 2, 3, true, uid);
var exits = new Dictionary<NodeExit, INodeInformation> { { NodeExit.Alpha, _lvl1Node }, { NodeExit.Theta, lvl2Node } };
INodeInformation nodeInformation = GetNodeInformation(new List<NodeEffect>(), exits, 0, 1, 2, false, myPlayer);
IAgentUpdateInfo agentUpdate = GetAgentUpdate(nodeInformation);
var result = MoveSkills.GreedyMoveToFirstClaimable(agentUpdate, _agent);
nodeInformation.AssertWasCalled(x => x.RouteTo(nodeInformation, lvl2Node.Layer, lvl2Node.Row, lvl2Node.Column));
}
public virtual ITargetNodeResult MockVirus(IAgent self, INodeInformation target) {
ITargetNodeResult ret;
ret = new TargetNodeResult {
AffectedNode = target,
Cooldown = 1,
LastsFor = 1,
Warmup = 1,
Result = NodeResultType.FailedDifficulty,
Message = "Failed (not-implemented-by-runtime) mock virus."
};
this.WaitToNextTick(self);
return ret;
}
private IAgentUpdateInfo GetAgentUpdate(INodeInformation nodeInformation)
{
IAgentUpdateInfo agentUpdate = MockRepository.GenerateMock<IAgentUpdateInfo>();
agentUpdate.Stub(x => x.Owner).Return(_owner);
agentUpdate.Stub(x => x.Node).Return(nodeInformation);
agentUpdate.Stub(x => x.Effects).Return(new List<AgentEffect>());
return agentUpdate;
}
/// <summary>
/// Get urn from tree node view
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public Urn GetNodeUrn(TreeNode node)
{
INodeInformation service = GetNodeInformation(node);
return(GetServiceUrn(service));
}
public ITargetNodeResult Move(INodeInformation targetNode)
{
return IAgentSkillExtensions.Move(this,targetNode);
}
public SQLMenuItem(INodeInformation Node, SSMSHelperPackage Package)
{
nodeInformation = Node;
package = Package;
}
public static INodeInformation FindParentDatabaseNode(INodeInformation node)
{
return(FindParentNode(node, DB_URNPATH));
}
public ObjectExplorerServer(INodeInformation nodeInformation, IExplorerHierarchy hierarchy)
{
NodeInformation = nodeInformation;
Hierarchy = hierarchy;
}
public static INodeInformation FindParentServerNode(INodeInformation node)
{
return(FindParentNode(node, SERVER_URNPATH));
}
public NodeContextInfo(NodeType type, INodeInformation ctx)
{
this.nodeContext = ctx;
this.BuildNodeInfoByType(type);
}
private void AddMenuItemToHierarchyObject(INodeInformation node, object item)
{
dbMenu = (HierarchyObject)node.GetService(typeof(IMenuHandler));
dbMenu.AddChild(string.Empty, item);
}
public static void Scaffold(INodeInformation node, IEngineer6 engineer)
{
if (!node.Effects.Contains(NodeEffect.Scaffold))
engineer.Scaffold(node);
}
public static ITargetNodeResult Claim(this IAgent self, INodeInformation target) {
var dlg = ClaimDelegate;
if (null != dlg) { return dlg(self, target); }
return IAgentSkillExtensions.Claim(self, target);
}
