Esempio n. 1
0
        // Helper method which will invoke the MouseOverItem event.
        private void HandleMouseOverItem()
        {
            // cbSize must be set before calling GetComboBoxInfo.
            COMBOBOXINFO pcbi = new COMBOBOXINFO();

            pcbi.cbSize = Marshal.SizeOf(pcbi);

            // Get combo box information.
            GetComboBoxInfo(Handle, ref pcbi);
            // Check for invalid pointer... just in case.
            if (pcbi.hwndList == IntPtr.Zero)
            {
                return;
            }

            // Current position of cursor.
            POINT pt = Cursor.Position;

            /* LBItemFromPt will return the Index of the Item on success.
            ** The documentation states that this function will return zero
            ** if it fails. That is not true though. It will return 0 for the
            ** first item in the list box. This function returns -1 on error! */
            int retVal = LBItemFromPt(pcbi.hwndList, pt, false);

            if (retVal == -1)
            {
                return;
            }

            // Invoke the event.
            MouseOverItem?.Invoke(this, new MouseOverEventArgs(retVal));
        }
Esempio n. 2
0
 protected void Pick(MouseOverList mouseOverList, VertexPositionNormalTextureHue[] vertexBuffer)
 {
     if ((mouseOverList.PickType & PickType) == PickType)
     {
         if (((!DrawFlip) && mouseOverList.IsMouseInObject(vertexBuffer[0].Position, vertexBuffer[3].Position)) ||
             ((DrawFlip) && mouseOverList.IsMouseInObject(vertexBuffer[2].Position, vertexBuffer[1].Position)))
         {
             MouseOverItem item;
             if (!DrawFlip)
             {
                 item          = new MouseOverItem(DrawTexture, vertexBuffer[0].Position, Entity);
                 item.Vertices = new Vector3[4] {
                     vertexBuffer[0].Position, vertexBuffer[1].Position, vertexBuffer[2].Position, vertexBuffer[3].Position
                 };
             }
             else
             {
                 item          = new MouseOverItem(DrawTexture, vertexBuffer[2].Position, Entity);
                 item.Vertices = new Vector3[4] {
                     vertexBuffer[2].Position, vertexBuffer[0].Position, vertexBuffer[3].Position, vertexBuffer[1].Position
                 };
             }
             mouseOverList.Add2DItem(item);
         }
     }
 }
Esempio n. 3
0
        private bool Draw3DStretched(SpriteBatch3D spriteBatch, Vector3 drawPosition, MouseOverList mouseOverList, Map map)
        {
            // this is an isometric stretched tile and needs a specialized draw routine.
            m_vertexBufferAlternate[0].Position = drawPosition + m_vertex0_yOffset;
            m_vertexBufferAlternate[1].Position = drawPosition + m_vertex1_yOffset;
            m_vertexBufferAlternate[2].Position = drawPosition + m_vertex2_yOffset;
            m_vertexBufferAlternate[3].Position = drawPosition + m_vertex3_yOffset;

            if (!spriteBatch.Draw(DrawTexture, m_vertexBufferAlternate, s_Technique))
            {
                return(false);
            }

            if ((mouseOverList.PickType & PickType) == PickType)
            {
                if (mouseOverList.IsMouseInObjectIsometric(m_vertexBufferAlternate))
                {
                    MouseOverItem item = new MouseOverItem(DrawTexture, m_vertexBufferAlternate[0].Position, Entity);
                    item.Vertices = new Vector3[4] {
                        m_vertexBufferAlternate[0].Position, m_vertexBufferAlternate[1].Position, m_vertexBufferAlternate[2].Position, m_vertexBufferAlternate[3].Position
                    };
                    mouseOverList.Add2DItem(item);
                }
            }

            return(true);
        }
