组合键检测

于 2024-12-28 22:19:58 发布
阅读量938 收藏 14
点赞数 23
分类专栏： MMORPG游戏技术专栏 文章标签： 组合键检测
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33060405/article/details/144796269
版权

在游戏中检测组合键的确可以通过按键状态管理和事件监听来实现。下面是一个简单的实现示例，展示如何使用字典来跟踪按键状态，并在每帧更新中检查组合键的状态。

1. 按键状态管理

我们可以使用一个字典来存储每个按键的状态（按下或释放）。在 Unity 中，我们可以在 Update 方法中检查按键的状态。

2. 事件监听

在每帧更新中，我们可以检查组合键是否被按下，并执行相应的操作。

示例代码

以下是一个简单的示例，展示如何实现组合键检测：

using UnityEngine;
using System.Collections.Generic;

public class KeyCombinationManager : MonoBehaviour
{
    private Dictionary<KeyCode, bool> keyStates = new Dictionary<KeyCode, bool>();

    void Start()
    {
        // 初始化按键状态
        foreach (KeyCode key in System.Enum.GetValues(typeof(KeyCode)))
        {
            keyStates[key] = false;
        }
    }

    void Update()
    {
        // 更新按键状态
        foreach (KeyCode key in keyStates.Keys)
        {
            if (Input.GetKeyDown(key))
            {
                keyStates[key] = true; // 按下
            }
            else if (Input.GetKeyUp(key))
            {
                keyStates[key] = false; // 释放
            }
        }

        // 检查组合键（例如：Shift + W）
        if (IsKeyCombinationPressed(KeyCode.W, KeyCode.LeftShift))
        {
            Debug.Log("Shift + W 被按下");
            // 执行相应的操作
        }

        // 检查其他组合键
        if (IsKeyCombinationPressed(KeyCode.S, KeyCode.LeftControl))
        {
            Debug.Log("Ctrl + S 被按下");
            // 执行相应的操作
        }
    }

    private bool IsKeyCombinationPressed(KeyCode mainKey, KeyCode modifierKey)
    {
        return keyStates[mainKey] && keyStates[modifierKey];
    }
}

代码说明

  1. 按键状态管理：

    • 使用一个字典 keyStates 来存储每个按键的状态。
    • 在 Start 方法中初始化字典，设置所有按键的状态为 false。

  2. 事件监听：

    • 在 Update 方法中，遍历字典，检查每个按键的状态。
    • 使用 Input.GetKeyDown 和 Input.GetKeyUp 来更新按键的状态。

  3. 组合键检测：

    • 定义一个方法 IsKeyCombinationPressed，接受主键和修饰键作为参数，返回这两个键是否同时被按下。
    • 在 Update 方法中调用该方法，检查特定的组合键（如 Shift + W 和 Ctrl + S）。

扩展功能

  • 支持更多组合键：可以通过扩展 IsKeyCombinationPressed 方法来支持更多的组合键。
  • 自定义组合键：可以将组合键的定义放入一个配置文件或数据结构中，以便于玩家自定义。
  • 按键冲突检测：在设置组合键时，可以添加冲突检测，确保玩家选择的组合键不会与其他功能冲突。

接下来，我们将进一步扩展组合键检测的功能，增加一些实用的特性和最佳实践，以提升用户体验和代码的可维护性。

3. 扩展功能

3.1 支持多种输入设备

为了支持不同的输入设备（如键盘、游戏手柄等），我们可以扩展 KeyCombinationManager 类，使其能够处理不同类型的输入。我们可以使用一个枚举来表示输入设备类型，并根据设备类型来检测按键。

public enum InputDeviceType
{
    Keyboard,
    Gamepad
}

public class KeyCombinationManager : MonoBehaviour
{
    private Dictionary<KeyCode, bool> keyStates = new Dictionary<KeyCode, bool>();
    private InputDeviceType currentDeviceType;

    void Start()
    {
        // 初始化按键状态
        foreach (KeyCode key in System.Enum.GetValues(typeof(KeyCode)))
        {
            keyStates[key] = false;
        }

        // 假设默认使用键盘
        currentDeviceType = InputDeviceType.Keyboard;
    }

    void Update()
    {
        UpdateKeyStates();

        // 检查组合键
        if (IsKeyCombinationPressed(KeyCode.W, KeyCode.LeftShift))
        {
            Debug.Log("Shift + W 被按下");
        }

        if (IsKeyCombinationPressed(KeyCode.S, KeyCode.LeftControl))
        {
            Debug.Log("Ctrl + S 被按下");
        }
    }

