Beispiel #1
0
        private static TradeEntry <PK8> GetTestTrade(TradeQueueInfo <PK8> info, int tag)
        {
            var trade = GetTestTrade(tag);

            trade.Trade.Notifier.OnFinish = r => RemoveAndCheck(info, trade, r);
            return(trade);
        }
Beispiel #2
0
        private static void RemoveAndCheck(TradeQueueInfo <PK8> info, TradeEntry <PK8> trade, PokeRoutineExecutor routine)
        {
            var result = info.Remove(trade);

            result.Should().BeTrue();
            routine.Should().NotBeNull();
        }
Beispiel #3
0
        private static void RemoveAndCheck <T>(TradeQueueInfo <T> info, TradeEntry <T> trade, PokeRoutineExecutorBase routine) where T : PKM, new()
        {
            var result = info.Remove(trade);

            result.Should().BeTrue();
            routine.Should().NotBeNull();
        }
Beispiel #4
0
        private static TradeEntry <T> GetTestTrade <T>(TradeQueueInfo <T> info, int tag, bool favor = false) where T : PKM, new()
        {
            var trade = GetTestTrade <T>(tag, favor);

            trade.Trade.Notifier.OnFinish = r => RemoveAndCheck(info, trade, r);
            return(trade);
        }
Beispiel #5
0
        public void TestFavortism()
        {
            var settings = new PokeTradeHubConfig();
            var hub      = new PokeTradeHub <PK8>(settings);
            var info     = new TradeQueueInfo <PK8>(hub);
            var queue    = info.Hub.Queues.GetQueue(PokeRoutineType.LinkTrade);

            const int count = 100;

            // Enqueue a bunch
            for (int i = 0; i < count; i++)
            {
                var s = GetTestTrade(info, i + 1);
                var r = info.AddToTradeQueue(s, s.UserID);
                r.Should().Be(QueueResultAdd.Added);
            }

            queue.Count.Should().Be(count);

            var f = settings.Favoritism;

            f.Mode     = FavoredMode.Exponent;
            f.Multiply = 0.4f;
            f.Exponent = 0.777f;

            // Enqueue some favorites
            for (int i = 0; i < count / 10; i++)
            {
                var s = GetTestTrade(info, count + i + 1, true);
                var r = info.AddToTradeQueue(s, s.UserID);
                r.Should().Be(QueueResultAdd.Added);
            }

            int expectedPosition = (int)Math.Ceiling(Math.Pow(count, f.Exponent));

            for (int i = 0; i < expectedPosition; i++)
            {
                queue.TryDequeue(out var detail, out _);
                detail.IsFavored.Should().Be(false);
            }

            {
                queue.TryDequeue(out var detail, out _);
                detail.IsFavored.Should().Be(true);
            }
        }
Beispiel #6
0
        public void TradeCanceled(PokeRoutineExecutor routine, PokeTradeDetail <T> info, PokeTradeResult msg)
        {
            OnFinish?.Invoke(routine);
            Trader.SendMessageAsync($"Trade canceled: {msg}").ConfigureAwait(false);

            var hub   = new PokeTradeHub <PK8>(new PokeTradeHubConfig());
            var qInfo = new TradeQueueInfo <PK8>(hub);

            if (qInfo.Count != 0)
            {
                string gameText = $"{SysCordInstance.Settings.BotGameStatus.Replace("{0}", $"Completed Trade #{info.ID}")}";
                Context.Client.SetGameAsync(gameText).ConfigureAwait(false);
            }
            else
            {
                string gameText = $"{SysCordInstance.Settings.BotGameStatus.Replace("{0}", $"Queue is Empty")}";
                Context.Client.SetGameAsync(gameText).ConfigureAwait(false);
            }
        }
