public AvatarController(IAvatar avatar)
        {
            m_avatar         = avatar;
            m_avatarControls = new AvatarControls(int.MaxValue);

            avatar.NewMessage += avatar_NewMessage;
        }
 public NetworkUserData(string id)
 {
     matchmakerId         = id;
     visualRepresentation = null;
     networkUser          = null;
     lastUpdateTimeStamp  = DateTime.Now;
     selectedStreamKey    = default;
     selectedObject       = null;
     vivoxParticipant     = null;
     voiceStateData       = VoiceStateData.defaultData;
 }
        public void CanSetPropertiesFrwd()
        {
            IAvatarControls avatarControls = new AvatarControls(0, 0.5f, 0.0f, -0.4f, true, true, true);

            m_avatarController.SetActions(avatarControls);
            Assert.Equal(m_avatar.DesiredSpeed, 0.5f);
            Assert.Equal(m_avatar.DesiredLeftRotation, -0.4f);
            Assert.True(m_avatar.Interact);
            Assert.True(m_avatar.PickUp);
            Assert.True(m_avatar.UseTool);
        }
        public void CanSetProperties45()
        {
            IAvatarControls avatarControls = new AvatarControls(0, 1f, 1f, -0.4f, true, true, true);

            m_avatarController.SetActions(avatarControls);
            Assert.Equal(m_avatar.DesiredSpeed, 1f);
            Assert.Equal(m_avatar.Direction, -MathHelper.Pi / 4, 2);
            Assert.Equal(m_avatar.DesiredLeftRotation, -0.4f);
            Assert.True(m_avatar.Interact);
            Assert.True(m_avatar.PickUp);
            Assert.True(m_avatar.UseTool);
        }
