Exemplo n.º 1
0
    private void CalculateTrajectory()
    {
        Trajectory.Clear();
        Ray        ray = new Ray(transform.position, ballRb.velocity.normalized);
        RaycastHit hit;
        bool       endOfCourt = false;
        int        sentinel   = 1000;

        while (!endOfCourt && sentinel > 0)
        {
            if (Physics.Raycast(ray, out hit))
            {
                if (hit.collider.gameObject.tag == "Wall")
                {
                    Trajectory.Add(hit.point);
                    var nextDir = Vector3.Reflect(ray.direction, hit.normal);
                    ray = new Ray(hit.point, nextDir);
                }
                else if (hit.collider.gameObject.tag == "Goal")
                {
                    Trajectory.Add(hit.point);
                    endOfCourt = true;
                }
                else
                {
                    Trajectory.Add(hit.point); // only other object is paddle, so we count as end
                    endOfCourt = true;
                }
            }

            sentinel--;
        }
    }
Exemplo n.º 2
0
    private void Update()
    {
        trajectory.Clear();

        Vector3 mousePosition = Input.mousePosition;

        mousePosition.z = 10;
        mousePosition   = Camera.main.ScreenToWorldPoint(mousePosition);

        float power = Vector3.Distance(mousePosition, transform.position);

        Vector3 direction = (mousePosition - transform.position).normalized;

        if (Input.GetMouseButton(0))
        {
            trajectory.Create(transform.position, direction * power * powerMultiplier);
        }

        if (Input.GetMouseButtonUp(0))
        {
            Instantiate(ball, transform.position, Quaternion.identity).GetComponent <Rigidbody>().AddForce(direction * power * powerMultiplier);
        }
    }
