public async Task addAbility([Remainder, Summary("Ability")] string ability) { if (characters == null) { characters = new List <CharacterNode>(); } CharacterNode old = findCharacter(Context.User); if (old == null) { await Context.User.SendMessageAsync("You do not have an active character."); return; } bool s = old.removeAbilityProficiency(ability); if (s) { await Context.User.SendMessageAsync("I added the proficiency for you."); } else { await Context.User.SendMessageAsync("That is not a valid proficiency."); } }
public async Task addST([Remainder, Summary("stat type")] string stat) { if (characters == null) { characters = new List <CharacterNode>(); } CharacterNode old = findCharacter(Context.User); if (old == null) { await Context.User.SendMessageAsync("You do not have an active character."); return; } bool s = old.addSavingThrowProf(stat); if (s) { await Context.User.SendMessageAsync("I added the proficiency for you."); } else { await Context.User.SendMessageAsync("That is not a valid proficiency."); } }
public void ShouldApplyVariationsOnRegularInput() { // Arrange var characterNode = new CharacterNode('a'); var quantifierNode = new QuantifierNOrMoreNode(5, characterNode); var rootNode = new ConcatenationNode(quantifierNode); var target = new QuantifierUnlimitedQuantityMutator(); var expectedResults = new List <string> { "a{4,}", "a{6,}", }; // Act var mutations = target.ApplyMutations(quantifierNode, rootNode).ToList(); // Assert var index = 0; var originalQuantifier = "a{5,}"; foreach (var mutation in mutations) { mutation.OriginalNode.ShouldBe(quantifierNode); mutation.ReplacementNode.ToString().ShouldBe(expectedResults[index]); mutation.ReplacementPattern.ShouldBe(expectedResults[index]); mutation.DisplayName.ShouldBe("Regex greedy quantifier quantity mutation"); mutation.Description.ShouldBe($"Quantifier \"{originalQuantifier}\" was replaced with \"{expectedResults[index]}\" at offset 1."); index++; } mutations.Count.ShouldBe(2); }
public void GetDescendantsShouldReturnAllDescendants() { // Arrange // a+bc* var charNodeA = new CharacterNode('a'); var charNodeB = new CharacterNode('b'); var charNodeC = new CharacterNode('c'); var quantifierPlus = new QuantifierPlusNode(charNodeA); var quantifierStar = new QuantifierStarNode(charNodeC); var grandchildren = new List <RegexNode> { quantifierPlus, charNodeB, quantifierStar }; var concatenationNode = new ConcatenationNode(grandchildren); var target = new TestRegexNode(concatenationNode); // Act IEnumerable <RegexNode> result = target.GetDescendantNodes(); // Assert result.Count().ShouldBe(6); result.First().ShouldBe(charNodeA); result.ElementAt(1).ShouldBe(quantifierPlus); result.ElementAt(2).ShouldBe(charNodeB); result.ElementAt(3).ShouldBe(charNodeC); result.ElementAt(4).ShouldBe(quantifierStar); result.Last().ShouldBe(concatenationNode); }
public ListResponse <BodyComponent> GetBodyComponentList(ListRequest <BodyComponent> request) { lock (_lock) { var actComponent = BodyComponentBase.GetActuallyComponent(request.Parameter); var compNode = CharacterNode.SearchNode(actComponent.BaseNodePath); compNode.Nodes.SortByImgID(); var resp = new ListResponse <BodyComponent> { Results = compNode.Nodes.Skip(request.Start).Take(request.Num).Select(nd => { var comp = new BodyComponent { ID = actComponent.FormatID(nd.Text), ConfigType = actComponent.ConfigType, MotionName = actComponent.DefaultMotionName }; return(GetBodyComponent(comp, false)); }).ToList() }; resp.HasNext = resp.Results.Count == request.Num; return(resp); } }
public async Task open([Remainder, Summary("File name")] string filename) { if (characters == null) { characters = new List <CharacterNode>(); } CharacterNode old = findCharacter(Context.User); if (old != null) { characters.Remove(old); } CharacterNode character = new CharacterNode("temp"); int error = character.openCharacter(filename, Context.User); if (error == 2) { await Context.Channel.SendMessageAsync("You are not the owner of that file"); } else if (error == 3) { await Context.Channel.SendMessageAsync("I could not locate that file."); } else { await Context.Channel.SendMessageAsync("I successfully loaded the file. Enter **!c view** to view it."); } characters.Add(character); }
public void SpanOnCommentGroupShouldStartAfter() { // Arrange var comment = new CommentGroupNode("This is a comment."); var a = new CharacterNode('a'); var b = new CharacterNode('b') { Prefix = comment }; var concat = new ConcatenationNode(new List <RegexNode> { a, b }); // Act var(commentStart, commentLength) = comment.GetSpan(); var(aStart, aLength) = a.GetSpan(); var(bStart, bLength) = b.GetSpan(); var(concatStart, concatLength) = concat.GetSpan(); // Assert concatStart.ShouldBe(0); concatLength.ShouldBe(a.ToString().Length + b.ToString().Length); aStart.ShouldBe(0); aLength.ShouldBe(1); commentStart.ShouldBe(1); commentLength.ShouldBe(comment.ToString().Length); bStart.ShouldBe(commentStart + commentLength); bLength.ShouldBe(1); }
public List <string> GetParent(string ID) { List <string> result = new List <string>(); CharacterNode target = new CharacterNode(); foreach (CharacterNode NpcNode in characterNodeContainer.CharacterNodes) { if (NpcNode.ID == ID) { target = NpcNode; break; } } if (target.ID != null) { if (target.Parents.Length != 0) { foreach (string parent in target.Parents) { foreach (string NpcID in player.NPCIDs) { if (parent == NpcID) { result.Add(parent); } } } } else { result.Add("00"); } } return(result); }
/** * Disables the current turn player and moves on to the next */ private void turnOver() { Debug.Log("Disabling " + battleQueueController.getCharacterRef().charName); if (turn == TYPE.PLAYER) { plyPanel.changeCurrentActivePlayer(players.IndexOf(battleQueueController.getCharacterRef()), false); } battleQueueController.getCharacterRef().setActive(false); battleQueueController = battleQueueController.getNext(); battleQueueController.getCharacterRef().setActive(true); Debug.Log("Enabling " + battleQueueController.getCharacterRef().charName); turn = battleQueueController.getCharacterRef().getType(); if (turn == TYPE.PLAYER) { heroCursor.reposition(battleQueueController.getCharacterRef().getPosition()); heroCursor.relocate(1.5f * scale, 0.5f * scale); plyPanel.changeCurrentActivePlayer(players.IndexOf(battleQueueController.getCharacterRef()), true); } else if (turn == TYPE.ENEMY) { heroCursor.gameObject.SetActive(false); } }
public void ShouldSkipDecrementOnZeroEndValue() { // Arrange var characterNode = new CharacterNode('a'); var quantifierNode = new QuantifierNMNode(0, 0, characterNode); var rootNode = new ConcatenationNode(quantifierNode); var target = new QuantifierQuantityMutator(); var expectedResults = new List <string> { "a{0,1}", }; // Act var mutations = target.ApplyMutations(quantifierNode, rootNode).ToList(); // Assert var index = 0; var originalQuantifier = "a{0,0}"; foreach (var mutation in mutations) { mutation.OriginalNode.ShouldBe(quantifierNode); mutation.ReplacementNode.ToString().ShouldBe(expectedResults[index]); mutation.ReplacementPattern.ShouldBe(expectedResults[index]); mutation.DisplayName.ShouldBe("Regex greedy quantifier quantity mutation"); mutation.Description.ShouldBe($"Quantifier \"{originalQuantifier}\" was replaced with \"{expectedResults[index]}\" at offset 1."); index++; } mutations.Count.ShouldBe(1); }
public async Task setHitDie(int num) { if (characters == null) { characters = new List <CharacterNode>(); } CharacterNode character = findCharacter(Context.User); if (character == null) { await Context.User.SendMessageAsync("You have no active character."); } else { if (num == 4 || num == 6 || num == 8 || num == 12 || num == 10 || num == 20 || num == 100) { character.setHitDie(num); await Context.User.SendMessageAsync("Hit die updated."); } else { await Context.User.SendMessageAsync("That is not a valid die."); } } }
public async Task setPrimaryStat(string stat) { if (characters == null) { characters = new List <CharacterNode>(); } CharacterNode character = findCharacter(Context.User); if (character == null) { await Context.User.SendMessageAsync("You have no active character."); } else { if (character.determineValidStat(stat)) { character.setPrimaryStat(stat); await Context.Channel.SendMessageAsync("Primary stat updated."); } else { await Context.Channel.SendMessageAsync("That is not a valid stat."); } } }
public bool equals(CharacterNode c) { if (c.getCharacterRef() == this.characterRef) { return(true); } return(false); }
protected override void AssertCharacter(Character model, CharacterNode node) { var(testCharacter, testNode) = GetTestCharacter(); AssertPropertiesAreEqual(testCharacter, model, nameof(model.Name), nameof(model.Description)); AssertPropertiesAreEqual(testNode, node, nameof(node.XPosition), nameof(node.YPosition)); }
public override void PresentStep(int index, PresentationViewController presentationViewController) { SCNTransaction.Begin(); switch (index) { case 0: // Set the slide's title and subtitle and add some text TextManager.SetTitle("Skinning"); TextManager.AddBulletAtLevel("Animate characters", 0); TextManager.AddBulletAtLevel("Deform geometries with a skeleton", 0); TextManager.AddBulletAtLevel("Joints and bones", 0); // Animate the character CharacterNode.AddAnimation(IdleAnimationGroup, new NSString("idleAnimation")); // The character is hidden. Wait a little longer before showing it // otherwise it may slow down the transition from the previous slide var delayInSeconds = 1.5; var popTime = new DispatchTime(DispatchTime.Now, (long)(delayInSeconds * Utils.NSEC_PER_SEC)); DispatchQueue.MainQueue.DispatchAfter(popTime, () => { SCNTransaction.Begin(); SCNTransaction.AnimationDuration = 0; CharacterNode.Hidden = false; CharacterNode.Opacity = 0; SCNTransaction.Commit(); SCNTransaction.Begin(); SCNTransaction.AnimationDuration = 1.5; SCNTransaction.AnimationTimingFunction = CAMediaTimingFunction.FromName(CAMediaTimingFunction.EaseIn); CharacterNode.Opacity = 1; SCNTransaction.Commit(); }); break; case 1: SCNTransaction.AnimationDuration = 1.5f; //TODO SetShowsBones (true); break; case 2: CharacterNode.AddAnimation(AnimationGroup1, new NSString("animation")); break; case 3: SCNTransaction.AnimationDuration = 1.5f; //TODO SetShowsBones (false); break; case 4: CharacterNode.AddAnimation(AnimationGroup1, new NSString("animation")); break; } SCNTransaction.Commit(); }
public void ToStringShouldReturnCharAsString() { // Arrange var target = new CharacterNode('a'); // Act var result = target.ToString(); // Assert result.ShouldBe("a"); }
public void ToStringShouldReturnQuantifierQuestionMarkOnChildNodeToString() { // Arrange var characterNode = new CharacterNode('a'); var target = new QuantifierQuestionMarkNode(characterNode); // Act var result = target.ToString(); // Assert result.ShouldBe("a?"); }
public void ToStringOnAtomicGroupWithChildNodeShouldReturnAtomicGroupWithChildNode() { // Arrange var childNode = new CharacterNode('a'); var target = new AtomicGroupNode(childNode); // Act var result = target.ToString(); // Assert result.ShouldBe("(?>a)"); }
public void ToStringOnLookaroundGroupChildNodeShouldReturnLookaroundWithChildNode() { // Arrange var childNode = new CharacterNode('a'); var target = new LookaroundGroupNode(true, true, childNode); // Act var result = target.ToString(); // Assert result.ShouldBe("(?=a)"); }
public void GetSpanShouldReturnTupleWithStart0AndLenght1() { // Arrange var target = new CharacterNode('a'); // Act var(Start, Length) = target.GetSpan(); // Assert Start.ShouldBe(0); Length.ShouldBe(1); }
public void ToStringOnBalancingGroupWithChildNodeShouldReturnBalencingGroupWithChildNode() { // Arrange var childNode = new CharacterNode('a'); var target = new BalancingGroupNode("balancedGroup", "currentGroup", false, childNode); // Act var result = target.ToString(); // Assert result.ShouldBe("(?<currentGroup-balancedGroup>a)"); }
public void ToStringShouldReturnOriginalQuantifierNMOnChildNodeToString() { // Arrange var characterNode = new CharacterNode('a'); var target = new QuantifierNMNode("05", "006", characterNode); // Act var result = target.ToString(); // Assert result.ShouldBe("a{05,006}"); }
public void ToStringOnNamedGroupNodeWithChildNodeShouldReturnNamedGroupWithChildNode() { // Arrange var childNode = new CharacterNode('a'); var target = new NamedGroupNode("name", false, childNode); // Act var result = target.ToString(); // Assert result.ShouldBe("(?<name>a)"); }
public void ToStringShouldReturnQuantifierNMOfIntegersNAndMIfNoOriginalNAndMIsGiven() { // Arrange var characterNode = new CharacterNode('a'); var target = new QuantifierNMNode(5, 6, characterNode); // Act var result = target.ToString(); // Assert result.ShouldBe("a{5,6}"); }
public void ToStringOnModeModifierGroupNodeWithChildNodeShouldReturnModeModifierGroupWithChildNodeAfterColon() { // Arrange var childNode = new CharacterNode('a'); var target = new ModeModifierGroupNode("imsnx-imsnx", childNode); // Act var result = target.ToString(); // Assert result.ShouldBe("(?imsnx-imsnx:a)"); }
public void ToStringOnNonCaptureGroupNodeWithChildNodeShouldReturnEmptyNonCaptureGroupWithChildNode() { // Arrange var childNode = new CharacterNode('a'); var target = new NonCaptureGroupNode(childNode); // Act var result = target.ToString(); // Assert result.ShouldBe("(?:a)"); }
public void MutateShouldNotMutateNonQuantifierNode() { // Arrange var characterNode = new CharacterNode('a'); var rootNode = new ConcatenationNode(characterNode); var target = new QuantifierRemovalMutator(); // Act var result = target.Mutate(characterNode, rootNode); // Assert result.ShouldBeEmpty(); }
public async Task remove([Remainder, Summary("Spell name")] string spellName) { CharacterNode character = findCharacter(Context.User); if (character == null) { await Context.User.SendMessageAsync("You have no active character."); return; } character.removeSpell(spellName); await Context.User.SendMessageAsync("The spell was removed from your spell list."); }
public void MutateShouldNotMutateNonCharacterClassNode() { // Arrange var characterNode = new CharacterNode('a'); var root = new ConcatenationNode(characterNode); var target = new CharacterClassNegationMutator(); // Act var result = target.Mutate(characterNode, root); // Assert result.ShouldBeEmpty(); }
public void SpanShouldStartAfterChildNodes() { // Arrange var childNode = new CharacterNode('a'); var target = new QuantifierQuestionMarkNode(childNode); // Act var(Start, Length) = target.GetSpan(); // Assert Start.ShouldBe(childNode.ToString().Length); Length.ShouldBe(1); }
public void traverse(string _desc, HtmlNode _node) { HtmlAgilityPack.HtmlNodeCollection nodes; CharacterNode chNode; nodes = _node.SelectNodes(@"//table[@class='ulist mt10']/tbody/tr"); foreach (HtmlNode chnode in nodes) { saveNodeToFile(chnode); chNode = new CharacterNode(chnode); } }
IEnumerator HandleEvent(GameObject goTarget) { //Debug.Log("Starting event!"); goTarget.SetActive(true); //We enable the frogs. yield return new WaitForSeconds(5.0f); //We wait for a moment. int layerMask = 1 << 11; // This would cast rays only against colliders in layer 11, the Memory Layer. // But instead we want to collide against everything except layer 11. The ~ operator does this, it inverts a bitmask. layerMask = ~layerMask; //Creating the event within the shared event graph. //1. We create the core event node. //2. We add all the large enemy frogs to the graph, and link them to the event. //3. We add the location of the event to the graph, and link it to the event. //4. We create the sub-event, and add it to the graph. //5. We link the sub-event to the location. //6. We add all the small enemy frogs to the graph, and link them to the sub event. //7. We then generate the personalised memories for all agents in the area. EventNode coreSharedEvent = new EventNode("FrogAttack", new int[] { 3 }, new string[] { "EVN_FrogAttack" }); MemoryGraphNode coreSharedEventNode = EventManager.Instance.SharedEventGraph.AddNamedNodeToGraph(coreSharedEvent); //We populate the shared event graph with info about the event. for (int i = 0; i < tLargeFrogs.Length; i++) { CharacterNode frogNode = new CharacterNode(tLargeFrogs[i].Tag); MemoryGraphNode frogEventNode = EventManager.Instance.SharedEventGraph.AddNamedNodeToGraph(frogNode); EventManager.Instance.SharedEventGraph.AddUndirectedEdge(coreSharedEventNode, frogEventNode, 11.0f); } LocationNode lNode = new LocationNode(Locations.SouthernPinnusula); MemoryGraphNode locationGraphNode = EventManager.Instance.SharedEventGraph.AddNamedNodeToGraph(lNode); EventManager.Instance.SharedEventGraph.AddUndirectedEdge(coreSharedEventNode, locationGraphNode, 11.0f); EventNode coreSharedSubEvent = new EventNode("SmallFrogEvent", new int[] { 17 }, new string[] { "Monsters" }); MemoryGraphNode coreSharedSubEventNode = EventManager.Instance.SharedEventGraph.AddNamedNodeToGraph(coreSharedSubEvent); EventManager.Instance.SharedEventGraph.AddUndirectedEdge(coreSharedEventNode, coreSharedSubEventNode, 11.0f); EventManager.Instance.SharedEventGraph.AddUndirectedEdge(coreSharedSubEventNode, locationGraphNode, 11.0f); for (int i = 0; i < tSmallFrogs.Length; i++) { CharacterNode frogNode = new CharacterNode(tSmallFrogs[i].Tag); MemoryGraphNode frogEventNode = EventManager.Instance.SharedEventGraph.AddNamedNodeToGraph(frogNode); EventManager.Instance.SharedEventGraph.AddUndirectedEdge(coreSharedSubEventNode, frogEventNode, 11.0f); } for (int i = 0; i < AgentManager.Instance.GetAgentCount(); i++) { CharacterDetails charDetails = AgentManager.Instance.GetAgent(i); MemoryGraph charGraph = charDetails.IsPlayer ? charDetails.PlayerAgent.MindsEye.MemoryGraph : charDetails.CognitiveAgent.MindsEye.MemoryGraph; EventNode coreEvent = new EventNode("FrogAttack", null, new string[] { "EVN_FrogAttack" }); MemoryGraphNode coreEventNode = charGraph.AddNamedNodeToGraph(coreEvent); string eventLocation = Locations.SouthernPinnusula.ToString(); bool sawEvent = false; int frogCount = 0; for (int x = 0; x < tLargeFrogs.Length; x++) { RaycastHit hit; Vector3 direction = tLargeFrogs[x].cTransform.position - charDetails.HeadTarget.position; if (Physics.Raycast(charDetails.HeadTarget.position, direction, out hit, Mathf.Infinity, layerMask)) { //Debug.Log(charDetails.CharCue.UniqueNodeID + " - " + hit.transform.name); EventTag eTag = hit.transform.GetComponent<EventTag>(); if (eTag != null && eTag.Tag == tLargeFrogs[x].Tag) ++frogCount; } } MemoryGraphNode largeFrogNode = null; if (frogCount > 0) { sawEvent = true; //Create Large Frogs sub-event! EventNode largeFrogEvent = new EventNode("LargeFrogEvent", new int[] { frogCount }, new string[] { "Monsters" }); largeFrogNode = charGraph.AddNamedNodeToGraph(largeFrogEvent); charGraph.AddUndirectedEdge(coreEventNode, largeFrogNode, 11.0f, 1.0f); //Creates a strong connection between the core event and the optional sub-event. } //Debug.Log(charDetails.name + " - I saw " + frogCount + " huge frogs!"); frogCount = 0; for (int x = 0; x < tSmallFrogs.Length; x++) { RaycastHit hit; Vector3 direction = tSmallFrogs[x].cTransform.position - charDetails.HeadTarget.position; if (Physics.Raycast(charDetails.HeadTarget.position, direction, out hit, direction.magnitude, layerMask)) { //Debug.Log(charDetails.CharCue.UniqueNodeID + " - " + hit.transform.name); EventTag eTag = hit.transform.GetComponent<EventTag>(); //if(eTag != null) //Debug.Log(charDetails.CharCue.UniqueNodeID + " : " + eTag.Tag); if (eTag != null && eTag.Tag == tSmallFrogs[x].Tag) ++frogCount; } } MemoryGraphNode smallFrogNode = null; if (frogCount > 0) { sawEvent = true; //Create small frogs sub-event! EventNode smallFrogEvent = new EventNode("SmallFrogEvent", new int[] { frogCount }, new string[] { "Monsters" }); smallFrogNode = charGraph.AddNamedNodeToGraph(smallFrogEvent); charGraph.AddUndirectedEdge(coreEventNode, smallFrogNode, 11.0f, 1.0f); //Creates a strong connection between the core event and the optional sub-event. } if (sawEvent) { MemoryGraphNode retainedMemory; if (charGraph.Contains(eventLocation) == false) retainedMemory = charGraph.AddNamedNodeToGraph(new LocationNode(Locations.SouthernPinnusula)); //This is a new memory! Add it to our memory graph. else retainedMemory = charGraph.GetNamedNodeFromGraph(eventLocation); charGraph.UpdateCueOpinion(retainedMemory.MemoryNode, -5.0f); //The agent will have a strong negative opinion about the area where they attack. charGraph.AddUndirectedEdge(coreEventNode, retainedMemory, 11.0f, 1.0f); //They will also make a strong connection between the area and the frogs. if (largeFrogNode != null) charGraph.AddDirectedEdge(largeFrogNode, retainedMemory, 11.0f, 1.0f); //Creates a strong (but one-way, since we already connect the core event) connection to the location. if (smallFrogNode != null) charGraph.AddDirectedEdge(smallFrogNode, retainedMemory, 11.0f, 1.0f); //Creates a strong (but one-way, since we already connect the core event) connection to the location. } } //We broadcast the Frog Sight Event and create the Shared Events and personalised Sub Events. //We also broadcast the start of the event (so people flee). yield return new WaitForSeconds(5.0f); //We broadcast the end of the event, and hide the frogs again. goTarget.SetActive(false); //Debug.Log("Ending event!"); //EventManager.Instance.SharedEventGraph.PrintGraph(); }