示例#1
0
        /// <summary>
        /// Update
        /// </summary>
        public override void Update()
        {
            DemoReel demo = (DemoReel)RB.Game;

            mShiftPressed = false;
            if (RB.KeyDown(KeyCode.LeftShift) || RB.KeyDown(KeyCode.RightShift) || mKeys["LeftShift"].WasPointerPressed || mKeys["RightShift"].WasPointerPressed)
            {
                mShiftPressed = true;
            }

            mNextButton.Update();
            mPrevButton.Update();

            ProcessStringInput(RB.InputString());

            int color = 1;

            if ((RB.Ticks % 200 > 170 && RB.Ticks % 200 < 180) || (RB.Ticks % 200) > 190)
            {
                color = 5;
            }

            mNextButton.LabelColor = color;
            mPrevButton.LabelColor = color;

            mScrollDelta = RB.PointerScrollDelta();

            mScrollDeltaAnim = Mathf.Lerp(mScrollDeltaAnim, mScrollDelta, 0.25f);

            if (RB.ButtonPressed(RB.BTN_SYSTEM))
            {
                Application.Quit();
            }
        }
示例#2
0
    public static Character checkCharacterInput(Map curMap, Character c)
    {
        Vector2i newPos = c.position;

        if (RB.KeyDown(KeyCode.W))
        {
            newPos.y -= 10;
        }

        if (RB.KeyDown(KeyCode.A))
        {
            newPos.x -= 10;
        }

        if (RB.KeyDown(KeyCode.S))
        {
            newPos.y += 10;
        }

        if (RB.KeyDown(KeyCode.D))
        {
            newPos.x += 10;
        }

        if (!curMap.isTileBlocked(newPos, c.size))
        {
            c.position = newPos;
        }

        return(c);
    }
示例#3
0
 public override void Update()
 {
     base.Update();
     if (hasFocus)
     {
         if (RB.KeyPressed(KeyCode.Return))
         {
             OnLoseFocus();
             return;
         }
         if (RB.KeyPressed(KeyCode.Backspace))
         {
             TickBackspaceDown = RB.Ticks;
         }
         if (RB.KeyDown(KeyCode.Backspace))
         {
             if ((RB.Ticks - TickBackspaceDown) % 8 == 0)
             {
                 //if(text.EndsWith("|")) {
                 //	RemoveText(2);
                 //	text.Append('|');
                 //} else {
                 RemoveText(1);
                 //}
             }
         }
         else
         {
             AddText(RB.InputString().Trim());
         }
     }
 }
示例#4
0
        private bool AnyPlayerKeyDown()
        {
            for (int i = 0; i < PlayerKeyCodes.Length; i++)
            {
                if (RB.KeyDown(PlayerKeyCodes[i]))
                {
                    return(true);
                }
            }

            return(false);
        }