Exemplo n.º 3
0
        //POGame poGame2;
        public override PlayerTask GetMove(POGame poGame)
        {
            var player = poGame.CurrentPlayer;

            // Implement a simple Mulligan Rule
            if (player.MulliganState == Mulligan.INPUT)
            {
                List <int> mulligan = new CustomScore().MulliganRule().Invoke(player.Choice.Choices.Select(p => poGame.getGame().IdEntityDic[p]).ToList());
                return(ChooseTask.Mulligan(player, mulligan));
            }

#if DEBUG
            Console.WriteLine($"root:{GetGameHashCode(poGame)}");
#endif
            PlayerTask bestAction = null;
            if (poGame.CurrentPlayer.Options().Count == 1)
            {
                bestAction = poGame.CurrentPlayer.Options()[0];
            }
            else
            {
                stopwatchForThisTurn.Start();

                long       bestActionCode = 0;
                Trajectory trajectory     = new Trajectory();

                List <PlayerTask> taskToSimulate = new List <PlayerTask>(1);
                taskToSimulate.Add(null);
                POGame poGameRoot = poGame;

                Node root;
                long gameHashCodeRoot = GetGameHashCode(poGameRoot);
                if (!nodeHashMap.TryGetValue(gameHashCodeRoot, out root))
                {
                    root = new Node();
                    nodeHashMap.Add(gameHashCodeRoot, root);
                }

                Expand(root, poGameRoot);

                /*foreach (var child in root.edges)
                 * {
                 *      Console.WriteLine(child.actionHashCode);
                 * }*/

                long      think_time = (30 * 1000 - stopwatchForThisTurn.ElapsedMilliseconds) / Math.Max(3, 5 - movesInThisTurn);
                Stopwatch stopwatch  = new Stopwatch();
                stopwatch.Start();
                //for (int itr = 0; itr < 100; ++itr)
                while (stopwatch.ElapsedMilliseconds <= think_time)
                {
                    Node node = root;
                    poGame = poGameRoot.getCopy();
                    long gameHashCode       = gameHashCodeRoot;
                    long actionHashCodeNext = 0;
                    bool simulateResult     = true;
                    int  index = 0;
                    trajectory.Clear();

                    // traverse
                    do
                    {
                        index = Select(node);

                        /*if (index >= node.edges.Count)
                         * {
                         *      Console.WriteLine($"{index}, {node.edges.Count}, {node == root}");
                         *      Debugger.Break();
                         * }*/
                        actionHashCodeNext = node.edges[index].actionHashCode;

                        // Until the end of my own turn
                        if (actionHashCodeNext == 0)
                        {
                            trajectory.Add((node, index));
                            break;
                        }

                        taskToSimulate[0] = null;
                        foreach (PlayerTask task in poGame.CurrentPlayer.Options())
                        {
                            if (GetActionHashCode(task) == actionHashCodeNext)
                            {
                                taskToSimulate[0] = task;
                                break;
                            }
                        }
                        if (taskToSimulate[0] == null)
                        {
                            // Hash key conflict
                            return(poGame.CurrentPlayer.Options().First());

                            /*foreach (PlayerTask task in poGame.CurrentPlayer.Options())
                             * {
                             *      Console.WriteLine($"{task}, {GetActionHashCode(task)}");
                             * }
                             * Console.WriteLine("---");
                             * foreach (var edge in node.edges)
                             * {
                             *      Console.WriteLine($"{edge.task}, {edge.actionHashCode}");
                             * }
                             * poGame2 = node.poGame;
                             * Console.WriteLine(poGame2.Turn);
                             * Console.WriteLine(gameHashCode);
                             * Console.WriteLine("---");
                             * foreach (var minion in poGame.CurrentPlayer.BoardZone)
                             * {
                             *      Console.WriteLine(minion.CantAttackHeroes);
                             * }
                             * var tasks = poGame.CurrentPlayer.Options();
                             * foreach (PlayerTask task in tasks)
                             * {
                             *      Console.WriteLine($"{task}, {GetActionHashCode(task)}");
                             * }
                             * Debugger.Break();*/
                        }

                        poGame = poGame.Simulate(taskToSimulate)[taskToSimulate[0]];
                        long gameHashCodeNext = GetGameHashCode(poGame);
                        if (gameHashCode == gameHashCodeNext)
                        {
                            // loop
                            node.edges.RemoveAt(index);
                            continue;
                        }
                        gameHashCode = gameHashCodeNext;

                        trajectory.Add((node, index));

                        if (!nodeHashMap.TryGetValue(gameHashCode, out node))
                        {
                            node = new Node();
                            //node.poGame = poGame;
                            nodeHashMap.Add(gameHashCode, node);
                        }
                    } while (node.edges != null);

                    if (simulateResult == false)
                    {
                        continue;
                    }

                    if (actionHashCodeNext != 0)
                    {
#if DEBUG
                        Console.WriteLine($"expand:{gameHashCode}");
#endif
                        Expand(node, poGame);

                        float value = Simulate(node, poGame);
                        Backup(trajectory, value);
                    }
                    else
                    {
                        float value;
                        if (node.edges[index].visitCount == 0)
                        {
                            value = ScoreToValue(Score(poGame));
                        }
                        else
                        {
                            value = node.edges[index].totalValue / node.edges[index].visitCount;
                        }
                        Backup(trajectory, value);
                    }
                }
                stopwatch.Stop();
                //Console.WriteLine($"{think_time}, {root.visitCount}, {root.visitCount * 1000 / stopwatch.ElapsedMilliseconds} nps");

                // Choose the most visited node
                float best = Single.MinValue;
                foreach (Edge child in root.edges)
                {
                    if (child.visitCount >= best)
                    {
                        best           = child.visitCount;
                        bestActionCode = child.actionHashCode;
                    }
                }

                // Choose an action with a matching hash code
                foreach (PlayerTask task in poGameRoot.CurrentPlayer.Options())
                {
                    if (GetActionHashCode(task) == bestActionCode)
                    {
                        bestAction = task;
                        break;
                    }
                }
            }

            stopwatchForThisTurn.Stop();
            ++movesInThisTurn;
            if (bestAction.PlayerTaskType == PlayerTaskType.END_TURN)
            {
                //Console.WriteLine(movesInThisTurn);
                stopwatchForThisTurn.Reset();
                movesInThisTurn = 0;
                nodeHashMap.Clear();
            }

            return(bestAction);
        }