void RecordRunningNodeName(MyBehaviorTreeState state, MyBehaviorTreeNode node)
        {
            if (!Sandbox.Engine.Utils.MyDebugDrawSettings.DEBUG_DRAW_BOTS)
            {
                return;
            }

            m_runningActionName = "";
            if (state == MyBehaviorTreeState.RUNNING)
            {
                if (node is MyBehaviorTreeActionNode)
                {
                    MyBehaviorTreeActionNode action = (MyBehaviorTreeActionNode)node;
                    m_runningActionName = action.GetActionName();
                }
                else
                {
                    string str = node.m_runningActionName;
                    if (str.Contains(ParentName))
                    {
                        str = str.Replace(ParentName, m_name + "-");
                    }
                    m_runningActionName = str;
                }
            }
        }
Exemplo n.º 2
0
 private void RecordRunningNodeName(MyBehaviorTreeState state)
 {
     if (MyDebugDrawSettings.DEBUG_DRAW_BOTS && (state == MyBehaviorTreeState.RUNNING))
     {
         base.m_runningActionName = this.m_child.m_runningActionName;
     }
 }
        void RecordRunningNodeName(IMyBot bot, MyBehaviorTreeState state)
        {
            if (!Sandbox.Engine.Utils.MyDebugDrawSettings.DEBUG_DRAW_BOTS || !(bot is MyAgentBot))
            {
                return;
            }

            switch (state)
            {
            case MyBehaviorTreeState.RUNNING:
                (bot as MyAgentBot).LastActions.AddLastAction(m_child.m_runningActionName);
                break;

            case MyBehaviorTreeState.ERROR:
                (bot as MyAgentBot).LastActions.AddLastAction("error");
                break;

            case MyBehaviorTreeState.FAILURE:
                (bot as MyAgentBot).LastActions.AddLastAction("failure");
                break;

            case MyBehaviorTreeState.SUCCESS:
                (bot as MyAgentBot).LastActions.AddLastAction("failure");
                break;

            case MyBehaviorTreeState.NOT_TICKED:
                (bot as MyAgentBot).LastActions.AddLastAction("not ticked");
                break;
            }
        }
Exemplo n.º 4
0
        private void RecordRunningNodeName(IMyBot bot, MyBehaviorTreeState state)
        {
            if (MyDebugDrawSettings.DEBUG_DRAW_BOTS && (bot is MyAgentBot))
            {
                switch (state)
                {
                case MyBehaviorTreeState.ERROR:
                    (bot as MyAgentBot).LastActions.AddLastAction("error");
                    return;

                case MyBehaviorTreeState.NOT_TICKED:
                    (bot as MyAgentBot).LastActions.AddLastAction("not ticked");
                    return;

                case MyBehaviorTreeState.SUCCESS:
                    (bot as MyAgentBot).LastActions.AddLastAction("failure");
                    return;

                case MyBehaviorTreeState.FAILURE:
                    (bot as MyAgentBot).LastActions.AddLastAction("failure");
                    return;

                case MyBehaviorTreeState.RUNNING:
                    (bot as MyAgentBot).LastActions.AddLastAction(this.m_child.m_runningActionName);
                    return;
                }
            }
        }
        void RecordRunningNodeName(MyBehaviorTreeState state)
        {
            if (!Sandbox.Engine.Utils.MyDebugDrawSettings.DEBUG_DRAW_BOTS)
            {
                return;
            }

            if (state == MyBehaviorTreeState.RUNNING)
            {
                m_runningActionName = m_child.m_runningActionName;
            }
        }
        private MyBehaviorTreeState InvertState(MyBehaviorTreeState state)
        {
            if (state == MyBehaviorTreeState.SUCCESS)
            {
                return(MyBehaviorTreeState.FAILURE);
            }
            else if (state == MyBehaviorTreeState.FAILURE)
            {
                return(MyBehaviorTreeState.SUCCESS);
            }

            return(state);
        }
Exemplo n.º 7
0
        private MyBehaviorTreeState TickChild(IMyBot bot, MyPerTreeBotMemory botTreeMemory, MyBehaviorTreeDecoratorNodeMemory thisMemory)
        {
            bot.BotMemory.RememberNode(this.m_child.MemoryIndex);
            MyBehaviorTreeState state = this.m_child.Tick(bot, botTreeMemory);

            thisMemory.NodeState  = state;
            thisMemory.ChildState = state;
            if (state != MyBehaviorTreeState.RUNNING)
            {
                bot.BotMemory.ForgetNode();
            }
            return(state);
        }
Exemplo n.º 8
0
        public override void Construct(MyObjectBuilder_BehaviorTreeNode nodeDefinition, MyBehaviorTree.MyBehaviorTreeDesc treeDesc)
        {
            base.Construct(nodeDefinition, treeDesc);
            MyObjectBuilder_BehaviorTreeDecoratorNode node = nodeDefinition as MyObjectBuilder_BehaviorTreeDecoratorNode;

            this.m_defaultReturnValue = (MyBehaviorTreeState)((sbyte)node.DefaultReturnValue);
            this.m_decoratorLogicName = node.DecoratorLogic.GetType().Name;
            this.m_decoratorLogic     = GetDecoratorLogic(node.DecoratorLogic);
            this.m_decoratorLogic.Construct(node.DecoratorLogic);
            if (node.BTNode != null)
            {
                this.m_child = MyBehaviorTreeNodeFactory.CreateBTNode(node.BTNode);
                this.m_child.Construct(node.BTNode, treeDesc);
            }
        }
