Example #1
0
        private void InitiatePolygonalBuilding()
        {
            if (CurrentPolygonWall == null)
            {
                // save mouse start position
                GlobalManagement.Instance.BuildingStartLocation = MousePosition.PxToMeter();
                NewPolygonalBuildingWalls = new List <WallElement>();
            }
            // create wall of building
            CurrentPolygonWall = new WallElement(new Wall()
            {
                Name = Constants.DefaultWallName
            });
            Point meterPosition = MousePosition.PxToMeter();

            CurrentPolygonWall.X1 = meterPosition.X;
            CurrentPolygonWall.Y1 = meterPosition.Y;
            CurrentPolygonWall.X2 = meterPosition.X;
            CurrentPolygonWall.Y2 = meterPosition.Y;

            NewPolygonalBuildingWalls.Add(CurrentPolygonWall);

            // add wall to map
            MapEntities.Add(CurrentPolygonWall);
        }
Example #2
0
    public void Update()
    {
        if (!activated)
        {
            CheckSafety();
            HeroPlacement();
        }
        else
        {
            if (health <= 0)
            {
                Death();
            }
        }

        index         = gameplay.heroes.IndexOf(this);
        mousePosition = MousePosition.Instance().position;

        HealthRender();

        if (enemiesInRange.Count == 0)
        {
            Detection(false);
            numberOfTargets = 0;
            focus           = null;
        }

        if (xp >= toNextLevel)
        {
            LevelUp();
        }
    }
        private void LayoutEditor_MouseUp(object sender, MouseEventArgs e)
        {
            if (!IsDragging)
            {
                if (e.Button.HasFlag(MouseButtons.Right))
                {
                    var p = PointToScreen(new Point(e.X, e.Y));

                    if (_barrels == null)
                    {
                        showBarrelsToolStripMenuItem.Enabled = showBarrelsToolStripMenuItem.Checked = false;
                    }
                    if (Image == null)
                    {
                        showImageToolStripMenuItem.Enabled = showImageToolStripMenuItem.Checked = false;
                    }
                    if (_engines == null)
                    {
                        showEnginesToolStripMenuItem.Enabled = showEnginesToolStripMenuItem.Checked = false;
                    }

                    contextMenuStrip1.Show(p);
                }
                return;
            }

            var celltype  = _mouseButton == MouseButtons.Left ? SelectedCategory : EraseCategory;
            var cellIndex = PointToCellIndex(e.X, e.Y);
            var position  = new MousePosition(e.X, e.Y, cellIndex);

            _selectedBrush.OnMouseUp(position, _layout, celltype);
            _mouseButton = MouseButtons.None;
            Invalidate();
        }
Example #4
0
    public void Launch(GameObject launchSite, int count)
    {
        // DebugScript = DebugCollider.GetComponent<DebugGameScript>();
        // DebugScript.Collider = Collider;
        MissileCount++;
        missileCommnandScript.MissileLaunched();
        TargetPoint = MousePosition.ToWorldSpace().ChangeZ(Z);
        MarkTarget(TargetPoint);

        var shape2d = gameObject.GetComponent <Shapes2D.Shape>();
        //shape2d.enabled = false;
        var spriteRenderer = gameObject.GetComponent <SpriteRenderer>();

        spriteRenderer.enabled = false;

        Vector3[] poses1 = new Vector3[2];
        lineRenderer.GetPositions(poses1);

        var pos = launchSite.transform.position;

        pos.z       = Z;
        LaunchPoint = new SpacePoint(Graphics.Space.World, pos);
        poses1[0]   = poses1[1] = LaunchPoint.Position;
        lineRenderer.SetPositions(poses1);
        Delta = Delta(LaunchPoint, TargetPoint);
        lineRenderer.enabled = true;
        tweener = Tweener2d.LinearTweener(LaunchPoint.Position, TargetPoint.Position, Velocity).GetEnumerator();
        State   = PlayerMissileState.Traveling;
    }
