public TrackBallController(Vector2 screenCenter, double trackBallRadius)
		{
			rotationStart = new Vector3();
			rotationCurrent = new Vector3();
			this.screenCenter = screenCenter;
			this.rotationTrackingRadius = trackBallRadius;
		}
 public void OnMouseMove(object sender, System.Windows.Forms.MouseEventArgs e)
 {
     var mouseState = Mouse.GetState();
     var keyboardState = Keyboard.GetState();
     var currentMouseCoordinate = new Vector2(e.X, e.Y);
     if (keyboardState.IsKeyDown(Key.ShiftLeft) && (mouseState[MouseButton.Middle] || (mouseState[MouseButton.Left] && keyboardState[Key.ControlLeft])))
     {
         var d = 5;
         var previousMouseWorldCoordinate = Maths.Project(ViewMatrix, Viewport.ProjectionMatrix, previousMouseCoordinate, (Rectangle)Viewport, Maths.ProjectionTarget.View);
         var mouseWorldCoordinate = Maths.Project(ViewMatrix, ProjectionMatrix, currentMouseCoordinate, (Rectangle)Viewport, Maths.ProjectionTarget.View);
         var delta = mouseWorldCoordinate - previousMouseWorldCoordinate;
         delta *= d;
         panTrack.Update(delta.X, delta.Y);
     }
     else if (keyboardState.IsKeyDown(Key.AltLeft) && (mouseState[MouseButton.Middle] || (mouseState[MouseButton.Left] && keyboardState[Key.ControlLeft])))
     {
         var previousMouseWorldCoordinate = Maths.Project(ViewMatrix, Viewport.ProjectionMatrix, previousMouseCoordinate, (Rectangle)Viewport, Maths.ProjectionTarget.View);
         var mouseWorldCoordinate = Maths.Project(ViewMatrix, ProjectionMatrix, currentMouseCoordinate, (Rectangle)Viewport, Maths.ProjectionTarget.View);
         var delta = mouseWorldCoordinate - previousMouseWorldCoordinate;
         delta *= 10;
         zoomTrack.Update(delta.Y);
     }
     else if (mouseState[MouseButton.Middle] || (mouseState[MouseButton.Left] && keyboardState[Key.ControlLeft]))
     {
         var delta = currentMouseCoordinate - previousMouseCoordinate;
         //delta *= 10;
         orbitTrack.Update(delta.X, delta.Y);
     }
     if (this.MouseMove != null) this.MouseMove(this, new MouseEventArgs(this, new Vector2(e.X, e.Y), default(Vector3), e.Button));
     previousMouseCoordinate = currentMouseCoordinate;
 }
 private void SetNewState(VelocityComponentState state)
 {
     if (_lastState != null)
         _previousState = _lastState;
     _lastState = state;
     Velocity = new Vector2(state.VelocityX, state.VelocityY);
 }
        public unsafe void Capture(Vector2 targetSize)
        {
            if (_previousTargetSize != targetSize)
            {
                SetupBuffers(targetSize);
                _previousTargetSize = targetSize;
            }

            _pboIndex = (_pboIndex + 1) % 2;
            _nextPboIndex = (_pboIndex + 1) % 2;

            var frame = _frameCache[_cachedFramesIndex++];
            _cachedFramesIndex %= _numberOfCachedFrames;

            frame.FrameIndex = _frameIndex++;

            GL.ReadBuffer(ReadBufferMode.ColorAttachment0);
            GL.BindBuffer(BufferTarget.PixelPackBuffer, _pboIds[_pboIndex]);
            GL.ReadPixels(0, 0, (int)targetSize.X, (int)targetSize.Y, PixelFormat.Bgra, PixelType.UnsignedByte, (IntPtr)0);

            GL.BindBuffer(BufferTarget.PixelPackBuffer, _pboIds[_nextPboIndex]);
            var ptr = GL.MapBufferRange(BufferTarget.PixelPackBuffer, (IntPtr)0, (IntPtr)GetTargetSizeInBytes(targetSize), BufferAccessMask.MapReadBit);

            fixed (byte* data = frame.Bytes)
            {
                memcpy((IntPtr)data, ptr, GetTargetSizeInBytes(targetSize));
            }

            GL.UnmapBuffer(BufferTarget.PixelPackBuffer);
            GL.BindBuffer(BufferTarget.PixelPackBuffer, 0);
            GL.ReadBuffer(ReadBufferMode.Back);

            _frames.TryAdd(frame);
        }