Exemplo n.º 9
0
        public override MyBehaviorTreeState Tick(IMyBot bot, MyPerTreeBotMemory botTreeMemory)
        {
            bot.BotMemory.RememberNode(this.m_child.MemoryIndex);
            if (MyDebugDrawSettings.DEBUG_DRAW_BOTS)
            {
                bot.LastBotMemory = bot.BotMemory.Clone();
            }
            MyBehaviorTreeState state = this.m_child.Tick(bot, botTreeMemory);

            botTreeMemory.GetNodeMemoryByIndex(base.MemoryIndex).NodeState = state;
            if (state != MyBehaviorTreeState.RUNNING)
            {
                bot.BotMemory.ForgetNode();
            }
            return(state);
        }
        protected MyBehaviorTreeState TryReserveAreaAroundEntity([BTParam] string areaName, [BTParam] float radius, [BTParam] int timeMs)
        {
            var logic = Bot.HumanoidLogic;
            MyBehaviorTreeState retStatus = MyBehaviorTreeState.FAILURE;

            if (logic != null)
            {
                switch (logic.ReservationStatus)
                {
                case Logic.MyReservationStatus.NONE:
                    logic.ReservationStatus   = Logic.MyReservationStatus.WAITING;
                    logic.ReservationAreaData = new MyAiTargetManager.ReservedAreaData()
                    {
                        WorldPosition    = Bot.HumanoidEntity.WorldMatrix.Translation,
                        Radius           = radius,
                        ReservationTimer = MyTimeSpan.FromMiliseconds(timeMs),
                        ReserverId       = new World.MyPlayer.PlayerId(Bot.Player.Id.SteamId, Bot.Player.Id.SerialId)
                    };
                    MyAiTargetManager.OnAreaReservationResult += AreaReservationHandler;
                    MyAiTargetManager.Static.RequestAreaReservation(areaName, Bot.HumanoidEntity.WorldMatrix.Translation, radius, timeMs, Bot.Player.Id.SerialId);
                    m_reservationTimeOut    = MySandboxGame.Static.UpdateTime + MyTimeSpan.FromSeconds(RESERVATION_WAIT_TIMEOUT_SECONDS);
                    logic.ReservationStatus = Logic.MyReservationStatus.WAITING;
                    retStatus = MyBehaviorTreeState.RUNNING;
                    break;

                case Logic.MyReservationStatus.SUCCESS:
                    retStatus = MyBehaviorTreeState.SUCCESS;
                    break;

                case Logic.MyReservationStatus.FAILURE:
                    retStatus = MyBehaviorTreeState.FAILURE;
                    break;

                case Logic.MyReservationStatus.WAITING:
                    if (m_reservationTimeOut < MySandboxGame.Static.UpdateTime)
                    {
                        retStatus = MyBehaviorTreeState.FAILURE;
                    }
                    else
                    {
                        retStatus = MyBehaviorTreeState.RUNNING;
                    }
                    break;
                }
            }
            return(retStatus);
        }
        public override void Construct(MyObjectBuilder_BehaviorTreeNode nodeDefinition, MyBehaviorTree.MyBehaviorTreeDesc treeDesc)
        {
            base.Construct(nodeDefinition, treeDesc);
            var ob = nodeDefinition as MyObjectBuilder_BehaviorTreeDecoratorNode;

            m_defaultReturnValue = (MyBehaviorTreeState)((byte)ob.DefaultReturnValue);
            m_decoratorLogicName = ob.DecoratorLogic.GetType().Name;

            m_decoratorLogic = GetDecoratorLogic(ob.DecoratorLogic);
            m_decoratorLogic.Construct(ob.DecoratorLogic);

            if (ob.BTNode != null)
            {
                m_child = MyBehaviorTreeNodeFactory.CreateBTNode(ob.BTNode);
                m_child.Construct(ob.BTNode, treeDesc);
            }
        }