Exemple #5
0
        public IAvatarControls GetActions()
        {
            float desiredForwardSpeed = DesiredForwardSpeed();
            float desiredRightSpeed   = DesiredRightSpeed();
            float desiredLeftRotation = m_avatar.DesiredLeftRotation;
            bool  interact            = m_avatar.Interact;
            bool  pickUp = m_avatar.PickUp;
            bool  use    = m_avatar.UseTool;
            var   fof    = m_avatar.Fof;

            AvatarControls realAvatarControls = new AvatarControls(int.MaxValue,
                                                                   desiredForwardSpeed, desiredRightSpeed, desiredLeftRotation, interact, use, pickUp, fof);

            //return m_avatarControls;
            return(realAvatarControls);
        }
            public override void Execute()
            {
                if (SimulationStep != 0 && SimulationStep % Owner.RunEvery != 0)
                {
                    return;
                }

                Owner.Controls.SafeCopyToHost();

                float leftSignal     = Owner.Controls.Host[ControlMapper.Idx("left")];
                float rightSignal    = Owner.Controls.Host[ControlMapper.Idx("right")];
                float fwSignal       = Owner.Controls.Host[ControlMapper.Idx("forward")];
                float bwSignal       = Owner.Controls.Host[ControlMapper.Idx("backward")];
                float rotLeftSignal  = Owner.Controls.Host[ControlMapper.Idx("rot_left")];
                float rotRightSignal = Owner.Controls.Host[ControlMapper.Idx("rot_right")];

                float fof_left  = Owner.Controls.Host[ControlMapper.Idx("fof_left")];
                float fof_right = Owner.Controls.Host[ControlMapper.Idx("fof_right")];
                float fof_up    = Owner.Controls.Host[ControlMapper.Idx("fof_up")];
                float fof_down  = Owner.Controls.Host[ControlMapper.Idx("fof_down")];

                float rotation   = ConvertBiControlToUniControl(rotRightSignal, rotLeftSignal);
                float speed      = ConvertBiControlToUniControl(fwSignal, bwSignal);
                float rightSpeed = ConvertBiControlToUniControl(rightSignal, leftSignal);
                float fof_x      = ConvertBiControlToUniControl(fof_left, fof_right);
                float fof_y      = ConvertBiControlToUniControl(fof_up, fof_down);

                bool interact = Owner.Controls.Host[ControlMapper.Idx("interact")] > 0.5;
                bool use      = Owner.Controls.Host[ControlMapper.Idx("use")] > 0.5;
                bool pickup   = Owner.Controls.Host[ControlMapper.Idx("pickup")] > 0.5;

                IAvatarControls ctrl = new AvatarControls(100, speed, rightSpeed, rotation, interact, use, pickup,
                                                          fof: new PointF(fof_x, fof_y));

                Owner.AvatarCtrl.SetActions(ctrl);
            }
        protected void RunRRLongRunning()
        {
#if !RENDER_DEBUG
            return;
#endif

            Renderer.MakeContextCurrent();

            int aID = m_gameController.GetAvatarIds().First();
            var rr  = m_gameController.RegisterRenderRequest <IFovAvatarRR>(aID);
            //var rr = m_gameController.RegisterRenderRequest<IFofAvatarRR>(aID);
            //rr1.Size = new SizeF(50, 50);
            //rr.FovAvatarRenderRequest = rr1;
            rr.RotateMap = true;

            rr.GameObjects = new GameObjectSettings(RenderRequestGameObject.TileLayers | RenderRequestGameObject.ObjectLayers)
            {
                Use3D = true,
            };
            rr.Effects        = new EffectSettings(RenderRequestEffect.None);
            rr.Postprocessing = new PostprocessingSettings(RenderRequestPostprocessing.None);
            rr.Overlay        = new OverlaySettings(RenderRequestOverlay.InventoryTool)
            {
                ToolBackground = ToolBackgroundType.BrownBorder
            };
            rr.Image = new ImageSettings(RenderRequestImageCopyingMode.DefaultFbo);


            #region Controls

            var ac       = m_gameController.GetAvatarController(aID);
            var controls = new AvatarControls(5);

            CancellationToken token = SetupWindow(
                delta =>
            {
                //rr.PositionCenter = new PointF(rr.PositionCenter.X - delta.X, rr.PositionCenter.Y + delta.Y);
                controls.DesiredLeftRotation = MathHelper.WrapAngle(delta.X * -0.1f);
                //controls.Fof = new PointF(0, controls.Fof.Value.Y + -delta.Y * 0.1f);
            },
                delta =>
            {
                rr.Size = new SizeF(rr.Size.Width - delta, rr.Size.Height - delta);
            },
                toggle =>
            {
                switch (toggle)
                {
                case Key.Number1:
                    {
                        var effects            = rr.Effects;
                        effects.EnabledEffects = effects.EnabledEffects.FlipEnumFlag(RenderRequestEffect.Smoke);
                        rr.Effects             = effects;
                    }
                    break;

                case Key.Number2:
                    {
                        var post = rr.Postprocessing;
                        post.EnabledPostprocessing = post.EnabledPostprocessing.FlipEnumFlag(RenderRequestPostprocessing.Noise);
                        rr.Postprocessing          = post;
                    }
                    break;

                case Key.Number3:
                    {
                        var effects            = rr.Effects;
                        effects.EnabledEffects = effects.EnabledEffects.FlipEnumFlag(RenderRequestEffect.DayNight);
                        rr.Effects             = effects;
                    }
                    break;

                case Key.Number4:
                    {
                        var effects            = rr.Effects;
                        effects.EnabledEffects = effects.EnabledEffects.FlipEnumFlag(RenderRequestEffect.Lights);
                        rr.Effects             = effects;
                    }
                    break;

                case Key.Number5:
                case Key.Number6:
                case Key.Number7:
                    rr.RotateMap = !rr.RotateMap;
                    break;

                case Key.Number8:
                    controls.PickUp   = true;
                    controls.Interact = true;
                    controls.Use      = true;
                    break;

                case Key.Number9:
                case Key.Number0:
                    rr.MultisampleLevel = (RenderRequestMultisampleLevel)(((int)rr.MultisampleLevel + 1) % 5);
                    break;
                }

                // A hack that enables recomputing the renderers based on new settings; it sets some stuff like size to default, though
                ((IRenderRequestBaseInternal <ToyWorld>)rr).Init();
            },
                (movement, isKeyUp) =>
            {
                float movementChange = isKeyUp ? 0 : 0.6f;

                switch (movement)
                {
                case Key.W:
                    controls.DesiredForwardSpeed = movementChange;
                    break;

                case Key.S:
                    controls.DesiredForwardSpeed = -movementChange;
                    break;

                case Key.A:
                    controls.DesiredRightSpeed = -movementChange;
                    break;

                case Key.D:
                    controls.DesiredRightSpeed = movementChange;
                    break;
                }
            });

            #endregion

            while (Renderer.Window.Exists && !token.IsCancellationRequested)
            {
                try
                {
                    //Task.Delay(15, token).Wait(token);
                }
                catch (OperationCanceledException)
                {
                    break;
                }

                ac.SetActions(controls);

                if (controls.PickUp)
                {
                    controls.PickUp = false;
                }

                m_gameController.MakeStep();
                Renderer.Context.SwapBuffers();
            }

            Assert.True(token.IsCancellationRequested);
        }
 public void ResetControls()
 {
     m_avatarControls = new AvatarControls(int.MaxValue);
     m_avatar.ResetControls();
 }
Exemple #9
0
 public AvatarController(IAvatar avatar)
 {
     m_avatar         = avatar;
     m_avatarControls = new AvatarControls(int.MaxValue);
 }