src/com/replica/replicaisland/InputGameInterface.java - platform/external/replicaisland - Git at Google

 /*
  * Copyright (C) 2010 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.replica.replicaisland;

 import android.view.KeyEvent;

 public class InputGameInterface extends BaseObject {
 	private static final float ORIENTATION_DEAD_ZONE_MIN = 0.03f;
 	private static final float ORIENTATION_DEAD_ZONE_MAX = 0.1f;
 	private static final float ORIENTATION_DEAD_ZONE_SCALE = 0.75f;

 	private final static float ROLL_TIMEOUT = 0.1f;
 	private final static float ROLL_RESET_DELAY = 0.075f;

     // Raw trackball input is filtered by this value. Increasing it will
     // make the control more twitchy, while decreasing it will make the control more precise.
     private final static float ROLL_FILTER = 0.4f;
     private final static float ROLL_DECAY = 8.0f;

     private final static float KEY_FILTER = 0.25f;
     private final static float SLIDER_FILTER = 0.25f;


 	private InputButton mJumpButton = new InputButton();
 	private InputButton mAttackButton = new InputButton();
 	private InputXY mDirectionalPad = new InputXY();
 	private InputXY mTilt = new InputXY();

 	private int mLeftKeyCode = KeyEvent.KEYCODE_DPAD_LEFT;
 	private int mRightKeyCode = KeyEvent.KEYCODE_DPAD_RIGHT;
 	private int mJumpKeyCode = KeyEvent.KEYCODE_SPACE;
 	private int mAttackKeyCode = KeyEvent.KEYCODE_SHIFT_LEFT;

 	private float mOrientationDeadZoneMin = ORIENTATION_DEAD_ZONE_MIN;
 	private float mOrientationDeadZoneMax = ORIENTATION_DEAD_ZONE_MAX;
 	private float mOrientationDeadZoneScale = ORIENTATION_DEAD_ZONE_SCALE;
 	private float mOrientationSensitivity = 1.0f;
 	private float mOrientationSensitivityFactor = 1.0f;
 	private float mMovementSensitivity = 1.0f;

 	private boolean mUseClickButtonForAttack = true;
 	private boolean mUseOrientationForMovement = false;
 	private boolean mUseOnScreenControls = false;

 	private float mLastRollTime;

 	public InputGameInterface() {
 		super();
 		reset();
 	}

 	@Override
 	public void reset() {
 		mJumpButton.release();
 		mAttackButton.release();
 		mDirectionalPad.release();
 		mTilt.release();
 	}


 	@Override
     public void update(float timeDelta, BaseObject parent) {
 		InputSystem input = sSystemRegistry.inputSystem;
 		final InputButton[] keys = input.getKeyboard().getKeys();
 		final InputXY orientation = input.getOrientationSensor();

 		// tilt is easy
 		mTilt.clone(orientation);

 		final InputTouchScreen touch = input.getTouchScreen();
 		final float gameTime = sSystemRegistry.timeSystem.getGameTime();

 		float sliderOffset = 0;

 		// update movement inputs
 		if (mUseOnScreenControls) {
 			final InputXY sliderTouch = touch.findPointerInRegion(
 					ButtonConstants.MOVEMENT_SLIDER_REGION_X,
                     ButtonConstants.MOVEMENT_SLIDER_REGION_Y,
                     ButtonConstants.MOVEMENT_SLIDER_REGION_WIDTH,
                     ButtonConstants.MOVEMENT_SLIDER_REGION_HEIGHT);

 			if (sliderTouch != null) {
 				final float halfWidth = ButtonConstants.MOVEMENT_SLIDER_BAR_WIDTH / 2.0f;
 				final float center = ButtonConstants.MOVEMENT_SLIDER_X + halfWidth;
 				final float offset = sliderTouch.getX() - center;
 				float magnitudeRamp = Math.abs(offset) > halfWidth ? 1.0f : (Math.abs(offset) / halfWidth);

 				final float magnitude = magnitudeRamp * Utils.sign(offset) * SLIDER_FILTER * mMovementSensitivity;
 				sliderOffset = magnitudeRamp * Utils.sign(offset);
 				mDirectionalPad.press(gameTime, magnitude, 0.0f);
 			} else {
 				mDirectionalPad.release();
 			}
 		} else if (mUseOrientationForMovement) {
 			mDirectionalPad.clone(orientation);
 			mDirectionalPad.setMagnitude(
 					filterOrientationForMovement(orientation.getX()),
 					filterOrientationForMovement(orientation.getY()));
 		} else {
 			// keys or trackball
 			final InputXY trackball = input.getTrackball();
 			final InputButton left = keys[mLeftKeyCode];
 			final InputButton right = keys[mRightKeyCode];
 			final float leftPressedTime = left.getLastPressedTime();
 			final float rightPressedTime = right.getLastPressedTime();


 			if (trackball.getLastPressedTime() > Math.max(leftPressedTime, rightPressedTime)) {
 				// The trackball never goes "up", so force it to turn off if it wasn't triggered in the last frame.
 				// What follows is a bunch of code to filter trackball events into something like a dpad event.
 				// The goals here are:
 				// 	- For roll events that occur in quick succession to accumulate.
 				//	- For roll events that occur with more time between them, lessen the impact of older events
 				//	- In the absence of roll events, fade the roll out over time.
 				if (gameTime - trackball.getLastPressedTime() < ROLL_TIMEOUT) {
 					float newX;
 					float newY;
 					final float delay = Math.max(ROLL_RESET_DELAY, timeDelta);
 					if (gameTime - mLastRollTime <= delay) {
 						newX = mDirectionalPad.getX() + (trackball.getX() * ROLL_FILTER * mMovementSensitivity);
 						newY = mDirectionalPad.getY() + (trackball.getY() * ROLL_FILTER * mMovementSensitivity);
 					} else {
 						float oldX = mDirectionalPad.getX() != 0.0f ? mDirectionalPad.getX() / 2.0f : 0.0f;
 						float oldY = mDirectionalPad.getX() != 0.0f ? mDirectionalPad.getX() / 2.0f : 0.0f;
 						newX = oldX + (trackball.getX() * ROLL_FILTER * mMovementSensitivity);
 						newY = oldY + (trackball.getX() * ROLL_FILTER * mMovementSensitivity);
 					}

 					mDirectionalPad.press(gameTime, newX, newY);
 					mLastRollTime = gameTime;
 					trackball.release();
 				} else {
 					float x = mDirectionalPad.getX();
 					float y = mDirectionalPad.getY();
 					if (x != 0.0f) {
 						int sign = Utils.sign(x);
 						x = x - (sign * ROLL_DECAY * timeDelta);
 						if (Utils.sign(x) != sign) {
 							x = 0.0f;
 						}
 					}

 					if (y != 0.0f) {
 						int sign = Utils.sign(y);
 						y = y - (sign * ROLL_DECAY * timeDelta);
 						if (Utils.sign(x) != sign) {
 							y = 0.0f;
 						}
 					}


 					if (x == 0 && y == 0) {
 						mDirectionalPad.release();
 					} else {
 						mDirectionalPad.setMagnitude(x, y);
 					}
 				}

 			} else {
 				float xMagnitude = 0.0f;
 				float yMagnitude = 0.0f;
 				float pressTime = 0.0f;
 				// left and right are mutually exclusive
 				if (leftPressedTime > rightPressedTime) {
 					xMagnitude = -left.getMagnitude() * KEY_FILTER * mMovementSensitivity;
 					pressTime = leftPressedTime;
 				} else {
 					xMagnitude = right.getMagnitude() * KEY_FILTER * mMovementSensitivity;
 					pressTime = rightPressedTime;
 				}

 				if (xMagnitude != 0.0f) {
 					mDirectionalPad.press(pressTime, xMagnitude, yMagnitude);
 				} else {
 					mDirectionalPad.release();
 				}
 			}
 		}

 		// update other buttons
 		final InputButton jumpKey = keys[mJumpKeyCode];

 		// when on-screen movement controls are on, the fly and attack buttons are flipped.
 		float flyButtonRegionX = ButtonConstants.FLY_BUTTON_REGION_X;
 		float stompButtonRegionX = ButtonConstants.STOMP_BUTTON_REGION_X;

 		if (mUseOnScreenControls) {
 			ContextParameters params = sSystemRegistry.contextParameters;
 			flyButtonRegionX = params.gameWidth - ButtonConstants.FLY_BUTTON_REGION_WIDTH - ButtonConstants.FLY_BUTTON_REGION_X;
 			stompButtonRegionX = params.gameWidth - ButtonConstants.STOMP_BUTTON_REGION_WIDTH - ButtonConstants.STOMP_BUTTON_REGION_X;
 		}

 		final InputXY jumpTouch = touch.findPointerInRegion(
 				flyButtonRegionX,
                 ButtonConstants.FLY_BUTTON_REGION_Y,
                 ButtonConstants.FLY_BUTTON_REGION_WIDTH,
                 ButtonConstants.FLY_BUTTON_REGION_HEIGHT);

 		if (jumpKey.getPressed()) {
 			mJumpButton.press(jumpKey.getLastPressedTime(), jumpKey.getMagnitude());
 		} else if (jumpTouch != null) {
 			if (!mJumpButton.getPressed()) {
 				mJumpButton.press(jumpTouch.getLastPressedTime(), 1.0f);
 			}
 		} else {
 			mJumpButton.release();
 		}

 		final InputButton attackKey = keys[mAttackKeyCode];
 		final InputButton clickButton = keys[KeyEvent.KEYCODE_DPAD_CENTER]; // special case

 		final InputXY stompTouch = touch.findPointerInRegion(
 				stompButtonRegionX,
                 ButtonConstants.STOMP_BUTTON_REGION_Y,
                 ButtonConstants.STOMP_BUTTON_REGION_WIDTH,
                 ButtonConstants.STOMP_BUTTON_REGION_HEIGHT);

 		if (mUseClickButtonForAttack && clickButton.getPressed()) {
 			mAttackButton.press(clickButton.getLastPressedTime(), clickButton.getMagnitude());
 		} else if (attackKey.getPressed()) {
 			mAttackButton.press(attackKey.getLastPressedTime(), attackKey.getMagnitude());
 		} else if (stompTouch != null) {
 			// Since touch events come in constantly, we only want to press the attack button
 			// here if it's not already down.  That makes it act like the other buttons (down once then up).
 			if (!mAttackButton.getPressed()) {
 				mAttackButton.press(stompTouch.getLastPressedTime(), 1.0f);
 			}
 		} else {
 			mAttackButton.release();
 		}

 		// This doesn't seem like exactly the right place to write to the HUD, but on the other hand,
 		// putting this code elsewhere causes dependencies between exact HUD content and physics, which
 		// we sometimes wish to avoid.
 		final HudSystem hud = sSystemRegistry.hudSystem;
         if (hud != null) {
             hud.setButtonState(mJumpButton.getPressed(), mAttackButton.getPressed(), mDirectionalPad.getPressed());
             hud.setMovementSliderOffset(sliderOffset);
         }
 	}


 	private float filterOrientationForMovement(float magnitude) {
 		float scaledMagnitude = magnitude * mOrientationSensitivityFactor;

 		return deadZoneFilter(scaledMagnitude, mOrientationDeadZoneMin, mOrientationDeadZoneMax, mOrientationDeadZoneScale);
 	}

 	private float deadZoneFilter(float magnitude, float min, float max, float scale) {
 		float smoothedMagnatude = magnitude;
     	if (Math.abs(magnitude) < min) {
     		smoothedMagnatude = 0.0f;	// dead zone
     	} else if (Math.abs(magnitude) < max) {
     		smoothedMagnatude *= scale;
     	}

     	return smoothedMagnatude;
 	}


 	public final InputXY getDirectionalPad() {
 		return mDirectionalPad;
 	}

 	public final InputXY getTilt() {
 		return mTilt;
 	}

 	public final InputButton getJumpButton() {
 		return mJumpButton;
 	}

 	public final InputButton getAttackButton() {
 		return mAttackButton;
 	}

 	public void setKeys(int left, int right, int jump, int attack) {
 		mLeftKeyCode = left;
 		mRightKeyCode = right;
 		mJumpKeyCode = jump;
 		mAttackKeyCode = attack;
 	}

 	public void setUseClickForAttack(boolean click) {
 		mUseClickButtonForAttack = click;
 	}

 	public void setUseOrientationForMovement(boolean orientation) {
 		mUseOrientationForMovement = orientation;
 	}

 	public void setOrientationMovementSensitivity(float sensitivity) {
 		mOrientationSensitivity = sensitivity;
 		mOrientationSensitivityFactor = 2.9f * sensitivity + 0.1f;
 	}

 	public void setMovementSensitivity(float sensitivity) {
 		mMovementSensitivity  = sensitivity;
 	}

 	public void setUseOnScreenControls(boolean onscreen) {
 		mUseOnScreenControls = onscreen;
 	}

 }
	/*
	* Copyright (C) 2010 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.replica.replicaisland;

	import android.view.KeyEvent;

	public class InputGameInterface extends BaseObject {
	private static final float ORIENTATION_DEAD_ZONE_MIN = 0.03f;
	private static final float ORIENTATION_DEAD_ZONE_MAX = 0.1f;
	private static final float ORIENTATION_DEAD_ZONE_SCALE = 0.75f;

	private final static float ROLL_TIMEOUT = 0.1f;
	private final static float ROLL_RESET_DELAY = 0.075f;

	// Raw trackball input is filtered by this value. Increasing it will
	// make the control more twitchy, while decreasing it will make the control more precise.
	private final static float ROLL_FILTER = 0.4f;
	private final static float ROLL_DECAY = 8.0f;

	private final static float KEY_FILTER = 0.25f;
	private final static float SLIDER_FILTER = 0.25f;


	private InputButton mJumpButton = new InputButton();
	private InputButton mAttackButton = new InputButton();
	private InputXY mDirectionalPad = new InputXY();
	private InputXY mTilt = new InputXY();

	private int mLeftKeyCode = KeyEvent.KEYCODE_DPAD_LEFT;
	private int mRightKeyCode = KeyEvent.KEYCODE_DPAD_RIGHT;
	private int mJumpKeyCode = KeyEvent.KEYCODE_SPACE;
	private int mAttackKeyCode = KeyEvent.KEYCODE_SHIFT_LEFT;

	private float mOrientationDeadZoneMin = ORIENTATION_DEAD_ZONE_MIN;
	private float mOrientationDeadZoneMax = ORIENTATION_DEAD_ZONE_MAX;
	private float mOrientationDeadZoneScale = ORIENTATION_DEAD_ZONE_SCALE;
	private float mOrientationSensitivity = 1.0f;
	private float mOrientationSensitivityFactor = 1.0f;
	private float mMovementSensitivity = 1.0f;

	private boolean mUseClickButtonForAttack = true;
	private boolean mUseOrientationForMovement = false;
	private boolean mUseOnScreenControls = false;

	private float mLastRollTime;

	public InputGameInterface() {
	super();
	reset();
	}

	@Override
	public void reset() {
	mJumpButton.release();
	mAttackButton.release();
	mDirectionalPad.release();
	mTilt.release();
	}



	@Override
	public void update(float timeDelta, BaseObject parent) {
	InputSystem input = sSystemRegistry.inputSystem;
	final InputButton[] keys = input.getKeyboard().getKeys();
	final InputXY orientation = input.getOrientationSensor();

	// tilt is easy
	mTilt.clone(orientation);

	final InputTouchScreen touch = input.getTouchScreen();
	final float gameTime = sSystemRegistry.timeSystem.getGameTime();

	float sliderOffset = 0;

	// update movement inputs
	if (mUseOnScreenControls) {
	final InputXY sliderTouch = touch.findPointerInRegion(
	ButtonConstants.MOVEMENT_SLIDER_REGION_X,
	ButtonConstants.MOVEMENT_SLIDER_REGION_Y,
	ButtonConstants.MOVEMENT_SLIDER_REGION_WIDTH,
	ButtonConstants.MOVEMENT_SLIDER_REGION_HEIGHT);

	if (sliderTouch != null) {
	final float halfWidth = ButtonConstants.MOVEMENT_SLIDER_BAR_WIDTH / 2.0f;
	final float center = ButtonConstants.MOVEMENT_SLIDER_X + halfWidth;
	final float offset = sliderTouch.getX() - center;
	float magnitudeRamp = Math.abs(offset) > halfWidth ? 1.0f : (Math.abs(offset) / halfWidth);

	final float magnitude = magnitudeRamp * Utils.sign(offset) * SLIDER_FILTER * mMovementSensitivity;
	sliderOffset = magnitudeRamp * Utils.sign(offset);
	mDirectionalPad.press(gameTime, magnitude, 0.0f);
	} else {
	mDirectionalPad.release();
	}
	} else if (mUseOrientationForMovement) {
	mDirectionalPad.clone(orientation);
	mDirectionalPad.setMagnitude(
	filterOrientationForMovement(orientation.getX()),
	filterOrientationForMovement(orientation.getY()));
	} else {
	// keys or trackball
	final InputXY trackball = input.getTrackball();
	final InputButton left = keys[mLeftKeyCode];
	final InputButton right = keys[mRightKeyCode];
	final float leftPressedTime = left.getLastPressedTime();
	final float rightPressedTime = right.getLastPressedTime();


	if (trackball.getLastPressedTime() > Math.max(leftPressedTime, rightPressedTime)) {
	// The trackball never goes "up", so force it to turn off if it wasn't triggered in the last frame.
	// What follows is a bunch of code to filter trackball events into something like a dpad event.
	// The goals here are:
	// - For roll events that occur in quick succession to accumulate.
	// - For roll events that occur with more time between them, lessen the impact of older events
	// - In the absence of roll events, fade the roll out over time.
	if (gameTime - trackball.getLastPressedTime() < ROLL_TIMEOUT) {
	float newX;
	float newY;
	final float delay = Math.max(ROLL_RESET_DELAY, timeDelta);
	if (gameTime - mLastRollTime <= delay) {
	newX = mDirectionalPad.getX() + (trackball.getX() * ROLL_FILTER * mMovementSensitivity);
	newY = mDirectionalPad.getY() + (trackball.getY() * ROLL_FILTER * mMovementSensitivity);
	} else {
	float oldX = mDirectionalPad.getX() != 0.0f ? mDirectionalPad.getX() / 2.0f : 0.0f;
	float oldY = mDirectionalPad.getX() != 0.0f ? mDirectionalPad.getX() / 2.0f : 0.0f;
	newX = oldX + (trackball.getX() * ROLL_FILTER * mMovementSensitivity);
	newY = oldY + (trackball.getX() * ROLL_FILTER * mMovementSensitivity);
	}

	mDirectionalPad.press(gameTime, newX, newY);
	mLastRollTime = gameTime;
	trackball.release();
	} else {
	float x = mDirectionalPad.getX();
	float y = mDirectionalPad.getY();
	if (x != 0.0f) {
	int sign = Utils.sign(x);
	x = x - (sign * ROLL_DECAY * timeDelta);
	if (Utils.sign(x) != sign) {
	x = 0.0f;
	}
	}

	if (y != 0.0f) {
	int sign = Utils.sign(y);
	y = y - (sign * ROLL_DECAY * timeDelta);
	if (Utils.sign(x) != sign) {
	y = 0.0f;
	}
	}


	if (x == 0 && y == 0) {
	mDirectionalPad.release();
	} else {
	mDirectionalPad.setMagnitude(x, y);
	}
	}

	} else {
	float xMagnitude = 0.0f;
	float yMagnitude = 0.0f;
	float pressTime = 0.0f;
	// left and right are mutually exclusive
	if (leftPressedTime > rightPressedTime) {
	xMagnitude = -left.getMagnitude() * KEY_FILTER * mMovementSensitivity;
	pressTime = leftPressedTime;
	} else {
	xMagnitude = right.getMagnitude() * KEY_FILTER * mMovementSensitivity;
	pressTime = rightPressedTime;
	}

	if (xMagnitude != 0.0f) {
	mDirectionalPad.press(pressTime, xMagnitude, yMagnitude);
	} else {
	mDirectionalPad.release();
	}
	}
	}

	// update other buttons
	final InputButton jumpKey = keys[mJumpKeyCode];

	// when on-screen movement controls are on, the fly and attack buttons are flipped.
	float flyButtonRegionX = ButtonConstants.FLY_BUTTON_REGION_X;
	float stompButtonRegionX = ButtonConstants.STOMP_BUTTON_REGION_X;

	if (mUseOnScreenControls) {
	ContextParameters params = sSystemRegistry.contextParameters;
	flyButtonRegionX = params.gameWidth - ButtonConstants.FLY_BUTTON_REGION_WIDTH - ButtonConstants.FLY_BUTTON_REGION_X;
	stompButtonRegionX = params.gameWidth - ButtonConstants.STOMP_BUTTON_REGION_WIDTH - ButtonConstants.STOMP_BUTTON_REGION_X;
	}

	final InputXY jumpTouch = touch.findPointerInRegion(
	flyButtonRegionX,
	ButtonConstants.FLY_BUTTON_REGION_Y,
	ButtonConstants.FLY_BUTTON_REGION_WIDTH,
	ButtonConstants.FLY_BUTTON_REGION_HEIGHT);

	if (jumpKey.getPressed()) {
	mJumpButton.press(jumpKey.getLastPressedTime(), jumpKey.getMagnitude());
	} else if (jumpTouch != null) {
	if (!mJumpButton.getPressed()) {
	mJumpButton.press(jumpTouch.getLastPressedTime(), 1.0f);
	}
	} else {
	mJumpButton.release();
	}

	final InputButton attackKey = keys[mAttackKeyCode];
	final InputButton clickButton = keys[KeyEvent.KEYCODE_DPAD_CENTER]; // special case

	final InputXY stompTouch = touch.findPointerInRegion(
	stompButtonRegionX,
	ButtonConstants.STOMP_BUTTON_REGION_Y,
	ButtonConstants.STOMP_BUTTON_REGION_WIDTH,
	ButtonConstants.STOMP_BUTTON_REGION_HEIGHT);

	if (mUseClickButtonForAttack && clickButton.getPressed()) {
	mAttackButton.press(clickButton.getLastPressedTime(), clickButton.getMagnitude());
	} else if (attackKey.getPressed()) {
	mAttackButton.press(attackKey.getLastPressedTime(), attackKey.getMagnitude());
	} else if (stompTouch != null) {
	// Since touch events come in constantly, we only want to press the attack button
	// here if it's not already down. That makes it act like the other buttons (down once then up).
	if (!mAttackButton.getPressed()) {
	mAttackButton.press(stompTouch.getLastPressedTime(), 1.0f);
	}
	} else {
	mAttackButton.release();
	}

	// This doesn't seem like exactly the right place to write to the HUD, but on the other hand,
	// putting this code elsewhere causes dependencies between exact HUD content and physics, which
	// we sometimes wish to avoid.
	final HudSystem hud = sSystemRegistry.hudSystem;
	if (hud != null) {
	hud.setButtonState(mJumpButton.getPressed(), mAttackButton.getPressed(), mDirectionalPad.getPressed());
	hud.setMovementSliderOffset(sliderOffset);
	}
	}


	private float filterOrientationForMovement(float magnitude) {
	float scaledMagnitude = magnitude * mOrientationSensitivityFactor;

	return deadZoneFilter(scaledMagnitude, mOrientationDeadZoneMin, mOrientationDeadZoneMax, mOrientationDeadZoneScale);
	}

	private float deadZoneFilter(float magnitude, float min, float max, float scale) {
	float smoothedMagnatude = magnitude;
	if (Math.abs(magnitude) < min) {
	smoothedMagnatude = 0.0f; // dead zone
	} else if (Math.abs(magnitude) < max) {
	smoothedMagnatude *= scale;
	}

	return smoothedMagnatude;
	}


	public final InputXY getDirectionalPad() {
	return mDirectionalPad;
	}

	public final InputXY getTilt() {
	return mTilt;
	}

	public final InputButton getJumpButton() {
	return mJumpButton;
	}

	public final InputButton getAttackButton() {
	return mAttackButton;
	}

	public void setKeys(int left, int right, int jump, int attack) {
	mLeftKeyCode = left;
	mRightKeyCode = right;
	mJumpKeyCode = jump;
	mAttackKeyCode = attack;
	}

	public void setUseClickForAttack(boolean click) {
	mUseClickButtonForAttack = click;
	}

	public void setUseOrientationForMovement(boolean orientation) {
	mUseOrientationForMovement = orientation;
	}

	public void setOrientationMovementSensitivity(float sensitivity) {
	mOrientationSensitivity = sensitivity;
	mOrientationSensitivityFactor = 2.9f * sensitivity + 0.1f;
	}

	public void setMovementSensitivity(float sensitivity) {
	mMovementSensitivity = sensitivity;
	}

	public void setUseOnScreenControls(boolean onscreen) {
	mUseOnScreenControls = onscreen;
	}

	}