Exemplo n.º 12
0
        protected MyBehaviorTreeState TryReserveAreaAroundEntity([BTParam] string areaName, [BTParam] float radius, [BTParam] int timeMs)
        {
            MyHumanoidBotLogic  humanoidLogic = this.Bot.HumanoidLogic;
            MyBehaviorTreeState fAILURE       = MyBehaviorTreeState.FAILURE;

            if (humanoidLogic != null)
            {
                switch (humanoidLogic.ReservationStatus)
                {
                case MyReservationStatus.NONE:
                {
                    humanoidLogic.ReservationStatus = MyReservationStatus.WAITING;
                    MyAiTargetManager.ReservedAreaData data = new MyAiTargetManager.ReservedAreaData {
                        WorldPosition    = this.Bot.HumanoidEntity.WorldMatrix.Translation,
                        Radius           = radius,
                        ReservationTimer = MyTimeSpan.FromMilliseconds((double)timeMs),
                        ReserverId       = new MyPlayer.PlayerId(this.Bot.Player.Id.SteamId, this.Bot.Player.Id.SerialId)
                    };
                    humanoidLogic.ReservationAreaData          = data;
                    MyAiTargetManager.OnAreaReservationResult += new Sandbox.Game.AI.MyAiTargetManager.AreaReservationHandler(this.AreaReservationHandler);
                    MyAiTargetManager.Static.RequestAreaReservation(areaName, this.Bot.HumanoidEntity.WorldMatrix.Translation, radius, (long)timeMs, this.Bot.Player.Id.SerialId);
                    this.m_reservationTimeOut       = MySandboxGame.Static.TotalTime + MyTimeSpan.FromSeconds(3.0);
                    humanoidLogic.ReservationStatus = MyReservationStatus.WAITING;
                    fAILURE = MyBehaviorTreeState.RUNNING;
                    break;
                }

                case MyReservationStatus.WAITING:
                    fAILURE = (this.m_reservationTimeOut >= MySandboxGame.Static.TotalTime) ? MyBehaviorTreeState.RUNNING : MyBehaviorTreeState.FAILURE;
                    break;

                case MyReservationStatus.SUCCESS:
                    fAILURE = MyBehaviorTreeState.SUCCESS;
                    break;

                case MyReservationStatus.FAILURE:
                    fAILURE = MyBehaviorTreeState.FAILURE;
                    break;

                default:
                    break;
                }
            }
            return(fAILURE);
        }
 private static Color GetColorByState(MyBehaviorTreeState state)
 {
     switch (state)
     {
         case MyBehaviorTreeState.ERROR:
             return Color.Bisque;
         case MyBehaviorTreeState.FAILURE:
             return Color.Red;
         case MyBehaviorTreeState.NOT_TICKED:
             return Color.White;
         case MyBehaviorTreeState.RUNNING:
             return Color.Yellow;
         case MyBehaviorTreeState.SUCCESS:
             return Color.Green;
         default:
             Debug.Fail("It shouldn't get here.");
             return Color.Black;
     }
 }
        public override MyBehaviorTreeState Tick(IMyBot bot, MyPerTreeBotMemory botTreeMemory)
        {
            var decoratorMemory = botTreeMemory.GetNodeMemoryByIndex(MemoryIndex) as MyBehaviorTreeDecoratorNodeMemory;

            if (m_child == null)
            {
                return(m_defaultReturnValue);
            }

            if (decoratorMemory.ChildState != MyBehaviorTreeState.RUNNING)
            {
                m_decoratorLogic.Update(decoratorMemory.DecoratorLogicMemory);
                if (m_decoratorLogic.CanRun(decoratorMemory.DecoratorLogicMemory))
                {
                    MyBehaviorTreeState state = TickChild(bot, botTreeMemory, decoratorMemory);
                    RecordRunningNodeName(state);
                    return(state);
                }
                else
                {
                    if (IsRunningStateSource)
                    {
                        bot.BotMemory.ProcessLastRunningNode(this);
                    }

                    botTreeMemory.GetNodeMemoryByIndex(MemoryIndex).NodeState = m_defaultReturnValue;
                    if (Sandbox.Engine.Utils.MyDebugDrawSettings.DEBUG_DRAW_BOTS && m_defaultReturnValue == MyBehaviorTreeState.RUNNING)
                    {
                        m_runningActionName = ParentName + m_decoratorLogicName;
                    }

                    return(m_defaultReturnValue);
                }
            }
            else
            {
                MyBehaviorTreeState state = TickChild(bot, botTreeMemory, decoratorMemory);
                RecordRunningNodeName(state);
                return(state);
                //return TickChild(bot, botTreeMemory, decoratorMemory);
            }
        }
Exemplo n.º 15
0
 private void SendDataToTool(IMyBot bot, MyPerTreeBotMemory botTreeMemory)
 {
     if (!this.DebugIsCurrentTreeVerified || (this.DebugLastWindowHandle.ToInt32() != this.m_toolWindowHandle.ToInt32()))
     {
         IntPtr wParam = new IntPtr(this.m_BTDataByName[this.m_botBehaviorIds[bot]].BehaviorTree.GetHashCode());
         WinApi.PostMessage(this.m_toolWindowHandle, 0x403, wParam, IntPtr.Zero);
         this.DebugIsCurrentTreeVerified = true;
         this.DebugLastWindowHandle      = new IntPtr(this.m_toolWindowHandle.ToInt32());
     }
     WinApi.PostMessage(this.m_toolWindowHandle, 0x401, IntPtr.Zero, IntPtr.Zero);
     for (int i = 0; i < botTreeMemory.NodesMemoryCount; i++)
     {
         MyBehaviorTreeState nodeState = botTreeMemory.GetNodeMemoryByIndex(i).NodeState;
         if (nodeState != MyBehaviorTreeState.NOT_TICKED)
         {
             WinApi.PostMessage(this.m_toolWindowHandle, 0x400, new IntPtr((long)((ulong)i)), new IntPtr((int)nodeState));
         }
     }
     WinApi.PostMessage(this.m_toolWindowHandle, 0x402, IntPtr.Zero, IntPtr.Zero);
 }
Exemplo n.º 16
0
        public override MyBehaviorTreeState Tick(IMyBot bot, MyPerTreeBotMemory botTreeMemory)
        {
            if (bot.ActionCollection.ReturnsRunning(this.m_actionName))
            {
                bot.BotMemory.ProcessLastRunningNode(this);
            }
            MyBehaviorTreeNodeMemory nodeMemoryByIndex = botTreeMemory.GetNodeMemoryByIndex(base.MemoryIndex);

            if (!nodeMemoryByIndex.InitCalled)
            {
                nodeMemoryByIndex.InitCalled = true;
                if (bot.ActionCollection.ContainsInitAction(this.m_actionName))
                {
                    bot.ActionCollection.PerformInitAction(bot, this.m_actionName);
                }
            }
            MyBehaviorTreeState state = bot.ActionCollection.PerformAction(bot, this.m_actionName, this.m_parameters);

            nodeMemoryByIndex.NodeState = state;
            return(state);
        }
Exemplo n.º 17
0
        private static Color GetColorByState(MyBehaviorTreeState state)
        {
            switch (state)
            {
            case MyBehaviorTreeState.ERROR:
                return(Color.Bisque);

            case MyBehaviorTreeState.NOT_TICKED:
                return(Color.White);

            case MyBehaviorTreeState.SUCCESS:
                return(Color.Green);

            case MyBehaviorTreeState.FAILURE:
                return(Color.Red);

            case MyBehaviorTreeState.RUNNING:
                return(Color.Yellow);
            }
            return(Color.Black);
        }
        void RecordRunningNodeName(MyBehaviorTreeState state, MyBehaviorTreeNode node)
        {
            if (!Sandbox.Engine.Utils.MyDebugDrawSettings.DEBUG_DRAW_BOTS)
                return;

            m_runningActionName = "";
            if (state == MyBehaviorTreeState.RUNNING)
            {
                if (node is MyBehaviorTreeActionNode)
                {
                    MyBehaviorTreeActionNode action = (MyBehaviorTreeActionNode)node;
                    m_runningActionName = action.GetActionName();
                }
                else
                {
                    string str = node.m_runningActionName;
                    if (str.Contains(ParentName))
                        str = str.Replace(ParentName, m_name + "-");
                    m_runningActionName = str;
                }
            }
        }
Exemplo n.º 19
0
 private void RecordRunningNodeName(MyBehaviorTreeState state, MyBehaviorTreeNode node)
 {
     if (MyDebugDrawSettings.DEBUG_DRAW_BOTS)
     {
         base.m_runningActionName = "";
         if (state == MyBehaviorTreeState.RUNNING)
         {
             if (node is MyBehaviorTreeActionNode)
             {
                 base.m_runningActionName = ((MyBehaviorTreeActionNode)node).GetActionName();
             }
             else
             {
                 string runningActionName = node.m_runningActionName;
                 if (runningActionName.Contains("Par_N"))
                 {
                     runningActionName = runningActionName.Replace("Par_N", this.m_name + "-");
                 }
                 base.m_runningActionName = runningActionName;
             }
         }
     }
 }
        private static Color GetColorByState(MyBehaviorTreeState state)
        {
            switch (state)
            {
            case MyBehaviorTreeState.ERROR:
                return(Color.Bisque);

            case MyBehaviorTreeState.FAILURE:
                return(Color.Red);

            case MyBehaviorTreeState.NOT_TICKED:
                return(Color.White);

            case MyBehaviorTreeState.RUNNING:
                return(Color.Yellow);

            case MyBehaviorTreeState.SUCCESS:
                return(Color.Green);

            default:
                Debug.Fail("It shouldn't get here.");
                return(Color.Black);
            }
        }
Exemplo n.º 21
0
        void RecordRunningNodeName(IMyBot bot, MyBehaviorTreeState state)
        {
            if (!Sandbox.Engine.Utils.MyDebugDrawSettings.DEBUG_DRAW_BOTS || !(bot is MyAgentBot))
                return;

            switch(state)
            {
                case MyBehaviorTreeState.RUNNING:
                    (bot as MyAgentBot).LastActions.AddLastAction(m_child.m_runningActionName);
                    break;
                case MyBehaviorTreeState.ERROR:
                    (bot as MyAgentBot).LastActions.AddLastAction("error");
                    break;
                case MyBehaviorTreeState.FAILURE:
                    (bot as MyAgentBot).LastActions.AddLastAction("failure");
                    break;
                case MyBehaviorTreeState.SUCCESS:
                    (bot as MyAgentBot).LastActions.AddLastAction("failure");
                    break;
                case MyBehaviorTreeState.NOT_TICKED:
                    (bot as MyAgentBot).LastActions.AddLastAction("not ticked");
                    break;
            }
        }
        void RecordRunningNodeName(MyBehaviorTreeState state)
        {
            if (!Sandbox.Engine.Utils.MyDebugDrawSettings.DEBUG_DRAW_BOTS)
                return;

            if (state == MyBehaviorTreeState.RUNNING)
                m_runningActionName = m_child.m_runningActionName;
        }