Example #5
0
        private IObject findObject(IViewport viewport, MousePosition position, Predicate <IObject> filter)
        {
            List <IObject> visibleObjects = _displayList.GetDisplayList(viewport);

            return(getObjectAt(visibleObjects, position.GetViewportX(viewport),
                               position.GetViewportY(viewport), viewport, filter));
        }
Example #6
0
 private void MouseService_MousePositionChanged(MousePosition position)
 {
     this.Invoke(new MethodInvoker(delegate
     {
         mousePositionLabels[mousePositionLabels.Keys.First()].Text = "Mouse pos: " + position.X + ", " + position.Y;
     }));
 }
    private void HandleAim()
    {
        var mousePos = MousePosition.GetMouseWorldPosition(Input.mousePosition, Camera.main);

        var aimDirection = (mousePos - transform.position).normalized;
        var angle        = Mathf.Atan2(aimDirection.y, aimDirection.x) * Mathf.Rad2Deg;

        aimTransform.eulerAngles = new Vector3(0, 0, angle);

        var localScale = new Vector3(0.5f, 0.5f, 1f);

        if (angle > 90 || angle < -90)
        {
            gameObject.transform.rotation = new Quaternion(0, 180, 0, 0);
            localScale.y = -0.5f;
        }

        else
        {
            gameObject.transform.rotation = new Quaternion(0, 0, 0, 0);
            localScale.y = 0.5f;
        }

        aimTransform.localScale = localScale;
    }
Example #8
0
    public override void UseSpell()
    {
        timer += Time.deltaTime;


        if (Input.GetButton("Fire1") && Player.energy > energyCost)
        {
            if (timer > 0.5f)
            {
                timer = 0;
            }
            else
            {
                return;
            }

            Player.energy -= energyCost;

            Destroy(Instantiate(particleSystem, transform.position, Quaternion.Euler(0, 0, Player.rotationZ)).gameObject, 3f);

            Vector3 mousePos     = MousePosition.GetMouseWorldPosition();
            Vector3 aimDirection = (mousePos - transform.position).normalized;


            RaycastHit2D hit = Physics2D.Raycast(transform.position, aimDirection, 15f);

            Debug.Log(hit.collider);

            ApplyDamage(hit.collider);


            Destroy(Instantiate(GameLogic.Instance.expolionPaticles, hit.collider.transform.position, Quaternion.identity), 0.5f);
        }
    }
Example #9
0
        private void updateEditorCursor(MousePosition mousePosition)
        {
            if (IsPaused)
            {
                if (_editorState.Cursor != null) return;
                _editorState.Cursor = _pointer;
                return;
            }

            var viewport = _game.State.Viewport;
            var projectBottom = _windowInfo.AppWindowHeight - viewport.ScreenArea.Y - viewport.ProjectionBox.Y * viewport.ScreenArea.Height;
            var projectTop = projectBottom - viewport.ProjectionBox.Height * viewport.ScreenArea.Height;

            if (mousePosition.XWindow < viewport.ScreenArea.X ||
                mousePosition.XWindow > viewport.ScreenArea.X + viewport.ScreenArea.Width ||
                mousePosition.YWindow < projectTop ||
                mousePosition.YWindow > projectBottom)
            {
                _editorState.Cursor = _pointer;
            }
            else
            {
                _editorState.Cursor = null;
            }
        }
    void Start()
    {
        mousePosition = GetComponent <MousePosition>();

        argsBuffer = new ComputeBuffer(1, args.Length * sizeof(uint), ComputeBufferType.IndirectArguments);
        UpdateBuffers();
    }
Example #11
0
 private void pnlTitle_MouseMove(object sender, MouseEventArgs e)
 {
     if (e.Button == MouseButtons.Left)
     {
         Location = MousePosition.Diff(dicMousePoint[e.Button]);
     }
 }
