//        [Timeout(10000)]
        public async Task ResolveBackgroundEvent()
        {
            logger.Debug("ResolveBackgroundEvent - Start");
            LayoutManager layoutManager = (LayoutManager)ServiceManager.LayoutManager;
            await layoutManager.VerifyLayoutAsync(true);

            BeaconAction orgAction = layoutManager.Layout.ResolvedActions.FirstOrDefault(ra => ra.BeaconAction.Uuid == "9ded63644e424d758b0218f7c70f2473").BeaconAction;

            List <Beacon> list = new List <Beacon>()
            {
                new Beacon()
                {
                    Id1 = "7367672374000000ffff0000ffff0004", Id2 = 39178, Id3 = 30929
                }
            };
            BackgroundEngine engine = new BackgroundEngine();
            TaskCompletionSource <BeaconAction> action = new TaskCompletionSource <BeaconAction>();

            engine.BeaconActionResolved += (sender, args) =>
            {
                action.SetResult(args);
            };
            await engine.InitializeAsync();

            await engine.ResolveBeaconActionsAsync(list, OUT_OF_RANGE_DB);


            BeaconAction result = await action.Task;

            Assert.AreEqual(orgAction, result, "action not found");
            logger.Debug("ResolveBackgroundEvent - End");
        }
        public async Task ResolveMultipleAction()
        {
            logger.Debug("ResolveMultipleAction - Start");
            LayoutManager layoutManager = (LayoutManager)ServiceManager.LayoutManager;
            await layoutManager.VerifyLayoutAsync(true);

            BackgroundEngine     engine  = new BackgroundEngine();
            IList <BeaconAction> actions = new List <BeaconAction>();

            engine.BeaconActionResolved += (sender, args) =>
            {
                actions.Add(args);
            };
            List <Beacon> list = new List <Beacon>()
            {
                new Beacon()
                {
                    Id1 = "7367672374000000ffff0000ffff0003", Id2 = 48869, Id3 = 21321
                }
            };

            await engine.InitializeAsync();

            await engine.ResolveBeaconActionsAsync(list, OUT_OF_RANGE_DB);


            Assert.AreEqual(4, actions.Count, "Not 4 action found");
            logger.Debug("ResolveMultipleAction - End");
        }
        public async Task ResolveSingleActionNoResult()
        {
            logger.Debug("ResolveSingleActionNoResult - Start");
            LayoutManager layoutManager = (LayoutManager)ServiceManager.LayoutManager;
            await layoutManager.VerifyLayoutAsync(true);

            BackgroundEngine engine = new BackgroundEngine();
            TaskCompletionSource <IList <BeaconAction> > action = new TaskCompletionSource <IList <BeaconAction> >();
            IList <BeaconAction> actions = new List <BeaconAction>();

            engine.BeaconActionResolved += (sender, args) =>
            {
                actions.Add(args);
                if (actions.Count >= 3)
                {
                    action.SetResult(actions);
                }
            };
            List <Beacon> list = new List <Beacon>()
            {
                new Beacon()
                {
                    Id1 = "7367672374000000ffff0000ffff1234", Id2 = 39178, Id3 = 30929
                }
            };

            if (await Task.WhenAny(action.Task, Task.Delay(500)) == action.Task)
            {
                Assert.AreEqual(0, action.Task.Result, "Not 0 action found");
            }
            else
            {
                //timeout is fine
            }
            logger.Debug("ResolveSingleActionNoResult - End");
        }
Пример #4
0
        private Task BackgroundSearch(CancellationToken token)
        {
            Action search = () =>
            {
                UpdateMessage?.Invoke("⌛thinking...");

                var currentBoard = Board.ToBitBoard();
                var moves        = Rule.FindMoves(currentBoard);
                var bestScore    = -Constants.HighestScore - 1;
                var bestMove     = -1;
                //var moveEvalMap = new Dictionary<int, int>();
                moveMaps.Clear();
                var i = 0;
                foreach (var move in moves)
                {
                    i++;
                    if (token.IsCancellationRequested)
                    {
                        break;
                    }

                    var oppboard = Rule.MoveSwitch(currentBoard, move);

                    var own = false;
                    if (!Rule.CanMove(oppboard))
                    {
                        oppboard = oppboard.Switch();
                        own      = true;
                    }

                    var sr = BackgroundEngine.Search(oppboard, GetSearchDepth());

                    if (sr.IsTimeout)
                    {
                        sr.Move  = -1;
                        sr.Score = -Constants.HighestScore;
                    }

                    var eval = own ? sr.Score : -sr.Score;//opp's score
                    if (eval > bestScore)
                    {
                        bestScore = eval;
                        bestMove  = move;
                    }
                    moveMaps[move] = new MoveMapItem {
                        Move = sr.Move, Eval = -eval
                    };
                    var nextMovesMessage = ToMessage(moveMaps, bestMove, bestScore);
                    //moveEvalMap[move] = eval;
                    //var moveEvalResult = string.Join(",", moveEvalMap.Select(kv => $"({kv.Key.ToNotation()}:{kv.Value})"));
                    UpdateMessage?.Invoke($"[{i}/{moves.Length}] {nextMovesMessage}");
                    //Console.WriteLine($"move:{move}, score:{eval}");
                }

                if (moveMaps.Count == 0)
                {
                    if (token.IsCancellationRequested)
                    {
                        UpdateMessage?.Invoke($"canceled.");
                    }
                    else
                    {
                        UpdateMessage?.Invoke($"no moves.");
                    }
                }
                else
                {
                    var nextMovesMessage = ToMessage(moveMaps, bestMove, bestScore);
                    UpdateMessage?.Invoke(nextMovesMessage);
                }
            };

            return(Task.Run(search, token));
        }