Exemple #5
1
		public ListBoxTextItem(string displayName, string itemValue)
			: base(displayName)
		{
			Padding = new BorderDouble(3);
			ItemValue = itemValue;
			MinimumSize = new Vector2(Width, Height);
		}
 private static void OnDraw(EventArgs args)
 {
     if (Enabled)
     {
         foreach (
             var unit in ObjectManager.Get<Obj_AI_Hero>().Where(u => u.IsValidTarget() && u.IsHPBarRendered))
         {
             // Get damage to unit
             var damage = damageToUnit(unit);
             // Continue on 0 damage
             if (damage <= 0)
             {
                 continue;
             }
             // Get remaining HP after damage applied in percent and the current percent of health
             var damagePercentage = ((unit.Health - damage) > 0 ? (unit.Health - damage) : 0) / unit.MaxHealth;
             var currentHealthPercentage = unit.Health / unit.MaxHealth;
             // Calculate start and end point of the bar indicator
             var startPoint =
                 new Vector2(
                     (int) (unit.HPBarPosition.X + BarOffset.X + damagePercentage * BarWidth),
                     (int) (unit.HPBarPosition.Y + BarOffset.Y) - 5);
             var endPoint =
                 new Vector2(
                     (int) (unit.HPBarPosition.X + BarOffset.X + currentHealthPercentage * BarWidth) + 1,
                     (int) (unit.HPBarPosition.Y + BarOffset.Y) - 5);
             // Draw the line
             Drawing.DrawLine(startPoint, endPoint, LineThickness, DrawingColor);
         }
     }
 }
 public static void OrbwalkLRCLK_ValueChanged(object sender, OnValueChangeEventArgs e)
 {
     if (e.GetNewValue<KeyBind>().Active)
     {
         LastClickPoint = Game.CursorPos.To2D();
     }
 }
 private static void Game_OnWndProc(WndEventArgs args)
 {
     if (args.Msg == (uint)WindowsMessages.WM_RBUTTONDOWN)
     {
         LastClickPoint = Game.CursorPos.To2D();
     }
 }
        internal override float SignedDistance(ref Vector3 position, float lodVoxelSize, IMyModule macroModulator, IMyModule detailModulator)
        {
            Vector3 localPosition = position - m_translation;
            Vector3.Transform(ref localPosition, ref m_invRotation, out localPosition);

            var primaryDistance = new Vector2(localPosition.X, localPosition.Z).Length() - m_primaryRadius;
            var signedDistance = new Vector2(primaryDistance, localPosition.Y).Length() - m_secondaryRadius;

            var potentialHalfDeviation = m_potentialHalfDeviation + lodVoxelSize;
            if (signedDistance > potentialHalfDeviation)
                return 1f;
            else if (signedDistance < -potentialHalfDeviation)
                return -1f;

            if (m_enableModulation)
            {
                Debug.Assert(m_deviationFrequency != 0f);
                float normalizer = 0.5f * m_deviationFrequency;
                var tmp = localPosition * normalizer;
                float halfDeviationRatio = (float)macroModulator.GetValue(tmp.X, tmp.Y, tmp.Z);
                signedDistance -= halfDeviationRatio * m_secondaryHalfDeviation;
            }

            if (m_enableModulation && -m_detailSize < signedDistance && signedDistance < m_detailSize)
            {
                Debug.Assert(m_detailFrequency != 0f);
                float normalizer = 0.5f * m_detailFrequency;
                var tmp = localPosition * normalizer;
                signedDistance += m_detailSize * (float)detailModulator.GetValue(tmp.X, tmp.Y, tmp.Z);
            }

            return signedDistance / lodVoxelSize;
        }
        /// <summary>
        /// Binds to specific events of the provided CoreWindow
        /// </summary>
        /// <param name="nativeWindow">A reference to <see cref="CoreWindow"/> or <see cref="UIElement"/> class.</param>
        /// <exception cref="ArgumentNullException">Is thrown when <paramref name="nativeWindow"/> is null.</exception>
        /// <exception cref="ArgumentException">Is thrown when <paramref name="nativeWindow"/> is not a <see cref="CoreWindow"/> and not an <see cref="UIElement"/></exception>
        protected override void BindWindow(object nativeWindow)
        {
            if (nativeWindow == null) throw new ArgumentNullException("nativeWindow");
            var window = nativeWindow as CoreWindow;
            if (window != null)
            {
                windowSize = new Size2F((float)window.Bounds.Width, (float)window.Bounds.Height);
                var position = window.PointerPosition;
                pointerPosition = new Vector2((float)position.X/windowSize.Width, (float)position.Y / windowSize.Height);

                window.PointerPressed += HandleWindowPointerEvent;
                window.PointerReleased += HandleWindowPointerEvent;
                window.PointerWheelChanged += HandleWindowPointerEvent;
                window.PointerMoved += HandleWindowPointerEvent;
                window.SizeChanged += window_SizeChanged;
                return;
            }

            uiElement = nativeWindow as FrameworkElement;
            if (uiElement != null)
            {
                windowSize = new Size2F((float)uiElement.ActualWidth, (float)uiElement.ActualHeight);
                uiElement.Loaded += HandleLoadedEvent;
                uiElement.SizeChanged += HandleSizeChangedEvent;
                uiElement.PointerPressed += HandleUIElementPointerEvent;
                uiElement.PointerReleased += HandleUIElementPointerEvent;
                uiElement.PointerWheelChanged += HandleUIElementPointerEvent;
                uiElement.PointerMoved += HandleUIElementPointerEvent;
                uiElement.PointerEntered += HandleUIElementPointerEvent;
                return;
            }

            throw new ArgumentException("Should be an instance of either CoreWindow or UIElement", "nativeWindow");
        }
 public static bool IsOnScreen(this Vector2 start, Vector2 end)
 {
     if (start.X > 0 && start.X < Drawing.Width && start.Y > 0 && start.Y < Drawing.Height && end.X > 0 &&
         end.X < Drawing.Width && end.Y > 0 && end.Y < Drawing.Height)
     {
         return true;
     }
     if (start.Intersection(end, new Vector2(0, 0), new Vector2(Drawing.Width, 0)).Intersects)
     {
         return true;
     }
     if (start.Intersection(end, new Vector2(0, 0), new Vector2(0, Drawing.Height)).Intersects)
     {
         return true;
     }
     if (
         start.Intersection(end, new Vector2(0, Drawing.Height), new Vector2(Drawing.Width, Drawing.Height))
             .Intersects)
     {
         return true;
     }
     return
         start.Intersection(end, new Vector2(Drawing.Width, 0), new Vector2(Drawing.Width, Drawing.Height))
             .Intersects;
 }
Exemple #12
1
        public override void OnUpdate(long msec)
        {
            var g2d = Graphics2D.GetInstance ();
            var pos = g2d.GetMousePosition ();

            if (Input.GetKeyDown (KeyCode.Mouse0)) {
                var start = new Vector3 (pos.X, pos.Y, 1000);
                var end = new Vector3 (pos.X, pos.Y, -1000);
                var node = World.Pick (start, end);
                if (node != null) {
                    this.picked = node;
                    this.delta = pos - new Vector2 (node.Position.X, node.Position.Y);
                }
            }
            if (Input.GetKeyUp(KeyCode.Mouse0)) {
                this.picked = null;
            }

            if (picked != null) {
                var t = pos - delta;
                picked.Translation = new Vector3(t.X, t.Y, 0);
            }

            base.OnUpdate (msec);
        }
Exemple #13
1
        public LogoElement(InterfaceElement parent, Vector2 location)
            : base(parent, location)
        {
            Opacity = 1f;

            Size = Program.Logo.Size;
        }
Exemple #14
1
        public static bool IsLyingInCone(Vector2 position, Vector2 apexPoint, Vector2 circleCenter, double aperture)
        {
            // This is for our convenience
            var halfAperture = aperture / 2;

            // Vector pointing to X point from apex
            var apexToXVect = apexPoint - position;

            // Vector pointing from apex to circle-center point.
            var axisVect = apexPoint - circleCenter;

            // X is lying in cone only if it's lying in
            // infinite version of its cone -- that is,
            // not limited by "round basement".
            // We'll use dotProd() to
            // determine angle between apexToXVect and axis.
            var isInInfiniteCone = DotProd(apexToXVect, axisVect) / Magn(apexToXVect) / Magn(axisVect) >
                // We can safely compare cos() of angles
                // between vectors instead of bare angles.
                                   Math.Cos(halfAperture);

            if (!isInInfiniteCone)
                return false;

            // X is contained in cone only if projection of apexToXVect to axis
            // is shorter than axis.
            // We'll use dotProd() to figure projection length.
            var isUnderRoundCap = DotProd(apexToXVect, axisVect) / Magn(axisVect) < Magn(axisVect);

            return isUnderRoundCap;
        }
Exemple #15
1
        public static Vector2 FindNearestLineCircleIntersections(this Vector2 start,
            Vector2 end,
            Vector2 circlePos,
            float radius)
        {
            float t;
            var dx = end.X - start.X;
            var dy = end.Y - start.Y;

            var a = dx * dx + dy * dy;
            var b = 2 * (dx * (start.X - circlePos.X) + dy * (start.Y - circlePos.Y));
            var c = (start.X - circlePos.X) * (start.X - circlePos.X) +
                    (start.Y - circlePos.Y) * (start.Y - circlePos.Y) - radius * radius;

            var det = b * b - 4 * a * c;
            if ((a <= 0.0000001) || (det < 0))
            {
                return Vector2.Zero;
            }
            if (det.Equals(0f))
            {
                t = -b / (2 * a);
                return new Vector2(start.X + t * dx, start.Y + t * dy);
            }

            t = (float)((-b + Math.Sqrt(det)) / (2 * a));
            var intersection1 = new Vector2(start.X + t * dx, start.Y + t * dy);
            t = (float)((-b - Math.Sqrt(det)) / (2 * a));
            var intersection2 = new Vector2(start.X + t * dx, start.Y + t * dy);

            return Vector2.Distance(intersection1, ObjectManager.Player.Position.LSTo2D()) >
                   Vector2.Distance(intersection2, ObjectManager.Player.Position.LSTo2D())
                ? intersection2
                : intersection1;
        }
		public PartPreviewMainWindow(PrintItemWrapper printItem, View3DWidget.AutoRotate autoRotate3DView, View3DWidget.OpenMode openMode = View3DWidget.OpenMode.Viewing)
			: base(750, 550)
		{
			UseOpenGL = true;
			string partPreviewTitle = LocalizedString.Get("MatterControl");
			Title = string.Format("{0}: ", partPreviewTitle) + Path.GetFileName(printItem.Name);

			this.Name = "Part Preview Window";

			partPreviewWidget = new PartPreviewContent(printItem, View3DWidget.WindowMode.StandAlone, autoRotate3DView, openMode);
			partPreviewWidget.Closed += (sender, e) =>
			{
				Close();
			};

			this.AddChild(partPreviewWidget);

			AddHandlers();

			Width = 750;
			Height = 550;

			MinimumSize = new Vector2(400, 300);
			ShowAsSystemWindow();
		}
		public TrackBallController(TrackBallController trackBallToCopy)
		{
			this.screenCenter = trackBallToCopy.screenCenter;
			this.rotationTrackingRadius = trackBallToCopy.rotationTrackingRadius;
			this.currentRotationMatrix = trackBallToCopy.currentRotationMatrix;
			this.currentTranslationMatrix = trackBallToCopy.currentTranslationMatrix;
		}
Exemple #18
0
        public static PointF Rotate(this PointF c, float angle)
        {
            var cosAngle = Math.Cos(angle);
            var sinAngle = Math.Sin(angle);

            return(new PointF((float)(cosAngle * c.X - sinAngle * c.Y), (float)(sinAngle * c.X + cosAngle * c.Y)));
        }
Exemple #19
0
        public static float LengthSquare(this PointF c)
        {
            var x = c.X;
            var y = c.Y;

            return(x * x + y * y);
        }
Exemple #20
0
        /// <summary>
        /// Distance square to the point
        /// </summary>
        public static float DistanceSquareTo(this PointF point1, PointF point2)
        {
            var dx = point2.X - point1.X;
            var dy = point2.Y - point1.Y;

            return(dx * dx + dy * dy);
        }
Exemple #21
0
 public PCircle( Vector2 position, float radius, int sides, bool filled )
     : base(filled)
 {
     this.position = position;
     this.radius = radius;
     this.sides = sides;
 }
 public EquilateralTriangle(Vector2 v0, Vector2 v1, Vector2 v2)
 {
     corners[0] = v0;
     corners[1] = v1;
     corners[2] = v2;
     Recreate();
 }
Exemple #23
0
        public IsoSphere(int s_steps, int t_steps, float x_scale, float y_scale, float z_scale)
        {
            int count = 4 * s_steps * t_steps ;
            
            Vertices = new Vector3[count];
            Normals = new Vector3[count];
            Texcoords = new Vector2[count];
            Indices = new int[6 * count / 4];

            int i = 0;
            for (double t = -System.Math.PI; (float)t < (float)System.Math.PI - Single.Epsilon; t += System.Math.PI / (double)t_steps)
            {
                for (double s = 0.0; (float)s < (float)DoublePI; s += System.Math.PI / (double)s_steps)
                {
                    Vertices[i].X = x_scale * (float)(System.Math.Cos(s) * System.Math.Sin(t));
                    Vertices[i].Y = y_scale * (float)(System.Math.Sin(s) * System.Math.Sin(t));
                    Vertices[i].Z = z_scale * (float)System.Math.Cos(t);
                    //vertices[i] = vertices[i].Scale(x_scale, y_scale, z_scale);
                    Normals[i] = Vector3.Normalize(Vertices[i]);

                    ++i;
                }
            }
            
            for (i = 0; i < 6*count/4; i+=6)
            {
                Indices[i] = i;
                Indices[i + 1] = i + 1;
                Indices[i + 2] = i + 2 * s_steps + 1;
                Indices[i + 3] = i + 2 * s_steps;
                Indices[i + 4] = i;
                Indices[i + 5] = i + 2 * s_steps + 1;
            }
        }
Exemple #24
0
        /// <summary>
        /// Determine which side of the line the 2D point is at
        /// </summary>
        /// <returns>
        /// 1 if on the right hand side;
        /// 0 if on the line;
        /// -1 if on the left hand side;
        /// </returns>
        public static float Side(this PointF c, PointF point)
        {
            var res = c.X * point.Y - point.X * c.Y;

            return(res > float.Epsilon ? 1 :
                   res < -float.Epsilon ? -1 : 0);
        }