示例#5
0
        private void HandlePlayerTurnKeys(ResultSet resultSet)
        {
            // Check if we should block all player input until all keys are up
            // This is useful to block player input when exiting menus
            if (mBlockMoveUntilKeyUp)
            {
                if (!AnyPlayerKeyDown())
                {
                    mBlockMoveUntilKeyUp = false;
                }
                else
                {
                    return;
                }
            }

            if (RB.ButtonPressed(RB.BTN_SYSTEM))
            {
                resultSet.AddExit();
                return;
            }

            if (RB.KeyPressed(KeyCode.I))
            {
                resultSet.AddShowInventory();
            }

            if (RB.KeyPressed(KeyCode.O))
            {
                resultSet.AddDropInventory();
            }

            if (RB.KeyPressed(KeyCode.P))
            {
                resultSet.AddShowCharacterScreen();
            }

            if (RB.KeyPressed(KeyCode.Return) || RB.KeyPressed(KeyCode.KeypadEnter))
            {
                resultSet.AddTakeStairs();
            }

            if (RB.KeyPressed(KeyCode.H))
            {
                resultSet.AddShowHelp();
            }

            Vector2i delta = Vector2i.zero;

            if (RB.KeyDown(KeyCode.W) || RB.KeyDown(KeyCode.Keypad8))
            {
                delta.y--;
            }
            else if (RB.KeyDown(KeyCode.S) || RB.KeyDown(KeyCode.Keypad2))
            {
                delta.y++;
            }
            else if (RB.KeyDown(KeyCode.A) || RB.KeyDown(KeyCode.Keypad4))
            {
                delta.x--;
            }
            else if (RB.KeyDown(KeyCode.D) || RB.KeyDown(KeyCode.Keypad6))
            {
                delta.x++;
            }
            else if (RB.KeyDown(KeyCode.Q) || RB.KeyDown(KeyCode.Keypad7))
            {
                delta.x--;
                delta.y--;
            }
            else if (RB.KeyDown(KeyCode.E) || RB.KeyDown(KeyCode.Keypad9))
            {
                delta.x++;
                delta.y--;
            }
            else if (RB.KeyDown(KeyCode.Z) || RB.KeyDown(KeyCode.Keypad1))
            {
                delta.x--;
                delta.y++;
            }
            else if (RB.KeyDown(KeyCode.C) || RB.KeyDown(KeyCode.Keypad3))
            {
                delta.x++;
                delta.y++;
            }

            if (delta.x > 1)
            {
                delta.x = 1;
            }
            else if (delta.x < -1)
            {
                delta.x = -1;
            }

            if (delta.y > 1)
            {
                delta.y = 1;
            }
            else if (delta.y < -1)
            {
                delta.y = -1;
            }

            if (delta.x == 0 && delta.y == 0)
            {
                mKeyRepeatStage = 0;
            }
            else
            {
                var ticksDelta = RB.Ticks - mLastMoveTimestamp;

                if (mKeyRepeatStage == 0 || (mKeyRepeatStage == 1 && ticksDelta > C.KEY_REPEAT_SPEED_STAGE1) || (mKeyRepeatStage > 1 && ticksDelta > C.KEY_REPEAT_SPEED_STAGE2))
                {
                    if (delta.x != 0 || delta.y != 0)
                    {
                        mKeyRepeatStage++;
                        mLastMoveTimestamp = RB.Ticks;
                        resultSet.AddMove(delta);
                    }
                }
            }

            // Wait
            if (RB.KeyPressed(KeyCode.X) || RB.KeyPressed(KeyCode.Keypad5))
            {
                resultSet.AddMove(Vector2i.zero);
            }

            if (RB.KeyPressed(KeyCode.G) || RB.KeyPressed(KeyCode.Keypad0))
            {
                resultSet.AddPickup(mPlayer);
            }

            if (RB.KeyPressed(KeyCode.F))
            {
                var ranged = mPlayer.e.equipment.equipment[(int)EquipmentSlot.Ranged];
                var arrow  = mPlayer.e.inventory.GetArrow();
                if (!ranged.isEmpty && !arrow.isEmpty)
                {
                    resultSet.AddTargeting(ranged);
                }
                else
                {
                    if (ranged.isEmpty)
                    {
                        resultSet.AddMessage(C.FSTR.Set("You do not have a ranged weapon equipped."));
                    }
                    else if (arrow.isEmpty)
                    {
                        resultSet.AddMessage(C.FSTR.Set("You do not have an arrow to shoot."));
                    }
                }
            }
        }
