public void AreIsomorphic_OnIsomorphicQuiversButNonIsomorphicPotentials_SameGroupSignaturesAndSameCounts() { var potential1 = new Potential <char>(new DetachedCycle <char>(new Path <char>('B', 'C', 'E', 'B')), +1) .AddCycle(new DetachedCycle <char>(new Path <char>('A', 'B', 'C', 'A')), -1) .AddCycle(new DetachedCycle <char>(new Path <char>('B', 'D', 'E', 'B')), -1); var potential2 = new Potential <char>(new DetachedCycle <char>(new Path <char>('B', 'C', 'E', 'B')), +1) .AddCycle(new DetachedCycle <char>(new Path <char>('A', 'B', 'C', 'A')), -1) .AddCycle(new DetachedCycle <char>(new Path <char>('C', 'E', 'F', 'C')), -1); var qp1 = new QuiverWithPotential <char>(potential1); var vertices2 = new char[] { 'A', 'B', 'C', 'D', 'E', 'F' }; var arrows2 = new Arrow <char>[] { new Arrow <char>('A', 'B'), new Arrow <char>('B', 'C'), new Arrow <char>('B', 'D'), new Arrow <char>('C', 'A'), new Arrow <char>('C', 'E'), new Arrow <char>('D', 'E'), new Arrow <char>('E', 'B'), new Arrow <char>('E', 'F'), new Arrow <char>('F', 'C'), }; var quiver2 = new Quiver <char>(vertices2, arrows2); var qp2 = new QuiverWithPotential <char>(quiver2, potential2); var checker = new QPIsomorphismChecker(); Assert.That(checker.AreIsomorphic(qp1, qp2), Is.False); }
public void Vertices_TypicalCase() { var vertices = new int[] { 1, 2, 3, 4, 5 }; var arrows = new Arrow <int>[] { new Arrow <int>(1, 2), new Arrow <int>(2, 3), new Arrow <int>(3, 1), new Arrow <int>(3, 2), new Arrow <int>(3, 3), new Arrow <int>(3, 4), new Arrow <int>(3, 5) }; var quiver = new Quiver <int>(vertices, arrows); Assert.That(quiver.Vertices, Is.EquivalentTo(vertices)); }
/// <summary> /// /// </summary> /// <typeparam name="TVertex">The type of the vertices in the quiver.</typeparam> /// <param name="quiver">The quiver.</param> /// <param name="startingVertex">The starting vertex of the paths to look at.</param> /// <param name="transformationRuleTree"></param> /// <returns>The state of the search after it is done.</returns> private AnalysisStateForSingleStartingVertex <TVertex> DoSearchInPathTree <TVertex>( Quiver <TVertex> quiver, TVertex startingVertex, TransformationRuleTreeNode <TVertex> transformationRuleTree, MaximalNonzeroEquivalenceClassRepresentativeComputationSettings settings) where TVertex : IEquatable <TVertex>, IComparable <TVertex> { // Set up for analysis/graph search var state = new AnalysisStateForSingleStartingVertex <TVertex>(startingVertex); // Analysis/graph search // Keep a stack of "recently equivalence-class-computed" nodes // In every iteration, pop a node from the stack and determine the equivalence classes // of its child nodes. // It would be cleaner to in every iteration determine the equivalence class of the // *current* node and enqueue its child nodes (in other words, to have the queue // contain nodes whose equivalence classes to explore), but this makes it non-trivial // to keep track of the maximal nonzero equivalence classes while (state.Stack.Count > 0) { var node = state.Stack.Pop(); bool isMaximalNonzero = true; foreach (var nextVertex in quiver.AdjacencyLists[node.Vertex]) { var child = state.GetInsertChildNode(node, nextVertex); if (DoPathLengthCheck(child, state, settings) == PathLengthCheckResult.TooLongPath) { state.TooLongPathEncountered = true; return(state); } var equivClassResult = DetermineEquivalenceClass(child, state, transformationRuleTree, settings); if (equivClassResult == EquivalenceClassResult.Nonzero) { isMaximalNonzero = false; state.Stack.Push(child); } else if (equivClassResult == EquivalenceClassResult.TooLongPath) { state.TooLongPathEncountered = true; return(state); } } if (isMaximalNonzero) { var representative = state.EquivalenceClasses.FindSet(node); if (!state.maximalPathRepresentatives.Contains(representative)) { state.maximalPathRepresentatives.Add(representative); } } } return(state); }
public override void initialize(int characterID, GameObject gameManager) { base.initialize(characterID, gameManager); bow.Initialize(); currentMovementSpeed = defaultMovespeed; quiver = new Quiver(); quiver.Initialize(7, this.gameObject); quiver.addArrow(ArrowType.FireArrow, 3); quiver.addArrow(ArrowType.IceArrow, 3); quiver.addArrow(ArrowType.ForceArrow, 3);; }
public override void initialize(int characterID, GameObject gameManager) { base.initialize (characterID, gameManager); bow.Initialize (); currentMovementSpeed = defaultMovespeed; quiver = new Quiver (); quiver.Initialize (7, this.gameObject); quiver.addArrow (ArrowType.FireArrow, 3); quiver.addArrow (ArrowType.IceArrow, 3); quiver.addArrow (ArrowType.ForceArrow, 3);; }
/// <summary> /// Essentially <see cref="ComputeMaximalNonzeroEquivalenceClassRepresentativesStartingAt"/> /// but with a more detailed, implementation-specific return value. /// </summary> /// <typeparam name="TVertex"></typeparam> /// <param name="quiver"></param> /// <param name="startingVertex"></param> /// <param name="transformationRuleTree"></param> /// <param name="settings"></param> /// <returns></returns> private AnalysisResultsForSingleStartingVertex <TVertex> AnalyzeWithStartingVertex <TVertex>( Quiver <TVertex> quiver, TVertex startingVertex, TransformationRuleTreeNode <TVertex> transformationRuleTree, MaximalNonzeroEquivalenceClassRepresentativeComputationSettings settings) where TVertex : IEquatable <TVertex>, IComparable <TVertex> { // Parameter validation if (quiver is null) { throw new ArgumentNullException(nameof(quiver)); } if (!quiver.Vertices.Contains(startingVertex)) { throw new ArgumentException($"The quiver does not contain the starting vertex {startingVertex}."); } if (transformationRuleTree is null) { throw new ArgumentNullException(nameof(transformationRuleTree)); } if (settings is null) { throw new ArgumentNullException(nameof(settings)); } // Do search in the tree of all paths starting at startingVertex AnalysisStateForSingleStartingVertex <TVertex> state = DoSearchInPathTree(quiver, startingVertex, transformationRuleTree, settings); // Do cancellativity check bool shouldDoCancellativityFailureDetection = settings.DetectCancellativityFailure && !state.TooLongPathEncountered; bool cancellativityFailureDetected = shouldDoCancellativityFailureDetection ? DetectFailureOfCancellativity(state) : false; bool shouldDoWeakCancellativityFailureDetection = settings.DetectWeakCancellativityFailure && !state.TooLongPathEncountered; bool weakCancellativityFailureDetected = shouldDoWeakCancellativityFailureDetection ? DetectFailureOfWeakCancellativity(state) : false; var cancellativityFailuresDetected = CancellativityTypes.None; if (cancellativityFailureDetected) { cancellativityFailuresDetected |= CancellativityTypes.Cancellativity; } if (weakCancellativityFailureDetected) { cancellativityFailuresDetected |= CancellativityTypes.WeakCancellativity; } // Return results var results = new AnalysisResultsForSingleStartingVertex <TVertex>(state, cancellativityFailuresDetected); return(results); }
public int PhysicalAttack(Monster monster) { int attackAmount = 0; try { if (PlayerWeapon.Equipped && PlayerWeapon.WeaponGroup != WeaponType.Bow) { attackAmount = PlayerWeapon.Attack(); } if (PlayerWeapon.Equipped && PlayerWeapon.WeaponGroup == WeaponType.Bow && PlayerQuiver.HaveArrows()) { PlayerQuiver.UseArrow(); attackAmount = PlayerWeapon.Attack(); } if (PlayerWeapon.Equipped && PlayerWeapon.WeaponGroup == WeaponType.Bow && !PlayerQuiver.HaveArrows()) { Quiver.DisplayOutOfArrowsMessage(); attackAmount = 5; } } catch (NullReferenceException) { OutputHelper.Display.StoreUserOutput( Settings.FormatFailureOutputText(), Settings.FormatDefaultBackground(), "Your weapon is not equipped! Going hand to hand!"); attackAmount = 5; } foreach (IEffect effect in Effects) { if (effect is ChangePlayerDamageEffect changeEffect) { attackAmount = changeEffect.GetUpdatedDamageFromChange(attackAmount); } } foreach (IEffect effect in monster.Effects) { if (effect is FrozenEffect frozenEffect) { attackAmount = frozenEffect.GetIncreasedDamageFromFrozen(attackAmount); } } return(attackAmount); }
public void tutorialQuiver() { quiver = new Quiver (); quiver.Initialize (7, this.gameObject); quiver.addArrow (ArrowType.FireArrow, 99); quiver.addArrow (ArrowType.IceArrow, 99); quiver.addArrow (ArrowType.ForceArrow, 99); quiver.addArrow (ArrowType.TreeArrow, 99); quiver.addArrow (ArrowType.PiercingArrow, 99); quiver.addArrow (ArrowType.SplitArrow, 99); quiver.tutorialMode = true; quiverReady = true; this.transform.position = new Vector3 (this.transform.position.x, 0.1f, this.transform.position.z); }
public void tutorialQuiver() { quiver = new Quiver(); quiver.Initialize(7, this.gameObject); quiver.addArrow(ArrowType.FireArrow, 99); quiver.addArrow(ArrowType.IceArrow, 99); quiver.addArrow(ArrowType.ForceArrow, 99); quiver.addArrow(ArrowType.TreeArrow, 99); quiver.addArrow(ArrowType.PiercingArrow, 99); quiver.addArrow(ArrowType.SplitArrow, 99); quiver.tutorialMode = true; quiverReady = true; this.transform.position = new Vector3(this.transform.position.x, 0.1f, this.transform.position.z); }
public void TryExtractQP_WorksOnClockwiseCycle(int cycleLength) { const double Radius = 1000; var vertices = Enumerable.Range(1, cycleLength); var arrows = vertices.Select(k => new Arrow <int>(k, k.Modulo(cycleLength) + 1)); double baseAngle = 2 * Math.PI / cycleLength; var vertexPositions = vertices.ToDictionary(k => k, k => new Point((int)(Radius * Math.Cos(-k * baseAngle)), (int)Math.Round(Radius * Math.Sin(-k * baseAngle)))); var quiverInPlane = new QuiverInPlane <int>(vertices, arrows, vertexPositions); var extractor = CreateQPExtractor(); var result = extractor.TryExtractQP(quiverInPlane, out var qp); var expectedQuiver = new Quiver <int>(vertices, arrows); var expectedPotential = new Potential <int>(new DetachedCycle <int>(vertices.AppendElement(1)), +1); var expectedQP = new QuiverWithPotential <int>(expectedQuiver, expectedPotential); Assert.That(result, Is.EqualTo(QPExtractionResult.Success)); Assert.That(qp, Is.EqualTo(expectedQP)); }
public static void EquipInitialGear(Player player) { Weapon playerWeapon = player.Inventory.Find(item => item is Weapon) as Weapon; EquipWeapon(player, playerWeapon); List <IItem> playerArmorList = player.Inventory.FindAll(item => item is Armor); foreach (IItem playerArmor in playerArmorList) { EquipArmor(player, (Armor)playerArmor); } if (player.PlayerClass == PlayerClassType.Archer) { Quiver quiver = player.Inventory.Find(item => item is Quiver) as Quiver; EquipQuiver(player, quiver); } }
private static void UnequipQuiver(Player player, Quiver quiver) { if (!quiver.Equipped) { string alreadyUnequipString = $"You have already unequipped {quiver.Name}."; OutputHelper.Display.StoreUserOutput( Settings.FormatFailureOutputText(), Settings.FormatDefaultBackground(), alreadyUnequipString); return; } quiver.Equipped = false; string unequipString = $"You have unequipped {player.PlayerQuiver.Name}."; OutputHelper.Display.StoreUserOutput( Settings.FormatSuccessOutputText(), Settings.FormatDefaultBackground(), unequipString); player.PlayerQuiver = null; }
public override void initialize(int characterID, GameObject gameManager) { base.initialize (characterID, gameManager); bow.Initialize (); bow.instantiateRangeIndicator (this.gameObject); quiver = new Quiver (); quiver.Initialize (7, this.gameObject); controller = new Controller (); controller.Initialize (currentMovementSpeed); setMainPlayer (); quiver.addArrow (ArrowType.FireArrow, 3); quiver.addArrow (ArrowType.IceArrow, 3); quiver.addArrow (ArrowType.ForceArrow, 3); quiver.addArrow (ArrowType.TreeArrow, 3); quiver.addArrow (ArrowType.PiercingArrow, 3); quiver.addArrow (ArrowType.SplitArrow, 3); currentAmmo = ArrowType.Arrow; }
public override void initialize(int characterID, GameObject gameManager) { base.initialize(characterID, gameManager); bow.Initialize(); bow.instantiateRangeIndicator(this.gameObject); quiver = new Quiver(); quiver.Initialize(7, this.gameObject); controller = new Controller(); controller.Initialize(currentMovementSpeed); setMainPlayer(); quiver.addArrow(ArrowType.FireArrow, 3); quiver.addArrow(ArrowType.IceArrow, 3); quiver.addArrow(ArrowType.ForceArrow, 3); quiver.addArrow(ArrowType.TreeArrow, 3); quiver.addArrow(ArrowType.PiercingArrow, 3); quiver.addArrow(ArrowType.SplitArrow, 3); currentAmmo = ArrowType.Arrow; }
static void Main(string[] args) { // create instance var quiver = new Quiver(); // register objects quiver.Push <IHoge, Hoge>(); quiver.Push <IFuga, Fuga>(50); // relate objects // [syntax] <from, to> quiver.Bind <IFuga, IHoge>("Fuga"); // take the instance var v = quiver.Pull <IHoge>() as Hoge; System.Console.WriteLine(v.Fuga.Value); System.Console.WriteLine("--- end ---"); System.Console.ReadKey(); }
public override void initialize(int characterID, GameObject gameManager) { targetsInRange = new ArrayList (); primaryTarget = null; base.initialize (characterID, gameManager); bow.Initialize (); currentMovementSpeed = defaultMovespeed; anim.StopPlayback (); shotTimer = Random.Range(0.5f, 5.0f); quiver = new Quiver (); quiver.Initialize (7, this.gameObject); quiver.addArrow (ArrowType.FireArrow, 3); quiver.addArrow (ArrowType.IceArrow, 3); quiver.addArrow (ArrowType.ForceArrow, 3); quiver.addArrow (ArrowType.TreeArrow, 3); quiver.addArrow (ArrowType.PiercingArrow, 3); quiver.addArrow (ArrowType.SplitArrow, 3); this.transform.position = new Vector3 (this.transform.position.x, 0.0f, this.transform.position.z); }
public override void initialize(int characterID, GameObject gameManager) { targetsInRange = new ArrayList(); primaryTarget = null; base.initialize(characterID, gameManager); bow.Initialize(); currentMovementSpeed = defaultMovespeed; anim.StopPlayback(); shotTimer = Random.Range(0.5f, 5.0f); quiver = new Quiver(); quiver.Initialize(7, this.gameObject); quiver.addArrow(ArrowType.FireArrow, 3); quiver.addArrow(ArrowType.IceArrow, 3); quiver.addArrow(ArrowType.ForceArrow, 3); quiver.addArrow(ArrowType.TreeArrow, 3); quiver.addArrow(ArrowType.PiercingArrow, 3); quiver.addArrow(ArrowType.SplitArrow, 3); this.transform.position = new Vector3(this.transform.position.x, 0.0f, this.transform.position.z); }
/// <inheritdoc/> public MaximalNonzeroEquivalenceClassRepresentativesResults <TVertex> ComputeMaximalNonzeroEquivalenceClassRepresentativesStartingAt <TVertex>( Quiver <TVertex> quiver, TVertex startingVertex, TransformationRuleTreeNode <TVertex> transformationRuleTree, MaximalNonzeroEquivalenceClassRepresentativeComputationSettings settings) where TVertex : IEquatable <TVertex>, IComparable <TVertex> { var analysisResults = AnalyzeWithStartingVertex(quiver, startingVertex, transformationRuleTree, settings); // The .ToList() call to eagerly evaluate the maximal path representatives is really // important here; otherwise, the MaximalPathRepresentatives property of the // MaximalNonzeroEquivalenceClassRepresentativesResult prevents the entire search tree // of analysisResults from being freed. var maximalPathRepresentatives = analysisResults.MaximalPathRepresentatives.Select(node => node.Path).ToList(); var outputResults = new MaximalNonzeroEquivalenceClassRepresentativesResults <TVertex>( analysisResults.CancellativityFailuresDetected, analysisResults.TooLongPathEncountered, maximalPathRepresentatives, analysisResults.LongestPathEncountered); return(outputResults); }
private void Start() { Destroy(GameObject.Find("Main Menu Music")); // intialize camera based values _cam = Camera.main; _originParent = transform.parent; _isCrouching = false; _pAnimController = GetComponent <PlayerAnimationController>(); interactionHintText.enabled = false; _baseFOV = getCurrentData?.baseFOV ?? 60f; _cam.fieldOfView = _baseFOV; // set up mouse for FPS view Cursor.visible = false; Cursor.lockState = CursorLockMode.Locked; // end camera initialization isClimbing = false; cc = GetComponent <CharacterController>(); _blackScreen = GameObject.FindGameObjectWithTag("ScreenShift"); if (SaveManager.instance.activeSave.respawnPos != null && SaveManager.instance.activeSave.sceneName == SceneManager.GetActiveScene().name) { cc.enabled = false; transform.position = SaveManager.instance.activeSave.respawnPos; cc.enabled = true; } // initialize quiver (StandardArrow equipped first) // initialize values if new game, else grab existing // if data comes back null (it shouldn't), create new instance _myQuiver = GetComponent <Quiver>(); _SetArrowInHand(arrowPrefabs[getMyArrowType]); // set after quiver _currentData = SavedData.GetDataStoredAt(SavedData.currentSaveSlot) ?? new SavedData(); UpdateCharacterToSaveData(_currentData); //grab options preferences and set them SetOptionVals(new OptionsData(_currentData)); }
private static void EquipQuiver(Player player, Quiver quiver) { if (quiver.Equipped) { string alreadyEquipString = $"You have already equipped {quiver.Name}."; OutputHelper.Display.StoreUserOutput( Settings.FormatFailureOutputText(), Settings.FormatDefaultBackground(), alreadyEquipString); return; } if (player.PlayerQuiver != null && player.PlayerQuiver.Equipped) { UnequipQuiver(player, player.PlayerQuiver); } player.PlayerQuiver = quiver; quiver.Equipped = true; string equipString = $"You have equipped {player.PlayerQuiver.Name}."; OutputHelper.Display.StoreUserOutput( Settings.FormatSuccessOutputText(), Settings.FormatDefaultBackground(), equipString); }
public void Arrows_TypicalCase() { var vertices = new int[] { 1, 2, 3, 4, 5 }; var arrows = new Arrow <int>[] { new Arrow <int>(1, 2), new Arrow <int>(2, 3), new Arrow <int>(3, 1), new Arrow <int>(3, 2), new Arrow <int>(3, 3), new Arrow <int>(3, 4), new Arrow <int>(3, 5) }; var quiver = new Quiver <int>(vertices, arrows); var expected = new Dictionary <int, List <int> > { { 1, new List <int> { 2 } }, { 2, new List <int> { 3 } }, { 3, new List <int> { 1, 2, 3, 4, 5 } }, { 4, new List <int> { } }, { 5, new List <int> { } } }; Assert.That(quiver.AdjacencyLists, Is.EquivalentTo(expected)); }
private void Awake() { instance = this; }
public void UpgradeQuiver( int UpgradeIndex) { QuiverUpgradeIndex = UpgradeIndex; quiver = QuiverUpgrades[QuiverUpgradeIndex]; }
public void UpgradeQuiver(int UpgradeIndex) { QuiverUpgradeIndex = UpgradeIndex; quiver = QuiverUpgrades[QuiverUpgradeIndex]; player.QuiverSize = quiver.QuiverSize; }
public void UpgradeQuiver(int UpgradeIndex) { QuiverUpgradeIndex = UpgradeIndex; quiver = QuiverUpgrades[QuiverUpgradeIndex]; }
public void UpgradeQuiver( int UpgradeIndex) { QuiverUpgradeIndex = UpgradeIndex; quiver = QuiverUpgrades[QuiverUpgradeIndex]; player.QuiverSize = quiver.QuiverSize; }
public void Setup() { quiverName = "Test quiver"; quiver = new Quiver(quiverName, 30, 25); }
public ItemClass(Quiver type) { this.Type = 11; this.Id = (int)type; }
//Object movement via Physics void onTriggerEnterEvent( Collider2D col ) { if(col.gameObject.layer == 10) { if(_right) { col.gameObject.rigidbody2D.AddForce(moveColR); //Unlock Achievement SteamManager.StatsAndAchievements.Unlock_Nice_Game_Developers_Achievement(); //Play crate noise audio.PlayOneShot(clips[0], 0.45F); } else if(!_right) { col.gameObject.rigidbody2D.AddForce(moveColL); //Unlock Achievement SteamManager.StatsAndAchievements.Unlock_Nice_Game_Developers_Achievement(); //Play crate noise audio.PlayOneShot(clips[0], 0.45F); } } else if(col.gameObject.tag == "Key") { audio.PlayOneShot(clips[1], 0.7F); } else if(col.gameObject.tag == "Bow") { audio.PlayOneShot(clips[7], 0.7F); if(col.gameObject.GetComponent<CollectBow>() != null) { //Inventory add //Debug.Log("You found a bow!"); _arrowCount = GameObject.Find("Player").GetComponent<Inventory>(); _arrowCount.Arrows += 1; Debug.Log ("Your Arrow as been inventoried!!!"+_arrowCount.Arrows); //Quiver add //Debug.Log("You grabbed a bow!"); _bowCount = GameObject.Find("Player").GetComponent<Quiver>(); _bowCount.bow += 1; Debug.Log ("This is the bow count" + _bowCount.bow); //Update PlayerPrefs PlayerPrefs.SetInt("bow", _bowCount.bow); _arrowCount.InventoryOnTimer(); } else if (col.gameObject.GetComponent<CollectGoldenBow>() != null) { //Inventory add //Debug.Log("You found a bow!"); _arrowCount = GameObject.Find("Player").GetComponent<Inventory>(); _arrowCount.Arrows += 5; _arrowCount.startCollectTimer = true; Debug.Log ("Your Arrow as been inventoried!!!"+_arrowCount.Arrows); //Quiver add //Debug.Log("You grabbed a bow!"); _bowCount = GameObject.Find("Player").GetComponent<Quiver>(); _bowCount.bow += 5; Debug.Log ("This is the bow count" + _bowCount.bow); //Update PlayerPrefs PlayerPrefs.SetInt("bow", _bowCount.bow); _arrowCount.InventoryOnTimer(); } //Destroy object Destroy(col.gameObject); } else if(col.gameObject.tag == "Door") { audio.PlayOneShot(clips[2], 0.7F); } }