    private void UpdateKeyStates()
    {
        foreach (KeyCode key in keyStates.Keys)
        {
            if (Input.GetKeyDown(key))
            {
                keyStates[key] = true; // 按下
            }
            else if (Input.GetKeyUp(key))
            {
                keyStates[key] = false; // 释放
            }
        }

        // 检测当前设备类型（示例：可以根据输入设备的变化来更新）
        // 这里可以添加逻辑来检测游戏手柄的输入
    }

    private bool IsKeyCombinationPressed(KeyCode mainKey, KeyCode modifierKey)
    {
        return keyStates[mainKey] && keyStates[modifierKey];
    }
}
3.2 支持自定义组合键

为了让玩家能够自定义组合键，我们可以创建一个配置类，允许玩家在游戏设置中选择他们的组合键。

[System.Serializable]
public class KeyMapping
{
    public string actionName;
    public KeyCode mainKey;
    public KeyCode modifierKey;
}

public class KeyMappingManager : MonoBehaviour
{
    public List<KeyMapping> keyMappings;

    void Start()
    {
        // 初始化按键映射
        keyMappings = new List<KeyMapping>
        {
            new KeyMapping { actionName = "Move Forward", mainKey = KeyCode.W, modifierKey = KeyCode.LeftShift },
            new KeyMapping { actionName = "Save", mainKey = KeyCode.S, modifierKey = KeyCode.LeftControl }
        };
    }

    void Update()
    {
        foreach (var mapping in keyMappings)
        {
            if (IsKeyCombinationPressed(mapping.mainKey, mapping.modifierKey))
            {
                Debug.Log($"{mapping.actionName} 被触发");
                // 执行相应的操作
            }
        }
    }

    private bool IsKeyCombinationPressed(KeyCode mainKey, KeyCode modifierKey)
    {
        return Input.GetKey(mainKey) && Input.GetKey(modifierKey);
    }
}

4. 用户界面和设置

4.1 创建用户界面

为了让玩家能够方便地自定义按键映射，我们可以创建一个简单的用户界面，允许玩家选择和设置他们的组合键。

using UnityEngine;
using UnityEngine.UI;

public class KeyMappingUI : MonoBehaviour
{
    public KeyMappingManager keyMappingManager;
    public GameObject keyMappingButtonPrefab;
    public Transform keyMappingPanel;

    void Start()
    {
        CreateKeyMappingUI();
    }

    void CreateKeyMappingUI()
    {
        foreach (Transform child in keyMappingPanel)
        {
            Destroy(child.gameObject); // 清除旧的UI元素
        }

        foreach (var mapping in keyMappingManager.keyMappings)
        {
            GameObject button = Instantiate(keyMappingButtonPrefab, keyMappingPanel);
            button.GetComponentInChildren<Text>().text = $"{mapping.actionName}: {mapping.mainKey} + {mapping.modifierKey}";
            button.GetComponent<Button>().onClick.AddListener(() => StartKeyRebinding(mapping));
        }
    }

    private void StartKeyRebinding(KeyMapping mapping)
    {
        // 这里可以实现按键重新绑定的逻辑
        Debug.Log($"开始重新绑定 {mapping.actionName}");
    }
}

5. 按键重新绑定逻辑

在 StartKeyRebinding 方法中，我们可以实现按键重新绑定的逻辑，允许玩家按下新的按键来替换当前的组合键。

private System.Collections.IEnumerator RebindKey(KeyMapping mapping)
{
    // 等待玩家按下新按键
    yield return new WaitUntil(() => Input.anyKeyDown);

    KeyCode newMainKey = KeyCode.None;
    KeyCode newModifierKey = KeyCode.None;

    // 检查玩家按下的按键
    foreach (KeyCode key in System.Enum.GetValues(typeof(KeyCode)))
    {
        if (Input.GetKeyDown(key))
        {
            if (IsModifierKey(key))
            {
                newModifierKey = key; // 记录修饰键
            }
            else
            {
                newMainKey = key; // 记录主键
            }
        }
    }

    if (newMainKey != KeyCode.None)
    {
        mapping.mainKey = newMainKey;
        mapping.modifierKey = newModifierKey; // 更新修饰键
        CreateKeyMappingUI(); // 更新UI
    }
}

private bool IsModifierKey(KeyCode key)
{
    return key == KeyCode.LeftShift || key == KeyCode.RightShift ||
           key == KeyCode.LeftControl || key == KeyCode.RightControl ||
           key == KeyCode.LeftAlt || key == KeyCode.RightAlt;
}

6. 总结

