a1nsworth

В самом простом случае можно реализовать так же, как реализовано управление одним игроком. Достаточно регистрировать события нажатия/отпускания клавиш. В sfml функция sf::Window::setKeyRepeatEnabled с аргументом false включает режим однократной регистрации нажатия клавиши. То есть событие keyPressed будет зарегистрировано однажды при нажатии клавиши, даже если она остается нажатой.

Можем считать, что между событиями keyPressed и keyReleased клавиша остается нажатой. Сохраним нажатые клавиши с списке и на каждом шаге игрового цикла будем менять соответственно нажатым клавишам состояние игры, в том числе игрока.

Пример реализации (C++17):

#include <SFML/Graphics.hpp>
#include <unordered_set>
#include <unordered_map>

using namespace std;

void normalize(sf::Vector2i& v) {
	int length = sqrt(1ll * v.x * v.x + 1ll * v.y * v.y);
	if (length != 0) {
		v.x /= length;
		v.y /= length;
	}
}

class Input {
public:
	using Keys = std::unordered_set<sf::Keyboard::Key>;

	void registerKeyEvent(sf::Event e) {
		if (e.type == sf::Event::KeyPressed)
			pressedKeys_.insert(e.key.code);
		else if (e.type == sf::Event::KeyReleased)
			pressedKeys_.erase(e.key.code);
	}

	const Keys& pressedKeys() const {
		return pressedKeys_;
	}

private:
	Keys pressedKeys_;
};

class Player {
public:
	enum class Control {
		moveUp, moveLeft, moveRight, moveDown
	};

	Player(sf::Vector2i initialPosition, sf::Color color)
		: position_{ initialPosition } {
		sprite_.setPosition(sf::Vector2f(initialPosition.x, initialPosition.y));
		sprite_.setFillColor(color);
		sprite_.setRadius(50);
	}

	Player& map(Control control, sf::Keyboard::Key key) {
		keyControls_[key] = control;
		return *this;
	}

	void process(const Input& input) {
		velocity_ = {};
		for (sf::Keyboard::Key k : input.pressedKeys()) {
			if (auto it = keyControls_.find(k); it != keyControls_.end()) {
				switch (it->second) {
				case Control::moveDown:
					velocity_.y = 1;
					break;
				case Control::moveUp:
					velocity_.y = -1;
					break;
				case Control::moveLeft:
					velocity_.x = -1;
					break;
				case Control::moveRight:
					velocity_.x = 1;
					break;
				default:
					break;
				}
			}
		}
		normalize(velocity_);
		velocity_ *= speed_;
	}

	void move(sf::Vector2i position) {
		position_ = position;
		sprite_.setPosition(sf::Vector2f(position.x, position.y));
	}

	const sf::CircleShape& sprite() const {
		return sprite_;
	}

	sf::Vector2i position() const {
		return position_;
	}

	sf::Vector2i velocity() const {
		return velocity_;
	}

private:
	int speed_ = 300; // pixels / s
	sf::Vector2i velocity_;
	sf::Vector2i position_;
	
	sf::CircleShape sprite_;

	std::unordered_map<sf::Keyboard::Key, Control> keyControls_;
};

class Game {
public:
	Game(sf::RenderWindow* gameWindow)
		: window_(gameWindow) {
		window_->setKeyRepeatEnabled(false);
		auto width = window_->getSize().x;
		auto height = window_->getSize().y;
		Player mrRed(sf::Vector2i(width / 3, height / 3 * 2), sf::Color::Red);
		mrRed.map(Player::Control::moveUp, sf::Keyboard::W)
			.map(Player::Control::moveDown, sf::Keyboard::S)
			.map(Player::Control::moveLeft, sf::Keyboard::A)
			.map(Player::Control::moveRight, sf::Keyboard::D);
		players_.emplace_back(std::move(mrRed));

		Player mrBlue(sf::Vector2i(width / 3 * 2, height / 3 * 2), sf::Color::Blue);
		mrBlue.map(Player::Control::moveUp, sf::Keyboard::Up)
			.map(Player::Control::moveDown, sf::Keyboard::Down)
			.map(Player::Control::moveLeft, sf::Keyboard::Left)
			.map(Player::Control::moveRight, sf::Keyboard::Right);
		players_.emplace_back(std::move(mrBlue));

		Player mrGreen(sf::Vector2i(width / 2, height / 3), sf::Color::Green);
		mrGreen.map(Player::Control::moveUp, sf::Keyboard::I)
			.map(Player::Control::moveDown, sf::Keyboard::K)
			.map(Player::Control::moveLeft, sf::Keyboard::J)
			.map(Player::Control::moveRight, sf::Keyboard::L);
		players_.emplace_back(std::move(mrGreen));
	}

	void update() {
		processInputEvents();
		sf::Time dt = clock_.restart();
		processMovement(dt.asMilliseconds());
		drawScene();
	}

private:
	void processInputEvents() {
		for (sf::Event e; window_->pollEvent(e); ) {
			if (e.type == sf::Event::Closed) {
				window_->close();
				return;
			}
			input_.registerKeyEvent(e);
		}
		for (auto& player : players_)
			player.process(input_);
	}

	void processMovement(sf::Int32 dt) {
		for (int id = 0; id < players_.size(); ++id) {
			auto& player = players_[id];
			sf::Vector2i position = player.position() + sf::Vector2i(
				player.velocity().x * 1e-3f * dt,
				player.velocity().y * 1e-3f * dt
			);
			player.move(position);
		}
	}

	void drawScene() {
		window_->clear(sf::Color::White);
		for (const auto& player : players_)
			window_->draw(player.sprite());
		window_->display();
	}

	std::vector<Player> players_;
	Input input_;
	sf::RenderWindow* window_;
	sf::Clock clock_;
};


int main() {
	sf::RenderWindow mainWindow(sf::VideoMode(600, 600), "Circles", sf::Style::Close);
	mainWindow.setFramerateLimit(120);
	Game game(&mainWindow);
	while (mainWindow.isOpen())
		game.update();
	return 0;
}

Мы создаем три круга, которые могут двигаться независимо. Клавиши движений назначаются в конструкторе Game.

FrameLimit ограничен, потому что скорость и другие результаты расчетов целочисленные и привязаны к пискелям. При слишком высокой частоте кадров изменения расстояний на каждом шаге симуляции будут незначительными, округлятся к 0. Лучше заменить целочисленную арифметику на float-арифметику, чтобы не было грубых ошибок округления как в normalize, и промежуточных преобразований sf::Vector.

За поддержание актуальности списка нажатых клавиш отвечает class Input.