No OneTemporary
Actions

Authored By

Unknown

Size

66 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/util/events.cpp b/util/events.cpp
	index fa610042..5de6b322 100644
	--- a/util/events.cpp
	+++ b/util/events.cpp
	@@ -1,534 +1,536 @@
	#ifdef USE_SDL
	#include <SDL.h>
	#endif
	#ifdef USE_ALLEGRO5
	#include <allegro5/allegro.h>
	#endif
	#include <vector>
	+#include <map>
	#include "bitmap.h"
	#include "events.h"
	#include "exceptions/shutdown_exception.h"
	#include "configuration.h"
	#include "debug.h"
	#include "funcs.h"
	#include "thread.h"
	#include "init.h"
	#include "parameter.h"
	#include "input/keyboard.h"
	#include "input/joystick.h"
	#include "input/input-manager.h"
	#include "input/input-source.h"

	+using std::map;
	+
	namespace Util{

	EventManager::EventManager():
	bufferKeys(false){
	#ifdef USE_ALLEGRO5
	queue = al_create_event_queue();
	if (al_is_keyboard_installed()){
	al_register_event_source(queue, al_get_keyboard_event_source());
	}
	if (Graphics::the_display != NULL){
	al_register_event_source(queue, al_get_display_event_source(Graphics::the_display));
	}
	#endif
	}

	#ifdef USE_SDL
	static void handleKeyDown(Keyboard & keyboard, const SDL_Event & event){
	keyboard.press(event.key.keysym.sym, event.key.keysym.unicode);
	}

	static void handleKeyUp(Keyboard & keyboard, const SDL_Event & event){
	keyboard.release(event.key.keysym.sym);
	}

	-static void handleJoystickButtonUp(Joystick * joystick, const SDL_Event & event){
	+static void handleJoystickButtonUp(map<int, Joystick *> joysticks, const SDL_Event & event){
	int device = event.jbutton.which;
	int button = event.jbutton.button;
	- if (device == joystick->getDeviceId()){
	+ Joystick * joystick = joysticks[device];
	+ if (joystick != NULL){
	joystick->releaseButton(button);
	}
	}

	-static void handleJoystickHat(Joystick * joystick, const SDL_Event & event){
	+static void handleJoystickHat(map<int, Joystick *> joysticks, const SDL_Event & event){
	int device = event.jhat.which;
	int motion = event.jhat.value;
	- if (device == joystick->getDeviceId()){
	+ Joystick * joystick = joysticks[device];
	+ if (joystick != NULL){
	joystick->hatMotion(motion);
	}

	#if 0
	/* should up/down control left/right -- flip these values? */
	#if WII
	const int axis_up_down = 0;
	const int axis_left_right = 1;
	const int up = 1;
	const int down = -1;
	const int left = -1;
	const int right = 1;
	#else
	const int axis_up_down = 1;
	const int axis_left_right = 0;
	const int up = -1;
	const int down = 1;
	const int left = -1;
	const int right = 1;
	#endif

	switch (motion){
	case SDL_HAT_CENTERED: break;
	case SDL_HAT_UP: joystick->axisMotion(axis_up_down, up); break;
	case SDL_HAT_DOWN: joystick->axisMotion(axis_up_down, down); break;
	case SDL_HAT_RIGHT: joystick->axisMotion(axis_left_right, right); break;
	case SDL_HAT_LEFT: joystick->axisMotion(axis_left_right, left); break;
	default: break;
	}
	#endif
	}

	-static void handleJoystickButtonDown(Joystick * joystick, const SDL_Event & event){
	+static void handleJoystickButtonDown(map<int, Joystick *> joysticks, const SDL_Event & event){
	int device = event.jbutton.which;
	int button = event.jbutton.button;
	- if (device == joystick->getDeviceId()){
	+ Joystick * joystick = joysticks[device];
	+ if (joystick != NULL){
	joystick->pressButton(button);
	}
	}

	-static void handleJoystickAxis(Joystick * joystick, const SDL_Event & event){
	+static void handleJoystickAxis(map<int, Joystick *> joysticks, const SDL_Event & event){
	int device = event.jaxis.which;
	int axis = event.jaxis.axis;
	int value = event.jaxis.value;
	- if (device == joystick->getDeviceId()){
	+ Joystick * joystick = joysticks[device];
	+ if (joystick != NULL){
	joystick->axisMotion(axis, value);
	}
	}

	-void EventManager::runSDL(Keyboard & keyboard, Joystick * joystick){
	+void EventManager::runSDL(Keyboard & keyboard, map<int, Joystick *> joysticks){
	keyboard.poll();
	- if (joystick){
	- joystick->poll();
	+ for (map<int, Joystick*>::iterator it = joysticks.begin(); it != joysticks.end(); it++){
	+ Joystick * joystick = it->second;
	+ if (joystick != NULL){
	+ joystick->poll();
	+ }
	}
	SDL_Event event;
	/* FIXME: android gets into an infinite loop while reading events */
	#ifdef ANDROID
	// int good = SDL_PollEvent(&event);
	// for (int check = 0; check < 10 && good; check++, good = SDL_PollEvent(&event)){
	// if (SDL_PollEvent(&event) == 1){
	while (SDL_PollEvent(&event) == 1){
	#else
	while (SDL_PollEvent(&event) == 1){
	#endif
	switch (event.type){
	case SDL_QUIT : {
	dispatch(CloseWindow);
	break;
	}
	case SDL_KEYDOWN : {
	handleKeyDown(keyboard, event);
	// dispatch(Key, event.key.keysym.sym);
	break;
	}
	case SDL_KEYUP : {
	handleKeyUp(keyboard, event);
	break;
	}
	case SDL_JOYBUTTONDOWN: {
	- if (joystick != NULL){
	- handleJoystickButtonDown(joystick, event);
	- }
	+ handleJoystickButtonDown(joysticks, event);
	break;
	}
	case SDL_JOYHATMOTION : {
	- if (joystick != NULL){
	- handleJoystickHat(joystick, event);
	- }
	+ handleJoystickHat(joysticks, event);
	break;
	}
	case SDL_JOYBUTTONUP: {
	- if (joystick != NULL){
	- handleJoystickButtonUp(joystick, event);
	- }
	+ handleJoystickButtonUp(joysticks, event);
	break;
	}
	case SDL_JOYAXISMOTION: {
	- if (joystick != NULL){
	- handleJoystickAxis(joystick, event);
	- }
	+ handleJoystickAxis(joysticks, event);
	break;
	}
	case SDL_VIDEORESIZE : {
	int width = event.resize.w;
	int height = event.resize.h;
	/* to keep the perspective correct
	* 640/480 = 1.33333
	*/
	double ratio = (double) GFX_X / (double) GFX_Y;
	if (width > height){
	height = (int)((double) width / ratio);
	} else {
	width = (int)((double) height * ratio);
	}
	dispatch(ResizeScreen, width, height);
	break;
	}
	default : {
	break;
	}
	}
	}
	}
	#endif

	#ifdef USE_ALLEGRO
	-void EventManager::runAllegro(Keyboard & keyboard, Joystick * joystick){
	+void EventManager::runAllegro(Keyboard & keyboard, map<int, Joystick *> joystick){
	keyboard.poll();
	}
	#endif

	#ifdef USE_ALLEGRO5
	static void handleKeyDown(Keyboard & keyboard, const ALLEGRO_EVENT & event){
	keyboard.press(event.keyboard.keycode, event.keyboard.unichar);
	}

	static void handleKeyUp(Keyboard & keyboard, const ALLEGRO_EVENT & event){
	keyboard.release(event.keyboard.keycode);
	}

	static void handleResize(const ALLEGRO_EVENT & event){
	double width = event.display.width;
	double height = event.display.height;
	if (width < GFX_X){
	width = GFX_X;
	}
	if (height < GFX_Y){
	height = GFX_Y;
	}
	/* to keep the perspective correct
	* 640/480 = 1.33333
	*/
	double ratio = (double) GFX_X / (double) GFX_Y;
	if (width > height){
	height = width / ratio;
	} else {
	width = height * ratio;
	}

	ALLEGRO_DISPLAY * display = event.display.source;
	al_acknowledge_resize(display);
	al_resize_display(display, (int) width, (int) height);
	ALLEGRO_TRANSFORM transformation;
	al_identity_transform(&transformation);
	// al_scale_transform(&transformation, (double) al_get_display_width(display) / (double) GFX_X, (double) al_get_display_height(display) / (double) GFX_Y);
	al_scale_transform(&transformation, (double) width / (double) GFX_X, (double) height / (double) GFX_Y);
	al_set_target_bitmap(Graphics::getScreenBuffer().getData()->getBitmap());
	al_use_transform(&transformation);
	}

	-void EventManager::runAllegro5(Keyboard & keyboard, Joystick * joystick){
	+void EventManager::runAllegro5(Keyboard & keyboard, map<int, Joystick *> joystick){
	keyboard.poll();

	ALLEGRO_EVENT event;
	while (al_get_next_event(queue, &event)){
	switch (event.type){
	/*
	case ALLEGRO_EVENT_KEY_DOWN: {
	Global::debug(0) << "Key down " << event.keyboard.keycode << std::endl;
	handleKeyDown(keyboard, event);
	break;
	}
	*/
	case ALLEGRO_EVENT_DISPLAY_RESIZE: {
	handleResize(event);
	break;
	}
	case ALLEGRO_EVENT_KEY_UP: {
	handleKeyUp(keyboard, event);
	break;
	}
	case ALLEGRO_EVENT_KEY_CHAR : {
	// Global::debug(0) << "Key char " << event.keyboard.keycode << " unicode " << event.keyboard.unichar << std::endl;
	handleKeyDown(keyboard, event);
	break;
	}
	}
	}

	/*
	if (joystick){
	joystick->poll();
	}
	SDL_Event event;
	while (SDL_PollEvent(&event) == 1){
	switch (event.type){
	case SDL_QUIT : {
	dispatch(CloseWindow);
	break;
	}
	case SDL_KEYDOWN : {
	handleKeyDown(keyboard, event);
	// dispatch(Key, event.key.keysym.sym);
	break;
	}
	case SDL_KEYUP : {
	handleKeyUp(keyboard, event);
	break;
	}
	case SDL_JOYBUTTONDOWN: {
	if (joystick != NULL){
	handleJoystickButtonDown(joystick, event);
	}
	break;
	}
	case SDL_JOYHATMOTION : {
	if (joystick != NULL){
	handleJoystickHat(joystick, event);
	}
	break;
	}
	case SDL_JOYBUTTONUP: {
	if (joystick != NULL){
	handleJoystickButtonUp(joystick, event);
	}
	break;
	}
	case SDL_JOYAXISMOTION: {
	if (joystick != NULL){
	handleJoystickAxis(joystick, event);
	}
	break;
	}
	case SDL_VIDEORESIZE : {
	int width = event.resize.w;
	int height = event.resize.h;
	/ * to keep the perspective correct
	* 640/480 = 1.33333
	* /
	if (width > height){
	height = (int)((double) width / 1.3333333333);
	} else {
	width = (int)((double) height * 1.3333333333);
	}
	dispatch(ResizeScreen, width, height);
	break;
	}
	default : {
	break;
	}
	}
	}
	*/
	}
	#endif

	-void EventManager::run(Keyboard & keyboard, Joystick * joystick){
	+void EventManager::run(Keyboard & keyboard, std::map<int, Joystick *> joysticks){
	#ifdef USE_SDL
	- runSDL(keyboard, joystick);
	+ runSDL(keyboard, joysticks);
	#elif USE_ALLEGRO
	- runAllegro(keyboard, joystick);
	+ runAllegro(keyboard, joysticks);
	#elif USE_ALLEGRO5
	- runAllegro5(keyboard, joystick);
	+ runAllegro5(keyboard, joysticks);
	#endif
	}

	/* kill the program if the user requests */
	void EventManager::waitForThread(WaitThread & thread){
	// Keyboard dummy;
	while (!thread.isRunning()){
	try{
	/* input manager will run the event manager */
	InputManager::poll();
	// run(dummy);
	} catch (const ShutdownException & death){
	thread.kill();
	throw death;
	}
	Util::rest(10);
	}
	}

	EventManager::~EventManager(){
	#ifdef USE_ALLEGRO5
	al_destroy_event_queue(queue);
	#endif
	}

	void EventManager::enableKeyBuffer(){
	bufferKeys = true;
	}

	void EventManager::disableKeyBuffer(){
	bufferKeys = false;
	}

	void EventManager::dispatch(Event type, int arg1){
	switch (type){
	case Key : {
	if (bufferKeys){
	keys.push_back(KeyType(arg1));
	}
	break;
	}
	default : {
	break;
	}
	}
	}

	void EventManager::dispatch(Event type, int arg1, int arg2){
	switch (type){
	case ResizeScreen : {
	Global::debug(1) << "Resizing screen to " << arg1 << ", " << arg2 << std::endl;
	if (Graphics::setGraphicsMode(0, arg1, arg2) == 0){
	Configuration::setScreenWidth(arg1);
	Configuration::setScreenHeight(arg2);
	}
	break;
	}
	default : break;
	}
	}

	void EventManager::dispatch(Event type){
	switch (type){
	case CloseWindow : {
	throw ShutdownException();
	}
	default : break;
	}
	}

	class LoopDone: public std::exception {
	public:
	LoopDone(){
	}

	~LoopDone() throw () {
	}
	};

	Logic::~Logic(){
	}

	Draw::Draw():
	frames(0),
	second_counter(Global::second_counter),
	fps(0){
	}

	void Draw::drawFirst(const Graphics::Bitmap & screen){
	}

	Draw::~Draw(){
	}

	double Draw::getFps() const {
	return fps;
	}

	void Draw::updateFrames(){
	if (second_counter != Global::second_counter){
	int difference = Global::second_counter - second_counter;
	double alpha = 0.2;
	/* unlikely, but just in case */
	if (difference == 0){
	difference = 1;
	}
	fps = (alpha * fps) + ((1 - alpha) * (double) frames / difference);
	// fps[fps_index] = (double) frames / (double) difference;
	// fps_index = (fps_index+1) % max_fps_index;
	second_counter = Global::second_counter;
	frames = 0;
	}

	frames += 1;
	}

	static void changeScreenMode(){
	Configuration::setFullscreen(!Configuration::getFullscreen());
	int gfx = (Configuration::getFullscreen() ? Global::FULLSCREEN : Global::WINDOWED);
	Graphics::setGraphicsMode(gfx, Global::getScreenWidth(), Global::getScreenHeight());
	}

	static void checkFullscreen(){
	InputMap<int> input;
	input.set(Keyboard::Key_F11, 0, true, 5);
	std::vector<InputMap<int>::InputEvent> events = InputManager::getEvents(input, InputSource());

	for (std::vector<InputMap<int>::InputEvent>::iterator it = events.begin(); it != events.end(); it++){
	InputMap<int>::InputEvent event = *it;

	if (!event.enabled){
	continue;
	}

	if (event.out == 5){
	changeScreenMode();
	}
	}
	}

	static void doStandardLoop(Logic & logic, Draw & draw){
	const Graphics::Bitmap & screen = *Graphics::screenParameter.current();
	draw.drawFirst(screen);
	Global::speed_counter4 = 0;
	double runCounter = 0;
	try{
	while (!logic.done()){
	if (Global::speed_counter4 > 0){
	// Global::debug(0) << "Speed counter " << Global::speed_counter4 << std::endl;
	runCounter += logic.ticks(Global::speed_counter4);
	Global::speed_counter4 = 0;
	bool need_draw = false;
	while (runCounter >= 1.0){
	need_draw = true;
	InputManager::poll();
	checkFullscreen();
	runCounter -= 1;
	logic.run();

	if (Global::shutdown()){
	throw ShutdownException();
	}

	if (logic.done()){
	/* quit the loop immediately */
	throw LoopDone();
	}
	}

	if (need_draw){
	draw.updateFrames();
	draw.draw(screen);
	}
	}

	while (Global::speed_counter4 == 0){
	/* if the fps is limited then don't keep redrawing */
	if (Global::rateLimit){
	rest(1);
	} else {
	draw.updateFrames();
	draw.draw(screen);
	}
	}
	}
	} catch (const LoopDone & done){
	}
	}

	void standardLoop(Logic & logic, Draw & draw){
	/* if a screen already exists (because we have nested standardLoops) then
	* leave this parameter alone, otherwise set a new parameter.
	*/
	/*
	if (Parameter<Graphics::Bitmap*>::current() == NULL){
	doStandardLoop(logic, draw);
	} else {
	doStandardLoop(logic, draw);
	}
	*/
	doStandardLoop(logic, draw);
	}

	}
	diff --git a/util/events.h b/util/events.h
	index fd408682..798a1de1 100644
	--- a/util/events.h
	+++ b/util/events.h
	@@ -1,116 +1,117 @@
	#ifndef _paintown_events_h
	#define _paintown_events_h

	/* handles global events from the system such as
	* window manager events (press X button)
	* keyboard/mouse/joystick input (for some backends like SDL)
	*/

	#include <vector>
	+#include <map>

	#ifdef USE_ALLEGRO5
	struct ALLEGRO_EVENT_SOURCE;
	struct ALLEGRO_EVENT_QUEUE;
	#endif

	#ifdef USE_SDL
	#include <SDL.h>
	#endif

	class Keyboard;
	class Joystick;

	namespace Graphics{
	class Bitmap;
	}

	namespace Util{

	class WaitThread;

	class EventManager{
	public:
	EventManager();
	- virtual void run(Keyboard & keyboard, Joystick * joystick);
	+ virtual void run(Keyboard & keyboard, std::map<int, Joystick *> joysticks);
	virtual void waitForThread(WaitThread & thread);
	virtual ~EventManager();

	#ifdef USE_SDL
	typedef SDLKey KeyType;
	#else
	typedef int KeyType;
	#endif

	inline const std::vector<KeyType> & getBufferedKeys() const {
	return keys;
	}

	void enableKeyBuffer();
	void disableKeyBuffer();

	private:
	enum Event{
	CloseWindow,
	ResizeScreen,
	Key
	};

	virtual void dispatch(Event type, int arg1, int arg2);
	virtual void dispatch(Event type, int arg1);
	virtual void dispatch(Event type);

	#ifdef USE_SDL
	- virtual void runSDL(Keyboard &, Joystick *);
	+ virtual void runSDL(Keyboard &, std::map<int, Joystick *>);
	#endif
	#ifdef USE_ALLEGRO
	- virtual void runAllegro(Keyboard & keyboard, Joystick *);
	+ virtual void runAllegro(Keyboard & keyboard, std::map<int, Joystick *>);
	#endif
	#ifdef USE_ALLEGRO5
	- virtual void runAllegro5(Keyboard & keyboard, Joystick *);
	+ virtual void runAllegro5(Keyboard & keyboard, std::map<int, Joystick *>);
	ALLEGRO_EVENT_QUEUE * queue;
	#endif

	std::vector<KeyType> keys;
	bool bufferKeys;
	};

	/* implement these classes to get the standard run loop */
	class Logic{
	public:
	/* run a cycle of logic */
	virtual void run() = 0;
	/* the run loop should finish */
	virtual bool done() = 0;

	/* return a number of logic ticks for a given number of ticks on
	* a real system.
	*/
	virtual double ticks(double systemTicks) = 0;

	virtual ~Logic();
	};

	class Draw{
	public:
	Draw();
	/* give the drawer a chance to draw stuff to the screen before any logic occurs.
	* default implementation is to do nothing.
	*/
	virtual void drawFirst(const Graphics::Bitmap & screen);
	/* standard draw method after logic has run */
	virtual void draw(const Graphics::Bitmap & screen) = 0;
	virtual ~Draw();
	/* called by the standardLoop */
	virtual void updateFrames();
	virtual double getFps() const;
	protected:
	int frames;
	unsigned int second_counter;
	double fps;
	};

	void standardLoop(Logic & logic, Draw & draw);

	}

	#endif
	diff --git a/util/input/allegro/allegro-joystick.cpp b/util/input/allegro/allegro-joystick.cpp
	index 42ba090e..a4c07cc8 100644
	--- a/util/input/allegro/allegro-joystick.cpp
	+++ b/util/input/allegro/allegro-joystick.cpp
	@@ -1,58 +1,62 @@
	#ifdef USE_ALLEGRO

	#include <allegro.h>
	#include "allegro-joystick.h"

	void AllegroJoystick::poll(){
	::poll_joystick();
	}

	/*
	JoystickInput AllegroJoystick::readAll(){
	JoystickInput input;
	JOYSTICK_INFO * info = &joy[0];
	switch(info->num_buttons > 4 ? 4 : info->num_buttons){
	case 4: input.button4 = info->button[3].b;
	case 3: input.button3 = info->button[2].b;
	case 2: input.button2 = info->button[1].b;
	case 1: input.button1 = info->button[0].b;
	case 0: {
	break;
	}
	}

	for (int stick = 0; stick < info->num_sticks; stick++){
	JOYSTICK_STICK_INFO * this_stick = &info->stick[stick];
	if (this_stick->num_axis > 0){
	int position = this_stick->axis[0].pos;
	if (position < 0){
	input.left = true;
	} else if (position > 0){
	input.right = true;
	}
	}
	if (this_stick->num_axis > 1){
	int position = this_stick->axis[1].pos;
	if (position < 0){
	input.up = true;
	} else if (position > 0){
	input.down = true;
	}
	}
	}

	return input;
	}
	*/

	AllegroJoystick::~AllegroJoystick(){
	}

	AllegroJoystick::AllegroJoystick(){
	}

	int AllegroJoystick::getDeviceId() const {
	return 0;
	}

	+int Joystick::numberOfJoysticks(){
	+ return ::num_joysticks;
	+}
	+
	#endif
	diff --git a/util/input/allegro5/joystick.cpp b/util/input/allegro5/joystick.cpp
	new file mode 100644
	index 00000000..d385565f
	--- /dev/null
	+++ b/util/input/allegro5/joystick.cpp
	@@ -0,0 +1,9 @@
	+#ifdef USE_ALLEGRO5
	+
	+#include "../joystick.h"
	+
	+int Joystick::numberOfJoysticks(){
	+ return 0;
	+}
	+
	+#endif
	diff --git a/util/input/input-manager.cpp b/util/input/input-manager.cpp
	index b7f686d3..50a4e4e4 100644
	--- a/util/input/input-manager.cpp
	+++ b/util/input/input-manager.cpp
	@@ -1,242 +1,244 @@
	#include "input-manager.h"
	#include "configuration.h"
	/* FIXME: break this dependancy. this is used for PaintownInput */
	#include "paintown-engine/object/object.h"
	#include "joystick.h"
	#include "util/events.h"
	#include "globals.h"
	#include "util/debug.h"
	#include <stdlib.h>
	#include <vector>

	using namespace std;

	InputManager * InputManager::manager = 0;

	InputManager::InputManager():
	-capture(0),
	-joystick(NULL){
	+capture(0){
	manager = this;
	if (Configuration::isJoystickEnabled()){
	- joystick = Joystick::create();
	+ for (int i = 0; i < Joystick::numberOfJoysticks(); i++){
	+ joysticks[i] = Joystick::create(i);
	+ }
	}
	}

	InputManager::~InputManager(){
	- delete joystick;
	+ /* FIXME: use reference counts for joysticks */
	+ for (map<int, Joystick*>::iterator it = joysticks.begin(); it != joysticks.end(); it++){
	+ Joystick * joystick = it->second;
	+ delete joystick;
	+ }
	}

	bool InputManager::anyInput(){
	if (manager == 0){
	Global::debug(0) << "BUG Input manager not set up" << endl;
	exit(0);
	}

	return manager->_anyInput();
	}

	bool InputManager::_anyInput(){
	if (keyboard.keypressed()){
	return true;
	}

	- if (joystick){
	- return joystick->pressed();
	- /*
	- JoystickInput all_joystick = joystick->readAll();
	- if (all_joystick.pressed()){
	- return true;
	+ for (map<int, Joystick*>::iterator it = joysticks.begin(); it != joysticks.end(); it++){
	+ Joystick * joystick = it->second;
	+ if (joystick){
	+ return joystick->pressed();
	}
	- */
	}

	return false;
	}

	/*
	vector<Input::PaintownInput> InputManager::getInput(const Configuration & configuration, const int facing){
	if (manager == 0){
	Global::debug(0) << "BUG Input manager not set up" << endl;
	exit(0);
	}

	return manager->_getInput(configuration, facing);
	}
	*/

	/*
	void InputManager::enableBufferInput(){
	manager->bufferKeys = true;
	}

	void InputManager::disableBufferInput(){
	manager->bufferKeys = false;
	}
	*/

	void InputManager::waitForClear(){
	manager->keyboard.clear();
	while (anyInput()){
	poll();
	Util::rest(1);
	}
	}

	void InputManager::waitForKeys(int key1, int key2){
	InputMap<int> wait;
	wait.set(key1, 0, false, 1);
	wait.set(key2, 0, false, 1);
	InputManager::waitForRelease(wait, 1);
	InputManager::waitForPress(wait, 1);
	InputManager::waitForRelease(wait, 1);
	}

	void InputManager::waitForKeys(int key){
	InputMap<int> wait;
	wait.set(key, 0, false, 1);
	InputManager::waitForRelease(wait, 1);
	InputManager::waitForPress(wait, 1);
	InputManager::waitForRelease(wait, 1);
	}

	/* these mappings should agree with configuration.cpp:defaultJoystick1Keys,
	* but otherwise they are completely arbitrary
	*/
	static Input::PaintownInput convertJoystickKey(const Joystick::Key key, const int facing){
	switch (key){
	case Joystick::Up : return Input::Up;
	case Joystick::Down : return Input::Down;
	case Joystick::Left : {
	if (facing == Paintown::Object::FACING_RIGHT){
	return Input::Back;
	} else {
	return Input::Forward;
	}
	}
	case Joystick::Right : {
	if (facing == Paintown::Object::FACING_RIGHT){
	return Input::Forward;
	} else {
	return Input::Back;
	}
	}
	case Joystick::Button1 : return Input::Attack1;
	case Joystick::Button2 : return Input::Attack2;
	case Joystick::Button3 : return Input::Attack3;
	case Joystick::Button4 : return Input::Jump;
	default : return Input::Unknown;
	}
	}

	static vector<Input::PaintownInput> convertJoystick(const Configuration & configuration, JoystickInput input, const int facing){
	vector<Input::PaintownInput> all;

	if (input.up){
	all.push_back(convertJoystickKey(configuration.getJoystickUp(), facing));
	}

	if (input.right){
	all.push_back(convertJoystickKey(configuration.getJoystickRight(), facing));
	}

	if (input.left){
	all.push_back(convertJoystickKey(configuration.getJoystickLeft(), facing));
	}

	if (input.down){
	all.push_back(convertJoystickKey(configuration.getJoystickDown(), facing));
	}

	if (input.button1){
	all.push_back(convertJoystickKey(configuration.getJoystickAttack1(), facing));
	}

	if (input.button2){
	all.push_back(convertJoystickKey(configuration.getJoystickAttack2(), facing));
	}

	if (input.button3){
	all.push_back(convertJoystickKey(configuration.getJoystickAttack3(), facing));
	}

	if (input.button4){
	all.push_back(convertJoystickKey(configuration.getJoystickJump(), facing));
	}

	return all;
	}

	void InputManager::poll(){
	if (manager == 0){
	Global::debug(0) << "BUG Input manager not set up" << endl;
	exit(0);
	}

	return manager->_poll();
	}

	int InputManager::readKey(){
	return manager->_readKey();
	}

	int InputManager::_readKey(){
	std::vector<int> keys;
	do{
	keyboard.readKeys(keys);
	if (keys.size() == 0){
	Util::rest(1);
	poll();
	}
	} while (keys.size() == 0);
	return keys.front();
	}

	void InputManager::_poll(){
	/* FIXME: not sure if its a good idea to put the event manager here */
	/*
	if (bufferKeys){
	eventManager.enableKeyBuffer();
	}
	*/
	- eventManager.run(keyboard, joystick);
	+ eventManager.run(keyboard, joysticks);

	// keyboard.poll();
	/*
	if (joystick != NULL){
	joystick->poll();
	}
	*/

	// const vector<Util::EventManager::KeyType> & keys = eventManager.getBufferedKeys();
	// bufferedKeys.insert(bufferedKeys.end(), keys.begin(), keys.end());
	}

	#if 0
	vector<Input::PaintownInput> InputManager::_getInput(const Configuration & configuration, const int facing){

	InputMap<Input::PaintownInput> input;

	enum Input::PaintownInput all[] = {Input::Forward, Input::Back, Input::Up, Input::Down, Input::Attack1, Input::Attack2, Input::Attack3, Input::Attack4, Input::Attack5, Input::Attack6, Input::Jump, Input::Grab};
	for (unsigned int i = 0; i < sizeof(all) / sizeof(Input::PaintownInput); i++){
	input.set(configuration.getKey(all[i], facing), 0, false, all[i]);
	input.set(configuration.getJoystickKey(all[i], facing), 0, false, all[i]);
	}

	InputMap<Input::PaintownInput>::Output state = InputManager::getMap(input);
	return InputMap<Input::PaintownInput>::getAllPressed(state);

	/*
	vector<int> all_keys;
	keyboard.readKeys( all_keys );

	vector<Input::PaintownInput> real_input = Input::convertKeyboard(configuration, facing, all_keys);

	if (joystick != NULL){
	vector<Input::PaintownInput> joystick_keys = convertJoystick(configuration, joystick->readAll(), facing);
	real_input.insert(real_input.begin(), joystick_keys.begin(), joystick_keys.end());
	}

	return real_input;
	*/
	}
	#endif
	diff --git a/util/input/input-manager.h b/util/input/input-manager.h
	index 0a610177..2cb608bb 100644
	--- a/util/input/input-manager.h
	+++ b/util/input/input-manager.h
	@@ -1,293 +1,295 @@
	#ifndef _paintown_input_manager
	#define _paintown_input_manager

	#include <vector>
	#include <algorithm>
	#include "input.h"
	#include "input-map.h"
	+#include "input-source.h"
	#include "util/funcs.h"
	#include "util/events.h"
	#include "keyboard.h"
	#include "exceptions/exception.h"

	class Configuration;
	class Joystick;
	class InputSource;

	template <class Output>
	class InputHandler{
	public:
	InputHandler(){
	}

	virtual ~InputHandler(){
	}

	virtual void press(const Output & out, Keyboard::unicode_t unicode) = 0;
	virtual void release(const Output & out, Keyboard::unicode_t unicode) = 0;
	};

	/* handles keyboard/joystick/whatever input during the game */
	class InputManager{
	public:
	/* main has one instance of this and thats it.
	* should the janitor have the reference instead?
	*/
	friend int paintown_main(int, char**);
	friend int main(int, char **);

	/* returns true if any input device is activated (keys pressed, joystick button */
	static bool anyInput();

	// static std::vector<Input::PaintownInput> getInput(const Configuration & configuration, const int facing);
	static void poll();
	/*
	static void enableBufferInput();
	static void disableBufferInput();
	*/
	static void waitForKeys(int key1, int key2);
	static void waitForKeys(int key1);
	static int readKey();
	static void waitForClear();

	/*
	template <class X>
	static void observeKeyboard(InputMap<X> & input){
	manager->keyboard.addObserver(InputMap<X>::observeKey, &input);
	}

	template <class X>
	static void unObserveKeyboard(InputMap<X> & input){
	manager->keyboard.removeObserver(InputMap<X>::observeKey, &input);
	}
	*/

	static std::vector<Keyboard::unicode_t> readText(){
	return manager->keyboard.readText();
	}

	template <typename X>
	static std::vector<Keyboard::unicode_t> readText(InputMap<X> & input, typename InputMap<X>::Output & output){
	return manager->_readText(input, output);
	}

	template <typename X>
	static typename InputMap<X>::Output getMap(InputMap<X> & input){
	if (manager){
	return manager->_getMap(input);
	}
	/* just crash hard.. who cares */
	throw Exception::Base(__FILE__, __LINE__);
	/* make the compiler happy about returning something */
	return (typename InputMap<X>::Output)1;
	}

	template <typename X>
	static typename std::vector<typename InputMap<X>::InputEvent> getEvents(InputMap<X> & input, const InputSource & source){
	return manager->_getEvents(input, source);
	}

	template <typename X>
	static void handleEvents(InputMap<X> & input, const InputSource & source, InputHandler<X> & handler){
	typename std::vector<typename InputMap<X>::InputEvent> events = getEvents(input, source);
	for (typename std::vector<typename InputMap<X>::InputEvent>::iterator it = events.begin(); it != events.end(); it++){
	const typename InputMap<X>::InputEvent & event = *it;
	if (event.enabled){
	handler.press(event.out, event.unicode);
	} else {
	handler.release(event.out, event.unicode);
	}
	}
	}

	template <typename X>
	static bool pressed(InputMap<X> & input, X out){
	if (manager){
	return manager->_pressed(input, out);
	}
	return false;
	}

	/* wait for a key to be released
	* really this waits for all inputs that would result in `out'
	* being generated to stop.
	*/
	template <typename X>
	static void waitForRelease(InputMap<X> & input, X out){
	while (InputManager::pressed(input, out)){
	Util::rest(1);
	InputManager::poll();
	}
	}

	template <typename X>
	static void waitForPress(InputMap<X> & input, X out){
	while (!InputManager::pressed(input, out)){
	Util::rest(1);
	InputManager::poll();
	}
	}

	template <typename X>
	static void captureInput(InputMap<X> & input){
	manager->_captureInput(input);
	}

	template <typename X>
	static void releaseInput(InputMap<X> & input){
	manager->_releaseInput(input);
	}

	protected:
	InputManager();
	virtual ~InputManager();

	virtual bool _anyInput();

	virtual int _readKey();

	// virtual std::vector<Input::PaintownInput> _getInput(const Configuration & configuration, const int facing);

	template <typename X>
	void _captureInput(InputMap<X> & input){
	capture = (void*) &input;
	}

	template <typename X>
	void _releaseInput(InputMap<X> & input){
	if (capture == (void*) &input){
	capture = 0;
	}
	}

	template <typename X>
	std::vector<Keyboard::unicode_t> _readText(InputMap<X> & input, typename InputMap<X>::Output & output){
	std::vector<Keyboard::unicode_t> text;
	std::vector<Keyboard::KeyData> all = keyboard.readData();
	for (std::vector<Keyboard::KeyData>::iterator it = all.begin(); it != all.end(); it++){
	const Keyboard::KeyData & data = *it;
	KeyState<X> * state = input.getState(data.key);
	if (state != NULL && output[state->out]){
	text.push_back(data.unicode);
	}
	}

	return text;
	}

	void removeDuplicates(std::vector<int> & storage){
	std::vector<int> output;
	int last = -1;
	for (std::vector<int>::iterator it = storage.begin(); it != storage.end(); it++){
	if (*it != last){
	output.push_back(*it);
	last = *it;
	}
	}
	storage = output;
	}

	template <typename X>
	typename std::vector<typename InputMap<X>::InputEvent> _getEvents(InputMap<X> & input, const InputSource & source){
	/* FIXME: get events from the source */
	std::vector<typename InputMap<X>::InputEvent> events;
	if (capture != NULL && capture != &input){
	return events;
	}

	const std::vector<typename Keyboard::KeyData> & buffer = keyboard.getBufferedKeys();
	for (std::vector<Keyboard::KeyData>::const_iterator it = buffer.begin(); it != buffer.end(); it++){
	const Keyboard::KeyData & data = *it;
	KeyState<X> * state = input.getState(data.key);
	if (state != NULL){
	events.push_back(typename InputMap<X>::InputEvent(state->out, data.unicode, data.enabled));
	}
	}

	+ Joystick * joystick = joysticks[source.getJoystick()];
	if (joystick){
	const std::vector<typename Joystick::Event> & joystickEvents = joystick->getEvents();
	for (std::vector<Joystick::Event>::const_iterator it = joystickEvents.begin(); it != joystickEvents.end(); it++){
	Joystick::Event event = *it;
	JoystickState<X> * state = input.getJoystickState(event.key);
	if (state != NULL){
	events.push_back(typename InputMap<X>::InputEvent(state->out, -1, event.enabled));
	}
	}
	}

	return events;
	}

	template <typename X>
	typename InputMap<X>::Output _getMap(InputMap<X> & input){
	typename InputMap<X>::Output output;

	if (capture != 0 && capture != &input){
	return output;
	}

	std::vector<int> all_keys;
	keyboard.readKeys(all_keys);
	keyboard.readBufferedKeys(all_keys);
	// all_keys.insert(all_keys.end(), bufferedKeys.begin(), bufferedKeys.end());
	// all_keys.insert(all_keys.end(), keyboard.currentKeys().begin(), keyboard.currentKeys.end());
	std::sort(all_keys.begin(), all_keys.end());
	removeDuplicates(all_keys);
	// std::unique(all_keys.begin(), all_keys.end());
	// bufferedKeys.clear();

	input.read(all_keys, &output);

	/*
	if (joystick != NULL){
	JoystickInput all_joystick = joystick->readAll();
	input.read(all_joystick, &output);
	}
	*/

	/* just bumps an internal counter */
	input.update();

	return output;
	}

	template <typename X>
	bool _pressed(InputMap<X> & input, X result){

	if (capture != 0 && capture != &input){
	return false;
	}

	std::vector<int> all_keys;
	keyboard.readKeys(all_keys);
	// all_keys.insert(all_keys.end(), bufferedKeys.begin(), bufferedKeys.end());
	std::sort(all_keys.begin(), all_keys.end());
	removeDuplicates(all_keys);
	// bufferedKeys.clear();
	bool out = false;

	out = input.pressed(all_keys, result);

	/*
	if (joystick != NULL){
	JoystickInput all_joystick = joystick->readAll();
	out \|= input.pressed(all_joystick, result);
	}
	*/

	return out;
	}

	virtual void _poll();

	private:
	static InputManager * manager;
	void * capture;
	- Joystick * joystick;
	+ std::map<int, Joystick *> joysticks;
	Keyboard keyboard;
	Util::EventManager eventManager;
	// std::vector<int> bufferedKeys;
	// bool bufferKeys;
	};

	#endif
	diff --git a/util/input/input-source.cpp b/util/input/input-source.cpp
	index 49290b9f..21d61b2c 100644
	--- a/util/input/input-source.cpp
	+++ b/util/input/input-source.cpp
	@@ -1,7 +1,11 @@
	#include "input-source.h"

	InputSource::InputSource(){
	}

	InputSource::~InputSource(){
	}
	+
	+int InputSource::getJoystick() const {
	+ return 0;
	+}
	diff --git a/util/input/input-source.h b/util/input/input-source.h
	index 28b1bd3d..828b67cd 100644
	--- a/util/input/input-source.h
	+++ b/util/input/input-source.h
	@@ -1,14 +1,16 @@
	#ifndef paintown_input_source_h
	#define paintown_input_source_h

	/* this class should abstract over actual devices (keyboard, joystick)
	* and return a list of events on request.
	*/

	class InputSource{
	public:
	InputSource();
	virtual ~InputSource();
	+
	+ virtual int getJoystick() const;
	};

	#endif
	diff --git a/util/input/joystick.cpp b/util/input/joystick.cpp
	index cdba0e4e..59297c14 100644
	--- a/util/input/joystick.cpp
	+++ b/util/input/joystick.cpp
	@@ -1,85 +1,85 @@
	#include <stdlib.h>
	#include "joystick.h"

	/*
	#ifdef LINUX
	#include "linux_joystick.h"
	#endif
	*/

	#ifdef USE_ALLEGRO
	#include "allegro/allegro-joystick.h"
	#endif
	#ifdef USE_SDL
	#ifdef WII
	#include "wii/joystick.h"
	#include "sdl/joystick.h"
	#elif MINPSPW
	#include "psp/joystick.h"
	#else
	#include "sdl/joystick.h"
	#endif
	#endif

	-Joystick * Joystick::create(){
	+Joystick * Joystick::create(int i){
	#ifdef USE_ALLEGRO
	return new AllegroJoystick();
	#endif
	#ifdef USE_SDL
	#ifdef WII
	- return new SDLJoystick();
	+ return new SDLJoystick(i);
	// return new WiiJoystick();
	#elif MINPSPW
	return new PSPJoystick();
	#else
	- return new SDLJoystick();
	+ return new SDLJoystick(i);
	#endif
	#endif
	/*
	#ifdef LINUX
	return new LinuxJoystick();
	#endif
	return NULL;
	*/
	return NULL;
	}

	Joystick::Joystick(){
	}

	Joystick::~Joystick(){
	}

	const char * Joystick::keyToName(Key key){
	switch (key){
	case Invalid: return "Invalid";
	case Up: return "Up";
	case Down: return "Down";
	case Left: return "Left";
	case Right: return "Right";
	case Button1: return "Button1";
	case Button2: return "Button2";
	case Button3: return "Button3";
	case Button4: return "Button4";
	case Button5: return "Button5";
	case Button6: return "Button6";
	case Quit: return "Quit";
	}
	return "Unknown";
	}

	bool Joystick::pressed() const {
	return events.size() > 0;
	}

	void Joystick::pressButton(int button){
	}

	void Joystick::releaseButton(int button){
	}

	void Joystick::axisMotion(int axis, int motion){
	}

	void Joystick::hatMotion(int motion){
	}
	diff --git a/util/input/joystick.h b/util/input/joystick.h
	index a3f7e01a..3450dc21 100644
	--- a/util/input/joystick.h
	+++ b/util/input/joystick.h
	@@ -1,108 +1,110 @@
	#ifndef _paintown_joystick_h
	#define _paintown_joystick_h

	#include <vector>

	struct JoystickInput{
	JoystickInput():
	left(false),
	right(false),
	up(false),
	down(false),
	button1(false),
	button2(false),
	button3(false),
	button4(false),
	button5(false),
	button6(false),
	quit(false){
	}

	JoystickInput(const JoystickInput & copy):
	left(copy.left),
	right(copy.right),
	up(copy.up),
	down(copy.down),
	button1(copy.button1),
	button2(copy.button2),
	button3(copy.button3),
	button4(copy.button4),
	button5(copy.button5),
	button6(copy.button6),
	quit(copy.quit){
	}

	/* true if something is pressed */
	bool pressed(){
	return left \|\| right \|\| up \|\| down \|\|
	button1 \|\| button2 \|\| button3 \|\| button4 \|\|
	button5 \|\| button6 \|\|
	quit;
	}

	bool left;
	bool right;
	bool up;
	bool down;
	bool button1;
	bool button2;
	bool button3;
	bool button4;
	bool button5;
	bool button6;
	bool quit;
	};

	class Joystick{
	public:
	virtual void poll() = 0;
	// virtual JoystickInput readAll() = 0;
	virtual bool pressed() const;
	virtual ~Joystick();

	virtual int getDeviceId() const = 0;
	virtual void pressButton(int button);
	virtual void releaseButton(int button);
	virtual void axisMotion(int axis, int motion);
	virtual void hatMotion(int motion);

	- static Joystick * create();
	+ /* create the ith joystick */
	+ static Joystick * create(int i);
	+ static int numberOfJoysticks();

	enum Key{
	Invalid = -1,
	Up = 0,
	Down,
	Left,
	Right,
	Button1,
	Button2,
	Button3,
	Button4,
	Button5,
	Button6,
	Quit,
	};

	struct Event{
	Event(Key key, bool enabled):
	key(key), enabled(enabled){
	}

	Key key;
	bool enabled;
	};

	virtual inline const std::vector<Event> & getEvents() const {
	return events;
	}

	static const char * keyToName(Key key);

	protected:

	std::vector<Event> events;

	Joystick();
	};

	#endif
	diff --git a/util/input/sdl/joystick.cpp b/util/input/sdl/joystick.cpp
	index d756b14a..d01cd15f 100644
	--- a/util/input/sdl/joystick.cpp
	+++ b/util/input/sdl/joystick.cpp
	@@ -1,680 +1,690 @@
	#ifdef USE_SDL

	#include <SDL.h>
	#include "joystick.h"
	#include "util/debug.h"
	#include <string>
	#include <vector>

	+#include <exception>
	+
	using std::string;
	using std::vector;

	class ButtonMapping{
	public:
	ButtonMapping(){
	}

	virtual ~ButtonMapping(){
	}

	virtual int toNative(int button) = 0;
	virtual int fromNative(int button) = 0;
	virtual Joystick::Key toKey(int button) = 0;
	virtual void axisMotionEvents(int axis, int motion, vector<Joystick::Event> & events) = 0;
	virtual void hatMotionEvents(int motion, vector<Joystick::Event> & events) = 0;
	};

	class DefaultButtonMapping: public ButtonMapping {
	public:
	int toNative(int button){
	return button;
	}

	int fromNative(int button){
	return button;
	}

	Joystick::Key toKey(int button){
	switch (button){
	case 0: return Joystick::Button1;
	case 1: return Joystick::Button2;
	case 2: return Joystick::Button3;
	case 3: return Joystick::Button4;
	case 4: return Joystick::Quit;
	case 5: return Joystick::Button5;
	case 6: return Joystick::Button6;
	default: return Joystick::Invalid;
	}
	}

	virtual void hatMotionEvents(int motion, vector<Joystick::Event> & events){
	bool up = false;
	bool down = false;
	bool left = false;
	bool right = false;
	switch (motion){
	case SDL_HAT_CENTERED: break;
	case SDL_HAT_UP: up = true; break;
	case SDL_HAT_RIGHT: right = true; break;
	case SDL_HAT_DOWN: down = true; break;
	case SDL_HAT_LEFT: left = true; break;
	case SDL_HAT_RIGHTUP: right = true; up = true; break;
	case SDL_HAT_RIGHTDOWN: right = true; down = true; break;
	case SDL_HAT_LEFTUP: left = true; up = true; break;
	case SDL_HAT_LEFTDOWN: left = true; down = true; break;
	}

	events.push_back(Joystick::Event(Joystick::Left, left));
	events.push_back(Joystick::Event(Joystick::Right, right));
	events.push_back(Joystick::Event(Joystick::Down, down));
	events.push_back(Joystick::Event(Joystick::Up, up));
	}

	void axisMotionEvents(int axis, int motion, vector<Joystick::Event> & events){
	/* FIXME */
	/*
	if (axis == 0){
	if (motion < 0){
	return Joystick::Left;
	} else if (motion > 0){
	return Joystick::Right;
	}
	} else if (axis == 1){
	if (motion < 0){
	return Joystick::Up;
	} else if (motion > 0){
	return Joystick::Down;
	}
	}
	*/

	}
	};

	/* used when a ps3 controller is plugged into a usb port of a normal pc */
	class Playstation3Controller: public ButtonMapping {
	public:
	enum Buttons{
	Cross = 14,
	Circle = 13,
	Triangle = 12,
	Square = 15,
	Start = 3,
	Select = 0,
	Up = 4,
	Left = 7,
	Down = 6,
	Right = 5,
	Stick1 = 1,
	Stick2 = 2,
	L2 = 8,
	L1 = 10,
	R2 = 9,
	R1 = 11,
	/* the middle ps3 button */
	Ps3 = 16
	};

	int toNative(int button){
	switch (button){
	case 0: return Square;
	case 1: return Cross;
	case 2: return Circle;
	case 3: return Triangle;
	case 4: return Start;
	}

	return button;
	}

	int fromNative(int button){
	switch (button){
	case Square: return 0;
	case Cross: return 1;
	case Circle: return 2;
	case Triangle: return 3;
	case Start: return Start;
	default: return 5;
	}

	return button;
	}

	Joystick::Key toKey(int button){
	switch (button){
	case Square: return Joystick::Button1;
	case Cross: return Joystick::Button2;
	case Circle: return Joystick::Button3;
	case Triangle: return Joystick::Button4;
	case L1: return Joystick::Button5;
	case R1: return Joystick::Button6;
	case Start: return Joystick::Quit;
	case Up: return Joystick::Up;
	case Down: return Joystick::Down;
	case Left: return Joystick::Left;
	case Right: return Joystick::Right;
	default: return Joystick::Invalid;
	}
	}

	/* TODO */
	void axisMotionEvents(int axis, int motion, vector<Joystick::Event> & events){
	}

	virtual void hatMotionEvents(int motion, vector<Joystick::Event> & events){
	}
	};

	class LogitechPrecision: public ButtonMapping {
	public:
	enum Buttons{
	Button1 = 0,
	Button2 = 1,
	Button3 = 2,
	Button4 = 3,
	Start = 8,
	Select = 9,
	R2 = 7,
	R1 = 5,
	L2 = 6,
	L1 = 4
	};

	int toNative(int button){
	return -1;
	}

	int fromNative(int button){
	return -1;
	}

	Joystick::Key toKey(int button){
	switch (button){
	case Button1: return Joystick::Button1;
	case Button2: return Joystick::Button2;
	case Button3: return Joystick::Button3;
	case Button4: return Joystick::Button4;
	case L1: return Joystick::Button5;
	case R1: return Joystick::Button6;
	case Start: return Joystick::Quit;
	}
	return Joystick::Invalid;
	}

	/* axis 1. negative up, positive down
	* axis 0, negative left, positive right
	*/
	void axisMotionEvents(int axis, int motion, vector<Joystick::Event> & events){
	int tolerance = 10;
	if (axis == 0){
	if (motion < -tolerance){
	events.push_back(Joystick::Event(Joystick::Left, true));
	} else if (motion > tolerance){
	events.push_back(Joystick::Event(Joystick::Right, true));
	} else {
	/* fake a release for left and right */
	events.push_back(Joystick::Event(Joystick::Left, false));
	events.push_back(Joystick::Event(Joystick::Right, false));
	}
	} else if (axis == 1){
	if (motion < -tolerance){
	events.push_back(Joystick::Event(Joystick::Up, true));
	} else if (motion > tolerance){
	events.push_back(Joystick::Event(Joystick::Down, true));
	} else {
	events.push_back(Joystick::Event(Joystick::Up, false));
	events.push_back(Joystick::Event(Joystick::Down, false));
	}
	}
	}

	virtual void hatMotionEvents(int motion, vector<Joystick::Event> & events){
	}
	};

	/* used for the ps3 controller with psl1ght's SDL version */
	class Ps3Controller: public ButtonMapping {
	public:
	enum Buttons{
	Left = 0,
	Down = 1,
	Right = 2,
	Up = 3,
	Select = 7,
	Start = 4,
	Square = 8,
	Cross = 9,
	Circle = 10,
	Triangle = 11,
	L1 = 13,
	R1 = 12,
	L2 = 15,
	R2 = 14,
	L3 = 6,
	R3 = 5
	};

	int toNative(int button){
	switch (button){
	case 0: return Square;
	case 1: return Cross;
	case 2: return Circle;
	case 3: return Triangle;
	case 4: return Start;
	}
	return button;
	}

	int fromNative(int button){
	switch (button){
	case Square: return 0;
	case Cross: return 1;
	case Circle: return 2;
	case Triangle: return 3;
	case Start: return Start;
	default: return 5;
	}
	return button;
	}

	Joystick::Key toKey(int button){
	switch (button){
	case Square: return Joystick::Button1;
	case Cross: return Joystick::Button2;
	case Circle: return Joystick::Button3;
	case Triangle: return Joystick::Button4;
	case L1: return Joystick::Button5;
	case R1: return Joystick::Button6;
	case Start: return Joystick::Quit;
	case Up: return Joystick::Up;
	case Down: return Joystick::Down;
	case Left: return Joystick::Left;
	case Right: return Joystick::Right;
	default: return Joystick::Invalid;
	}
	}

	/* TODO */
	void axisMotionEvents(int axis, int motion, vector<Joystick::Event> & events){
	}

	virtual void hatMotionEvents(int motion, vector<Joystick::Event> & events){
	}
	};

	class XBox360Controller: public ButtonMapping {
	public:
	enum Buttons{
	A = 0,
	B = 1,
	X = 2,
	Y = 3,
	L1 = 4,
	R1 = 5,
	Start = 6,
	Xbox = 7,
	L3 = 8,
	R3 = 9,
	select = 10
	};

	int toNative(int button){
	return 0;
	}

	int fromNative(int button){
	return 0;
	}

	Joystick::Key toKey(int button){
	switch (button){
	case A: return Joystick::Button1;
	case B: return Joystick::Button2;
	case X: return Joystick::Button3;
	case Y: return Joystick::Button4;
	case L1: return Joystick::Button5;
	case R1: return Joystick::Button6;
	case Start: return Joystick::Quit;
	}
	return Joystick::Invalid;
	}

	void axisMotionEvents(int axis, int motion, vector<Joystick::Event> & events){
	/* axis 6 and 7 are the hats. sdl passes them as hat events */
	#if 0
	if (axis == 6){
	if (motion < 0){
	events.push_back(Joystick::Event(Joystick::Left, true));
	} else if (motion > 0){
	events.push_back(Joystick::Event(Joystick::Right, true));
	} else if (motion == 0){
	/* fake a release for left and right */
	events.push_back(Joystick::Event(Joystick::Left, false));
	events.push_back(Joystick::Event(Joystick::Right, false));
	}
	} else if (axis == 7){
	if (motion < 0){
	events.push_back(Joystick::Event(Joystick::Up, true));
	} else if (motion > 0){
	events.push_back(Joystick::Event(Joystick::Down, true));
	} else if (motion == 0){
	events.push_back(Joystick::Event(Joystick::Up, false));
	events.push_back(Joystick::Event(Joystick::Down, false));
	}
	}
	#endif
	}

	virtual void hatMotionEvents(int motion, vector<Joystick::Event> & events){
	bool up = false;
	bool down = false;
	bool left = false;
	bool right = false;
	switch (motion){
	case SDL_HAT_CENTERED: break;
	case SDL_HAT_UP: up = true; break;
	case SDL_HAT_RIGHT: right = true; break;
	case SDL_HAT_DOWN: down = true; break;
	case SDL_HAT_LEFT: left = true; break;
	case SDL_HAT_RIGHTUP: right = true; up = true; break;
	case SDL_HAT_RIGHTDOWN: right = true; down = true; break;
	case SDL_HAT_LEFTUP: left = true; up = true; break;
	case SDL_HAT_LEFTDOWN: left = true; down = true; break;
	}

	events.push_back(Joystick::Event(Joystick::Left, left));
	events.push_back(Joystick::Event(Joystick::Right, right));
	events.push_back(Joystick::Event(Joystick::Down, down));
	events.push_back(Joystick::Event(Joystick::Up, up));
	}
	};

	class Wiimote: public ButtonMapping {
	public:
	enum Buttons{
	A = 0,
	B = 1,
	Button1 = 2,
	Button2 = 3,
	Minus = 4,
	Plus = 5,
	Home = 6
	};

	int toNative(int button){
	return 0;
	}

	int fromNative(int button){
	return 0;
	}

	Joystick::Key toKey(int button){
	switch (button){
	case A: return Joystick::Button1;
	case B: return Joystick::Button2;
	case Button1: return Joystick::Button3;
	case Button2: return Joystick::Button4;
	case Minus: return Joystick::Button5;
	case Plus: return Joystick::Button6;
	case Home: return Joystick::Quit;
	}
	return Joystick::Invalid;
	}

	void axisMotionEvents(int axis, int motion, vector<Joystick::Event> & events){
	}

	virtual void hatMotionEvents(int motion, vector<Joystick::Event> & events){
	/* rotate all the directions 90 degrees */
	bool up = false; // right
	bool down = false; // left
	bool left = false; // up
	bool right = false; // down
	switch (motion){
	case SDL_HAT_CENTERED: break;
	case SDL_HAT_UP: up = true; break;
	case SDL_HAT_RIGHT: right = true; break;
	case SDL_HAT_DOWN: down = true; break;
	case SDL_HAT_LEFT: left = true; break;
	case SDL_HAT_RIGHTUP: up = true; right = true; break;
	case SDL_HAT_RIGHTDOWN: down = true; right = true; break;
	case SDL_HAT_LEFTUP: up = true; left = true; break;
	case SDL_HAT_LEFTDOWN: down = true; left = true; break;
	}

	events.push_back(Joystick::Event(Joystick::Left, left));
	events.push_back(Joystick::Event(Joystick::Right, right));
	events.push_back(Joystick::Event(Joystick::Down, down));
	events.push_back(Joystick::Event(Joystick::Up, up));
	}
	};

	class GamecubePad: public ButtonMapping {
	public:
	enum Buttons{
	A = 0,
	B = 1,
	X = 2,
	Y = 3,
	Z = 4,
	Start = 7
	};

	int toNative(int button){
	return 0;
	}

	int fromNative(int button){
	return 0;
	}

	Joystick::Key toKey(int button){
	switch (button){
	case A: return Joystick::Button1;
	case B: return Joystick::Button2;
	case X: return Joystick::Button3;
	case Y: return Joystick::Button4;
	case Z: return Joystick::Button5;
	case Start: return Joystick::Quit;
	}
	return Joystick::Invalid;
	}

	void axisMotionEvents(int axis, int motion, vector<Joystick::Event> & events){
	// printf("axis %d motion %d\n", axis, motion);
	}

	virtual void hatMotionEvents(int motion, vector<Joystick::Event> & events){
	bool up = false;
	bool down = false;
	bool left = false;
	bool right = false;
	switch (motion){
	case SDL_HAT_CENTERED: break;
	case SDL_HAT_UP: up = true; break;
	case SDL_HAT_RIGHT: right = true; break;
	case SDL_HAT_DOWN: down = true; break;
	case SDL_HAT_LEFT: left = true; break;
	case SDL_HAT_RIGHTUP: right = true; up = true; break;
	case SDL_HAT_RIGHTDOWN: right = true; down = true; break;
	case SDL_HAT_LEFTUP: left = true; up = true; break;
	case SDL_HAT_LEFTDOWN: left = true; down = true; break;
	}

	events.push_back(Joystick::Event(Joystick::Left, left));
	events.push_back(Joystick::Event(Joystick::Right, right));
	events.push_back(Joystick::Event(Joystick::Down, down));
	events.push_back(Joystick::Event(Joystick::Up, up));
	}

	};

	ButtonMapping * makeButtonMapping(string name){
	#ifdef PS3
	return new Ps3Controller();
	#endif
	if (name == "Sony PLAYSTATION(R)3 Controller"){
	return new Playstation3Controller();
	}
	if (name.find("Logitech(R) Precision(TM) Gamepad") != string::npos){
	return new LogitechPrecision();
	}
	if (name == "Microsoft X-Box 360 pad"){
	return new XBox360Controller();
	}
	if (name.find("Wiimote") != string::npos){
	return new Wiimote();
	}
	if (name.find("Gamecube") != string::npos){
	return new GamecubePad();
	}
	return new DefaultButtonMapping();
	}

	void SDLJoystick::poll(){
	events.clear();
	}

	static bool read_button(SDL_Joystick * joystick, int button){
	return SDL_JoystickGetButton(joystick, button);
	}

	/*
	JoystickInput SDLJoystick::readAll(){
	JoystickInput input;
	return input;
	if (joystick){
	int buttons = SDL_JoystickNumButtons(joystick);
	switch (buttons > 5 ? 5 : buttons){
	case 5: input.quit = read_button(joystick, buttonMapping->toNative(4));
	case 4: input.button4 = read_button(joystick, buttonMapping->toNative(3));
	case 3: input.button3 = read_button(joystick, buttonMapping->toNative(2));
	case 2: input.button2 = read_button(joystick, buttonMapping->toNative(1));
	case 1: input.button1 = read_button(joystick, buttonMapping->toNative(0));
	case 0: {
	break;
	}
	}
	}

	int axis = SDL_JoystickNumAxes(joystick);
	if (axis > 0){
	int position = SDL_JoystickGetAxis(joystick, 0);
	if (position < 0){
	input.left = true;
	} else if (position > 0){
	input.right = true;
	}
	}

	if (axis > 1){
	int position = SDL_JoystickGetAxis(joystick, 1);
	if (position < 0){
	input.up = true;
	} else if (position > 0){
	input.down = true;
	}
	}

	int hats = SDL_JoystickNumHats(joystick);
	if (hats > 0){
	int hat = SDL_JoystickGetHat(joystick, 0);
	if ((hat & SDL_HAT_UP) == SDL_HAT_UP){
	input.up = true;
	}
	if ((hat & SDL_HAT_DOWN) == SDL_HAT_DOWN){
	input.down = true;
	}
	if ((hat & SDL_HAT_LEFT) == SDL_HAT_LEFT){
	input.left = true;
	}
	if ((hat & SDL_HAT_RIGHT) == SDL_HAT_RIGHT){
	input.right = true;
	}
	if ((hat & SDL_HAT_RIGHTUP) == SDL_HAT_RIGHTUP){
	input.right = true;
	input.up = true;
	}
	if ((hat & SDL_HAT_RIGHTDOWN) == SDL_HAT_RIGHTDOWN){
	input.right = true;
	input.down = true;
	}
	if ((hat & SDL_HAT_LEFTDOWN) == SDL_HAT_LEFTDOWN){
	input.left = true;
	input.down = true;
	}
	if ((hat & SDL_HAT_LEFTUP) == SDL_HAT_LEFTUP){
	input.left = true;
	input.up = true;
	}
	}

	return input;
	}
	*/

	SDLJoystick::~SDLJoystick(){
	if (joystick){
	SDL_JoystickClose(joystick);
	}
	}

	-SDLJoystick::SDLJoystick():
	+SDLJoystick::SDLJoystick(int id):
	joystick(NULL){
	/* TODO: don't always open joystick 0, try to support all of them */
	if (SDL_NumJoysticks() > 0){
	- Global::debug(1) << "Opened joystick '" << SDL_JoystickName(0) << "'" << std::endl;
	- joystick = SDL_JoystickOpen(0);
	+ joystick = SDL_JoystickOpen(id);
	+ if (joystick == NULL){
	+ Global::debug(0) << "Could not open joystick at index " << id << std::endl;
	+ } else {
	+ Global::debug(1) << "Opened joystick '" << SDL_JoystickName(id) << "'" << std::endl;
	+ }
	// printf("Opened joystick '%s'\n", SDL_JoystickName(4));
	- buttonMapping = makeButtonMapping(SDL_JoystickName(0));
	+ buttonMapping = makeButtonMapping(SDL_JoystickName(id));
	}
	}

	void SDLJoystick::pressButton(int button){
	// Global::debug(0) << "Pressed button " << button << std::endl;
	if (joystick){
	Key event = buttonMapping->toKey(button);
	if (event != Invalid){
	events.push_back(Event(event, true));
	}
	}
	}

	void SDLJoystick::releaseButton(int button){
	if (joystick){
	Key event = buttonMapping->toKey(button);
	if (event != Invalid){
	events.push_back(Event(event, false));
	}
	}
	}

	void SDLJoystick::hatMotion(int motion){
	if (joystick){
	buttonMapping->hatMotionEvents(motion, events);
	}
	}

	void SDLJoystick::axisMotion(int axis, int motion){
	// Global::debug(0) << "Axis motion on " << axis << " motion " << motion << std::endl;
	if (joystick){
	buttonMapping->axisMotionEvents(axis, motion, events);
	/*
	Event move = buttonMapping->axisMotionToEvent(axis, motion);
	if (move.key != Invalid){
	events.push_back(move);
	}
	*/
	}
	}

	int SDLJoystick::getDeviceId() const {
	if (joystick){
	return SDL_JoystickIndex(joystick);
	}

	return -1;
	}

	+int Joystick::numberOfJoysticks(){
	+ return SDL_NumJoysticks();
	+}
	+
	#endif
	diff --git a/util/input/sdl/joystick.h b/util/input/sdl/joystick.h
	index 43df47fa..f20267e3 100644
	--- a/util/input/sdl/joystick.h
	+++ b/util/input/sdl/joystick.h
	@@ -1,37 +1,37 @@
	#ifndef _paintown_sdl_joystick_h
	#define _paintown_sdl_joystick_h

	#ifdef USE_SDL

	#include <SDL.h>
	#include "../joystick.h"
	#include "util/pointer.h"

	class ButtonMapping;

	class SDLJoystick: public Joystick {
	public:
	virtual void poll();
	// virtual JoystickInput readAll();
	virtual int getDeviceId() const;
	virtual void pressButton(int button);
	virtual void releaseButton(int button);
	virtual void axisMotion(int axis, int motion);
	virtual void hatMotion(int motion);

	virtual ~SDLJoystick();

	friend class Joystick;
	protected:
	/* convert buttons between what paintown wants and what sdl wants */
	int to_native_button(int button);
	int from_native_button(int button);

	- SDLJoystick();
	+ SDLJoystick(int i);
	SDL_Joystick * joystick;
	Util::ReferenceCount<ButtonMapping> buttonMapping;
	};

	#endif

	#endif

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jun 11, 9:53 AM (3 w, 5 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 68217
Default Alt Text: (66 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions