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