通过以上的扩展，我们实现了以下功能：

  1. 支持多种输入设备：可以根据不同的输入设备类型来检测按键。
  2. 自定义组合键：允许玩家自定义组合键，并在游戏设置中进行修改。
  3. 用户界面：创建了一个简单的用户界面，方便玩家查看和修改按键映射。
  4. 按键重新绑定：实现了按键重新绑定的逻辑，允许玩家通过按下新按键来替换当前的组合键。

我们可以继续扩展组合键检测的功能，进一步增强用户体验和代码的灵活性。以下是一些可以考虑的扩展和改进：

7. 按键冲突检测

在允许玩家自定义组合键时，重要的一点是要检测按键冲突，确保玩家选择的组合键不会与其他功能冲突。我们可以在设置新组合键时进行冲突检测。

7.1 实现冲突检测

我们可以在重新绑定按键时，检查新按键是否已经被其他功能使用。

private bool IsKeyAlreadyUsed(KeyCode mainKey, KeyCode modifierKey)
{
    foreach (var mapping in keyMappingManager.keyMappings)
    {
        if (mapping.mainKey == mainKey && mapping.modifierKey == modifierKey)
        {
            return true; // 找到冲突
        }
    }
    return false; // 没有冲突
}

private System.Collections.IEnumerator RebindKey(KeyMapping mapping)
{
    // 等待玩家按下新按键
    yield return new WaitUntil(() => Input.anyKeyDown);

    KeyCode newMainKey = KeyCode.None;
    KeyCode newModifierKey = KeyCode.None;

    // 检查玩家按下的按键
    foreach (KeyCode key in System.Enum.GetValues(typeof(KeyCode)))
    {
        if (Input.GetKeyDown(key))
        {
            if (IsModifierKey(key))
            {
                newModifierKey = key; // 记录修饰键
            }
            else
            {
                newMainKey = key; // 记录主键
            }
        }
    }

    if (newMainKey != KeyCode.None)
    {
        // 检查冲突
        if (!IsKeyAlreadyUsed(newMainKey, newModifierKey))
        {
            mapping.mainKey = newMainKey;
            mapping.modifierKey = newModifierKey; // 更新修饰键
            CreateKeyMappingUI(); // 更新UI
        }
        else
        {
            Debug.LogWarning("按键冲突，请选择其他按键。");
            // 可以在UI中显示冲突提示
        }
    }
}

8. 保存和加载按键设置

为了让玩家的设置在游戏中持久化，我们可以实现保存和加载按键设置的功能。可以使用 PlayerPrefs 或者将设置保存到文件中。

8.1 使用 PlayerPrefs 保存设置
public void SaveKeyMappings()
{
    foreach (var mapping in keyMappings)
    {
        PlayerPrefs.SetString(mapping.actionName, $"{mapping.mainKey},{mapping.modifierKey}");
    }
    PlayerPrefs.Save();
}

public void LoadKeyMappings()
{
    foreach (var mapping in keyMappings)
    {
        string savedMapping = PlayerPrefs.GetString(mapping.actionName, $"{mapping.mainKey},{mapping.modifierKey}");
        string[] keys = savedMapping.Split(',');

        if (keys.Length == 2)
        {
            mapping.mainKey = (KeyCode)System.Enum.Parse(typeof(KeyCode), keys[0]);
            mapping.modifierKey = (KeyCode)System.Enum.Parse(typeof(KeyCode), keys[1]);
        }
    }
    CreateKeyMappingUI(); // 更新UI
}

9. 提供默认设置

在游戏中，提供一个“恢复默认设置”的选项，可以让玩家快速恢复到初始的按键设置。

public void ResetToDefaultMappings()
{
    keyMappings.Clear();
    keyMappings.Add(new KeyMapping { actionName = "Move Forward", mainKey = KeyCode.W, modifierKey = KeyCode.LeftShift });
    keyMappings.Add(new KeyMapping { actionName = "Save", mainKey = KeyCode.S, modifierKey = KeyCode.LeftControl });
    CreateKeyMappingUI(); // 更新UI
}

10. 视觉反馈

在玩家按下组合键时，提供视觉反馈（如按钮高亮、提示信息等），可以增强用户体验。

10.1 高亮显示

在 UI 中，可以在玩家按下组合键时高亮显示相应的按钮。

private void HighlightButton(KeyMapping mapping)
{
    // 假设有一个方法可以获取按钮的引用
    Button button = GetButtonForMapping(mapping);
    if (button != null)
    {
        // 高亮显示按钮
        button.GetComponent<Image>().color = Color.yellow; // 例如，改变颜色
    }
}