Esempio n. 4
0
    private void UpdateCamera()
    {
        if (ongui)
        {
            return;
        }
        RaycastHit h;
        var        screenPointToRay = camera.ScreenPointToRay(Input.mousePosition);


        if (_ObsCamera.spec)
        {
            mouseDir = camera.transform.forward;
            if (Physics.Raycast(screenPointToRay, out h, 20, 1 << (int)Layer.Level | 1 << (int)Layer.Enemy))
            {
                mousePos = ZeroY(h.point);
                _ObsCamera.transform.LookAt(h.point);
            }
            else
            {
                mousePos = ZeroY(_ObsCamera.camT.position + mouseDir * 10);
            }
        }
        else
        {
            plane.collider.Raycast(screenPointToRay, out h, 1000);
            mousePos = ZeroY(h.point);
            mouseDir = ZeroY(h.point - upPos).normalized;
        }
        MouseOverEnemy = null;
        foreach (var a in _Game.zombies)
        {
            if (a.alive)
            {
                float m = 2;
                if ((mousePos - a.upPos).magnitude < m)
                {
                    m = (mousePos - a.pos).magnitude;
                    MouseOverEnemy = a;
                }
            }
        }
        if (Physics.Raycast(screenPointToRay, out h, 100, 1 << (int)Layer.Coin))
        {
            var coin = h.transform.root.GetComponent <DroppedItem>();
            if (coin != null)
            {
                coin.Shine(true);
                MouseOverItem = coin;
            }
        }
        else
        {
            if (MouseOverItem != null)
            {
                MouseOverItem.Shine(false);
                MouseOverItem = null;
            }
        }
        if (Input.GetKeyDown(KeyCode.Mouse0) && MouseOverItem != null)
        {
            oldMouse0 = false;
            foreach (Slot a in _Game.inventorySlots)
            {
                if (a.item == null)
                {
                    a.item = MouseOverItem.item;
                    Destroy(MouseOverItem.gameObject);
                    break;
                }
            }
        }
        _Hud.progressBar.gameObject.SetActive(MouseOverEnemy);
        if (MouseOverEnemy)
        {
            _Hud.progressBarTitle.text   = MouseOverEnemy.name;
            _Hud.progressBarTitle2.text  = MouseOverEnemy.modelGroup.ToString();
            _Hud.progressBar.sliderValue = (float)MouseOverEnemy.life / MouseOverEnemy.maxlife;
        }
    }
Esempio n. 5
0
        private void render(out Vector2 renderOffset)
        {
            // Prerender objects
            _spriteBatch.Prepare(false, false);
            MapObjectPrerendered.RenderObjects(_spriteBatch);

            // ClientVars.EngineVars.RenderSize = 20;

            int RenderBeginX = CenterPosition.X - (ClientVars.EngineVars.RenderSize / 2);
            int RenderBeginY = CenterPosition.Y - (ClientVars.EngineVars.RenderSize / 2);
            int RenderEndX = RenderBeginX + ClientVars.EngineVars.RenderSize;
            int RenderEndY = RenderBeginY + ClientVars.EngineVars.RenderSize;

            renderOffset.X = (ClientVars.EngineVars.BackBufferWidth >> 1) - 22;
            renderOffset.X -= (int)((CenterPosition.X_offset - CenterPosition.Y_offset) * 22);
            renderOffset.X -= (RenderBeginX - RenderBeginY) * 22;

            renderOffset.Y = ((ClientVars.EngineVars.BackBufferHeight - (ClientVars.EngineVars.RenderSize * 44)) >> 1);
            renderOffset.Y += (CenterPosition.Z * 4) + (int)(CenterPosition.Z_offset * 4);
            renderOffset.Y -= (int)((CenterPosition.X_offset + CenterPosition.Y_offset) * 22);
            renderOffset.Y -= (RenderBeginX + RenderBeginY) * 22;

            ObjectsRendered = 0; // Count of objects rendered for statistics and debug
            MouseOverList overList = new MouseOverList(); // List of items for mouse over
            overList.MousePosition = _input.MousePosition;
            List<MapObject> mapObjects;
            Vector3 drawPosition = new Vector3();

            for (int ix = RenderBeginX; ix < RenderEndX; ix++)
            {
                drawPosition.X = (ix - RenderBeginY) * 22 + renderOffset.X;
                drawPosition.Y = (ix + RenderBeginY) * 22 + renderOffset.Y;

                DrawTerrain = true;

                for (int iy = RenderBeginY; iy < RenderEndY; iy++)
                {
                    MapTile tile = Map.GetMapTile(ix, iy, true);
                    if (tile == null)
                        continue;

                    mapObjects = tile.Items;
                    for (int i = 0; i < mapObjects.Count; i++)
                    {
                        if (mapObjects[i].Draw(_spriteBatch, drawPosition, overList, PickType, _maxItemAltitude))
                            ObjectsRendered++;
                    }
                    tile.ClearTemporaryObjects();

                    drawPosition.X -= 22f;
                    drawPosition.Y += 22f;
                }
            }

            // Update the MouseOver objects
            _overObject = overList.GetForemostMouseOverItem(_input.MousePosition);
            _overGround = overList.GetForemostMouseOverItem<MapObjectGround>(_input.MousePosition);

            // Draw the objects we just send to the spritebatch.
            _spriteBatch.Prepare(true, true);
            _spriteBatch.Flush();
        }
        private bool Draw3DStretched(SpriteBatch3D sb, Vector3 drawPosition, MouseOverList molist, PickTypes pickType, int maxAlt)
        {
            // this is an isometric stretched tile and needs a specialized draw routine.
            _vertexBufferAlternate[0].Position = drawPosition + _vertex0_yOffset;
            _vertexBufferAlternate[1].Position = drawPosition + _vertex1_yOffset;
            _vertexBufferAlternate[2].Position = drawPosition + _vertex2_yOffset;
            _vertexBufferAlternate[3].Position = drawPosition + _vertex3_yOffset;

            if (!sb.Draw(_draw_texture, _vertexBufferAlternate))
                return false;

            if ((pickType & _pickType) == _pickType)
                if (molist.IsMouseInObjectIsometric(_vertexBufferAlternate))
                {
                    MouseOverItem item = new MouseOverItem(_draw_texture, _vertexBufferAlternate[0].Position, this);
                    item.Vertices = new Vector3[4] { _vertexBufferAlternate[0].Position, _vertexBufferAlternate[1].Position, _vertexBufferAlternate[2].Position, _vertexBufferAlternate[3].Position };
                    molist.Add2DItem(item);
                }

            return true;
        }