Example #12
0
    private void MoveToCursor()
    {
        Vector3 worldMPos = MousePosition.GetMouseWorldPos(0f, cam);

        this.transform.position = new Vector3(worldMPos.x, worldMPos.y, this.transform.position.z);
        //this.transform.position = Vector3.Lerp(this.transform.position, worldMPos, 6f);
    }
    private void TriggerAttack()
    {
        var mousePos        = Input.mousePosition;
        var direction       = MousePosition.GetMouseWorldPosition(mousePos, mainCamera);
        var attackDirection = (transform.position - direction).normalized;
        var angle           = Mathf.Atan2(attackDirection.y, attackDirection.x) * Mathf.Rad2Deg;

        if ((angle < -135 && angle > -180) || (angle > 135 && angle < 180))
        {
            animator.SetTrigger("Attack_S");
            currentAttackPoint         = attackPoints[0];
            rendererTransform.rotation = new Quaternion(0, 0, 0, 0);
        }
        else if (angle > -45 && angle < 45)
        {
            animator.SetTrigger("Attack_S");
            currentAttackPoint         = attackPoints[1];
            rendererTransform.rotation = new Quaternion(0, 180, 0, 0);
        }
        else if (angle < -45 && angle > -135)
        {
            currentAttackPoint = attackPoints[2];
            animator.SetTrigger("Attack_U");
        }
        else if (angle > 45 && angle < 135)
        {
            currentAttackPoint = attackPoints[3];
            animator.SetTrigger("Attack_D");
        }
    }
Example #14
0
 public bool InputOutsideRectangle(Rectangle rect, InputState state)
 {
     if (!rect.Contains(MousePosition.ToPoint()))
     {
         return(LMBState == state || RMBState == state || MMBState == state);
     }
     return(false);
 }
Example #15
0
            /// <summary>
            /// This method will call the OnMouseMove event exposed from the library and pass on the location of the mouse pointer.
            /// </summary>
            /// <param name="e">Argument passed by the MouseEvent under the Internal GlobalMouseHook.</param>
            /// <returns>Returns true if the event was handled and false if not.</returns>
            bool MouseMove(InternalGlobalMouseHook.POINT mousePos)
            {
                //Compared to the previous two methods, we just need the position of the mouse as it moved.
                MousePosition        mousePosition        = new MousePosition(mousePos.x, mousePos.y);
                GlobalMouseEventArgs globalMouseEventArgs = new GlobalMouseEventArgs(GHMouseButtons.None, mousePosition); //No button was pressed. We only need to pass on the mousePosition to the event.

                return(CallEvent(OnMouseMove, globalMouseEventArgs));
            }
Example #16
0
        private void setMousePosition(MousePositionEventArgs e)
        {
            float x = convertX(e.MousePosition.XWindow);
            float y = convertY(e.MousePosition.YWindow);

            MousePosition = new MousePosition(x, y, _coordinates);
            _hitTest.Refresh(MousePosition);
        }
Example #17
0
        private void setMousePosition(MousePositionEventArgs e)
        {
            float x = convertX(e.MousePosition.XWindow);
            float y = convertY(e.MousePosition.YWindow);

            updateWindowSizeFunctions();
            MousePosition = new MousePosition(x, y, _state.Viewport);
        }
Example #18
0
        protected override void OnProcessOutputSchema(MutableObject newSchema)
        {
            WorldPosition.SetValue(Vector3.one, newSchema);
            MousePosition.SetValue(Vector3.one, newSchema);
            DragActive.SetValue(true, newSchema);

            Router.TransmitAllSchema(newSchema);
        }
Example #19
0
    public static MousePosition Instance()
    {
        if (instance == null)
        {
            instance = new GameObject("MousePosition").AddComponent <MousePosition>();
        }

        return(instance);
    }
Example #20
0
    public void Awake()
    {
        gameplay      = Gameplay.Instance();
        tavern        = Tavern.Instance();
        mousePosition = MousePosition.Instance();
        infoPopup     = InfoPopup.Instance();

        selected = false;
    }
Example #21
0
 private void lb_ShowText_MouseMove(object sender, MouseEventArgs e)
 {
     if (ModifierKeys == Keys.Control && MouseButtons == MouseButtons.Left &&
         this.Location !=
         PaintManager.CurrentView.PointToClient(MousePosition.AddOffset(new Point(-MouseDownPosition.X, -MouseDownPosition.Y))))
     {
         this.Location = PaintManager.CurrentView.PointToClient(MousePosition.AddOffset(new Point(-MouseDownPosition.X, -MouseDownPosition.Y)));
     }
 }