Exemple #25
0
        /// <summary>
        /// Distance to the point
        /// </summary>
        public static float DistanceTo(this PointF point1, PointF point2)
        {
            var dx = point2.X - point1.X;
            var dy = point2.Y - point1.Y;

            return((float)Math.Sqrt(dx * dx + dy * dy));
        }
        public override void RecreateControls(bool constructor)
        {
            base.RecreateControls(constructor);

            

            AddCaption(MySpaceTexts.ScreenCaptionWorkshopTags);

            Vector2 origin = new Vector2(0f, -0.025f * (m_activeTags.Count + 2));
            Vector2 offset = new Vector2(0f,  0.05f);

            m_checkboxes.Clear();

            foreach (var pair in m_activeTags)
            {
                AddLabeledCheckbox(origin += offset, pair.Key, pair.Value);
                if (m_typeTag == MySteamWorkshop.WORKSHOP_MOD_TAG)
                {
                    var name = pair.Key.Replace(" ", string.Empty);
                    var path = Path.Combine(MyFileSystem.ContentPath, "Textures", "GUI", "Icons", "buttons", name + ".dds");
                    if (File.Exists(path))
                    {
                        AddIcon(origin + new Vector2(-0.05f, 0f), path, new Vector2(0.04f, 0.05f));
                    }
                }
            }

            origin += offset;

            Controls.Add(m_okButton = MakeButton(origin += offset, MySpaceTexts.Ok, MySpaceTexts.Ok, OnOkClick, MyGuiDrawAlignEnum.HORISONTAL_RIGHT_AND_VERTICAL_CENTER));
            Controls.Add(m_cancelButton = MakeButton(origin, MySpaceTexts.Cancel, MySpaceTexts.Cancel, OnCancelClick, MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_CENTER));

            CloseButtonEnabled = true;
        }
        // Get ready to start.
        private void ResetBoundingRect(Vector2[] vertices)
        {
            _numPoints = vertices.Count();
            // Find the minimum and maximum points
            // in all four directions.
            double minx = vertices[0].X;
            double maxx = minx;
            double miny = vertices[0].Y;
            double maxy = miny;
            double minxi = 0;
            double maxxi = 0;
            double minyi = 0;
            double maxyi = 0;
            for (int i = 1; i < _numPoints; i++)
            {
                if (minx > vertices[i].X)
                {
                    minx = vertices[i].X;
                    minxi = i;
                }
                if (maxx < vertices[i].X)
                {
                    maxx = vertices[i].X;
                    maxxi = i;
                }
                if (miny > vertices[i].Y)
                {
                    miny = vertices[i].Y;
                    minyi = i;
                }
                if (maxy < vertices[i].Y)
                {
                    maxy = vertices[i].Y;
                    maxyi = i;
                }
            }
            _controlPoints[0] = (int)minxi;
            _controlPoints[1] = (int)maxyi;
            _controlPoints[2] = (int)maxxi;
            _controlPoints[3] = (int)minyi;
            _currentControlPoint = -1;
            // Reset the current and best bounding rectangle.
            _currentRectangle = new Vector2[]
            {
            new Vector2(minx, miny),
            new Vector2(maxx, miny),
            new Vector2(maxx, maxy),
            new Vector2(minx, maxy),
            };

            var currentArea = (maxx - minx) * (maxy - miny);
            _bestRectangle = _currentRectangle;
            _bestArea = currentArea;
            // So far we have not checked any edges.
            _edgeChecked = new bool[_numPoints];
            for (int i = 0; i < _numPoints; i++)
            {
                _edgeChecked[i] = false;
            }
        }
Exemple #28
0
        public override void Update(GameTime gameTime)
        {
            if (mouseDelta == Vector2.Zero)
                return;

            Vector3 cameraDirection = camera.Direction;
            float length = cameraDirection.Length();
            cameraDirection.Normalize();

            Vector3 cameraNormalDirection = Vector3.Cross(camera.UpVector, cameraDirection);

            Vector3 cameraTargetNormalDirectionUp = Vector3.Cross(cameraDirection, cameraNormalDirection);
            cameraTargetNormalDirectionUp.Normalize();

            Vector3 newTargetRelative = cameraDirection;

            if (mouseDelta.X != 0)
                newTargetRelative -= cameraNormalDirection * mouseDelta.X * mouseSensivity * 1.0f / gameTime.ElapsedMiliseconds;

            if (mouseDelta.Y != 0)
                newTargetRelative -=
                    cameraTargetNormalDirectionUp * mouseDelta.Y *
                    mouseSensivity * mouseYInverted * 1.0f/gameTime.ElapsedMiliseconds;

            newTargetRelative = Vector3.Multiply(newTargetRelative, length);
            camera.Target = camera.Position + newTargetRelative;

            Cursor.Position = Master.I.form.PointToScreen(new Point(Master.I.form.ClientSize.Width / 2, Master.I.form.ClientSize.Height / 2));
            Cursor.Hide();
            mouseDelta = Vector2.Zero;
        }