11. 代码结构优化

为了提高代码的可读性和可维护性，可以考虑将按键管理、UI管理和设置管理分离到不同的类中。这样可以遵循单一职责原则，使代码更易于管理。

12. 完整示例

结合以上所有功能，以下是一个更完整的示例代码结构：

using UnityEngine;
using UnityEngine.UI;
using System.Collections.Generic;

public enum InputDeviceType
{
    Keyboard,
    Gamepad
}

[System.Serializable]
public class KeyMapping
{
    public string actionName;
    public KeyCode mainKey;
    public KeyCode modifierKey;
}

public class KeyMappingManager : MonoBehaviour
{
    public List<KeyMapping> keyMappings;

    void Start()
    {
        LoadKeyMappings();
    }

    void Update()
    {
        foreach (var mapping in keyMappings)
        {
            if (IsKeyCombinationPressed(mapping.mainKey, mapping.modifierKey))
            {
                Debug.Log($"{mapping.actionName} 被触发");
            }
        }
    }

    private bool IsKeyCombinationPressed(KeyCode mainKey, KeyCode modifierKey)
    {
        return Input.GetKey(mainKey) && Input.GetKey(modifierKey);
    }

    public void SaveKeyMappings()
    {
        foreach (var mapping in keyMappings)
        {
            PlayerPrefs.SetString(mapping.actionName, $"{mapping.mainKey},{mapping.modifierKey}");
        }
        PlayerPrefs.Save();
    }

    public void LoadKeyMappings()
    {
        foreach (var mapping in keyMappings)
        {
            string savedMapping = PlayerPrefs.GetString(mapping.actionName, $"{mapping.mainKey},{mapping.modifierKey}");
            string[] keys = savedMapping.Split(',');

            if (keys.Length == 2)
            {
                mapping.mainKey = (KeyCode)System.Enum.Parse(typeof(KeyCode), keys[0]);
                mapping.modifierKey = (KeyCode)System.Enum.Parse(typeof(KeyCode), keys[1]);
            }
        }
    }

    public void ResetToDefaultMappings()
    {
        keyMappings.Clear();
        keyMappings.Add(new KeyMapping { actionName = "Move Forward", mainKey = KeyCode.W, modifierKey = KeyCode.LeftShift });
        keyMappings.Add(new KeyMapping { actionName = "Save", mainKey = KeyCode.S, modifierKey = KeyCode.LeftControl });
    }
}

public class KeyMappingUI : MonoBehaviour
{
    public KeyMappingManager keyMappingManager;
    public GameObject keyMappingButtonPrefab;
    public Transform keyMappingPanel;

    void Start()
    {
        CreateKeyMappingUI();
    }

    void CreateKeyMappingUI()
    {
        foreach (Transform child in keyMappingPanel)
        {
            Destroy(child.gameObject); // 清除旧的UI元素
        }

        foreach (var mapping in keyMappingManager.keyMappings)
        {
            GameObject button = Instantiate(keyMappingButtonPrefab, keyMappingPanel);
            button.GetComponentInChildren<Text>().text = $"{mapping.actionName}: {mapping.mainKey} + {mapping.modifierKey}";
            button.GetComponent<Button>().onClick.AddListener(() => StartKeyRebinding(mapping));
        }
    }

    private void StartKeyRebinding(KeyMapping mapping)
    {
        // 这里可以实现按键重新绑定的逻辑
        Debug.Log($"开始重新绑定 {mapping.actionName}");
    }
}

13. 结论

通过以上的扩展和改进，我们实现了一个功能丰富的组合键检测系统，支持自定义按键、冲突检测、保存和加载设置、视觉反馈等功能。这些功能将大大提升玩家的体验和游戏的可玩性。