Example #22
0
        void OpenNewWallpaper(MousePosition pos)
        {
            var dialog = new OpenFileDialog();

            if (dialog.ShowDialog() == DialogResult.OK)
            {
                Framework.Wallpaper.Set(dialog.FileName, Framework.Wallpaper.Style.Stretched);
            }
        }
Example #23
0
    private void FlipSpriteX()
    {
        Vector3 mPos = MousePosition.GetMouseWorldPos(0f, cam);
        Vector3 dir  = (mPos - transform.position).normalized;

        float angle = Mathf.Atan2(dir.y, dir.x) * Mathf.Rad2Deg;

        ps.facingLeft = angle > 90 || angle < -90;
    }
 // Update is called once per frame
 void LateUpdate()
 {
     if (StateManager.Instance.State == GameState.targetingAbility)
     {
         if (Input.GetButtonDown("Cancel"))
         {
             Cancel();
         }
         else if (Input.GetMouseButtonDown(0))
         {
             Tile clicked = MousePosition.GetTile();
             if (listener.GetAvailableTargets().Contains(clicked))
             {
                 StateManager.Instance.DebugPop();
                 listener.Notify(clicked);
                 Tile.UnColourAll();
             }
         }
         else if (_aoe == AreaOfEffect.Burst)
         {
             Tile.UnColourAll();
             // colour tiles in the Area
             foreach (Tile t in _targets)
             {
                 t.ColourMe(Color.green);
             }
             // colours tiles in the area of effect
             Tile mt = MousePosition.GetTile();
             if (_targets.Contains(mt))
             {
                 foreach (Tile t in Burst(mt))
                 {
                     t.ColourMe(Color.red);
                 }
             }
         }
         else if (_aoe == AreaOfEffect.Line)
         {
             Tile.UnColourAll();
             // colour tiles in the Area
             foreach (Tile t in _targets)
             {
                 t.ColourMe(Color.green);
             }
             // colours tiles in the area of effect
             Tile mt = MousePosition.GetTile();
             if (_targets.Contains(mt))
             {
                 foreach (Tile t in Line3(_orig, mt))
                 {
                     t.ColourMe(Color.red);
                 }
             }
         }
     }
 }
Example #25
0
        public AndroidInput(AndroidSimpleGestures gestures, AGS.API.Size virtualResolution,
                            IGameState state, IShouldBlockInput shouldBlockInput, IGameWindowSize windowSize)
        {
            MousePosition     = new MousePosition(0f, 0f, state.Viewport);
            _shouldBlockInput = shouldBlockInput;
            _windowSize       = windowSize;
            _state            = state;
            API.MousePosition.VirtualResolution = virtualResolution;
            float density = Resources.System.DisplayMetrics.Density;

            API.MousePosition.GetWindowWidth  = () => (int)(_windowSize.GetWidth(null) - ((GLUtils.ScreenViewport.X * 2) / density));
            API.MousePosition.GetWindowHeight = () => (int)(_windowSize.GetHeight(null) - ((GLUtils.ScreenViewport.Y * 2) / density));
            MouseDown = new AGSEvent <AGS.API.MouseButtonEventArgs>();
            MouseUp   = new AGSEvent <AGS.API.MouseButtonEventArgs>();
            MouseMove = new AGSEvent <MousePositionEventArgs>();
            KeyDown   = new AGSEvent <KeyboardEventArgs>();
            KeyUp     = new AGSEvent <KeyboardEventArgs>();

            gestures.OnUserDrag += async(sender, e) =>
            {
                if (isInputBlocked())
                {
                    return;
                }
                DateTime now = DateTime.Now;
                _lastDrag   = now;
                IsTouchDrag = true;
                setMousePosition(e);
                await MouseMove.InvokeAsync(new MousePositionEventArgs(MousePosition));

                await Task.Delay(300);

                if (_lastDrag <= now)
                {
                    IsTouchDrag = false;
                }
            };
            gestures.OnUserSingleTap += async(sender, e) =>
            {
                if (isInputBlocked())
                {
                    return;
                }
                setMousePosition(e);
                LeftMouseButtonDown = true;
                await MouseDown.InvokeAsync(new MouseButtonEventArgs(null, MouseButton.Left, MousePosition));

                await Task.Delay(250);

                await MouseUp.InvokeAsync(new MouseButtonEventArgs(null, MouseButton.Left, MousePosition));

                LeftMouseButtonDown = false;
            };
            AndroidGameWindow.Instance.OnNewView += onViewChanged;
            onViewChanged(null, AndroidGameWindow.Instance.View);
        }
 private void ProcessMousePositionUpdate(MousePosition mousePosition)
 {
     if (ConfigurationService.InstanceId == mousePosition.RecipientId)
     {
         if (MousePositionUpdate != null)
         {
             MousePositionUpdate(mousePosition);
         }
     }
 }