Exemplo n.º 23
0
        public MyBehaviorTreeState TryReserveEntity(ref MyBBMemoryTarget inTarget, int timeMs)
        {
            MyBehaviorTreeState retStatus = MyBehaviorTreeState.FAILURE;

            if (Bot == null || Bot.Player == null)
            {
                return(MyBehaviorTreeState.FAILURE);
            }

            var logic = Bot.HumanoidLogic;

            if (inTarget != null && inTarget.EntityId.HasValue && inTarget.TargetType != MyAiTargetEnum.POSITION && inTarget.TargetType != MyAiTargetEnum.NO_TARGET)
            {
                switch (logic.EntityReservationStatus)
                {
                case Logic.MyEntityReservationStatus.NONE:
                    switch (inTarget.TargetType)
                    {
                    case MyAiTargetEnum.GRID:
                    case MyAiTargetEnum.CUBE:
                    case MyAiTargetEnum.CHARACTER:
                    case MyAiTargetEnum.ENTITY:
                        logic.EntityReservationStatus = Logic.MyEntityReservationStatus.WAITING;
                        logic.ReservationEntityData   = new MyAiTargetManager.ReservedEntityData()
                        {
                            Type       = MyReservedEntityType.ENTITY,
                            EntityId   = inTarget.EntityId.Value, ReservationTimer = timeMs,
                            ReserverId = new World.MyPlayer.PlayerId(Bot.Player.Id.SteamId, Bot.Player.Id.SerialId)
                        };
                        MyAiTargetManager.OnReservationResult += ReservationHandler;
                        MyAiTargetManager.Static.RequestEntityReservation(logic.ReservationEntityData.EntityId, logic.ReservationEntityData.ReservationTimer, Bot.Player.Id.SerialId);
                        break;

                    case MyAiTargetEnum.ENVIRONMENT_ITEM:
                        logic.EntityReservationStatus = Logic.MyEntityReservationStatus.WAITING;
                        logic.ReservationEntityData   = new MyAiTargetManager.ReservedEntityData()
                        {
                            Type             = MyReservedEntityType.ENVIRONMENT_ITEM,
                            EntityId         = inTarget.EntityId.Value,
                            LocalId          = inTarget.TreeId.Value,
                            ReservationTimer = timeMs,
                            ReserverId       = new World.MyPlayer.PlayerId(Bot.Player.Id.SteamId, Bot.Player.Id.SerialId)
                        };
                        MyAiTargetManager.OnReservationResult += ReservationHandler;
                        MyAiTargetManager.Static.RequestEnvironmentItemReservation(logic.ReservationEntityData.EntityId, logic.ReservationEntityData.LocalId,
                                                                                   logic.ReservationEntityData.ReservationTimer, Bot.Player.Id.SerialId);
                        break;

                    case MyAiTargetEnum.VOXEL:
                        logic.EntityReservationStatus = Logic.MyEntityReservationStatus.WAITING;
                        logic.ReservationEntityData   = new MyAiTargetManager.ReservedEntityData()
                        {
                            Type             = MyReservedEntityType.VOXEL,
                            EntityId         = inTarget.EntityId.Value,
                            GridPos          = inTarget.VoxelPosition,
                            ReservationTimer = timeMs,
                            ReserverId       = new World.MyPlayer.PlayerId(Bot.Player.Id.SteamId, Bot.Player.Id.SerialId)
                        };
                        MyAiTargetManager.OnReservationResult += ReservationHandler;
                        MyAiTargetManager.Static.RequestVoxelPositionReservation(logic.ReservationEntityData.EntityId, logic.ReservationEntityData.GridPos,
                                                                                 logic.ReservationEntityData.ReservationTimer, Bot.Player.Id.SerialId);
                        break;

                    default:
                        break;
                    }
                    m_reservationTimeOut          = Stopwatch.GetTimestamp() + Stopwatch.Frequency * RESERVATION_WAIT_TIMEOUT_SECONDS;
                    logic.EntityReservationStatus = Logic.MyEntityReservationStatus.WAITING;
                    retStatus = MyBehaviorTreeState.RUNNING;
                    break;

                case Logic.MyEntityReservationStatus.SUCCESS:
                    retStatus = MyBehaviorTreeState.SUCCESS;
                    break;

                case Logic.MyEntityReservationStatus.FAILURE:
                    retStatus = MyBehaviorTreeState.FAILURE;
                    break;

                case Logic.MyEntityReservationStatus.WAITING:
                    if (m_reservationTimeOut < Stopwatch.GetTimestamp())
                    {
                        retStatus = MyBehaviorTreeState.FAILURE;
                    }
                    else
                    {
                        retStatus = MyBehaviorTreeState.RUNNING;
                    }
                    break;
                }
            }
            return(retStatus);
        }
Exemplo n.º 24
0
        protected MyBehaviorTreeState GetTargetWithPriority([BTParam] float radius, [BTInOut] ref MyBBMemoryTarget outTarget, [BTInOut] ref MyBBMemoryInt priority)
        {
            var             myPosition = Bot.Navigation.PositionAndOrientation.Translation;
            BoundingSphereD bb         = new BoundingSphereD(myPosition, radius);

            if (priority == null)
            {
                priority = new MyBBMemoryInt();
            }
            int bestPriority = priority.IntValue;

            if (bestPriority <= 0)
            {
                bestPriority = int.MaxValue;
            }

            MyBehaviorTreeState retval = IsTargetValid(ref outTarget);

            if (retval == MyBehaviorTreeState.FAILURE)
            {
                bestPriority = 7;
                MyBBMemoryTarget.UnsetTarget(ref outTarget);
            }
            Vector3D?targetPosition = SpiderTarget.GetMemoryTargetPosition(outTarget);

            if (!targetPosition.HasValue || Vector3D.Distance(targetPosition.Value, Bot.AgentEntity.PositionComp.GetPosition()) > 400.0f)
            {
                bestPriority = 7;
                MyBBMemoryTarget.UnsetTarget(ref outTarget);
            }

            var myFaction = MySession.Static.Factions.GetPlayerFaction(Bot.AgentEntity.ControllerInfo.ControllingIdentityId);

            // Priorities are as follows:
            // 1st characters, 3rd turrets, 4th weapons, 5th non-armor blocks, 6th armor blocks
            var entityList = MyEntities.GetTopMostEntitiesInSphere(ref bb);

            entityList.ShuffleList(); // Prevent all spiders going for the same player
            foreach (var entity in entityList)
            {
                if (entity == Bot.AgentEntity)
                {
                    continue;
                }
                if (!SpiderTarget.IsEntityReachable(entity))
                {
                    continue;
                }

                int entityPriority = 6;
                var character      = entity as MyCharacter;
                var grid           = entity as MyCubeGrid;

                if (character != null && character.ControllerInfo != null)
                {
                    var faction = MySession.Static.Factions.GetPlayerFaction(character.ControllerInfo.ControllingIdentityId);
                    if (myFaction != null && faction == myFaction)
                    {
                        continue;
                    }
                    if (character.IsDead)
                    {
                        continue;
                    }

                    //if character fly up exclude him from targets
                    var result = Sandbox.Engine.Physics.MyPhysics.CastRay(character.WorldMatrix.Translation - 3 * character.WorldMatrix.Up, character.WorldMatrix.Translation + 3 * character.WorldMatrix.Up, Sandbox.Engine.Physics.MyPhysics.CollisionLayers.DefaultCollisionLayer);
                    if (result == null || (result as VRage.Game.ModAPI.IHitInfo).HitEntity == character)
                    {
                        continue;
                    }

                    entityPriority = 1;

                    if (entityPriority < bestPriority)
                    {
                        retval       = MyBehaviorTreeState.SUCCESS;
                        bestPriority = entityPriority;
                        MyBBMemoryTarget.SetTargetEntity(ref outTarget, MyAiTargetEnum.CHARACTER, character.EntityId);
                        continue;
                    }
                }
                else if (grid != null && bestPriority > 3)
                {
                    Vector3D    spiderPosInGrid = grid.WorldToGridScaledLocal(myPosition);
                    double      closestDist     = double.MaxValue;
                    MySlimBlock closestBlock    = null;
                    foreach (var block in grid.CubeBlocks)
                    {
                        Vector3D blockLocalPos = new Vector3D(block.Min + block.Max);
                        blockLocalPos = blockLocalPos * 0.5;

                        double dist = Vector3D.RectangularDistance(ref blockLocalPos, ref spiderPosInGrid);
                        if (dist < closestDist)
                        {
                            closestBlock = block;
                            closestDist  = dist;
                        }
                    }

                    if (closestBlock != null)
                    {
                        retval       = MyBehaviorTreeState.SUCCESS;
                        bestPriority = 3;
                        MyBBMemoryTarget.SetTargetCube(ref outTarget, (closestBlock.Min + closestBlock.Max) / 2, grid.EntityId);
                    }
                }
            }
            entityList.Clear();

            /*var players = Sync.Players.GetOnlinePlayers();
             * MyCharacter closestCharacter = null;
             * double closestDistanceSq = float.MaxValue;
             * foreach (var player in players)
             * {
             *  if (player.Id.SerialId != 0)
             *  {
             *      var bot = MyAIComponent.Static.Bots.TryGetBot<MyHumanoidBot>(player.Id.SerialId);
             *      if (bot == null || bot.BotDefinition.BehaviorType == "Barbarian")
             *          continue;
             *  }
             *
             *  if (!(player.Character is MyCharacter) || !AiTargetBase.IsEntityReachable(player.Character))
             *  {
             *      continue;
             *  }
             *
             *  if (player.Character.IsDead)
             *      continue;
             *
             *  var distanceSq = Vector3D.DistanceSquared(player.Character.PositionComp.GetPosition(), myPosition);
             *  if (distanceSq < radius * radius && distanceSq < closestDistanceSq)
             *  {
             *      closestCharacter = player.Character;
             *      closestDistanceSq = distanceSq;
             *  }
             * }*/

            //return closestCharacter;

            priority.IntValue = bestPriority;

            // CH: TODO: This is temporary. Remove it!
            //if (outTarget.TargetType == MyAiTargetEnum.CUBE)
            //{
            //    MyEntity outGrid;
            //    MyEntities.TryGetEntityById(outTarget.EntityId.Value, out outGrid);
            //    Debug.Assert(outGrid != null);
            //    var grid = outGrid as MyCubeGrid;
            //    MySlimBlock block = grid.GetCubeBlock(outTarget.BlockPosition);
            //    Debug.Assert(block != null);

            //    //MyTrace.Send(TraceWindow.Ai, "TARGETTING CUBE: " + grid.ToString() + " " + block.ToString());
            //}

            return(retval);
        }
        protected MyBehaviorTreeState TryReserveEntity([BTIn] ref MyBBMemoryTarget inTarget, [BTParam] int timeMs)
        {
            MyBehaviorTreeState retStatus = MyBehaviorTreeState.FAILURE;

            if (Bot == null || Bot.Player == null)
            {
                return(MyBehaviorTreeState.FAILURE);
            }

            var logic = Bot.HumanoidLogic;

            if (inTarget != null && inTarget.EntityId.HasValue && inTarget.TargetType != MyAiTargetEnum.POSITION && inTarget.TargetType != MyAiTargetEnum.NO_TARGET)
            {
                switch (logic.ReservationStatus)
                {
                case Logic.MyReservationStatus.NONE:
                    switch (inTarget.TargetType)
                    {
                    case MyAiTargetEnum.GRID:
                    case MyAiTargetEnum.CUBE:
                    case MyAiTargetEnum.CHARACTER:
                    case MyAiTargetEnum.ENTITY:
                        logic.ReservationStatus     = Logic.MyReservationStatus.WAITING;
                        logic.ReservationEntityData = new MyAiTargetManager.ReservedEntityData()
                        {
                            Type       = MyReservedEntityType.ENTITY,
                            EntityId   = inTarget.EntityId.Value, ReservationTimer = timeMs,
                            ReserverId = new World.MyPlayer.PlayerId(Bot.Player.Id.SteamId, Bot.Player.Id.SerialId)
                        };
                        MyAiTargetManager.OnReservationResult += ReservationHandler;
                        MyAiTargetManager.Static.RequestEntityReservation(logic.ReservationEntityData.EntityId, logic.ReservationEntityData.ReservationTimer, Bot.Player.Id.SerialId);
                        break;

                    case MyAiTargetEnum.ENVIRONMENT_ITEM:
                        logic.ReservationStatus     = Logic.MyReservationStatus.WAITING;
                        logic.ReservationEntityData = new MyAiTargetManager.ReservedEntityData()
                        {
                            Type             = MyReservedEntityType.ENVIRONMENT_ITEM,
                            EntityId         = inTarget.EntityId.Value,
                            LocalId          = inTarget.TreeId.Value,
                            ReservationTimer = timeMs,
                            ReserverId       = new World.MyPlayer.PlayerId(Bot.Player.Id.SteamId, Bot.Player.Id.SerialId)
                        };
                        MyAiTargetManager.OnReservationResult += ReservationHandler;
                        MyAiTargetManager.Static.RequestEnvironmentItemReservation(logic.ReservationEntityData.EntityId, logic.ReservationEntityData.LocalId,
                                                                                   logic.ReservationEntityData.ReservationTimer, Bot.Player.Id.SerialId);
                        break;

                    case MyAiTargetEnum.VOXEL:
                        logic.ReservationStatus     = Logic.MyReservationStatus.WAITING;
                        logic.ReservationEntityData = new MyAiTargetManager.ReservedEntityData()
                        {
                            Type             = MyReservedEntityType.VOXEL,
                            EntityId         = inTarget.EntityId.Value,
                            GridPos          = inTarget.VoxelPosition,
                            ReservationTimer = timeMs,
                            ReserverId       = new World.MyPlayer.PlayerId(Bot.Player.Id.SteamId, Bot.Player.Id.SerialId)
                        };
                        MyAiTargetManager.OnReservationResult += ReservationHandler;
                        MyAiTargetManager.Static.RequestVoxelPositionReservation(logic.ReservationEntityData.EntityId, logic.ReservationEntityData.GridPos,
                                                                                 logic.ReservationEntityData.ReservationTimer, Bot.Player.Id.SerialId);
                        break;

                    default:
                        logic.ReservationStatus = Logic.MyReservationStatus.FAILURE;
                        retStatus = MyBehaviorTreeState.FAILURE;
                        break;
                    }
                    m_reservationTimeOut = MySandboxGame.Static.UpdateTime + MyTimeSpan.FromSeconds(RESERVATION_WAIT_TIMEOUT_SECONDS);
                    break;

                case Logic.MyReservationStatus.SUCCESS:
                case Logic.MyReservationStatus.FAILURE:
                    break;

                case Logic.MyReservationStatus.WAITING:
                    if (m_reservationTimeOut < MySandboxGame.Static.UpdateTime)
                    {
                        logic.ReservationStatus = Logic.MyReservationStatus.FAILURE;
                    }
                    break;
                }
            }

            switch (logic.ReservationStatus)
            {
            case Logic.MyReservationStatus.WAITING:
                return(MyBehaviorTreeState.RUNNING);

            case Logic.MyReservationStatus.SUCCESS:
                return(MyBehaviorTreeState.SUCCESS);

            case Logic.MyReservationStatus.FAILURE:
            default:
                return(MyBehaviorTreeState.FAILURE);
            }
        }
Exemplo n.º 26
0
        protected MyBehaviorTreeState GetTargetWithPriority([BTParam] float radius, [BTInOut] ref MyBBMemoryTarget outTarget, [BTInOut] ref MyBBMemoryInt priority)
        {
            if (CyberhoundLogic.SelfDestructionActivated) // self destruction activated, do not change target.
            {
                return(MyBehaviorTreeState.SUCCESS);
            }

            var             myPosition = Bot.Navigation.PositionAndOrientation.Translation;
            BoundingSphereD bb         = new BoundingSphereD(myPosition, radius);

            if (priority == null)
            {
                priority = new MyBBMemoryInt();
            }
            int bestPriority = priority.IntValue;

            if (bestPriority <= 0 || Bot.Navigation.Stuck)
            {
                bestPriority = int.MaxValue;
            }

            MyBehaviorTreeState retval = IsTargetValid(ref outTarget);

            if (retval == MyBehaviorTreeState.FAILURE)
            {
                bestPriority = 7;
                MyBBMemoryTarget.UnsetTarget(ref outTarget);
            }
            Vector3D?targetPosition = CyberhoundTarget.GetMemoryTargetPosition(outTarget);

            if (!targetPosition.HasValue ||
                Vector3D.DistanceSquared(targetPosition.Value, Bot.AgentEntity.PositionComp.GetPosition()) > 400.0f * 400.0f)
            {
                bestPriority = 7;
                MyBBMemoryTarget.UnsetTarget(ref outTarget);
            }
            if (targetPosition.HasValue)
            {
                Vector3D targetPositionValue = targetPosition.Value;
                var      planet = MyGravityProviderSystem.GetNearestPlanet(targetPositionValue);
                if (planet != null)
                {
                    Vector3D targetPositionProjected = planet.GetClosestSurfacePointGlobal(ref targetPositionValue);
                    if (Vector3D.DistanceSquared(targetPositionProjected, targetPositionValue) > 1.5f * 1.5f &&
                        Vector3D.DistanceSquared(targetPositionProjected, Bot.AgentEntity.PositionComp.GetPosition()) < 5.0f * 5.0f)
                    {
                        bestPriority = 7;
                        MyBBMemoryTarget.UnsetTarget(ref outTarget);
                    }
                }
            }

            var myFaction = MySession.Static.Factions.GetPlayerFaction(Bot.AgentEntity.ControllerInfo.ControllingIdentityId);


            // Priorities are as follows:
            // 1st characters, 3rd turrets, 4th weapons, 5th non-armor blocks, 6th armor blocks
            var entityList = MyEntities.GetTopMostEntitiesInSphere(ref bb);

            entityList.ShuffleList(); // Prevent all Cyberhounds going for the same player
            foreach (var entity in entityList)
            {
                if (entity == Bot.AgentEntity ||
                    entity is MyVoxelBase ||
                    !CyberhoundTarget.IsEntityReachable(entity))
                {
                    continue;
                }
                // exclude entities above ground
                Vector3D entityPos = entity.PositionComp.GetPosition();
                var      planet    = MyGravityProviderSystem.GetNearestPlanet(entityPos);
                if (planet != null)
                {
                    Vector3D entityPosProjected = planet.GetClosestSurfacePointGlobal(ref entityPos);
                    if (Vector3D.DistanceSquared(entityPosProjected, entityPos) > 1.0f)
                    {
                        continue;
                    }
                }

                int entityPriority = 6;
                var character      = entity as MyCharacter;
                var grid           = entity as MyCubeGrid;

                if (character != null)
                {
                    var faction = MySession.Static.Factions.GetPlayerFaction(character.ControllerInfo.ControllingIdentityId);
                    if (myFaction != null && faction == myFaction)
                    {
                        continue;
                    }
                    if (character.IsDead)
                    {
                        continue;
                    }

                    entityPriority = 1;

                    if (entityPriority < bestPriority)
                    {
                        retval       = MyBehaviorTreeState.SUCCESS;
                        bestPriority = entityPriority;
                        MyBBMemoryTarget.SetTargetEntity(ref outTarget, MyAiTargetEnum.CHARACTER, character.EntityId);
                        lastTargetedEntityPosition = character.PositionComp.GetPosition();
                        continue;
                    }
                }
                else if (grid != null && bestPriority > 3)
                {
                    Vector3D    CyberhoundPosInGrid = grid.WorldToGridScaledLocal(myPosition);
                    double      closestDist         = double.MaxValue;
                    MySlimBlock closestBlock        = null;
                    foreach (var block in grid.CubeBlocks)
                    {
                        Vector3D blockLocalPos = new Vector3D(block.Min + block.Max);
                        blockLocalPos = blockLocalPos * 0.5;

                        double dist = Vector3D.RectangularDistance(ref blockLocalPos, ref CyberhoundPosInGrid);
                        if (dist < closestDist)
                        {
                            closestBlock = block;
                            closestDist  = dist;
                        }
                    }

                    if (closestBlock != null)
                    {
                        retval       = MyBehaviorTreeState.SUCCESS;
                        bestPriority = 3;
                        MyBBMemoryTarget.SetTargetCube(ref outTarget, (closestBlock.Min + closestBlock.Max) / 2, grid.EntityId);
                        BoundingBoxD bbBlock;
                        closestBlock.GetWorldBoundingBox(out bbBlock);
                        lastTargetedEntityPosition = bbBlock.Center;
                    }
                }
            }
            entityList.Clear();
            priority.IntValue = bestPriority;

            // CH: TODO: This is temporary. Remove it!
            if (outTarget.TargetType == MyAiTargetEnum.CUBE)
            {
                MyEntity outGrid;
                MyEntities.TryGetEntityById(outTarget.EntityId.Value, out outGrid);
                Debug.Assert(outGrid != null);
                var         grid  = outGrid as MyCubeGrid;
                MySlimBlock block = grid.GetCubeBlock(outTarget.BlockPosition);
                Debug.Assert(block != null);

                //MyTrace.Send(TraceWindow.Ai, "TARGETTING CUBE: " + grid.ToString() + " " + block.ToString());
            }

            if (outTarget.TargetType == MyAiTargetEnum.NO_TARGET)
            {
                retval = MyBehaviorTreeState.FAILURE;
            }
            return(retval);
        }
Exemplo n.º 27
0
        private MyBehaviorTreeState InvertState(MyBehaviorTreeState state)
        {
            if (state == MyBehaviorTreeState.SUCCESS)
                return MyBehaviorTreeState.FAILURE;
            else if (state == MyBehaviorTreeState.FAILURE)
                return MyBehaviorTreeState.SUCCESS;

            return state;
        }