示例#6
0
        private void DrawKeyboard(int x, int y)
        {
            var demo = (DemoReel)RB.Game;

            RB.CameraSet(new Vector2i(-x, -y));

            Rect2i keyboardRect = RectBetweenKeys("Esc", "KeypadEnter");

            keyboardRect = keyboardRect.Expand(8);

            int cornerSize = 8;

            RB.DrawEllipseFill(new Vector2i(keyboardRect.x + cornerSize, keyboardRect.y + cornerSize), new Vector2i(cornerSize, cornerSize), DemoUtil.IndexToRGB(3));
            RB.DrawEllipse(new Vector2i(keyboardRect.x + cornerSize, keyboardRect.y + cornerSize), new Vector2i(cornerSize, cornerSize), DemoUtil.IndexToRGB(2));

            RB.DrawEllipseFill(new Vector2i(keyboardRect.x + keyboardRect.width - cornerSize - 1, keyboardRect.y + cornerSize), new Vector2i(cornerSize, cornerSize), DemoUtil.IndexToRGB(3));
            RB.DrawEllipse(new Vector2i(keyboardRect.x + keyboardRect.width - cornerSize - 1, keyboardRect.y + cornerSize), new Vector2i(cornerSize, cornerSize), DemoUtil.IndexToRGB(2));

            RB.DrawEllipseFill(new Vector2i(keyboardRect.x + cornerSize, keyboardRect.y + keyboardRect.height - cornerSize - 1), new Vector2i(cornerSize, cornerSize), DemoUtil.IndexToRGB(3));
            RB.DrawEllipse(new Vector2i(keyboardRect.x + cornerSize, keyboardRect.y + keyboardRect.height - cornerSize - 1), new Vector2i(cornerSize, cornerSize), DemoUtil.IndexToRGB(2));

            RB.DrawEllipseFill(new Vector2i(keyboardRect.x + keyboardRect.width - cornerSize - 1, keyboardRect.y + keyboardRect.height - cornerSize - 1), new Vector2i(cornerSize, cornerSize), DemoUtil.IndexToRGB(3));
            RB.DrawEllipse(new Vector2i(keyboardRect.x + keyboardRect.width - cornerSize - 1, keyboardRect.y + keyboardRect.height - cornerSize - 1), new Vector2i(cornerSize, cornerSize), DemoUtil.IndexToRGB(2));

            RB.DrawRect(new Rect2i(keyboardRect.x + cornerSize, keyboardRect.y, keyboardRect.width - (cornerSize * 2), keyboardRect.height), DemoUtil.IndexToRGB(2));
            RB.DrawRectFill(new Rect2i(keyboardRect.x + cornerSize, keyboardRect.y + 1, keyboardRect.width - (cornerSize * 2), keyboardRect.height - 2), DemoUtil.IndexToRGB(3));

            RB.DrawRect(new Rect2i(keyboardRect.x, keyboardRect.y + cornerSize, cornerSize, keyboardRect.height - (cornerSize * 2)), DemoUtil.IndexToRGB(2));
            RB.DrawRectFill(new Rect2i(keyboardRect.x + 1, keyboardRect.y + cornerSize, cornerSize - 1, keyboardRect.height - (cornerSize * 2)), DemoUtil.IndexToRGB(3));

            RB.DrawRect(new Rect2i(keyboardRect.x + keyboardRect.width - cornerSize, keyboardRect.y + cornerSize, cornerSize, keyboardRect.height - (cornerSize * 2)), DemoUtil.IndexToRGB(2));
            RB.DrawRectFill(new Rect2i(keyboardRect.x + keyboardRect.width - cornerSize - 1, keyboardRect.y + cornerSize, cornerSize, keyboardRect.height - (cornerSize * 2)), DemoUtil.IndexToRGB(3));

            int holeColor = 2;

            Rect2i holeRect = RectBetweenKeys("Esc", "Esc");

            holeRect = holeRect.Expand(1);
            RB.DrawRectFill(holeRect, DemoUtil.IndexToRGB(holeColor));

            holeRect = RectBetweenKeys("F1", "F4");
            holeRect = holeRect.Expand(1);
            RB.DrawRectFill(holeRect, DemoUtil.IndexToRGB(holeColor));

            holeRect = RectBetweenKeys("F5", "F8");
            holeRect = holeRect.Expand(1);
            RB.DrawRectFill(holeRect, DemoUtil.IndexToRGB(holeColor));

            holeRect = RectBetweenKeys("F9", "F12");
            holeRect = holeRect.Expand(1);
            RB.DrawRectFill(holeRect, DemoUtil.IndexToRGB(holeColor));

            holeRect = RectBetweenKeys("PrintScreen", "Pause");
            holeRect = holeRect.Expand(1);
            RB.DrawRectFill(holeRect, DemoUtil.IndexToRGB(holeColor));

            holeRect = RectBetweenKeys("~", "RightCtrl");
            holeRect = holeRect.Expand(1);
            RB.DrawRectFill(holeRect, DemoUtil.IndexToRGB(holeColor));

            holeRect = RectBetweenKeys("Insert", "PageDown");
            holeRect = holeRect.Expand(1);
            RB.DrawRectFill(holeRect, DemoUtil.IndexToRGB(holeColor));

            holeRect = RectBetweenKeys("Up", "Up");
            holeRect = holeRect.Expand(1);
            RB.DrawRectFill(holeRect, DemoUtil.IndexToRGB(holeColor));

            holeRect = RectBetweenKeys("Left", "Right");
            holeRect = holeRect.Expand(1);
            RB.DrawRectFill(holeRect, DemoUtil.IndexToRGB(holeColor));

            holeRect = RectBetweenKeys("NumLock", "KeypadEnter");
            holeRect = holeRect.Expand(1);
            RB.DrawRectFill(holeRect, DemoUtil.IndexToRGB(holeColor));

            foreach (KeyValuePair <string, KeyboardKey> key in mKeys)
            {
                KeyboardKey k = key.Value;

                bool pressed = RB.KeyDown(k.Code1) || RB.KeyDown(k.Code2);

                if (pressed || IsVirtualKeyPressed(k))
                {
                    RB.DrawRectFill(new Rect2i(k.Rect.x + 2, k.Rect.y + 2, k.Rect.width - 2, k.Rect.height - 2), DemoUtil.IndexToRGB(5));
                    RB.Print(new Vector2i(k.Rect.x + 3, k.Rect.y + 3), DemoUtil.IndexToRGB(0), k.Label);
                }
                else
                {
                    RB.DrawRectFill(k.Rect, DemoUtil.IndexToRGB(4));
                    RB.Print(new Vector2i(k.Rect.x + 2, k.Rect.y + 2), DemoUtil.IndexToRGB(0), k.Label);
                    RB.DrawRect(k.Rect, DemoUtil.IndexToRGB(3));
                }
            }

            RB.CameraReset();
        }