public static MeNode SanitizeMitigation(MeNode tree, Entity target, Entity caster, double amount) { List <MeNode> leaves = new List <MeNode>(); foreach (MeNode leaf in tree.Leaves) { leaves.Add(SanitizeMitigation(leaf, caster, target, amount)); } MeNode node = null; if (tree.Value.Type == VariableType.PlaceHolder) { if (tree.Value.ToPlaceholder().Equals(LConstants.TargetKeyword)) { node = new MeNode(target); } else if (tree.Value.ToPlaceholder().Equals(LConstants.SourceKeyword)) { node = new MeNode(caster); } else if (tree.Value.ToPlaceholder().Equals(LConstants.ValueKeyword)) { node = new MeNode(amount); } } else { node = new MeNode(tree.Value); } node.Leaves.AddRange(leaves); return(node); }
public void EntityTestPropertyTypeUpdatesWithFunction() { //initial test string strKey = "STR"; string expression = $"{LConstants.GET_PROP_F}({BaseEntity.Key},{strKey})"; double expected = BaseEntity.GetProperty(strKey).Value; MeNode tree = TreeConverter.Build(expression, Engine); MeNode partiallyResolved = TreeResolver.ResolveGivenOperations(tree, new string[1] { LConstants.GET_PROP_F }); Assert.AreEqual(expected, partiallyResolved.Value.ToDouble()); //apply a status that modifies the value string expression2 = $"{LConstants.ADD_MOD_F}(STR,$0)"; MeNode[] statuses = Engine.GetSanitizer().SplitAndConvert(expression2); StatusTemplate test = new StatusTemplate(statuses) { Interval = TreeConverter.Build("0", Engine) }; test.Key = "TEST_STATUS_KEY33"; double[] values = { 10 }; BaseEntity.ApplyStatus(test, BaseEntity, 10, values); BaseEntity.Update(); //test again expected = BaseEntity.GetProperty(strKey).Value; Assert.AreEqual(expected, partiallyResolved.Value.ToDouble()); BaseEntity.Cleanse(); }
public void CastTestPushbackChannelSkill() { long delay = 10; BaseEntity mob = new MockEntity(Engine); double expectedMobHealth = mob.GetProperty(Entity.HP_KEY).Value - 50; _testPlayer.Cast(mob, _testChannelSkill.Key); _testPlayer.AddPushback(delay); MockTimer timer = (MockTimer)Engine.GetTimer(); MeNode duration = _testChannelSkill.ByLevel[0].Duration; duration = Sanitizer.ReplaceTargetAndSource(duration, _testPlayer, _testPlayer); long skillDuration = duration.Resolve().Value.ToLong(); for (int i = 0; i < skillDuration; ++i) { timer.ForceTick(); _testPlayer.Update(); mob.Update(); } timer.ForceTick(); _testPlayer.Update(); mob.Update(); Assert.AreEqual(expectedMobHealth, mob.GetProperty(Entity.HP_KEY).Value); }
public MeVariable ResolveStatus(MeNode tree, double[] values) { Dictionary <string, double> valueMap = GetNumericValueMap(values); ReplaceNumericPlaceholders(tree, valueMap); return(TreeResolver.Resolve(tree).Value); }
public void CastTestNonInterrupt() { BaseEntity mob = new MockEntity(Engine); double expectedMobHealth = mob.GetProperty(Entity.HP_KEY).Value - 10; _testPlayer.Cast(mob, _unpushable.Key); _testPlayer.InterruptCasting(); MockTimer timer = (MockTimer)Engine.GetTimer(); MeNode duration = _unpushable.ByLevel[0].Duration; duration = Sanitizer.ReplaceTargetAndSource(duration, _testPlayer, _testPlayer); long skillDuration = duration.Resolve().Value.ToLong(); for (int i = 0; i < skillDuration; ++i) { timer.ForceTick(); } timer.ForceTick(); _testPlayer.Update(); Assert.AreEqual(expectedMobHealth, mob.GetProperty(Entity.HP_KEY).Value); }
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); }
private void AddStatusFromTemplate(StatusTemplate status, Entity source, double duration, double[] values) { long removeTime = GetRemoveTime(duration); AppliedStatus newStatus = new AppliedStatus() { Source = source, LastTick = 0, RemovalTime = removeTime, Template = status, NumericValues = values }; MeNode intervalTree = Sanitizer.ReplaceTargetAndSource(status.Interval, source, this); newStatus.Interval = intervalTree.Resolve().Value.ToLong(); Statuses.Add(newStatus); foreach (MeNode tree in newStatus.Template.Modifiers) { StatModifier mod = Engine.GetSanitizer().ResolveStatus(tree, newStatus.NumericValues).ToModifier(); newStatus.MyMods.Add(mod); Attributes[mod.StatKey].Modifiers.Add(mod); } RefreshProperties(); int stackCount = 0; foreach (AppliedStatus sts in Statuses) { if (sts.Template.Key.Equals(newStatus.Template.Key)) { ++stackCount; } } Engine.Log().Log($"[{Name}] Affected by {status.Name}[{stackCount}]."); }
public static MeNode ReplaceExpValues(MeNode tree, double prev, long level) { List <MeNode> leaves = new List <MeNode>(); foreach (MeNode leaf in tree.Leaves) { leaves.Add(ReplaceExpValues(leaf, prev, level)); } MeNode node; if (tree.Value.Type == VariableType.PlaceHolder) { if (tree.Value.ToPlaceholder().Equals(LConstants.ExpPrevKeyword)) { node = new MeNode(prev); } else if (tree.Value.ToPlaceholder().Equals(LConstants.LevelKeyword)) { node = new MeNode(level); } else { node = new MeNode(tree.Value); } } else { node = new MeNode(tree.Value); } node.Leaves.AddRange(leaves); return(node); }
public void EntityTestHarmStatusIntervalIsFormula() { BaseEntity ent = new MockEntity(Engine) { Name = "MOCK_PLAYER", Key = "MOCK_KEY" }; double damage = 10; string expression = $"{LConstants.HARM_F}({LConstants.TargetKeyword},{LConstants.TargetKeyword},T,{damage})"; MeNode[] statuses = Engine.GetSanitizer().SplitAndConvert(expression); string intervalExpression = $"10-{LConstants.GET_PROP_F}({LConstants.SourceKeyword},INT)*2"; MeNode intervalNode = TreeConverter.Build(intervalExpression, Engine); StatusTemplate test = new StatusTemplate(statuses) { Interval = intervalNode }; test.Key = "TEST_STATUS_KEY2"; ent.ApplyStatus(test, ent, 5, null); double expectedHp = ent.GetProperty(Entity.HP_KEY).Value - damage; double expectedHp2 = ent.GetProperty(Entity.HP_KEY).Value - damage * 2; MockTimer timer = (MockTimer)Engine.GetTimer(); ent.Update(); timer.ForceTick(); Assert.AreEqual(expectedHp, ent.GetProperty(Entity.HP_KEY).Value); ent.Update(); Assert.AreEqual(expectedHp2, ent.GetProperty(Entity.HP_KEY).Value); }
public void ReplaceNumericPlaceholders(MeNode tree, double[] values) { if (values != null) { ReplaceNumericPlaceholders(tree, GetNumericValueMap(values)); } }
public static MeNode ReplaceTargetAndSource(MeNode tree, Entity caster, Entity target) { List <MeNode> leaves = new List <MeNode>(); foreach (MeNode leaf in tree.Leaves) { leaves.Add(ReplaceTargetAndSource(leaf, caster, target)); } MeNode node = null; if (tree.Value.Type == VariableType.PlaceHolder) { if (tree.Value.ToPlaceholder() == LConstants.TargetKeyword) { node = new MeNode(target); } else if (tree.Value.ToPlaceholder() == LConstants.SourceKeyword) { node = new MeNode(caster); } else { node = new MeNode(tree.Value); } } else { node = new MeNode(tree.Value); } node.Leaves.Clear(); node.Leaves.AddRange(leaves); return(node); }
public void TreeResolverTestArrayProperty() { string expression = $"{LConstants.ARRAY_F}(10,11,12){LConstants.PROP_OP}{LConstants.ARR_LENGTH}"; double expected = 3; MeNode tree = TreeConverter.Build(expression, Engine); MeNode result = tree.Resolve(); Assert.AreEqual(expected, result.Value.ToDouble()); }
public Entity(IGameEngine engine) { Engine = engine; Attributes = new Dictionary <string, EntityAttribute>(); ResourceMap = new Dictionary <string, ResourceInstance>(); Stats = new Dictionary <string, StatInstance>(); BaseValueMap = new Dictionary <string, BaseProperty>(); ReviveDuration = new MeNode(0); }
public void TreeResolverTestResolveOnlyFunctionsNamed() { string expression = $"{LConstants.HARM_F}({MockPlayer.Key},{MockPlayer.Key},P,{LConstants.GET_PROP_F}({MockPlayer.Key},{LConstants.IF_F}({LConstants.GET_PROP_F}({MockPlayer.Key},STR) > {LConstants.GET_PROP_F}({MockPlayer.Key},AGI),STR,AGI)))"; MeNode tree = TreeConverter.Build(expression, Engine); MeNode partiallyResolved = TreeResolver.ResolveGivenOperations(tree, new string[1] { LConstants.GET_PROP_F }); Assert.AreEqual(tree.Value.Type, partiallyResolved.Value.Type); }
public DamageTypeTemplate(IGameEngine engine, string mitigation, string dodge, string crit, string critmod) { Mitigation = mitigation != null?TreeConverter.Build(mitigation, engine) : null; Dodge = dodge != null?TreeConverter.Build(dodge, engine) : null; CriticalChance = crit != null?TreeConverter.Build(crit, engine) : null; CriticalModifier = critmod != null?TreeConverter.Build(critmod, engine) : null; }
public void TreeResolverTestEntityProperty() { string strKey = "STR"; string expression = $"{MockPlayer.Key}{LConstants.PROP_OP}{strKey}"; double expected = MockPlayer.GetProperty(strKey).Value; MeNode tree = TreeConverter.Build(expression, Engine); MeNode result = tree.Resolve(); Assert.AreEqual(expected, result.Value.ToDouble()); }
public static ResourceTemplate getMockHP(IGameEngine engine) { MeNode max = TreeConverter.Build("VIT*20", engine);; MeNode regen = TreeConverter.Build("0", engine); ResourceTemplate hp = new ResourceTemplate(); hp.Formula = max; hp.RegenFormula = regen; hp.Key = Entity.HP_KEY; hp.RegenInterval = new MeNode(GcConstants.Resources.DEFAULT_INTERVAL); return(hp); }
private void SetCurrentCD() { //set skill's cooldown] if (CurrentlyCasting == null) { return; } MeNode cd = CurrentlyCasting.Skill.Values().Cooldown; cd = Sanitizer.ReplaceTargetAndSource(cd, this, CurrentlyCasting.Target); CurrentlyCasting.Skill.CooldownFinishTime = Engine.GetTimer().GetFuture((long)cd.Resolve().Value.ToDouble()); }
public void VariableTestAssignOperatorWorks() { string varName = "testVar"; double number = 3.14; string expression = $"{varName} {LConstants.ASSIGN_OP} {number}"; MeNode tree = TreeConverter.Build(expression, Engine); tree.Resolve(); MeVariable result = Engine.GetVariable(varName); Assert.IsNotNull(result); Assert.AreEqual(number, result.ToDouble()); }
public void LevelingTestPowerOperator() { double prev = 500; for (int i = 0; i < 20; ++i) { MeNode ExpFormula = TreeConverter.Build($"{prev}+50*2^{LConstants.FLOOR_F}({i}/5.0)", Engine); double res = ExpFormula.Resolve().Value.ToDouble(); double exp = prev + 50 * Math.Pow(2, Math.Floor(i / 5.0)); prev = exp; Assert.AreEqual(exp, res); } }
public void SetHarmsToPeriodic(MeNode tree) { foreach (MeNode leaf in tree.Leaves) { SetHarmsToPeriodic(leaf); } MeNode node = new MeNode(tree.Value); if (tree.Value.Type == VariableType.Function && tree.Value.ToFunction().Key.Equals(LConstants.HARM_F)) { MeNode periodic = new MeNode(true); periodic.Parent = tree; tree.Leaves.Add(periodic); } }
public void ReplaceNumericPlaceholders(MeNode tree, Dictionary <string, double> valueMap) { foreach (MeNode leaf in tree.Leaves) { ReplaceNumericPlaceholders(leaf, valueMap); } if (tree.Value.Type == VariableType.PlaceHolder) { tree.Value = new MeVariable() { Value = valueMap[tree.Value.ToPlaceholder()], Type = VariableType.NumericValue } } ; }
public void FunctionalTreeConverterTestCopy() { string expression = "11+10"; double[] expected = { 11, 10 }; MeNode tree = TreeConverter.Build(expression, Engine); MeNode copy = tree.Resolve(); Assert.AreEqual(tree.Value.ToOperator().Key, "+"); Assert.AreEqual(2, tree.Leaves.Count); for (int i = 0; i < expected.Length; ++i) { Assert.AreEqual(expected[i], tree.Leaves[i].Value.ToDouble()); } }
public void SanitizerTestReplacePropetyOperators() { string expected = "AGI"; string expression = $"1 + {expected}"; double expectedValue = MockPlayer.GetProperty(expected).Value + 1; MeNode result = Sanitizer.ReplacePropeties(TreeConverter.Build(expression, Engine), MockPlayer); Assert.AreEqual(LConstants.PROP_OP, result.Leaves[1].Value.GetString()); Assert.AreEqual(expected, result.Leaves[1].Leaves[1].Value.ToMeString()); MeNode resolved = result.Resolve(); Assert.AreEqual(expectedValue, resolved.Value.ToDouble()); }
private void TickCurrentCast() { if (CurrentlyCasting == null) { return; } long now = Engine.GetTimer().GetNow(); if (CurrentlyCasting.Skill.Skill.Type == SkillType.Cast) { if (CurrentlyCasting.CastFinishTime <= now) { string castedFinish = Key.Equals(CurrentlyCasting.Target.Key) ? "" : $" on {CurrentlyCasting.Target.Name}"; Engine.Log().Log($"[{Name}] Casted {CurrentlyCasting.Skill.Skill.Name}{castedFinish}."); //casting has finished so resolve the formula MeNode[] toResolve = CurrentlyCasting.Skill.Formulas; foreach (MeNode node in toResolve) { MeNode sanitized = Sanitizer.ReplaceTargetAndSource(node, this, CurrentlyCasting.Target); sanitized.Resolve(); } FinishCasting(); } } else if (CurrentlyCasting.Skill.Skill.Type == SkillType.Channel) { if (CurrentlyCasting.CastFinishTime <= now) { Engine.Log().Log($"[{Name}] Finished channeling {CurrentlyCasting.Skill.Skill.Name}."); FinishCasting(); } else { //apply the formulas if it's the case if (CurrentlyCasting.NextInterval == 0 || CurrentlyCasting.NextInterval < now) { MeNode[] toResolve = CurrentlyCasting.Skill.Formulas; foreach (MeNode node in toResolve) { Sanitizer.ReplaceTargetAndSource(node, this, CurrentlyCasting.Target).Resolve(); } CurrentlyCasting.NextInterval = now + CurrentlyCasting.Interval * 1000; } } } }
public static MeNode Resolve(MeNode node, int index = 0) { for (int i = 0; i < node.Leaves.Count; ++i) { node.Leaves[i] = Resolve(node.Leaves[i], i); } if (node.Parent != null && node.Parent.Value.Type == VariableType.Function) { if (!node.Parent.Value.ToFunction().ExecuteSubNode(index)) { List <MeVariable> parameters = new List <MeVariable>(); foreach (MeNode subNode in node.Leaves) { parameters.Add(subNode.Value); } return(new MeNode(new MeFunction(node.Value, parameters.ToArray()))); } } switch (node.Value.Type) { case VariableType.Function: List <MeVariable> parameters = new List <MeVariable>(); foreach (MeNode subNode in node.Leaves) { parameters.Add(subNode.Value); } return(new MeNode(node.Value.ToFunction().Execute(parameters.ToArray()))); case VariableType.Operator: { List <MeVariable> opParameters = new List <MeVariable>(); foreach (MeNode subNode in node.Leaves) { opParameters.Add(subNode.Value); } MeNode amt = new MeNode(node.Value.ToOperator().Execute(opParameters.ToArray())); return(amt); } default: { return(node); } } }
public long GetMaxExp(int level) { if (ExpFormula == null) { return(0); } if (ExpValues.Count <= level) { ExpValues.Capacity = level + 1; for (int i = ExpValues.Count - 1; i <= level; ++i) { double prev = ExpValues[i]; MeNode sanitized = Sanitizer.ReplaceExpValues(ExpFormula, (long)prev, i + 1); ExpValues.Add((long)Math.Floor(sanitized.Resolve().Value.ToDouble())); } } return(ExpValues[level]); }
public static MeNode ResolveGivenOperations(MeNode node, string[] operationNames, int index = 0) { for (int i = 0; i < node.Leaves.Count; ++i) { node.Leaves[i] = ResolveGivenOperations(node.Leaves[i], operationNames, i); } if (node.Value.Type == VariableType.Function || node.Value.Type == VariableType.Operator) { foreach (string key in operationNames) { if (node.Value.GetString().Equals(key)) { return(node.Resolve()); } } } return(node); }
public MockEntity(IGameEngine engine) : base(engine) { AddAttribute("VIT", 5); AddAttribute("STR", 5); AddAttribute("INT", 5); AddAttribute("AGI", 10); AddAttribute("DEF", 10); AddAttribute("MDEF", 10); AddResource(getMockHP(engine)); MeNode mpNode = TreeConverter.Build("INT*10", engine); MeNode mpRegen = TreeConverter.Build("INT/100", engine); ResourceTemplate resTemp = new ResourceTemplate(); resTemp.Formula = mpNode; resTemp.RegenFormula = mpRegen; resTemp.Key = "MP"; resTemp.RegenInterval = new MeNode(GcConstants.Resources.DEFAULT_INTERVAL); AddResource(resTemp); }
public double GetMitigatedAmount(double amount, Entity source, Entity target) { bool crited; if (CriticalChance != null) { MeNode resolvedCritChance = Sanitizer.ReplaceTargetAndSource(CriticalChance, source, target) .Resolve(); crited = Utils.Utility.Chance(resolvedCritChance.Value.ToDouble()); } else { crited = false; } double mutliplier = 1.0; if (crited) { if (CriticalModifier != null) { mutliplier = Sanitizer.ReplaceTargetAndSource(CriticalModifier, source, target) .Resolve().Value.ToDouble(); } } double finalAmount = mutliplier * amount; if (Mitigation != null) { MeNode mitigation = Sanitizer.SanitizeMitigation(Mitigation, target, source, finalAmount) .Resolve(); return(mitigation.Value.ToDouble()); } else { return(finalAmount); } }
///<summary> /// Recursive method to print an inventory tree node ///</summary> private static void printNode(MeNode node, int indent) { // Make it pretty for (int i = 0; i < indent; ++i) { Console.Write(' '); } Console.WriteLine(node.getName() + " (" + node.getNode().type + ")"); if (node.getChildren().Count != 0) { for (int c = 0; c < node.getChildren().Count; ++c) { printNode((MeNode) node.getChildren()[c], indent + 2); } } }
///<summary> /// Print the inventory tree retrieved from /// the PropertyCollector ///</summary> private static void printInventoryTree(ObjectContent[] ocs) { // Hashtable MoRef.Value -> MeNode Hashtable nodes = new Hashtable(); // The root folder node MeNode root = null; for (int oci = 0; oci < ocs.Length; ++oci) { ObjectContent oc = ocs[oci]; ManagedObjectReference mor = oc.obj; DynamicProperty[] dps = oc.propSet; if (dps != null) { ManagedObjectReference parent = null; String name = null; for (int dpi = 0; dpi < dps.Length; ++dpi) { DynamicProperty dp = dps[dpi]; if (dp != null) { if ("name".Equals(dp.name)) { name = (String)dp.val; } if ("parent".Equals(dp.name)) { parent = (ManagedObjectReference)dp .val; } } } // Create a MeNode to hold the data MeNode node = new MeNode(parent, mor, name); // The root folder has no parent if (parent == null) { root = node; } // Add the node nodes.Add(node.getNode().Value, node); } } // Build the nodes into a tree foreach (String key in nodes.Keys) { MeNode meNode = nodes[key] as MeNode; if (meNode.getParent() != null) { MeNode parent = (MeNode)nodes[meNode.getParent().Value]; parent.getChildren().Add(meNode); } } Console.WriteLine("Inventory Tree"); printNode(root, 0); }
void PrintNode(MeNode node, TextWriter file, String mobUrl, String docRoot, Hashtable typeToDoc, Hashtable typeToImage) { String mobLink = mobUrl + System.Web.HttpUtility.UrlEncode(node.node.Value); String page = typeToDoc[node.node.type] as String; String image = typeToImage[node.node.type] as String; String link = null; if(page != null && docRoot != null) { link = docRoot + page; } if(node.children.Count > 0) { node.children.Sort(new MeNodeCompare()); file.WriteLine("<li style=\"list-style-image:url("+image+")\"><a target=\"mob\" href=\""+mobLink+"\">"+node.name+"</a></li>"); if(link != null) { file.WriteLine("<a target=\"mob\" href=\""+link+"\">?</a>"); } file.WriteLine("<ul>"); foreach (MeNode lNode in node.children) { PrintNode(lNode, file, mobUrl, docRoot, typeToDoc, typeToImage); } file.WriteLine("</ul>"); } else { file.WriteLine("<li style=\"list-style-image:url("+image+")\"><a target=\"mob\" href=\""+mobLink+"\">"+node.name+"</a></li>"); if(link != null) { file.WriteLine("<a target=\"mob\" href=\""+link+"\">?</a>"); } } }
/// <summary> /// Retrieve inventory from the given root /// </summary> private void PrintInventory() { try { // Retrieve Contents recursively starting at the root folder // and using the default property collector. ObjectContent[] ocary = cb.getServiceUtil().GetContentsRecursively(null, null, typeInfo, true); Hashtable nodes = new Hashtable(); MeNode root = null; for (int oci = 0; oci < ocary.Length; oci++) { ObjectContent oc = ocary[oci]; ManagedObjectReference mor = oc.obj; DynamicProperty[] pcary = oc.propSet; if (pcary != null) { ManagedObjectReference parent = null; String name = null; for (int pci = 0; pci < pcary.Length; pci++) { DynamicProperty pc = pcary[pci]; if (pc != null) { if("name" == pc.name) { name = pc.val as String; } if("parent" == pc.name) { parent = pc.val as ManagedObjectReference; } } } MeNode node = new MeNode(parent, mor, name); if(parent == null) { root = node; } nodes.Add(node.node.Value, node); } } // Organize the nodes into a 'tree' foreach (String key in nodes.Keys) { MeNode meNode = nodes[key] as MeNode; if(meNode.parent != null) { ((MeNode)nodes[meNode.parent.Value]).children.Add(meNode); } } String mobUrl = cb.getServiceUrl(); mobUrl = mobUrl.Replace("/sdk", "/mob"); if(mobUrl.IndexOf("mob") == -1) { mobUrl += "/mob"; } mobUrl += "/?moid="; // Map of ManagedEntity to doc file Hashtable typeToDoc = new Hashtable(); typeToDoc["ComputeResource"] = "/vim.ComputeResource.html"; typeToDoc["ClusterComputeResource"] = "/vim.ClusterComputeResource.html"; typeToDoc["Datacenter"] = "/vim.Datacenter.html"; typeToDoc["Folder"] = "/vim.Folder.html"; typeToDoc["HostSystem"] = "/vim.HostSystem.html"; typeToDoc["ResourcePool"] = "/vim.ResourcePool.html"; typeToDoc["VirtualMachine"] = "/vim.VirtualMachine.html"; Hashtable typeToImage = new Hashtable(); typeToImage["ComputeResource"] = "compute-resource.png"; typeToImage["ClusterComputeResource"] = "compute-resource.png"; typeToImage["Datacenter"] = "datacenter.png"; typeToImage["Folder"] = "folder-open.png"; typeToImage["HostSystem"] = "host.png"; typeToImage["ResourcePool"] = "resourcePool.png"; typeToImage["VirtualMachine"] = "virtualMachine.png"; String docRoot = cb.get_option("docref"); if (docRoot != null) { // Try to determine where we are in sample tree // SDK/samples_2_0/DotNet/cs/MobStartPage/bin/Debug String cDir = Directory.GetCurrentDirectory(); if (cDir.EndsWith("Debug") || cDir.EndsWith("Release")) { docRoot = "../../../../../../doc/ReferenceGuide"; } else if (cDir.EndsWith("MobStartPage")) { docRoot = "../../../../doc/ReferenceGuide"; } else if (cDir.EndsWith("cs")) { docRoot = "../../../doc/ReferenceGuide"; } bool docsFound = docRoot != null; // Not Url? if (docsFound && docRoot.IndexOf("http") == -1) { String testFile = docRoot.Replace("/", "\\") + "\\index.html"; docsFound = File.Exists(testFile); } if (!docsFound) { //log.LogLine("Warning: Can't find docs at: " + docRoot); docRoot = null; } // Write out as html into string StringWriter nodeHtml = new StringWriter(); PrintNode(root, nodeHtml, mobUrl, docRoot, typeToDoc, typeToImage); nodeHtml.Close(); Assembly assembly = Assembly.GetExecutingAssembly(); CopyFileFromResource(assembly, "MobStartPage.index.html", "index.html"); CopyFileFromResource(assembly, "MobStartPage.compute-resource.png", "compute-resource.png"); CopyFileFromResource(assembly, "MobStartPage.datacenter.png", "datacenter.png"); CopyFileFromResource(assembly, "MobStartPage.folder.png", "folder.png"); CopyFileFromResource(assembly, "MobStartPage.folder-open.png", "folder-open.png"); CopyFileFromResource(assembly, "MobStartPage.host.png", "host.png"); CopyFileFromResource(assembly, "MobStartPage.resourcePool.png", "resourcePool.png"); CopyFileFromResource(assembly, "MobStartPage.virtualMachine.png", "virtualMachine.png"); // Get and write inventory.html Stream stream = assembly.GetManifestResourceStream("MobStartPage.inventory.html"); StreamReader reader = new StreamReader(stream); String fileData = reader.ReadToEnd(); using (StreamWriter file = new StreamWriter("inventory.html")) { String serverName = cb.getServiceUrl(); int lastCharacter = serverName.LastIndexOfAny(":/".ToCharArray()); if (lastCharacter != -1) { serverName = serverName.Substring(0, lastCharacter); } int firstCharacter = serverName.LastIndexOf('/'); if (firstCharacter != -1) { serverName = serverName.Substring(firstCharacter + 1); } String output = String.Format(fileData, serverName, nodeHtml.ToString()); file.WriteLine(output); } System.Diagnostics.Process.Start("index.html"); cb.log.LogLine("Done Printing Inventory"); } else { System.Console.WriteLine("Please provide the valid reference-doc-location."); } } catch (Exception e) { cb.log.LogLine("MobStartPage : Failed Getting Contents"); throw e; } }