public IEnumerator OutOfGameTime_UpdatesOnReload( [ValueSource(nameof(RealSeconds))] double secondsOutOfGame ) { FortuneFountainSaveData fortuneFountainSaveData = FortuneFountainSaveData.NewSaveFile(nameof(OutOfGameTime_UpdatesOnReload)); //Go to the next frame and then save (to make sure we "discard" the time spent creating the save file) yield return(null); fortuneFountainSaveData.Save(false); //record the time we saved at var saveTime = FrameTime.Now; var outOfGameTime = TimeSpan.FromSeconds(secondsOutOfGame); yield return(TestUtils.WaitFor(outOfGameTime)); fortuneFountainSaveData.Reload(); //record the time we loaded at var loadTime = FrameTime.Now; //make sure that the OOG-time is the difference between loading and saving //NOTE: This value will always be slightly larger than secondsOutOfGame due to the time actually spend saving & loading, etc. Assert.That(fortuneFountainSaveData, Has.Property(nameof(fortuneFountainSaveData.OutOfGameTimeSinceLastThrow)).EqualTo(loadTime - saveTime)); }
public void TestSerializeThrowables() { const string nickName = nameof(TestSerializeThrowables); FortuneFountainSaveData fortuneFountainSaveData = FortuneFountainSaveData.NewSaveFile(nickName); for (int i = 0; i < ValuableDatabase.ValuableTypes.Length; i++) { // copying `i` into `index` inside the loop 'cus otherwise lambdas can get messed up var index = i; var karmaValue = Random.Range(1, 25); var valuableType = ValuableDatabase.ValuableTypes[index]; Log($"Grabbing a {valuableType} with a value of {karmaValue}"); fortuneFountainSaveData.Hand.AddToHand(new ThrowableValuable(valuableType, karmaValue)); fortuneFountainSaveData.Save(useReSaveDelay: false); Log($"before loading throwables:", fortuneFountainSaveData.Hand.Throwables.JoinLines()); //load the save data we created FortuneFountainSaveData loadedSaveData = FortuneFountainSaveData.Load(nickName); Log($"original SaveData:", fortuneFountainSaveData); Log($"loaded SaveData:", loadedSaveData); AssertAll.Of( () => Assert.That(loadedSaveData.ToJson(), Contains.Substring($"\"{nameof(Hand._throwables)}\":")), () => Assert.That(loadedSaveData.Hand.Throwables.Count, Is.EqualTo(index + 1)), () => Assert.That(loadedSaveData.Hand.Throwables[index] as ThrowableValuable, Has.Property(nameof(ThrowableValuable.ValuableType)).EqualTo(valuableType)), () => Assert.That(loadedSaveData.Hand.Throwables[index] as ThrowableValuable, Has.Property(nameof(ThrowableValuable.PresentValue)).EqualTo(karmaValue)) ); } }
public IEnumerator OutOfGameTime_DoesNotUpdateOnSave( [ValueSource(nameof(RealSeconds))] double secondsOutOfGame ) { FortuneFountainSaveData fortuneFountainSaveData = FortuneFountainSaveData.NewSaveFile(nameof(OutOfGameTime_DoesNotUpdateOnSave)); var outOfGameSpan = TimeSpan.FromSeconds(secondsOutOfGame); //Set the OutOfGameTimeSinceLastThrow (using reflection since the setter is private) fortuneFountainSaveData.GetType().GetProperty(nameof(FortuneFountainSaveData.OutOfGameTimeSinceLastThrow)) ?.SetValue(fortuneFountainSaveData, outOfGameSpan); Assert.That(fortuneFountainSaveData.OutOfGameTimeSinceLastThrow, Is.EqualTo(outOfGameSpan)); const int repetitions = 5; for (int rep = 0; rep < repetitions; rep++) { yield return(new WaitForSecondsRealtime(0.01f)); fortuneFountainSaveData.Save(false); Assert.That(fortuneFountainSaveData.OutOfGameTimeSinceLastThrow, Is.EqualTo(outOfGameSpan), $"[{nameof(rep)}: {rep}] The {nameof(FortuneFountainSaveData.OutOfGameTimeSinceLastThrow)} should not have changed when we {nameof(FortuneFountainSaveData.Save)}-ed!"); } }
public void ThrowEmptiesHand() { FortuneFountainSaveData fortuneFountainSaveData = SimpleSaveData(nameof(ThrowEmptiesHand)); fortuneFountainSaveData.Hand.Throw(); Assert.That(fortuneFountainSaveData.Hand.Throwables, Is.Empty); }
public void TestSerializeEmptyHand() { const string nickName = nameof(TestSerializeEmptyHand); FortuneFountainSaveData fortuneFountainSaveData = FortuneFountainSaveData.NewSaveFile(nickName); LogUtils.Log(fortuneFountainSaveData); Assert.That(fortuneFountainSaveData.ToJson(), Contains.Substring($"\"{nameof(Hand)}\": {{")); }
public void ThrowSingleRemovesThrowable() { FortuneFountainSaveData fortuneFountainSaveData = SimpleSaveData(nameof(ThrowSingleRemovesThrowable)); var toBeThrown = fortuneFountainSaveData.Hand.Throwables[0]; toBeThrown.Flick(); CollectionAssert.DoesNotContain(fortuneFountainSaveData.Hand.Throwables, toBeThrown); }
private static FortuneFountainSaveData SimpleSaveData(string nickName) { FortuneFountainSaveData fortuneFountainSaveData = new FortuneFountainSaveData(nickName); fortuneFountainSaveData.Hand.AddToHand(new ThrowableValuable(ValuableType.Coin, 10)); fortuneFountainSaveData.Hand.AddToHand(new ThrowableValuable(ValuableType.Coin, 20)); fortuneFountainSaveData.Hand.AddToHand(new ThrowableValuable(ValuableType.Coin, 30)); Assume.That(fortuneFountainSaveData.Hand.Throwables, Is.Not.Empty); return(fortuneFountainSaveData); }
public void TestInGameTimeSinceLastThrowWithoutSaving( [ValueSource(nameof(Seconds))] double secondsInGame ) { FortuneFountainSaveData fortuneFountainSaveData = FortuneFountainSaveData.NewSaveFile(nameof(TestInGameTimeSinceLastThrowWithoutSaving)); var inGameTime = TimeSpan.FromSeconds(secondsInGame); fortuneFountainSaveData.Hand.LastThrowTime = FrameTime.Now - inGameTime; Assert.That(fortuneFountainSaveData.InGameTimeSinceLastThrow, Is.InRange(inGameTime.Multiply(0.999), inGameTime.Multiply(1.001))); }
public void ThrowOneTwice() { var save1 = new FortuneFountainSaveData(nameof(ThrowOneTwice)); save1.Hand.AddToHand(new ThrowableValuable(ValuableType.Coin, 1)); save1.Hand.Throw(); Assert.That(save1.Karma, Is.EqualTo(1)); Assert.That(save1.Hand.Throwables, Is.Empty); save1.Hand.Throw(); Assert.That(save1.Karma, Is.EqualTo(1)); }
public static PrimaryKeyedList <ValuableType, PlayerValuable> GetUniformPlayerValuables( FortuneFountainSaveData saveData, double rate = 1) { var keyedList = new PrimaryKeyedList <ValuableType, PlayerValuable>(); foreach (var valuableType in ValuableDatabase.ValuableTypes) { keyedList.Add(new PlayerValuable(saveData, valuableType)); keyedList[valuableType].Rate = rate; } return(keyedList); }
public IEnumerator OutOfGameTime_MultipleSessionsWithoutThrowing() { const float sessionSeconds = 2f; const int numberOfSessions = 2; var sessionSpan = TimeSpan.FromSeconds(sessionSeconds); locations = Locations.None; FortuneFountainSaveData fortuneFountainSaveData = FortuneFountainSaveData.NewSaveFile(nameof(OutOfGameTime_MultipleSessionsWithoutThrowing)); yield return(null); fortuneFountainSaveData.Save(false); var realTimeNowAtSave = FrameTime.Now; Assert.That(fortuneFountainSaveData, Has.Property(nameof(fortuneFountainSaveData.OutOfGameTimeSinceLastThrow)).EqualTo(TimeSpan.Zero), $"We haven't waited yet, so there shouldn't be any {nameof(FortuneFountainSaveData.OutOfGameTimeSinceLastThrow)}!"); Assert.That(fortuneFountainSaveData, Has.Property(nameof(fortuneFountainSaveData.LastSaveTime)).EqualTo(realTimeNowAtSave)); var expectedOutOfGameTime = TimeSpan.Zero; for (int session = 0; session < numberOfSessions; session++) { yield return(TestUtils.WaitForRealtime(sessionSpan)); fortuneFountainSaveData.Reload(); var realTimeNowAtReload = FrameTime.Now; Assert.That(realTimeNowAtReload, Is.Not.EqualTo(realTimeNowAtSave)); var frameTimeDuration = realTimeNowAtReload - realTimeNowAtSave; expectedOutOfGameTime += frameTimeDuration; Assert.That( fortuneFountainSaveData, Has.Property(nameof(fortuneFountainSaveData.OutOfGameTimeSinceLastThrow)) .EqualTo(expectedOutOfGameTime) ); yield return(TestUtils.WaitForRealtime(sessionSpan)); fortuneFountainSaveData.Save(false); realTimeNowAtSave = FrameTime.Now; } }
public void TestFirstValuableEnabledOnNewSave() { const string nickName = nameof(TestFirstValuableEnabledOnNewSave); var fortuneFountainSaveData = FortuneFountainSaveData.NewSaveFile(nickName); const ValuableType expectedFirstValuableType = 0; Assert.That(fortuneFountainSaveData.PlayerValuables, Has.Some.Property(nameof(PlayerValuable.ValuableType)).EqualTo(expectedFirstValuableType), $"The new save file didn't contain PlayerValuable type 0 ({expectedFirstValuableType})!"); Assert.That(fortuneFountainSaveData.PlayerValuables.Count, Is.EqualTo(1), "The save file contained extra player valuables!"); }
public IEnumerator TestCompleteButUncheckedGenDuringPreviousSession( [Values(4)] int uniformValuableGenerationRate, [Values(2)] int itemsPerWait ) { GameManager.SaveData = FortuneFountainSaveData.NewSaveFile(nameof(TestCompleteButUncheckedGenDuringPreviousSession)); //Set the uniform gen rates to a decent number, so that we don't have to wait very long to get meaningful results GameManager.SaveData.PlayerValuables = TestData.GetUniformPlayerValuables(GameManager.SaveData, uniformValuableGenerationRate); var genInterval = GameManager.SaveData.PlayerValuables[0].GenerateInterval; float genWait = (float)genInterval.TotalSeconds; //Create the generation counters var genCounters = CreateValuableGenerationCounters(GameManager.SaveData.PlayerValuables); //Wait long enough to generate something (but DON'T check for it) yield return(new WaitForSecondsRealtime(genWait * itemsPerWait)); //Save the game - still without checking for any generation GameManager.SaveData.Save(false); //Wait long enough that we COULD have generated something if we were playing; then reload yield return(new WaitForSecondsRealtime(genWait * itemsPerWait)); GameManager.SaveData.Reload(); //Wait long enough to generate something during THIS session as well yield return(new WaitForSecondsRealtime(genWait * itemsPerWait)); //Make sure that we still haven't generated anything, and that that LastGenerationTime values haven't changed Assert.That(genCounters, Has.All.Values().EqualTo(new ValuableGenerationCounter() { Amount = 0, Events = 0 })); //Check for generation var itemsGenerated = GameManager.SaveData.PlayerValuables.CheckGenerate(); //Assert that we've now had exactly 1 generation event, where we generated 2 * itemsPerWait Assert.That(genCounters, Has.All.Values().EqualTo(new ValuableGenerationCounter() { Amount = 2 * itemsPerWait, Events = 1 })); Assert.That(itemsGenerated, Has.All.EqualTo(2 * itemsPerWait)); }
public IEnumerator LastThrowTime() { FortuneFountainSaveData fortuneFountainSaveData = new FortuneFountainSaveData(nameof(LastThrowTime)); Assert.That(fortuneFountainSaveData.Hand.LastThrowTime, Is.EqualTo(FrameTime.Now)); var initialTime = fortuneFountainSaveData.Hand.LastThrowTime; yield return(new WaitForSecondsRealtime(0.001f)); fortuneFountainSaveData.Hand.Throw(); Assert.That(fortuneFountainSaveData.Hand.LastThrowTime, Is.EqualTo(FrameTime.Now)); Assert.That(fortuneFountainSaveData.Hand.LastThrowTime, Is.Not.EqualTo(initialTime)); }
public void TestGenerateInterval( [ValueSource(nameof(rates))] double rateInItemsPerSecond ) { var saveData = new FortuneFountainSaveData(nameof(TestGenerateInterval)); var pv = new PlayerValuable(saveData, ValuableType.Coin) { Rate = rateInItemsPerSecond }; Assert.That(TimeSpan.FromSeconds(1).Divide(pv.GenerateInterval), Is.InRange(Math.Floor(rateInItemsPerSecond), rateInItemsPerSecond * 1.00001)); Assert.That(pv.GenerateInterval, Is.EqualTo(TimeSpan.FromTicks((long)(TimeSpan.TicksPerSecond / rateInItemsPerSecond)))); }
public void ThrowResetsOutOfGameTime() { FortuneFountainSaveData fortuneFountainSaveData = UglySaveData(nameof(ThrowResetsOutOfGameTime)); var outOfGameSpan = TimeSpan.FromDays(500); ReflectionUtils.SetVariableValue(fortuneFountainSaveData, nameof(fortuneFountainSaveData.OutOfGameTimeSinceLastThrow), outOfGameSpan); Assert.That(fortuneFountainSaveData, Has.Property(nameof(fortuneFountainSaveData.OutOfGameTimeSinceLastThrow)).EqualTo(outOfGameSpan)); fortuneFountainSaveData.Hand.Throw(); Assert.That(fortuneFountainSaveData, Has.Property(nameof(fortuneFountainSaveData.OutOfGameTimeSinceLastThrow)).EqualTo(TimeSpan.Zero)); }
public void PostThrowSingleKarma() { FortuneFountainSaveData fortuneFountainSaveData = UglySaveData(nameof(PostThrowSingleKarma)); double expectedKarmaTotal = 0; var throwablesCopy = fortuneFountainSaveData.Hand.ThrowableValuables.Copy(); foreach (var throwable in throwablesCopy) { expectedKarmaTotal += throwable.PresentValue; throwable.Flick(); Assert.That(fortuneFountainSaveData.Karma, Is.EqualTo(expectedKarmaTotal)); } }
/// <summary> /// "Starts" the game, doing things such as loading the appropriate save file. /// </summary> private void LoadFortuneFountain() { SaveFileName = GetAppropriateSaveFileName(); if (Application.isEditor && ClearDevSaveFileOnPlay) { ClearDevSaveFile(); } //attempt to load the save data; if we can't, create a new one if (!FortuneFountainSaveData.TryLoad(SaveFileName, out SaveData)) { LogUtils.Log($"No save file exists with the {nameof(FortuneFountainSaveData.Nickname)} {SaveFileName}, so we're creating a new one..."); SaveData = FortuneFountainSaveData.NewSaveFile(SaveFileName); } LogUtils.Log(SaveData); }
public void ThrowResetsGenerateTimeUtilized() { FortuneFountainSaveData fortuneFountainSaveData = FortuneFountainSaveData.NewSaveFile(nameof(ThrowResetsGenerateTimeUtilized)); fortuneFountainSaveData.PlayerValuables = TestData.GetUniformPlayerValuables(fortuneFountainSaveData); var utilizedTime = TimeSpan.FromSeconds(1); fortuneFountainSaveData.PlayerValuables.ForEach(it => it.GenerateTimeUtilized = utilizedTime); Assert.That(fortuneFountainSaveData.PlayerValuables, Has.All.Property(nameof(PlayerValuable.GenerateTimeUtilized)).EqualTo(utilizedTime)); fortuneFountainSaveData.Hand.Throw(); Assert.That(fortuneFountainSaveData.PlayerValuables, Has.All.Property(nameof(PlayerValuable.GenerateTimeUtilized)).EqualTo(TimeSpan.Zero)); }
public void TestGenerateIsLimitedByRate() { const string nickName = nameof(TestGenerateIsLimitedByRate); GameManager.SaveData = FortuneFountainSaveData.NewSaveFile(nickName); var generateCounter = 0; PlayerValuable.GeneratePlayerValuableEvent += (valuable, amount) => generateCounter++; LogUtils.Log(GameManager.SaveData.PlayerValuables[0]); LogUtils.Log(JsonConvert.SerializeObject(GameManager.SaveData.PlayerValuables[0])); for (var i = 0; i < 10; i++) { GameManager.SaveData.PlayerValuables.CheckGenerate(); Assert.That(generateCounter, Is.EqualTo(0), $"Error on {i + 1}th generation!"); } }
public IEnumerator EventSubscribersPersistAfterReloadMultiple() { GameManager.SaveData = FortuneFountainSaveData.NewSaveFile(nameof(EventSubscribersPersistAfterReloadMultiple)); var eventWasTriggered = false; PlayerValuable.GeneratePlayerValuableEvent += (valuable, amount) => eventWasTriggered = true; yield return(new WaitForSecondsRealtime((float)GameManager.SaveData.PlayerValuables[0].GenerateInterval .TotalSeconds)); GameManager.SaveData.Save(false); GameManager.SaveData.Reload(); GameManager.SaveData.Reload(); GameManager.SaveData.Reload(); GameManager.SaveData.PlayerValuables.CheckGenerate(); Assert.True(eventWasTriggered); }
public void TestSimpleGeneration(double rate, double secondsSinceLastGenerateCheckAndThrow) { GameManager.SaveData = FortuneFountainSaveData.NewSaveFile(nameof(TestSimpleGeneration)); var startTime = FrameTime.Now.AddSeconds(-secondsSinceLastGenerateCheckAndThrow); GameManager.SaveData.PlayerValuables = TestData.GetUniformPlayerValuables(GameManager.SaveData, rate); GameManager.SaveData.Hand.LastThrowTime = startTime; GameManager.SaveData.LastLoadTime = startTime; ReflectionUtils.SetVariableValue(GameManager.SaveData, nameof(GameManager.SaveData.LastSaveTime), startTime); GameManager.SaveData.PlayerValuables.ForEach(it => it.LastGenerateCheckTime = startTime); var generatedItems = GameManager.SaveData.PlayerValuables.CheckGenerate(TimeSpan.MaxValue); //TODO: This test probably needs to be revisited so that this can be a cleaner assertion var expectedItemsGenerated = secondsSinceLastGenerateCheckAndThrow * rate; AssertAll.Of( generatedItems, Has.All.EqualTo(generatedItems[0]), Is.All.InRange(expectedItemsGenerated.Floor(), expectedItemsGenerated.Ceiling()) ); }
public IEnumerator TestPartialUncheckedItemsGeneratedDuringLastSession( [Values(0.5)] double previousGenIntervals, [Values(3)] double totalItemsToGenerate ) { Assume.That(previousGenIntervals, Is.LessThan(1)); Assume.That(totalItemsToGenerate, Is.GreaterThan(previousGenIntervals)); GameManager.SaveData = FortuneFountainSaveData.NewSaveFile(nameof(TestPartialUncheckedItemsGeneratedDuringLastSession)); GameManager.SaveData.PlayerValuables = TestData.GetUniformPlayerValuables(GameManager.SaveData); yield return(TestUtils.WaitForRealtime(GameManager.SaveData.PlayerValuables[0].GenerateInterval, previousGenIntervals)); GameManager.SaveData.Save(false); var genCounters = CreateValuableGenerationCounters(GameManager.SaveData.PlayerValuables); yield return(TestUtils.WaitForRealtime(GameManager.SaveData.PlayerValuables[0].GenerateInterval, 2)); GameManager.SaveData.Reload(); var sleepIntervals = totalItemsToGenerate - previousGenIntervals + 0.5; LogUtils.Log($"{nameof(sleepIntervals)} = {sleepIntervals}"); yield return(TestUtils.WaitForRealtime(GameManager.SaveData.PlayerValuables[0].GenerateInterval, sleepIntervals)); var itemsGenerated = GameManager.SaveData.PlayerValuables.CheckGenerate(); Assert.That(itemsGenerated, Has.All.EqualTo(totalItemsToGenerate)); Assert.That(genCounters, Has.All.Values().EqualTo(new ValuableGenerationCounter() { Amount = (int)totalItemsToGenerate, Events = 1 })); }
public void PostThrowHandKarma() { FortuneFountainSaveData fortuneFountainSaveData = UglySaveData(nameof(PostThrowHandKarma)); AssertAll.Of( () => Assert.That(fortuneFountainSaveData.Karma, Is.EqualTo(0)), () => Assert.That(fortuneFountainSaveData.Hand.Throwables, Is.Not.Empty) ); var expectedPostThrowKarma = fortuneFountainSaveData.Hand.KarmaInHand; LogUtils.Log( $"Before throwing, there is {fortuneFountainSaveData.Karma} karma", $"In my hand, there is {fortuneFountainSaveData.Hand.KarmaInHand} karma" ); fortuneFountainSaveData.Hand.Throw(); AssertAll.Of( () => Assert.That(fortuneFountainSaveData.Karma, Is.EqualTo(expectedPostThrowKarma)), () => Assert.That(fortuneFountainSaveData.Hand.Throwables, Is.Empty) ); }
private static FortuneFountainSaveData UglySaveData([NotNull] string nickName) { var throwables = new List <Throwable>() { new ThrowableValuable(ValuableType.Coin, 10), new ThrowableValuable(ValuableType.Fiduciary, 54), new ThrowableValuable(ValuableType.Coin, 87), new ThrowableValuable(ValuableType.Gem, 98), new ThrowableValuable(ValuableType.Livestock, 12341435), new ThrowableValuable(ValuableType.Collectible, 7845687), new ThrowableValuable(ValuableType.Metal, 0), new ThrowableValuable(ValuableType.Scrip, -123), new ThrowableValuable(ValuableType.Coin, 1.5), new ThrowableValuable(ValuableType.Scrip, Math.PI), new ThrowableValuable(ValuableType.Fiduciary, Math.E), new ThrowableValuable(ValuableType.Fiduciary, -238475.52349578), }; FortuneFountainSaveData fortuneFountainSaveData = new FortuneFountainSaveData(nickName) { Hand = { _throwables = throwables } }; fortuneFountainSaveData.Hand.FixHierarchy(); AssertAll.Of( fortuneFountainSaveData.Hand.Throwables, Is.Not.Empty, Has.All.Property(nameof(Throwable.MyHand)).EqualTo(fortuneFountainSaveData.Hand) ); return(fortuneFountainSaveData); }
public void GrabValuable() { FortuneFountainSaveData fortuneFountainSaveData = new FortuneFountainSaveData(nameof(GrabValuable)); foreach (var valuableType in ValuableDatabase.ValuableTypes) { //assert that it doesn't contain the item before we grab it var heldValuableTypes = fortuneFountainSaveData.Hand.Throwables.Select(it => it as ThrowableValuable) .Where(it => it != null) .Select(it => it.ValuableType); Assert.That(heldValuableTypes, Has.None.EqualTo(valuableType)); //grab the item fortuneFountainSaveData.Hand.AddToHand(new ThrowableValuable(valuableType, 10)); //assert that we're now holding it Assert.That( fortuneFountainSaveData.Hand.Throwables.Select(it => it as ThrowableValuable) .Where(it => it != null) .Select(it => it.ValuableType), Has.Some.EqualTo(valuableType) ); } }
public IEnumerator OutOfGameTime_UpdatesOnLoad( [ValueSource(nameof(RealSeconds))] double secondsOutOfGame ) { FortuneFountainSaveData fortuneFountainSaveData = FortuneFountainSaveData.NewSaveFile(nameof(OutOfGameTime_UpdatesOnLoad)); yield return(null); fortuneFountainSaveData.Save(false); var saveTime = FrameTime.Now; var outOfGameSpan = TimeSpan.FromSeconds(secondsOutOfGame); yield return(TestUtils.WaitForRealtime(outOfGameSpan)); var loadedSaveData = FortuneFountainSaveData.Load(fortuneFountainSaveData.Nickname); var loadTime = FrameTime.Now; Assert.That(loadedSaveData, Has.Property(nameof(loadedSaveData.OutOfGameTimeSinceLastThrow)).EqualTo(loadTime - saveTime)); }
private void ClearDevSaveFile() { FortuneFountainSaveData.Delete(DevSaveFileName); }
public void GenerateEventsLimitedByMaxGenerateTime( double generateTimeLimitInSeconds, double itemsPerSecond, double extraGenerationSeconds ) { //the number of items we expect to generate - which should always be limited by maxGenerationSeconds var expectedItemsGenerated = generateTimeLimitInSeconds * itemsPerSecond; Ignore.Unless( () => Assume.That(generateTimeLimitInSeconds, Is.GreaterThan(0), $"{nameof(generateTimeLimitInSeconds)} must be greater than 0!"), () => Assume.That(itemsPerSecond, Is.GreaterThan(0), $"{nameof(itemsPerSecond)} must be greater than 0!"), () => Assume.That(extraGenerationSeconds, Is.GreaterThanOrEqualTo(0), $"{nameof(extraGenerationSeconds)} must be positive!"), () => Assume.That(expectedItemsGenerated, Is.GreaterThanOrEqualTo(1), $"{nameof(expectedItemsGenerated)} must be at least 1!") ); //this test is very quick and runs a LOT of times, so we should disable logging to prevent it from being crazy slow // LogUtils.locations = LogUtils.Locations.None; const string nickName = nameof(GenerateEventsLimitedByMaxGenerateTime); GameManager.SaveData = FortuneFountainSaveData.NewSaveFile(nickName); //Setting up the player data GameManager.SaveData.PlayerValuables = TestData.GetUniformPlayerValuables(GameManager.SaveData, itemsPerSecond); GameManager.SaveData.Hand.LastThrowTime = FrameTime.Now - TimeSpan.FromSeconds(generateTimeLimitInSeconds + extraGenerationSeconds); GameManager.SaveData.PlayerValuables.ForEach(it => it.LastGenerateCheckTime = GameManager.SaveData.Hand.LastThrowTime); GameManager.SaveData.Hand.GenerateTimeLimit = TimeSpan.FromSeconds(generateTimeLimitInSeconds); Assert.That(GameManager.SaveData.PlayerValuables[0].GenerateInterval, Is.LessThanOrEqualTo(GameManager.SaveData.Hand.GenerateTimeLimit), $"We must have enough time to generate at least one item - i.e. {nameof(PlayerValuable.GenerateInterval)} <= {nameof(Hand.GenerateTimeLimit)}!"); var genCounters = CreateValuableGenerationCounters(GameManager.SaveData.PlayerValuables); //Generate the items GameManager.SaveData.PlayerValuables.CheckGenerate(); //Check for the proper number of events & actual items generated AssertAll.Of( () => Assert.That( GroupThrowables(GameManager.SaveData.Hand.Throwables), Has.All.Values().With.Count.InRange(Math.Floor(expectedItemsGenerated), Math.Ceiling(expectedItemsGenerated)) ), () => Assert.That(genCounters, Has.All.Values().With.Property(nameof(ValuableGenerationCounter.Events)).EqualTo(1)), () => Assert.That(genCounters, Has.All.Values().With.Property(nameof(ValuableGenerationCounter.Amount)) .InRange(Math.Floor(expectedItemsGenerated), Math.Ceiling(expectedItemsGenerated))) ); }
public IEnumerator GenerateAllViaCollectionExtension( [Values(true, false)] bool checkThrowables ) { const string nickName = nameof(TestGenerateIsLimitedByRate); GameManager.SaveData = FortuneFountainSaveData.NewSaveFile(nickName); GameManager.SaveData.PlayerValuables = TestData.GetUniformPlayerValuables(GameManager.SaveData); Assume.That(GameManager.SaveData.PlayerValuables.Count, Is.GreaterThan(1), "We need to test more than 1 valuable type!"); Assume.That(GameManager.SaveData.PlayerValuables, Has.All.Property("Rate").EqualTo(1), "All valuables should have a generation rate of 1!"); //Add counter events for each of the valuables var generateCounters = CreateValuableGenerationCounters(GameManager.SaveData.PlayerValuables); //Set the LastGenerateTime for each valuable to be their previous interval (that way, they are ready to generate) var setTime = FrameTime.Now - GameManager.SaveData.PlayerValuables[0].GenerateInterval; GameManager.SaveData.Hand.LastThrowTime = setTime; GameManager.SaveData.PlayerValuables.ForEach(it => it.LastGenerateCheckTime = setTime); if (checkThrowables) { Assert.That(GameManager.SaveData.Hand.Throwables.Count, Is.EqualTo(0)); } //Generate stuff GameManager.SaveData.PlayerValuables.CheckGenerate(); Assert.That(generateCounters, Has.All.Values().EqualTo(new ValuableGenerationCounter() { Events = 1, Amount = 1 })); if (checkThrowables) { Assert.That(GameManager.SaveData.Hand.Throwables.Count, Is.EqualTo(generateCounters.Sum(it => it.Value.Amount))); } //sleep so we can expect to generate another item yield return(TestUtils.WaitForRealtime(GameManager.SaveData.PlayerValuables[0].GenerateInterval)); //Generate stuff GameManager.SaveData.PlayerValuables.CheckGenerate(); Assert.That(generateCounters, Has.All.Values().EqualTo(new ValuableGenerationCounter() { Events = 2, Amount = 2 })); if (checkThrowables) { Assert.That(GameManager.SaveData.Hand.Throwables.Count, Is.EqualTo(generateCounters.Sum(it => it.Value.Amount))); } //sleep so that we can expect to generate _2_ more items yield return (TestUtils.WaitForRealtime(GameManager.SaveData.PlayerValuables[0].GenerateInterval.Multiply(2))); //Generate stuff GameManager.SaveData.PlayerValuables.CheckGenerate(); Assert.That(generateCounters, Has.All.Values().EqualTo(new ValuableGenerationCounter() { Events = 3, Amount = 4 })); if (checkThrowables) { Assert.That(GameManager.SaveData.Hand.Throwables, Has.Property(nameof(Hand.Throwables.Count)).EqualTo(generateCounters.Sum(it => it.Value.Amount))); } }