用Python pynput库捕捉每一次组合键的优雅舞步
木头大左的博客
05-23 803
pynput是一个强大而灵活的库，它为Python开发者提供了一个探索计算机输入设备的窗口。通过本文的介绍，你已经了解了如何使用pynput来记录组合键操作，以及如何将这一技术应用于实际项目中。记住，技术本身并不是目的，它是一个工具，能够帮助实现自己的想法和解决问题。所以，拿起你的键盘，开启你的创造之旅吧！让pynput成为你手中的魔杖，释放出无限的可能。
Unity3D游戏开发之“组合键判断”
u010707274的博客
05-18 5897
Unity3D游戏开发之“组合键判断” 在做编辑器功能的时候可能会用到组合键的功能，可能很多朋友不知道怎么判断或者判断的方法太复杂。 下面分享一个我自己用的一个组合键的判断函数。此函数可以判断键盘键的组合、键盘和鼠标键的组合。代码如下： 本帖隐藏的内容[C#] 纯文本查看 复制代码? 0102030405060708091011121314151617181920212223242526
【组合键检测】一个用来实现组合键/快捷键的帧检测算法/类
qq_46181326的博客
06-25 624
用来解决主循环中非抢占式组合键/快捷键的检测/侦听的办法
组合键的检测
SP_daiyq的专栏
08-05 4865
VC中如何检测组合键： BOOL CxxxxxDlg::PreTranslateMessage(MSG* pMsg) { // TODO: Add your specialized code here and/or call the base class if (p
我的键盘的测试类（组合键）
beicuinan的专栏
12-26 256
我的键盘的测试类（组合键）KeyBoardTest.mxml [code="java"] [/code]
Mac 系统按键冲突检测
王龙鑫的博客
02-06 3054
Mac 系统按键冲突检测工具
Qt捕获组合按键实现
11-10
qt的键盘事件不能捕获多个按键按下.即便是在使用modifiers()时,也只能获得类似于shfit+x,ctrl+c,alt+y等等之类的快捷键,对于shift+x+c诸如此类更多的组合就无能为力的.本案例中提供了一种捕获shift+a+b....组合键的方法
VC++ 按键检测，监测键盘任意按键
03-17
内容索引:VC/C++源码,系统相关,键盘,按键检测　检测键盘的每个按键，当编译运行本程序后，你的鼠标和键盘操作将被监控，不管你按下了键盘上的任何键，它都将在窗口中显示出来，一个不错的按键检测程序，VC++源代码...
键盘组合键的判断
09-20
在键盘事件中判断当前按下的是不是组合键，用来实现对应的功能，或者直接将此时的状态传输出去，以实现自己需要的功能
WinForm中快捷键与组合按键的设置方法
09-05
若要检测更复杂的组合键，如Ctrl+Alt+0，可以将枚举值转换为整型并进行比较： ```csharp if ((int)e.Modifiers == ((int)Keys.Control + (int)Keys.Alt) && e.KeyCode == Keys.D0) { MessageBox.Show("按下了...
键盘冲突测试hKBTEST
07-31
用于检测键盘能最多按多少个键不冲突，运行软件后同时按下多个键盘按键，之后会检测出多少个键不冲突。
js键位检测
01-12
js键位检测所有键位 内有所有键盘码 下载请谨慎 检测按下的键位
KeyboardTest键位检测工具
04-05
KeyboardTest键位检测工具，检测当前按键，调试程序方便
键盘按键检测工具
06-17
键盘按键检测工具
COM口小键盘测试工具
03-06
主要用于医院收费系统医保密码键盘com口的测试工具
小功能⭐️Untiy组合键检测
星河造梦坊
09-03 756
Untiy组合键检测
ADC口检测多个组合按键的方法
weixin_40365379的博客
06-12 3611
一般情况下，一个GPIO口只能连接一个按键，通过检测外部输入的高、低电平判断按键的开闭状态。使用按键切换串联或并联的电阻网络电压的通路，可能得到该网络与不同的按键状态相对应的分压值，处理器检测该分压值之后再映射到按键状态，从而实现按键检测。接如果按键同一时刻只有一个闭合，可以用下图分压电阻相互串联的方式检测。电阻串联分压的按键检测电路，适用于没有组合键的情况如果按键存在多个同时闭合的情况，则应该用下图电阻并联的方式实现检测存在多个按键同时被按下时的ADC检测电路。
软件设计 —— 检测按键单击、多击、长按或组合动作
最新发布
改变自己现在能改变的，珍惜自己现在所拥有的
12-03 772
带有按键的作品设计时，按键动作检测是必不可少的，如何判断按键是单击、双击、三击和长按动作呢？2、把按键检测函数放到这个周期内执行，即10ms执行一次该函数。1、定时器定时一个10ms周期。
unity响应键盘的组合键
热门推荐
u013720726的博客
06-08 1万+
响应组合键即判断两个按键是否同时被按下if(Input.GetKey("c")&&Input.GetKey("1")){ //do sth }这段代码就是在同时按下c键和1键是响应
易语言实现组合键检测教程
描述中的“易语言取组合键例程”进一步阐释了该资源的核心内容，即通过易语言提供的方法来检测和响应用户的键盘操作，特别是组合键的输入。组合键是指同时按下两个或两个以上的键（例如Ctrl+C，Ctrl+V等复制粘贴操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

你一身傲骨怎能输

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值