Example #27
0
    private Vector2 CalcDir()
    {
        Vector3 mPos = MousePosition.GetMouseWorldPos(0f, cam);
        Vector3 tmp  = (mPos - player.position).normalized;
        Vector2 dir  = new Vector2(-Mathf.Round(tmp.x), -Mathf.Round(tmp.y));

        //Vector2 dir = new Vector2(-tmp.x, -tmp.y);
        Debug.Log("DIR: " + dir);
        return(dir);
    }
Example #28
0
    private Vector3 calcTargetPos(float x, float y)
    {
        Vector3 mPos = MousePosition.GetMouseWorldPos(6f, cam);
        Vector3 tPos = (player.position + mPos) / 2f;

        tPos.x = Mathf.Clamp(tPos.x, -x + player.position.x, x + player.position.x);
        tPos.y = Mathf.Clamp(tPos.y, -y + player.position.y, y + player.position.y);

        return(tPos);
    }
    // Called once in its life time
    private void Awake()
    {
        this.cursor        = this.GetComponent <Image>();
        this.rectTransform = this.GetComponent <RectTransform>();

        this.mouseScreenBehaviour    = this.GetComponent <MouseScreenBehaviour>();
        this.mouseSelectionBehaviour = this.GetComponent <MouseSelectionBehaviour>();

        this.mousePosition = new MousePosition();
    }
        public void ATestyTest()
        {
            MousePosition postion = new MousePosition();

            postion.X = 10;

            postion.Y = 10;

            IrisCore.MouseService.SetMousePosition(postion);
        }
Example #31
0
 public bool Contains(MousePosition.MousePosition point)
 {
     return Contains(point.GridPoint.X, point.GridPoint.Y);
 }