Exemple #29
0
 public void AddWall(Vector2 p1, Vector2 p2)
 {
     double angle1, angle2;
     angle1 = Math.Atan2(p1.Y, p1.X);
     angle2 = Math.Atan2(p2.Y, p2.X);
     double adiff = angle2 - angle1;
     if (adiff < 0) adiff += Math.PI * 2.0;
     if (adiff > Math.PI)
     {
         Vector2 tmp = p2; p2 = p1; p1 = tmp;
         double tmp2 = angle1; angle1 = angle2; angle2 = tmp2;
     }
     if (angle1 < 0) angle1 += Math.PI * 2.0;
     if (angle2 < 0) angle2 += Math.PI * 2.0;
     if (angle2 < angle1)
     {
         float tmp = getinetersecty0(p1, p2);
         addit(tmp, 0.0f, p2.Length(), (float)angle2);
         addit(p1.Length(), (float)angle1, tmp, (float)Math.PI * 2.0f);
     }
     else
     {
         addit(p1.Length(), (float)angle1, p2.Length(), (float)angle2);
     }
 }
Exemple #30
0
        static int calcularDistancia()
        {
            Vector2 posicionBot = new Vector2(Program.bot.cliente.Self.SimPosition.X, Program.bot.cliente.Self.SimPosition.Y);
            Vector2 posicionCamarero = new Vector2(posCamarero.X, posCamarero.Y);

            return (int)(Math.Abs(Math.Sqrt(Math.Pow(posicionBot.X - posicionCamarero.X, 2) + Math.Pow(posicionBot.Y - posicionCamarero.Y, 2))));
        }
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            int cooldown;
            if (state == null) cooldown = 1000;
            else cooldown = (int)state;

            Status = CycleStatus.NotStarted;

            if (host.HasConditionEffect(ConditionEffects.Paralyzed)) return;

            var player = (Player)host.GetNearestEntity(distance, null);
            if (player != null)
            {
                Vector2 vect;
                vect = new Vector2(player.X - host.X, player.Y - host.Y);
                vect.Normalize();
                float dist = host.GetSpeed(speed) * (time.thisTickTimes / 1000f);
                host.ValidateAndMove(host.X + (-vect.X) * dist, host.Y + (-vect.Y) * dist);
                host.UpdateCount++;

                if (cooldown <= 0)
                {
                    Status = CycleStatus.Completed;
                    cooldown = 1000;
                }
                else
                {
                    Status = CycleStatus.InProgress;
                    cooldown -= time.thisTickTimes;
                }
            }

            state = cooldown;
        }
Exemple #32
0
        public override void Initialize()
        {
            this.game = new MusicProject.Game();
            this.game.Initialize(this);

            #region WAVE SOFTWARE LICENSE AGREEMENT
            this.backgroundSplashColor = new Color("#ebebeb");
            this.spriteBatch = new SpriteBatch(WaveServices.GraphicsDevice);

            var resourceNames = Assembly.GetExecutingAssembly().GetManifestResourceNames();
            string name = string.Empty;

            foreach (string item in resourceNames)
            {
                if (item.Contains("SplashScreen.wpk"))
                {
                    name = item;
                    break;
                }
            }

            if (string.IsNullOrWhiteSpace(name))
            {
                throw new InvalidProgramException("License terms not agreed.");
            }

            using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(name))
            {
                this.splashScreen = WaveServices.Assets.Global.LoadAsset<Texture2D>(name, stream);
            }

            position = new Vector2();
            #endregion
        }
Exemple #33
0
        /// <summary>
        /// Adds the enemy.
        /// </summary>
        /// <param name="position">The position.</param>
        public void AddEnemy(Vector2 position)
        {
            Enemy enemy = this.enemies[this.enemyIndex];
            enemy.Position = position;

            this.enemyIndex = (this.enemyIndex + 1) % this.enemyMax;
        }
Exemple #34
0
        public static float Length(this PointF c)
        {
            var x = c.X;
            var y = c.Y;

            return((float)Math.Sqrt(x * x + y * y));
        }
