概述

之前代码中，我们总会去判断按键的输入，然而由于Input又臭又长的函数名和必须赋予的动作名称，代码看起来很不美观。所以这节我们使用Godot的自动加载功能，也就是创建单例的方法来将按键处理封装为一个简单的全局对象，然后再调用其中封装的函数来重构我们的代码。

mInput.gd

image.png image.png 
  1. # mInput.gd 加载为单例，全局可用。
  2. extends Node
  4. # 将会使用到的动作名称保存到相应的变量
  5. var left_action = "ui_left"
  6. var right_action = "ui_right"
  7. var up_action = "ui_up"
  8. var down_action = "ui_down"
  9. var jump_action = "ui_accept"
  12. # 封装Input.is_action_just_pressed()
  13. func just_pressed(action:String) -> bool:
  14.     return Input.is_action_just_pressed(action)
  16. # 封装Input.is_action_pressed()
  17. func pressed(action:String) -> bool:
  18.     return Input.is_action_pressed(action)
  20. # 跳跃
  21. func input_jump() -> bool:
  22.     return just_pressed(jump_action)
  24. # 获取水平方向上的方向或按键力度
  25. func get_x():
  26.     return Input.get_axis(left_action,right_action)
  28. # 获取垂直方向上的方向或按键力度
  29. func get_y():
  30.     return Input.get_axis(left_action,right_action)
  32. # 获取上下左右按键所取得的方向向量。
  33. func get_dir():
  34.     return Input.get_vector(left_action,right_action,up_action,down_action)

代码分析

可以看到，首先我们使用变量来存储我们将要用到的动作名称，然后我们封装了Input.is_action_just_pressed和Input.is_action_pressed，最后再封装各种函数来对应我们常用的输入，比如，跳跃、左右移动或上下移动以及在平面移动时获取的方向或力度以及方向向量。

用自动加载创建单例

我们在项目设置、自动加载下添加我们的mInput.gd代码为单例MInput。
image.png

用单例重构代码

此时我们就可以在本项目的任何场景中将MInput作为一个全局对象直接访问了，当然也包括它的各种成员变量和方法。所谓单例就是在整个声明周期中只有一个实例的类，简单的也可以理解为全局对象。
此时，我们再次重构上一节的代码：

代码

image.png image.png image.png

原始代码

  1. extends KinematicBody2D
  2. var speed = 60.0 # 速度 像素/秒
  4. var velocity = Vector2.ZERO # 速度向量
  5. var gravity = 3000 # 重力加速度
  6. var jump_force = 3000.0 # 单次跳跃高度
  7. var is_jumping = false
  9. enum states {
  10.     ON_FLOOR,   # 在地面上
  11.     IN_AIR      # 在空中
  12. }
  14. var _state = states.IN_AIR
  16. func _physics_process(delta):
  17.     velocity = Vector2.ZERO
  18.     match _state:
  20.         # 在地面
  21.         states.ON_FLOOR:
  22.             # 边缘掉落
  23.             if not is_on_floor():
  24.                 change_state_to(states.ON_FLOOR)
  25.                 is_jumping = false
  26.                 return
  28.             # 左右移动
  29.             velocity.x = MInput.get_x() * speed
  30.             # 实现下落 -- 用于边缘下落
  31.             velocity.y += gravity * delta
  32.             # 跳跃
  33.             if MInput.input_jump():
  34.                 velocity.y = -jump_force
  35.                 change_state_to(states.IN_AIR)
  36.                 is_jumping = true
  38.             velocity = move_and_slide(velocity,Vector2.UP)
  40.         # 在空中
  41.         states.IN_AIR:
  42.             # 掉到地板
  43.             if is_on_floor():
  44.                 change_state_to(states.ON_FLOOR)
  45.                 is_jumping = false
  46.                 return
  48.             # 左右移动
  49.             velocity.x = MInput.get_x() * speed
  50.             # 实现下落 -- 用于边缘下落
  51.             velocity.y += gravity * delta
  52.             # 跳跃 -- 二级跳
  53.             if is_jumping and MInput.input_jump():
  54.                 velocity.y = -jump_force
  55.                 change_state_to(states.IN_AIR)
  56.                 is_jumping = false
  58.             velocity = move_and_slide(velocity,Vector2.UP)
  59.             pass
  61. # 更改状态
  62. func change_state_to(new_state:int):
  63.     _state = new_state
  65.     # 根据不同的状态，进行一些额外配置
  66.     match _state:
  67.         states.IN_AIR:
  68.             pass
  69.         states.ON_FLOOR:
  70.             pass

总结

可以看到，通过调用MInput单例（或者你可以叫全局对象），你可以避开以往又臭又长的按键检测代码。
当然，本节的按键处理单例还只是个初步的玩法，你完全可以更进一步的封装来彻底简化Input和InputMap相关的代码。当然，这种模式也是可以跨游戏项目复用的，基本原理有了，具体怎么写怎么实现都无所谓了。