Example #32
0
 public MapChip GetChip(MousePosition.MousePosition select)
 {
     return _mapChipList[select.GridPoint.Y, select.GridPoint.X];
 }
	/// <summary>
	/// Update this instance.
	/// </summary>
	void Update () 
	{
		// Right mouse button - explode any sprite the we click on
		if(Input.GetMouseButtonDown(0) && (Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.LeftAlt)))
		{
			Vector3 mouseWorldPosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
			mouseWorldPosition.z = Camera.main.transform.position.z;

			RaycastHit2D rayCastResult = Physics2D.Raycast(mouseWorldPosition, new Vector3(0, 0, 0), 0.0f);

			if (rayCastResult.rigidbody)
			{
				if(Input.GetKey(KeyCode.LeftControl))
				{
					SpriteSlicer2D.ExplodeSprite(rayCastResult.rigidbody.gameObject, 16, 400.0f, true, ref m_SlicedSpriteInfo);

					if(m_SlicedSpriteInfo.Count == 0)
					{
						// Couldn't cut for whatever reason, add some force anyway
						rayCastResult.rigidbody.AddForce(new Vector2(0.0f, 400.0f));
					}
				}
			}
		}

		// Left mouse button - hold and swipe to cut objects
		else if(Input.GetMouseButton(0))
		{
			bool mousePositionAdded = false;
			m_MouseRecordTimer -= Time.deltaTime;

			// Record the world position of the mouse every x seconds
			if(m_MouseRecordTimer <= 0.0f)
			{
				MousePosition newMousePosition = new MousePosition();
				newMousePosition.m_WorldPosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
				newMousePosition.m_Time = Time.time;

				m_MousePositions.Add(newMousePosition);
				m_MouseRecordTimer = m_MouseRecordInterval;
				mousePositionAdded = true;

				// Remove the first recorded point if we've recorded too many
				if(m_MousePositions.Count > m_MaxMousePositions)
				{
					m_MousePositions.RemoveAt(0);
				}
			}

			// Forget any positions that are too old to care about
			if(m_MousePositions.Count > 0 && (Time.time - m_MousePositions[0].m_Time) > m_MouseRecordInterval * m_MaxMousePositions)
			{
				m_MousePositions.RemoveAt(0);
			}

			// Go through all our recorded positions and slice any sprites that intersect them
			if(mousePositionAdded)
			{
				for(int loop = 0; loop < m_MousePositions.Count - 1; loop++)
				{
					SpriteSlicer2D.SliceAllSprites(m_MousePositions[loop].m_WorldPosition, m_MousePositions[m_MousePositions.Count - 1].m_WorldPosition, true, ref m_SlicedSpriteInfo);

					if(m_SlicedSpriteInfo.Count > 0)
					{
						// Add some force in the direction of the swipe so that stuff topples over rather than just being
						// sliced but remaining stationary
						for(int spriteIndex = 0; spriteIndex < m_SlicedSpriteInfo.Count; spriteIndex++)
						{
							for(int childSprite = 0; childSprite < m_SlicedSpriteInfo[spriteIndex].ChildObjects.Count; childSprite++)
							{
								Vector2 sliceDirection = m_MousePositions[m_MousePositions.Count - 1].m_WorldPosition - m_MousePositions[loop].m_WorldPosition;
								sliceDirection.Normalize();
								m_SlicedSpriteInfo[spriteIndex].ChildObjects[childSprite].GetComponent<Rigidbody2D>().AddForce(sliceDirection * 500.0f);
							}
						}

						m_MousePositions.Clear();
						break;
					}
				}
			}

			if(m_TrailRenderer)
			{
				Vector3 trailPosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
				trailPosition.z = -9.0f;
				m_TrailRenderer.transform.position = trailPosition;
			}
		}
		else
		{
			m_MousePositions.Clear();
		}

		// Sliced sprites sharing the same layer as standard Unity sprites could increase the draw call count as
		// the engine will have to keep swapping between rendering SlicedSprites and Unity Sprites.To avoid this, 
		// move the newly sliced sprites either forward or back along the z-axis after they are created
		for(int spriteIndex = 0; spriteIndex < m_SlicedSpriteInfo.Count; spriteIndex++)
		{
			for(int childSprite = 0; childSprite < m_SlicedSpriteInfo[spriteIndex].ChildObjects.Count; childSprite++)
			{
				Vector3 spritePosition = m_SlicedSpriteInfo[spriteIndex].ChildObjects[childSprite].transform.position;
				spritePosition.z = -1.0f;
				m_SlicedSpriteInfo[spriteIndex].ChildObjects[childSprite].transform.position = spritePosition;
			}
		}

        if(m_FadeFragments)
        {
            // If we've chosen to fade out fragments once an object is destroyed, add a fade and destroy component
            for (int spriteIndex = 0; spriteIndex < m_SlicedSpriteInfo.Count; spriteIndex++)
            {
                for (int childSprite = 0; childSprite < m_SlicedSpriteInfo[spriteIndex].ChildObjects.Count; childSprite++)
                {
                    if (!m_SlicedSpriteInfo[spriteIndex].ChildObjects[childSprite].GetComponent<Rigidbody2D>().isKinematic)
                    {
                        m_SlicedSpriteInfo[spriteIndex].ChildObjects[childSprite].AddComponent<FadeAndDestroy>();
                    }                    
                }
            }
        }

		m_SlicedSpriteInfo.Clear();
	}