Exemple #35
0
		public TextWidget(string text, double x = 0, double y = 0, double pointSize = 12, Justification justification = Justification.Left, RGBA_Bytes textColor = new RGBA_Bytes(), bool ellipsisIfClipped = true, bool underline = false, RGBA_Bytes backgroundColor = new RGBA_Bytes())
		{
			pointSize *= GlobalPointSizeScaleRatio;
			Selectable = false;
			DoubleBuffer = DoubleBufferDefault;
			AutoExpandBoundsToText = false;
			EllipsisIfClipped = ellipsisIfClipped;
			OriginRelativeParent = new Vector2(x, y);
			this.textColor = textColor;
			if (this.textColor.Alpha0To255 == 0)
			{
				// we assume it is the default if alpha 0.  Also there is no reason to make a text color of this as it will draw nothing.
				this.textColor = RGBA_Bytes.Black;
			}
			if (backgroundColor.Alpha0To255 != 0)
			{
				BackgroundColor = backgroundColor;
			}

			base.Text = text;
			StyledTypeFace typeFaceStyle = new StyledTypeFace(LiberationSansFont.Instance, pointSize, underline);
			printer = new TypeFacePrinter(text, typeFaceStyle, justification: justification);

			LocalBounds = printer.LocalBounds;

			MinimumSize = new Vector2(LocalBounds.Width, LocalBounds.Height);
		}
Exemple #36
0
 internal Offset(Vector2 vec, int width, int height)
 {
     X = vec.X;
     Y = vec.Y;
     Width = width;
     Height = height;
 }
Exemple #37
0
        /// <summary>
        /// Normal from the line to the point
        /// </summary>
        public static PointF Normal(this PointF direction, PointF point)
        {
            var cosAngle = (point.X * direction.X + point.Y * direction.Y) / direction.LengthSquare();
            var x        = direction.X * cosAngle;
            var y        = direction.Y * cosAngle;

            return(new PointF(point.X - x, point.Y - y));
        }
Exemple #38
0
        /// <summary>
        /// Normal from the line to the point (the line is defined by normalized direction)
        /// </summary>
        public static PointF Normal2(this PointF normalizedDirection, PointF point)
        {
            var cosAngle = point.X * normalizedDirection.X + point.Y * normalizedDirection.Y;
            var x        = normalizedDirection.X * cosAngle;
            var y        = normalizedDirection.Y * cosAngle;

            return(new PointF(point.X - x, point.Y - y));
        }
Exemple #39
0
        /// <summary>
        /// Minimal degree between vectors
        /// </summary>
        public static float Angle(this PointF c1, PointF c2)
        {
            var a = c1.Angle() - c2.Angle();

            a += (float)((a > PI) ? -2 * PI : (a < -PI) ? 2 * PI : 0);

            return(a);
        }
Exemple #40
0
        public static PointF Rotate(this PointF c, float angle, PointF center)
        {
            var cosAngle = Math.Cos(angle);
            var sinAngle = Math.Sin(angle);

            var xx = c.X - center.X;
            var yy = c.Y - center.Y;

            return(new PointF((float)(cosAngle * xx - sinAngle * yy + center.X), (float)(sinAngle * xx + cosAngle * yy + center.Y)));
        }
Exemple #41
0
        /// <summary>
        /// This is essentially the same as Lerp but instead the function will ensure that the speed never exceeds maxDistanceDelta.
        /// Negative values of maxDistanceDelta pushes the vector away from target.
        /// </summary>
        public static PointF MoveTowards(this PointF current, PointF target, float maxDistanceDelta)
        {
            var dir       = target.Sub(current);
            var magnitude = dir.Length();

            if (magnitude <= maxDistanceDelta || magnitude <= float.Epsilon)
            {
                return(target);
            }
            return(current.Add(dir.Mul(maxDistanceDelta / magnitude)));
        }
Exemple #42
0
 /// <summary>
 /// Linear interpolation
 /// </summary>
 public static PointF LerpTrim(this PointF x1, PointF x2, float k)
 {
     if (k < 0)
     {
         k = 0f;
     }
     if (k > 1)
     {
         k = 1f;
     }
     return(Lerp(x1, x2, k));
 }
Exemple #43
0
        public static PointF Intersection2(this PointF dir1, PointF point1, PointF dir2, PointF point2)
        {
            var x0 = point1.X;
            var p  = dir1.X;
            var y0 = point1.Y;
            var q  = dir1.Y;

            var x1 = point2.X;
            var p1 = dir2.X;
            var y1 = point2.Y;
            var q1 = dir2.Y;

            var x = (x0 * q * p1 - x1 * q1 * p - y0 * p * p1 + y1 * p * p1) / (q * p1 - q1 * p);
            var y = (y0 * p * q1 - y1 * p1 * q - x0 * q * q1 + x1 * q * q1) / (p * q1 - p1 * q);

            return(new PointF(x, y));
        }
Exemple #44
0
        // Find the point of intersection between
        // the lines p1 --> p2 and p3 --> p4.
        // Находит пересечение отрезков, если точно известно, что они пересекаются
        public static PointF SegmentIntersection(PointF p1, PointF p2, PointF p3, PointF p4)
        {
            // Get the segments' parameters.
            float dx12 = p2.X - p1.X;
            float dy12 = p2.Y - p1.Y;
            float dx34 = p4.X - p3.X;
            float dy34 = p4.Y - p3.Y;

            // Solve for t1 and t2
            float denominator = (dy12 * dx34 - dx12 * dy34);

            float t1 = ((p1.X - p3.X) * dy34 + (p3.Y - p1.Y) * dx34) / denominator;
            float t2 = ((p3.X - p1.X) * dy12 + (p1.Y - p3.Y) * dx12) / -denominator;

            // Find the point of intersection.
            return(new PointF(p1.X + dx12 * t1, p1.Y + dy12 * t1));
        }
