实现控制逻辑

#pragma once
// 引入组件系统头文件
#include <UnigineComponentSystem.h>
#include <UnigineInput.h>
#include <UniginePhysics.h>

class InputController : public Unigine::ComponentBase
{
private:
	static InputController* instance;

public:
	// 组件构造函数和方法列表
	COMPONENT_DEFINE(InputController, ComponentBase);
	// -------------------------------
	COMPONENT_INIT(init, 0);
	COMPONENT_UPDATE(update,0);

	// 定义操作类型列表：油门、刹车、转向、手刹和位置重置
	enum INPUT_ACTION_TYPE
	{
		THROTTLE = 0,
		BRAKE,
		WHEEL_LEFT,
		WHEEL_RIGHT,
		HAND_BRAKE,
		RESET,
	};

	static float getAction(InputController::INPUT_ACTION_TYPE action);
	static InputController* getInstance();

	// 输入状态接口
	class IInputState
	{
		public:
			virtual ~IInputState() {}
			virtual float getState() { return 0; }
	};

	// 按键按下 和 长按 的接口实现
	class InputStateKeyboardPressed : public IInputState {
		private:
			Unigine::Input::KEY key = Unigine::Input::KEY::KEY_UNKNOWN;

		public:
			InputStateKeyboardPressed(Unigine::Input::KEY key) { this->key = key; }
			float getState()  {
				return Unigine::Input::isKeyPressed(key) ? 1.0f : 0.0f;
			};
	};

	class InputStateKeyboardDown : public IInputState {

		private:
			Unigine::Input::KEY key = Unigine::Input::KEY::KEY_UNKNOWN;

		public:
			InputStateKeyboardDown(Unigine::Input::KEY key) { this->key = key; }
			float getState() {
				return Unigine::Input::isKeyDown(key) ? 1.0f : 0.0f;
			};
	};

	// 输入行为的抽象类，在初始化时接受一组状态列表；
	// 如果其中至少有一个状态被触发，则其状态值为 1.0f
	private: class InputAction
	{
		private: 
			Unigine::Vector <IInputState*> states;

		public:
			float state = 0.0f;

			InputAction(Unigine::Vector <IInputState*> states) { this->states = states; }

			void update()
			{
				float s = -Unigine::Math::Consts::INF; 

				for(int i=0; i < states.size();i++)
				{
					s = Unigine::Math::max(s, states[i]->getState());
				}

				state = s;
			}
	};

	// 控制按键的输入操作列表
	InputAction actions[6] =
	{
		InputAction(Unigine::Vector<IInputState*>({new InputStateKeyboardPressed(Unigine::Input::KEY::KEY_W) })),
		InputAction(Unigine::Vector<IInputState*>({new InputStateKeyboardPressed(Unigine::Input::KEY::KEY_S) })),
		InputAction(Unigine::Vector<IInputState*>({new InputStateKeyboardPressed(Unigine::Input::KEY::KEY_A) })),
		InputAction(Unigine::Vector<IInputState*>({new InputStateKeyboardPressed(Unigine::Input::KEY::KEY_D) })),
		InputAction(Unigine::Vector<IInputState*>({new InputStateKeyboardPressed(Unigine::Input::KEY::KEY_SPACE) })),
		InputAction(Unigine::Vector<IInputState*>({new InputStateKeyboardDown(Unigine::Input::KEY::KEY_F5) })),
	};

protected:
	主循环重写方法
	void init();
	void update();
};

#include "InputController.h"
REGISTER_COMPONENT(InputController);

InputController* InputController::instance = nullptr;

void InputController::init()
{
	instance = this;
}

// 每帧更新所有操作的状态
void InputController::update()
{
	for(InputAction action : actions)
	{
		action.update();
	}
}

InputController* InputController::getInstance() 
{
	return instance;
};

float InputController::getAction(InputController::INPUT_ACTION_TYPE action)
{
	if (instance == nullptr)
		return 0.0f;
	if (!instance->isEnabled())
		return 0.0f;
	instance->actions[(int)action].update();

	return instance->actions[(int)action].state;
}

#pragma once
#include "Car.h"
#include "InputController.h"
#include <UnigineComponentSystem.h>
class CarPlayer :
    public Car
{
public:
	// 组件构造函数和方法列表
	COMPONENT_DEFINE(CarPlayer, Car);
	// -------------------------------
	COMPONENT_UPDATE(update,2);

protected:
	主循环重写方法
	void update();
};

#include "CarPlayer.h"
#include "InputController.h"
#include <UnigineComponentSystem.h>
using namespace Unigine;
REGISTER_COMPONENT(CarPlayer);

void CarPlayer::update()
{
	// 设置方向盘转向
	float wheel = 0.0f;

	wheel -= InputController::getAction(InputController::INPUT_ACTION_TYPE::WHEEL_RIGHT);
	wheel += InputController::getAction(InputController::INPUT_ACTION_TYPE::WHEEL_LEFT);

	setWheelPosition(wheel);

	// 刹车和油门
	float brake = InputController::getAction(InputController::INPUT_ACTION_TYPE::BRAKE);
	float throttle = InputController::getAction(InputController::INPUT_ACTION_TYPE::THROTTLE);

	// 当速度方向、刹车或油门状态变化时，切换驾驶模式
	float velocity = getSpeed() * (getCurrentMoveDirection() == Car::MOVE_DIRECTION::FORWARD ? 1 : -1);

	if (velocity > 0.0f)
	{
		if (velocity < 1.25f && brake > Math::Consts::EPS && throttle < Math::Consts::EPS)
			setMoveDirection(Car::MOVE_DIRECTION::REVERSE);
	}
	else
	{
		if (velocity > -1.25f && throttle > Math::Consts::EPS && brake < Math::Consts::EPS)
			setMoveDirection(Car::MOVE_DIRECTION::FORWARD);
	}

	// 在倒车模式下，油门和刹车是相反的
	if (getCurrentMoveDirection() == Car::MOVE_DIRECTION::REVERSE)
	{
		float t = brake;
		brake = throttle;
		throttle = t;
	}

	// 设置油门和刹车
	setThrottle(throttle);
	setBrake(brake);
	// 设置手刹：根据按键状态，或在输入控制器被禁用（例如游戏结束）时强制开启
	setHandBrake(InputController::getInstance()->isEnabled() ? InputController::getAction(InputController::INPUT_ACTION_TYPE::HAND_BRAKE) : 1.0f);

	Car::update();
}