Esempio n. 7
0
        internal virtual bool Draw(SpriteBatch3D sb, Vector3 drawPosition, MouseOverList molist, PickTypes pickType, int maxAlt)
        {
            VertexPositionNormalTextureHue[] vertexBuffer;

            if (Z >= maxAlt)
                return false;

            if (m_draw_flip)
            {
                // 2   0
                // |\  |
                // |  \|
                // 3   1
                vertexBuffer = VertexPositionNormalTextureHue.PolyBufferFlipped;
                vertexBuffer[0].Position = drawPosition;
                vertexBuffer[0].Position.X += m_draw_X + 44;
                vertexBuffer[0].Position.Y -= m_draw_Y;

                vertexBuffer[1].Position = vertexBuffer[0].Position;
                vertexBuffer[1].Position.Y += m_draw_height;

                vertexBuffer[2].Position = vertexBuffer[0].Position;
                vertexBuffer[2].Position.X -= m_draw_width;

                vertexBuffer[3].Position = vertexBuffer[1].Position;
                vertexBuffer[3].Position.X -= m_draw_width;
            }
            else
            {
                // 0---1
                //    /
                //  /
                // 2---3
                vertexBuffer = VertexPositionNormalTextureHue.PolyBuffer;
                vertexBuffer[0].Position = drawPosition;
                vertexBuffer[0].Position.X -= m_draw_X;
                vertexBuffer[0].Position.Y -= m_draw_Y;

                vertexBuffer[1].Position = vertexBuffer[0].Position;
                vertexBuffer[1].Position.X += m_draw_width;

                vertexBuffer[2].Position = vertexBuffer[0].Position;
                vertexBuffer[2].Position.Y += m_draw_height;

                vertexBuffer[3].Position = vertexBuffer[1].Position;
                vertexBuffer[3].Position.Y += m_draw_height;
            }

            if (vertexBuffer[0].Hue != m_draw_hue)
                vertexBuffer[0].Hue = vertexBuffer[1].Hue = vertexBuffer[2].Hue = vertexBuffer[3].Hue = m_draw_hue;

            if (!sb.Draw(m_draw_texture, vertexBuffer))
            {
                return false;
            }

            if (m_draw_IsometricOverlap)
            {
                drawIsometricOverlap(sb, vertexBuffer, new Vector2(drawPosition.X, drawPosition.Y - (Z * 4)));
            }

            if ((pickType & m_pickType) == m_pickType)
            {
                if (((!m_draw_flip) && molist.IsMouseInObject(vertexBuffer[0].Position, vertexBuffer[3].Position)) ||
                    ((m_draw_flip) && molist.IsMouseInObject(vertexBuffer[2].Position, vertexBuffer[1].Position)))
                {
                    MouseOverItem item;
                    if (!m_draw_flip)
                    {
                        item = new MouseOverItem(m_draw_texture, vertexBuffer[0].Position, this);
                        item.Vertices = new Vector3[4] { vertexBuffer[0].Position, vertexBuffer[1].Position, vertexBuffer[2].Position, vertexBuffer[3].Position };
                    }
                    else
                    {
                        item = new MouseOverItem(m_draw_texture, vertexBuffer[2].Position, this);
                        item.Vertices = new Vector3[4] { vertexBuffer[2].Position, vertexBuffer[0].Position, vertexBuffer[3].Position, vertexBuffer[1].Position };
                    }
                    molist.Add2DItem(item);
                }
            }

            return true;
        }