Exemple #45
0
        /// <summary>
        /// Точка пересечения между двумя примыми, заднными направляющей и точкой
        /// </summary>
        public static PointF Intersection(this PointF dir1, PointF point1, PointF dir2, PointF point2)
        {
            var x2 = point1.X;
            var y2 = point1.Y;
            var x1 = point1.X + dir1.X;
            var y1 = point1.Y + dir1.Y;

            var a2 = point2.X;
            var b2 = point2.Y;
            var a1 = point2.X + dir2.X;
            var b1 = point2.Y + dir2.Y;

            var c = (b2 - b1) / (a2 - a1 + 0.00001f);
            var z = (y2 - y1) / (x2 - x1 + 0.00001f);

            var x = (c * x2 - y2 - z * a2 + b2) / (c - z);
            var y = c * x - c * x2 + y2;

            return(new PointF(x, y));
        }
Exemple #46
0
 /// <summary>
 /// Norma of cross product (норма векторного произведения, площадь натянутого паралелограмма)
 /// </summary>
 public static float DotVectorLength(this PointF x1, PointF x2)
 {
     return(Math.Abs(x1.X * x2.Y - x1.Y * x2.X));
 }
Exemple #47
0
 /// <summary>
 /// Angle from (-PI ; PI]
 /// </summary>
 public static float Angle(this PointF c)
 {
     return((float)Math.Atan2(c.Y, c.X));
 }
Exemple #48
0
        public static PointF InitFromAngle(this PointF c, float r, float angle)
        {
            var res = new PointF((float)(r * Math.Cos(angle)), (float)(r * Math.Sin(angle)));

            return(res);
        }
Exemple #49
0
 public static PointF Rotate90(this PointF c)
 {
     return(new PointF(-c.Y, c.X));
 }
Exemple #50
0
        /// <summary>
        /// Projection on direction
        /// </summary>
        public static PointF Projection(this PointF x, PointF normalizedDirection)
        {
            var cosAngle = x.X * normalizedDirection.X + x.Y * normalizedDirection.Y;

            return(new PointF(normalizedDirection.X * cosAngle, normalizedDirection.Y * cosAngle));
        }
Exemple #51
0
        public static PointF Inverse(this PointF c)
        {
            var res = new PointF(-c.X, -c.Y);

            return(res);
        }
Exemple #52
0
        /// <summary>
        /// Linear interpolation
        /// </summary>
        /// <param name="k">From 0 to 1</param>
        /// <returns></returns>
        public static PointF Lerp(this PointF x1, PointF x2, float k)
        {
            var m = 1.0f - k;

            return(new PointF(x1.X * m + x2.X * k, x1.Y * m + x2.Y * k));
        }
Exemple #53
0
        /// <summary>
        /// Complex conjugate (комплексно-сопряженный вектор)
        /// </summary>
        public static PointF Conjugate(this PointF c)
        {
            var res = new PointF(c.X, -c.Y);

            return(res);
        }
Exemple #54
0
 public static float CosAngle(this PointF c)
 {
     return(c.X / c.Length());
 }
Exemple #55
0
 public static System.Drawing.Point ToPoint(this PointF c)
 {
     return(new System.Drawing.Point((int)Math.Round(c.X), (int)Math.Round(c.Y)));
 }
Exemple #56
0
 public static PointF Rotate(this PointF c, float cosAngle, float sinAngle)
 {
     return(new PointF(cosAngle * c.X - sinAngle * c.Y, sinAngle * c.X + cosAngle * c.Y));
 }
Exemple #57
0
 /// <summary>
 /// Cos of angle betwwen this and other vector
 /// </summary>
 public static float CosAngle(this PointF x1, PointF x2)
 {
     return((x1.X * x2.X + x1.Y * x2.Y) / x1.Length() / x2.Length());
 }
Exemple #58
0
 /// <summary>
 /// Dot product for complex numbers (скалярное произведение комплексных чисел)
 /// </summary>
 public static PointF DotComplex(this PointF x1, PointF x2)
 {
     return(new PointF(x1.X * x2.X - x1.Y * x2.Y, x1.Y * x2.X + x1.X * x2.Y));
 }
Exemple #59
0
 public static string ToString(this PointF c)
 {
     return(string.Format("{0:0.00};{1:0.00}", c.X, c.Y));
 }
Exemple #60
0
 public static System.Drawing.PointF ToPointF(this PointF c)
 {
     return(new System.Drawing.PointF(c.X, c.Y));
 }