Beispiel #7
0
        public void TradeFinished(PokeRoutineExecutor routine, PokeTradeDetail <T> info, T result)
        {
            OnFinish?.Invoke(routine);
            var    tradedToUser = Data.Species;
            string message;

            var hub   = new PokeTradeHub <PK8>(new PokeTradeHubConfig());
            var qInfo = new TradeQueueInfo <PK8>(hub);

            if (qInfo.Count != 0)
            {
                string gameText = $"{SysCordInstance.Settings.BotGameStatus.Replace("{0}", $"Completed Trade #{info.ID}")}";
                Context.Client.SetGameAsync(gameText).ConfigureAwait(false);
            }
            else
            {
                string gameText = $"{SysCordInstance.Settings.BotGameStatus.Replace("{0}", $"Queue is Empty")}";
                Context.Client.SetGameAsync(gameText).ConfigureAwait(false);
            }

            if (Data.IsEgg && info.Type == PokeTradeType.EggRoll)
            {
                message = tradedToUser != 0 ? $"Trade finished. Enjoy your Mysterious egg!" : "Trade finished!";
            }
            if (Data.IsEgg && info.Type == PokeTradeType.LanRoll)
            {
                message = tradedToUser != 0 ? $"Trade finished. Enjoy your Really Illegal Egg!" : "Trade finished!";
            }
            else
            {
                message = tradedToUser != 0 ? $"Trade finished. Enjoy your {(Species)tradedToUser}!" : "Trade finished!";
            }

            Trader.SendMessageAsync(message).ConfigureAwait(false);
            if (result.Species != 0 && Hub.Config.Discord.ReturnPK8s)
            {
                Trader.SendPKMAsync(result, $"Here is what you traded me!{(info.Type != PokeTradeType.LanTrade && info.Type != PokeTradeType.LanRoll /* Don't want people thinking Showdown works on LAN */? $"\n{ReusableActions.GetFormattedShowdownText(result)}" : "")}").ConfigureAwait(false);
            }
        }
Beispiel #8
0
        public void TestEnqueue()
        {
            var hub   = new PokeTradeHub <PK8>(new PokeTradeHubConfig());
            var info  = new TradeQueueInfo <PK8>(hub);
            var queue = info.Hub.Queues.GetQueue(PokeRoutineType.LinkTrade);

            var t1 = GetTestTrade(info, 1);
            var t2 = GetTestTrade(info, 2);
            var t3 = GetTestTrade(info, 3);
            var s  = GetTestTrade(info, 4);

            var executor = new MockExecutor(new PokeBotConfig());

            // Enqueue a bunch
            var r1 = info.AddToTradeQueue(t1, t1.UserID);

            r1.Should().Be(QueueResultAdd.Added);

            var r2 = info.AddToTradeQueue(t2, t2.UserID);

            r2.Should().Be(QueueResultAdd.Added);

            var r3 = info.AddToTradeQueue(t3, t3.UserID);

            r3.Should().Be(QueueResultAdd.Added);

            // Sudo add with the same ID
            var id = t1.UserID;
            var sr = info.AddToTradeQueue(s, id);

            sr.Should().Be(QueueResultAdd.AlreadyInQueue);

            sr = info.AddToTradeQueue(s, id, true);
            sr.Should().Be(QueueResultAdd.Added);

            var dequeue = queue.TryDequeue(out var first, out uint priority);

            priority.Should().Be(PokeTradeQueue <PK8> .Tier1); // sudo
            dequeue.Should().BeTrue();
            ReferenceEquals(first, s.Trade).Should().BeTrue();

            first.Notifier.TradeInitialize(executor, first);
            first.Notifier.TradeSearching(executor, first);
            first.Notifier.TradeFinished(executor, first, new PK8 {
                Species = 777
            });

            var status = info.CheckPosition(t1.UserID, PokeRoutineType.LinkTrade);

            status.Position.Should().Be(1); // not zero indexed
            var count = info.UserCount(z => z.Type == PokeRoutineType.LinkTrade);

            count.Should().Be(3);
            queue.Count.Should().Be(3);

            dequeue = queue.TryDequeue(out var second, out priority);
            priority.Should().Be(PokeTradeQueue <PK8> .TierFree); // sudo
            dequeue.Should().BeTrue();
            ReferenceEquals(second, t1.Trade).Should().BeTrue();

            second.Notifier.TradeInitialize(executor, second);
            second.Notifier.TradeSearching(executor, second);
            second.Notifier.TradeCanceled(executor, second, PokeTradeResult.TrainerTooSlow);

            status = info.CheckPosition(t1.UserID, PokeRoutineType.LinkTrade);
            status.Position.Should().Be(-1);
            count = info.UserCount(z => z.Type == PokeRoutineType.LinkTrade);
            count.Should().Be(2);
            queue.Count.Should().Be(2);
        }