RobotControlThread sends data.

src/ve/ucv/ciens/ccg/networkdata/MotorEventACK.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2014 Miguel Angel Astor Romero
+ *
+ * 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 ve.ucv.ciens.ccg.networkdata;
+
+import java.io.Serializable;
+
+public class MotorEventACK implements Serializable {
+	private static final long serialVersionUID = 9989L;
+
+	private boolean clientQueueIsFull;
+
+	public MotorEventACK(boolean isQueueFull){
+		this.clientQueueIsFull = isQueueFull;
+	}
+
+	public boolean isClientQueueFull(){
+		return this.clientQueueIsFull;
+	}
+}

src/ve/ucv/ciens/ccg/nxtar/NxtARCore.java

@@ -28,9 +28,7 @@ import ve.ucv.ciens.ccg.nxtar.states.OuyaMainMenuState;
 import ve.ucv.ciens.ccg.nxtar.states.PauseState;
 import ve.ucv.ciens.ccg.nxtar.states.TabletMainMenuState;
 import ve.ucv.ciens.ccg.nxtar.utils.ProjectConstants;
-
 import aurelienribon.tweenengine.Tween;
-import aurelienribon.tweenengine.TweenEquation;
 import aurelienribon.tweenengine.TweenEquations;
 import aurelienribon.tweenengine.primitives.MutableFloat;
 
@@ -39,14 +37,11 @@ import com.badlogic.gdx.Game;
 import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.controllers.Controllers;
 import com.badlogic.gdx.controllers.mappings.Ouya;
-import com.badlogic.gdx.graphics.Color;
-import com.badlogic.gdx.graphics.GL20;
 import com.badlogic.gdx.graphics.OrthographicCamera;
 import com.badlogic.gdx.graphics.Pixmap;
 import com.badlogic.gdx.graphics.Pixmap.Format;
 import com.badlogic.gdx.graphics.Texture;
 import com.badlogic.gdx.graphics.g2d.BitmapFont;
-import com.badlogic.gdx.graphics.g2d.Sprite;
 import com.badlogic.gdx.graphics.g2d.SpriteBatch;
 
 /**
@@ -173,14 +168,17 @@ public class NxtARCore extends Game implements NetworkConnectionListener{
 
 		Gdx.app.debug(TAG, CLASS_NAME + ".create() :: Creating network threads");
 		serviceDiscoveryThread = ServiceDiscoveryThread.getInstance();
-		videoThread = VideoStreamingThread.getInstance()/*.setToaster(toaster)*/;
+		videoThread = VideoStreamingThread.getInstance();
-		//robotThread = RobotControlThread.getInstance().setToaster(toaster);
+		robotThread = RobotControlThread.getInstance();
 
 		serviceDiscoveryThread.start();
+
 		videoThread.start();
 		videoThread.startStreaming();
 		videoThread.addNetworkConnectionListener(this);
-		//robotThread.start();
+
+		robotThread.addNetworkConnectionListener(this);
+		robotThread.start();
 
 		// Set the current and next states.
 		currState = game_states_t.MAIN_MENU;
@@ -206,11 +204,9 @@ public class NxtARCore extends Game implements NetworkConnectionListener{
 		Controllers.addListener(states[currState.getValue()]);
 
 		// Anything else.
-		Gdx.app.setLogLevel(Application.LOG_INFO);
+		//Gdx.app.setLogLevel(Application.LOG_INFO);
-		//Gdx.app.setLogLevel(Application.LOG_DEBUG);
+		Gdx.app.setLogLevel(Application.LOG_DEBUG);
 		//Gdx.app.setLogLevel(Application.LOG_NONE);
-
-		//batch.setBlendFunction(GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA);
 	}
 
 	public void render(){
@@ -287,9 +283,10 @@ public class NxtARCore extends Game implements NetworkConnectionListener{
 	public void dispose(){
 		// Finish network threads.
 		videoThread.finish();
-		fadeTexture.dispose();
+		robotThread.finish();
 
 		// Dispose graphic objects.
+		fadeTexture.dispose();
 		batch.dispose();
 		if(ProjectConstants.DEBUG){
 			font.dispose();
@@ -303,9 +300,10 @@ public class NxtARCore extends Game implements NetworkConnectionListener{
 
 	@Override
 	public synchronized void networkStreamConnected(String streamName){
-		if(streamName.equals(VideoStreamingThread.THREAD_NAME) || streamName.equals(RobotControlThread.THREAD_NAME))
+		//if(streamName.equals(VideoStreamingThread.THREAD_NAME) || streamName.equals(RobotControlThread.THREAD_NAME))
-			connections += 1;
+		Gdx.app.log(TAG, CLASS_NAME + ".networkStreamConnected() :: Stream " + streamName + " connected.");
-		if(connections >= 1){
+		connections += 1;
+		if(connections >= 2){
 			Gdx.app.debug(TAG, CLASS_NAME + ".networkStreamConnected() :: Stopping service broadcast.");
 			serviceDiscoveryThread.finish();
 			mcastEnabler.disableMulticast();

src/ve/ucv/ciens/ccg/nxtar/network/RobotControlThread.java

@@ -16,11 +16,16 @@
 package ve.ucv.ciens.ccg.nxtar.network;
 
 import java.io.IOException;
+import java.io.InvalidClassException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
 
+import ve.ucv.ciens.ccg.networkdata.MotorEvent;
+import ve.ucv.ciens.ccg.networkdata.MotorEventACK;
 import ve.ucv.ciens.ccg.nxtar.interfaces.NetworkConnectionListener;
-import ve.ucv.ciens.ccg.nxtar.interfaces.Toaster;
+import ve.ucv.ciens.ccg.nxtar.network.monitors.MotorEventQueue;
 import ve.ucv.ciens.ccg.nxtar.utils.ProjectConstants;
 
 import com.badlogic.gdx.Gdx;
@@ -33,15 +38,24 @@ public class RobotControlThread extends Thread {
 	private NetworkConnectionListener netListener;
 	private ServerSocket server;
 	private Socket client;
-	private Toaster toaster;
+	private MotorEventQueue queue;
+	private Object pauseMonitor;
+	private boolean paused;
+	private boolean done;
+	private ObjectOutputStream os;
+	private ObjectInputStream is;
 
 	private RobotControlThread(){
 		super(THREAD_NAME);
 
 		netListener = null;
+		queue = MotorEventQueue.getInstance();
+		pauseMonitor = new Object();
+		paused = false;
+		done = false;
 
 		try{
-			server = new ServerSocket(ProjectConstants.SERVER_TCP_PORT_2);
+			server = new ServerSocket(ProjectConstants.MOTOR_CONTROL_PORT);
 		}catch(IOException io){
 			Gdx.app.error(TAG, CLASS_NAME + ".RobotControlThread() :: Error creating server: " + io.getMessage(), io);
 		}
@@ -55,25 +69,109 @@ public class RobotControlThread extends Thread {
 		return SingletonHolder.INSTANCE;
 	}
 
-	public RobotControlThread setToaster(Toaster toaster){
-		this.toaster = toaster;
-		return this;
-	}
-
 	public void addNetworkConnectionListener(NetworkConnectionListener listener){
 		netListener = listener;
 	}
 
+	public void pauseThread(){
+		synchronized(pauseMonitor){
+			paused = true;
+		}
+	}
+
+	public void resumeThread(){
+		synchronized(pauseMonitor){
+			paused = false;
+		}
+	}
+
+	public void finish(){
+		done = true;
+	}
+
 	@Override
 	public void run(){
+		MotorEvent message;
+		MotorEventACK ack;
+
 		try{
 			client = server.accept();
-			if(netListener != null)
+			if(netListener != null) netListener.networkStreamConnected(THREAD_NAME);
-				netListener.networkStreamConnected(THREAD_NAME);
+			os = new ObjectOutputStream(client.getOutputStream());
-			toaster.showShortToast("Client connected to RobotControlThread");
+			is = new ObjectInputStream(client.getInputStream());
-			client.close();
+
 		}catch(IOException io){
 			Gdx.app.error(TAG, CLASS_NAME + ".run() :: Error accepting client: " + io.getMessage(), io);
+			return;
+		}
+
+		while(!paused){
+			if(done){
+				break;
+			}
+
+			// Send the motor event.
+			try{
+				message = queue.getNextEvent();
+				os.writeObject(message);
+				message = null;
+
+			}catch(InvalidClassException ic){
+				Gdx.app.error(TAG, CLASS_NAME + ".run() :: InvalidClassException during transmission: " + ic.getMessage(), ic);
+				break;
+
+			}catch(IOException io){
+				Gdx.app.error(TAG, CLASS_NAME + ".run() :: IOException during transmission: " + io.getMessage(), io);
+				break;
+			}
+
+			// Receive ack.
+			try{
+				ack = (MotorEventACK)is.readObject();
+			}catch(ClassNotFoundException cn){
+				Gdx.app.error(TAG, CLASS_NAME + ".run() :: InvalidClassException during reception: " + cn.getMessage(), cn);
+				break;
+
+			}catch(ClassCastException cc){
+				Gdx.app.error(TAG, CLASS_NAME + ".run() :: InvalidClassException during reception: " + cc.getMessage(), cc);
+				break;
+
+			}catch(IOException io){
+				Gdx.app.error(TAG, CLASS_NAME + ".run() :: InvalidClassException during reception: " + io.getMessage(), io);
+				break;
+			}
+
+			if(ack.isClientQueueFull()){
+				// Wait for client to notify.
+				// A client will never send two queue full acks in a row.
+				try{
+					ack = (MotorEventACK)is.readObject();
+				}catch(ClassNotFoundException cn){
+					Gdx.app.error(TAG, CLASS_NAME + ".run() :: InvalidClassException during reception: " + cn.getMessage(), cn);
+					break;
+
+				}catch(ClassCastException cc){
+					Gdx.app.error(TAG, CLASS_NAME + ".run() :: InvalidClassException during reception: " + cc.getMessage(), cc);
+					break;
+
+				}catch(IOException io){
+					Gdx.app.error(TAG, CLASS_NAME + ".run() :: InvalidClassException during reception: " + io.getMessage(), io);
+					break;
+				}
+
+			}else{
+				// Clean and continue.
+				ack = null;
+				message = null;
+				continue;
+			}
+		}
+
+
+		try{
+			client.close();
+		}catch(IOException io){
+			Gdx.app.error(TAG, CLASS_NAME + ".run() :: Error closing client: " + io.getMessage(), io);
 		}
 	}
 }

src/ve/ucv/ciens/ccg/nxtar/network/ServiceDiscoveryThread.java

@@ -31,7 +31,7 @@ import com.badlogic.gdx.Gdx;
  * <p> This thread performs an ad hoc service discovery protocol. A multicast datagram packet is sent every
  * 250 miliseconds carrying the string "NxtAR server is here!" on the multicast address defined 
  * in {@link ve.ucv.ciens.ccg.nxtar.utils.ProjectConstants#MULTICAST_ADDRESS}. The port defined in
- * {@link ve.ucv.ciens.ccg.nxtar.utils.ProjectConstants#SERVER_UDP_PORT} is used for the transmissions. The server stops
+ * {@link ve.ucv.ciens.ccg.nxtar.utils.ProjectConstants#SERVICE_DISCOVERY_PORT} is used for the transmissions. The server stops
  * when another thread calls the {@link #finish()} method or the server fails to transmit {@link #MAX_RETRIES} packets in
  * a row, whichever happens first.</p>
  * 
@@ -89,7 +89,7 @@ public class ServiceDiscoveryThread extends Thread {
 		// Create a UDP socket at the port defined in ProjectConstants.SERVER_UDP_PORT.
 		Gdx.app.debug(TAG, CLASS_NAME + ".ServiceDiscoveryThread() :: Creating multicast server.");
 		try{
-			udpServer = new DatagramSocket(ProjectConstants.SERVER_UDP_PORT);
+			udpServer = new DatagramSocket(ProjectConstants.SERVICE_DISCOVERY_PORT);
 		}catch(IOException io){
 			Gdx.app.error(TAG, CLASS_NAME + ".ServiceDiscoveryThread() :: Error creating UDP socket: " + io.getMessage());
 			udpServer = null;
@@ -150,10 +150,11 @@ public class ServiceDiscoveryThread extends Thread {
 					break;
 				}
 				// Send the packet and reset the retry counter.
-				DatagramPacket packet = new DatagramPacket(buffer, buffer.length, group, ProjectConstants.SERVER_UDP_PORT);
+				DatagramPacket packet = new DatagramPacket(buffer, buffer.length, group, ProjectConstants.SERVICE_DISCOVERY_PORT);
 				udpServer.send(packet);
 				retries = 0;
 				try{ sleep(250L); }catch(InterruptedException ie){ }
+
 			}catch(IOException io){
 				Gdx.app.error(TAG, CLASS_NAME + ".run() :: Error sending packet: " + io.getMessage());
 				retries += 1;

src/ve/ucv/ciens/ccg/nxtar/network/VideoStreamingThread.java

@@ -29,7 +29,7 @@ import ve.ucv.ciens.ccg.nxtar.utils.ProjectConstants;
 
 import com.badlogic.gdx.Gdx;
 
-public class VideoStreamingThread extends Thread {
+public class VideoStreamingThread extends Thread{
 	public static final String THREAD_NAME = "VideoStreamingThread";
 	private static final String TAG = "NXTAR_CORE_VIDEOTHREAD";
 	private static final String CLASS_NAME = VideoStreamingThread.class.getSimpleName();
@@ -65,7 +65,7 @@ public class VideoStreamingThread extends Thread {
 		frameMonitor = VideoFrameMonitor.getInstance();
 
 		try{
-			socket = new DatagramSocket(ProjectConstants.SERVER_TCP_PORT_1);
+			socket = new DatagramSocket(ProjectConstants.VIDEO_STREAMING_PORT);
 		}catch(IOException io){
 			Gdx.app.error(TAG, CLASS_NAME + ".VideoStreamingThread() :: Error creating server: " + io.getMessage(), io);
 		}

src/ve/ucv/ciens/ccg/nxtar/network/monitors/MotorEventQueue.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2014 Miguel Angel Astor Romero
+ *
+ * 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 ve.ucv.ciens.ccg.nxtar.network.monitors;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+import ve.ucv.ciens.ccg.networkdata.MotorEvent;
+
+/**
+ * <p>A simple monitor class that encapsulates a queue.</p>
+ * <p>As it name says it stores motor events to be forwarded to the NXT robot.</p>
+ * <p>This class implements the singleton design pattern.<p> 
+ * 
+ * @author Miguel Angel Astor Romero
+ */
+public class MotorEventQueue{
+	/**
+	 * The event queue implemented as a linked list.
+	 */
+	private Queue<MotorEvent> motorEvents;
+
+	private MotorEventQueue(){
+		motorEvents = new LinkedList<MotorEvent>();
+	}
+
+	private static class SingletonHolder{
+		public static final MotorEventQueue instance = new MotorEventQueue();
+	}
+
+	/**
+	 * Return the singleton instance of this class.
+	 * @return The singleton instance.
+	 */
+	public static MotorEventQueue getInstance(){
+		return SingletonHolder.instance;
+	}
+
+	/**
+	 * <p>Get the first event on the queue.</p>
+	 * <p> If there are no events to return this method blocks until some thread calls the addEvent() method.</p>
+	 * @return The event at the front of the queue.
+	 */
+	public synchronized MotorEvent getNextEvent(){
+		while(motorEvents.size() == 0){
+			try{ wait(); }catch(InterruptedException ie){ }
+		}
+		return motorEvents.poll();
+	}
+
+	/**
+	 * <p>Adds an event to the back of the queue.</p>
+	 * @param event The event to add.
+	 */
+	public synchronized void addEvent(MotorEvent event){
+		motorEvents.add(event);
+		notifyAll();
+	}
+}

src/ve/ucv/ciens/ccg/nxtar/states/InGameState.java

@@ -17,9 +17,11 @@ package ve.ucv.ciens.ccg.nxtar.states;
 
 import java.util.Arrays;
 
+import ve.ucv.ciens.ccg.networkdata.MotorEvent;
+import ve.ucv.ciens.ccg.networkdata.MotorEvent.motor_t;
 import ve.ucv.ciens.ccg.nxtar.NxtARCore;
 import ve.ucv.ciens.ccg.nxtar.NxtARCore.game_states_t;
-import ve.ucv.ciens.ccg.nxtar.exceptions.ImageTooBigException;
+import ve.ucv.ciens.ccg.nxtar.network.monitors.MotorEventQueue;
 import ve.ucv.ciens.ccg.nxtar.network.monitors.VideoFrameMonitor;
 import ve.ucv.ciens.ccg.nxtar.utils.ProjectConstants;
 import ve.ucv.ciens.ccg.nxtar.utils.Size;
@@ -76,11 +78,14 @@ public class InGameState extends BaseState{
 	private boolean[] motorButtonsTouched;
 	private int[] motorButtonsPointers;
 
+	// Monitors.
 	private VideoFrameMonitor frameMonitor;
+	private MotorEventQueue queue;
 
 	public InGameState(final NxtARCore core){
 		this.core = core;
 		frameMonitor = VideoFrameMonitor.getInstance();
+		queue = MotorEventQueue.getInstance();
 
 		// Set up rendering fields;
 		videoFrame = null;
@@ -126,8 +131,7 @@ public class InGameState extends BaseState{
 	}
 
 	@Override
-	public void render(float delta) {
+	public void render(float delta){
-		Pixmap temp;
 		byte[] frame;
 		byte[] prevFrame = null;
 		Size dimensions = null;
@@ -148,20 +152,10 @@ public class InGameState extends BaseState{
 		frame = frameMonitor.getCurrentFrame();
 		if(frame != null && !Arrays.equals(frame, prevFrame)){
 			dimensions = frameMonitor.getFrameDimensions();
-			temp = new Pixmap(frame, 0, dimensions.getWidth() * dimensions.getHeight());
+			videoFrame = new Pixmap(frame, 0, dimensions.getWidth() * dimensions.getHeight());
-			if(videoFrame == null){
-				try{
-					videoFrame = new Pixmap(getOptimalTextureSize(dimensions.getWidth()), getOptimalTextureSize(dimensions.getHeight()), temp.getFormat());
-				}catch(ImageTooBigException e){
-					core.toast("Cannot display received frame.\n" + e.getMessage(), true);
-					Gdx.app.exit();
-					return;
-				}
-			}
-			videoFrame.drawPixmap(temp, 0, 0);
-			temp.dispose();
 			videoFrameTexture = new Texture(videoFrame);
 			videoFrameTexture.setFilter(TextureFilter.Linear, TextureFilter.Linear);
+			videoFrame.dispose();
 
 			TextureRegion region = new TextureRegion(videoFrameTexture, 0, 0, dimensions.getWidth(), dimensions.getHeight());
 
@@ -199,59 +193,38 @@ public class InGameState extends BaseState{
 				motorD.draw(core.batch);
 			}
 		}core.batch.end();
-		
+
 		prevFrame = frame;
 	}
 
 	@Override
-	public void resize(int width, int height) {
+	public void resize(int width, int height){
 		// TODO Auto-generated method stub
 
 	}
 
 	@Override
-	public void show() {
+	public void show(){ }
-		// TODO Auto-generated method stub
-
-	}
 
 	@Override
-	public void hide() {
+	public void hide(){ }
-		// TODO Auto-generated method stub
-
-	}
 
 	@Override
-	public void pause() {
+	public void pause(){ }
-		// TODO Auto-generated method stub
-
-	}
 
 	@Override
-	public void resume() {
+	public void resume(){ }
-		// TODO Auto-generated method stub
-
-	}
 
 	@Override
-	public void dispose() {
+	public void dispose(){
 		if(videoFrameTexture != null)
 			videoFrameTexture.dispose();
 		if(buttonTexture != null)
 			buttonTexture.dispose();
-		if(videoFrame != null)
-			videoFrame.dispose();
 		backgroundTexture.dispose();
 		if(backgroundShader != null) backgroundShader.dispose();
 	}
 
-	private int getOptimalTextureSize(int imageSideLength) throws ImageTooBigException{
-		for(int po2: ProjectConstants.POWERS_OF_2){
-			if(imageSideLength < po2) return po2;
-		}
-		throw new ImageTooBigException("No valid texture size found. Image too large.");
-	}
-
 	/*;;;;;;;;;;;;;;;;;;
 	  ; HELPER METHODS ;
 	  ;;;;;;;;;;;;;;;;;;*/
@@ -301,28 +274,9 @@ public class InGameState extends BaseState{
 	  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;*/
 
 	@Override
-	public boolean keyDown(int keycode) {
+	public boolean touchDown(int screenX, int screenY, int pointer, int button){
-		if(keycode == Input.Keys.BACK){
+		MotorEvent event;
-			core.nextState = game_states_t.MAIN_MENU;
-			return true;
-		}
-		return false;
-	}
 
-	@Override
-	public boolean keyUp(int keycode) {
-		// TODO Auto-generated method stub
-		return false;
-	}
-
-	@Override
-	public boolean keyTyped(char character) {
-		// TODO Auto-generated method stub
-		return false;
-	}
-
-	@Override
-	public boolean touchDown(int screenX, int screenY, int pointer, int button) {
 		if(!Ouya.runningOnOuya){
 			win2world.set(screenX, screenY, 0.0f);
 			camera.unproject(win2world);
@@ -333,27 +287,69 @@ public class InGameState extends BaseState{
 
 			if(motorA.getBoundingRectangle().contains(touchPointWorldCoords)){
 				Gdx.app.log(TAG, CLASS_NAME + ".touchDown() :: Motor A button pressed");
-				motorButtonsTouched[0] = true;
+
-				motorButtonsPointers[0] = pointer;
+				// Enqueue the event corresponding to this button if the opposing button is not pressed already.
+				if(!motorButtonsTouched[1]){
+					motorButtonsTouched[0] = true;
+					motorButtonsPointers[0] = pointer;
+
+					event = new MotorEvent();
+					event.setMotor(motor_t.MOTOR_C);
+					event.setPower((byte)100);
+					queue.addEvent(event);
+				}
+
 			}else if(motorB.getBoundingRectangle().contains(touchPointWorldCoords)){
 				Gdx.app.log(TAG, CLASS_NAME + ".touchDown() :: Motor B button pressed");
-				motorButtonsTouched[1] = true;
+
-				motorButtonsPointers[1] = pointer;
+				// Enqueue the event corresponding to this button if the opposing button is not pressed already.
+				if(!motorButtonsTouched[0]){
+					motorButtonsTouched[1] = true;
+					motorButtonsPointers[1] = pointer;
+
+					event = new MotorEvent();
+					event.setMotor(motor_t.MOTOR_C);
+					event.setPower((byte)-100);
+					queue.addEvent(event);
+				}
+
 			}else if(motorC.getBoundingRectangle().contains(touchPointWorldCoords)){
 				Gdx.app.log(TAG, CLASS_NAME + ".touchDown() :: Motor C button pressed");
-				motorButtonsTouched[2] = true;
+
-				motorButtonsPointers[2] = pointer;
+				// Enqueue the event corresponding to this button if the opposing button is not pressed already.
+				if(!motorButtonsTouched[3]){
+					motorButtonsTouched[2] = true;
+					motorButtonsPointers[2] = pointer;
+
+					event = new MotorEvent();
+					event.setMotor(motor_t.MOTOR_A);
+					event.setPower((byte)-100);
+					queue.addEvent(event);
+				}
+
 			}else if(motorD.getBoundingRectangle().contains(touchPointWorldCoords)){
 				Gdx.app.log(TAG, CLASS_NAME + ".touchDown() :: Motor D button pressed");
-				motorButtonsTouched[3] = true;
+
-				motorButtonsPointers[3] = pointer;
+				// Enqueue the event corresponding to this button if the opposing button is not pressed already.
+				if(!motorButtonsTouched[2]){
+					motorButtonsTouched[3] = true;
+					motorButtonsPointers[3] = pointer;
+
+					event = new MotorEvent();
+					event.setMotor(motor_t.MOTOR_A);
+					event.setPower((byte)100);
+					queue.addEvent(event);
+				}
+
 			}
 		}
 		return true;
 	}
 
 	@Override
-	public boolean touchUp(int screenX, int screenY, int pointer, int button) {
+	public boolean touchUp(int screenX, int screenY, int pointer, int button){
+		MotorEvent event;
+
 		if(!Ouya.runningOnOuya){
 			win2world.set(screenX, screenY, 0.0f);
 			camera.unproject(win2world);
@@ -364,27 +360,70 @@ public class InGameState extends BaseState{
 
 			if(motorA.getBoundingRectangle().contains(touchPointWorldCoords)){
 				Gdx.app.log(TAG, CLASS_NAME + ".touchUp() :: Motor A button released");
-				motorButtonsPointers[0] = -1;
+
-				motorButtonsTouched[0] = false;
+
+				// Enqueue the event corresponding to releasing this button if the opposing button is not pressed already.
+				if(!motorButtonsTouched[1]){
+					motorButtonsPointers[0] = -1;
+					motorButtonsTouched[0] = false;
+
+					event = new MotorEvent();
+					event.setMotor(motor_t.MOTOR_C);
+					event.setPower((byte) 0);
+					queue.addEvent(event);
+				}
+
 			}else if(motorB.getBoundingRectangle().contains(touchPointWorldCoords)){
 				Gdx.app.log(TAG, CLASS_NAME + ".touchUp() :: Motor B button released");
-				motorButtonsPointers[1] = -1;
+
-				motorButtonsTouched[1] = false;
+				// Enqueue the event corresponding to releasing this button if the opposing button is not pressed already.
+				if(!motorButtonsTouched[0]){
+					motorButtonsPointers[1] = -1;
+					motorButtonsTouched[1] = false;
+
+					event = new MotorEvent();
+					event.setMotor(motor_t.MOTOR_C);
+					event.setPower((byte) 0);
+					queue.addEvent(event);
+				}
+
 			}else if(motorC.getBoundingRectangle().contains(touchPointWorldCoords)){
 				Gdx.app.log(TAG, CLASS_NAME + ".touchUp() :: Motor C button released");
-				motorButtonsPointers[2] = -1;
+
-				motorButtonsTouched[2] = false;
+				// Enqueue the event corresponding to releasing this button if the opposing button is not pressed already.
+				if(!motorButtonsTouched[3]){
+					motorButtonsPointers[2] = -1;
+					motorButtonsTouched[2] = false;
+
+					event = new MotorEvent();
+					event.setMotor(motor_t.MOTOR_A);
+					event.setPower((byte) 0);
+					queue.addEvent(event);
+				}
+
 			}else if(motorD.getBoundingRectangle().contains(touchPointWorldCoords)){
 				Gdx.app.log(TAG, CLASS_NAME + ".touchUp() :: Motor D button released");
-				motorButtonsPointers[3] = -1;
+
-				motorButtonsTouched[3] = false;
+				// Enqueue the event corresponding to releasing this button if the opposing button is not pressed already.
+				if(!motorButtonsTouched[2]){
+					motorButtonsPointers[3] = -1;
+					motorButtonsTouched[3] = false;
+
+					event = new MotorEvent();
+					event.setMotor(motor_t.MOTOR_A);
+					event.setPower((byte) 0);
+					queue.addEvent(event);
+				}
+
 			}
 		}
 		return true;
 	}
 
 	@Override
-	public boolean touchDragged(int screenX, int screenY, int pointer) {
+	public boolean touchDragged(int screenX, int screenY, int pointer){
+		MotorEvent event;
+
 		if(!Ouya.runningOnOuya){
 			win2world.set(screenX, screenY, 0.0f);
 			camera.unproject(win2world);
@@ -392,28 +431,71 @@ public class InGameState extends BaseState{
 
 			if(pointer == motorButtonsPointers[0] && !motorA.getBoundingRectangle().contains(touchPointWorldCoords)){
 				Gdx.app.log(TAG, CLASS_NAME + ".touchDragged() :: Motor A button released");
-				motorButtonsPointers[0] = -1;
+
-				motorButtonsTouched[0] = false;
+				// Enqueue the event corresponding to releasing this button if the opposing button is not pressed already.
+				if(!motorButtonsTouched[1]){
+					motorButtonsPointers[0] = -1;
+					motorButtonsTouched[0] = false;
+
+					event = new MotorEvent();
+					event.setMotor(motor_t.MOTOR_C);
+					event.setPower((byte) 0);
+					queue.addEvent(event);
+				}
+
 			}else if(pointer == motorButtonsPointers[1] && !motorB.getBoundingRectangle().contains(touchPointWorldCoords)){
 				Gdx.app.log(TAG, CLASS_NAME + ".touchDragged() :: Motor B button released");
-				motorButtonsPointers[1] = -1;
+
-				motorButtonsTouched[1] = false;
+				// Enqueue the event corresponding to releasing this button if the opposing button is not pressed already.
+				if(!motorButtonsTouched[0]){
+					motorButtonsPointers[1] = -1;
+					motorButtonsTouched[1] = false;
+
+					event = new MotorEvent();
+					event.setMotor(motor_t.MOTOR_C);
+					event.setPower((byte) 0);
+					queue.addEvent(event);
+				}
+
 			}else if(pointer == motorButtonsPointers[2] && !motorC.getBoundingRectangle().contains(touchPointWorldCoords)){
 				Gdx.app.log(TAG, CLASS_NAME + ".touchDragged() :: Motor C button released");
-				motorButtonsPointers[2] = -1;
+
-				motorButtonsTouched[2] = false;
+				// Enqueue the event corresponding to releasing this button if the opposing button is not pressed already.
+				if(!motorButtonsTouched[3]){
+					motorButtonsPointers[2] = -1;
+					motorButtonsTouched[2] = false;
+
+					event = new MotorEvent();
+					event.setMotor(motor_t.MOTOR_A);
+					event.setPower((byte) 0);
+					queue.addEvent(event);
+				}
+
 			}else if(pointer == motorButtonsPointers[3] && !motorD.getBoundingRectangle().contains(touchPointWorldCoords)){
 				Gdx.app.log(TAG, CLASS_NAME + ".touchDragged() :: Motor D button released");
-				motorButtonsPointers[3] = -1;
+
-				motorButtonsTouched[3] = false;
+				// Enqueue the event corresponding to releasing this button if the opposing button is not pressed already.
+				if(!motorButtonsTouched[2]){
+					motorButtonsPointers[3] = -1;
+					motorButtonsTouched[3] = false;
+
+					event = new MotorEvent();
+					event.setMotor(motor_t.MOTOR_A);
+					event.setPower((byte) 0);
+					queue.addEvent(event);
+				}
+
 			}
 		}
 		return true;
 	}
 
 	@Override
-	public boolean mouseMoved(int screenX, int screenY) {
+	public boolean keyDown(int keycode){
-		// TODO Auto-generated method stub
+		if(keycode == Input.Keys.BACK){
+			core.nextState = game_states_t.MAIN_MENU;
+			return true;
+		}
 		return false;
 	}
 
@@ -422,7 +504,7 @@ public class InGameState extends BaseState{
 	  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;*/
 
 	@Override
-	public boolean buttonDown(Controller controller, int buttonCode) {
+	public boolean buttonDown(Controller controller, int buttonCode){
 		if(stateActive){
 			Gdx.app.log(TAG, CLASS_NAME + ".buttonDown() :: " + controller.getName() + " :: " + Integer.toString(buttonCode));
 			return true;
@@ -432,7 +514,7 @@ public class InGameState extends BaseState{
 	}
 
 	@Override
-	public boolean buttonUp(Controller controller, int buttonCode) {
+	public boolean buttonUp(Controller controller, int buttonCode){
 		if(stateActive){
 			Gdx.app.log(TAG, CLASS_NAME + ".buttonDown() :: " + controller.getName() + " :: " + Integer.toString(buttonCode));
 			return true;
@@ -442,7 +524,7 @@ public class InGameState extends BaseState{
 	}
 
 	@Override
-	public boolean axisMoved(Controller controller, int axisCode, float value) {
+	public boolean axisMoved(Controller controller, int axisCode, float value){
 		if(stateActive){
 			if(value >= Ouya.STICK_DEADZONE){
 				if(axisCode == Ouya.AXIS_LEFT_TRIGGER){
@@ -459,47 +541,62 @@ public class InGameState extends BaseState{
 	}
 
 	@Override
-	public boolean scrolled(int amount) {
+	public void connected(Controller controller){ }
+
+	@Override
+	public void disconnected(Controller controller){ }
+
+	/*;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	  ; UNUSED LISTENER METHODS ;
+	  ;;;;;;;;;;;;;;;;;;;;;;;;;;;*/
+
+	@Override
+	public boolean mouseMoved(int screenX, int screenY){
+		return false;
+	}
+
+	@Override
+	public boolean keyUp(int keycode){
 		// TODO Auto-generated method stub
 		return false;
 	}
 
 	@Override
-	public void connected(Controller controller) {
+	public boolean keyTyped(char character){
 		// TODO Auto-generated method stub
-
+		return false;
-	}
-
-	@Override
-	public void disconnected(Controller controller) {
-		// TODO Auto-generated method stub
-
 	}
 
 	@Override
 	public boolean povMoved(Controller controller, int povCode,
-			PovDirection value) {
+			PovDirection value){
 		// TODO Auto-generated method stub
 		return false;
 	}
 
 	@Override
 	public boolean xSliderMoved(Controller controller, int sliderCode,
-			boolean value) {
+			boolean value){
 		// TODO Auto-generated method stub
 		return false;
 	}
 
 	@Override
 	public boolean ySliderMoved(Controller controller, int sliderCode,
-			boolean value) {
+			boolean value){
 		// TODO Auto-generated method stub
 		return false;
 	}
 
 	@Override
 	public boolean accelerometerMoved(Controller controller,
-			int accelerometerCode, Vector3 value) {
+			int accelerometerCode, Vector3 value){
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	@Override
+	public boolean scrolled(int amount){
 		// TODO Auto-generated method stub
 		return false;
 	}

src/ve/ucv/ciens/ccg/nxtar/states/MainMenuStateBase.java

@@ -15,6 +15,7 @@
  */
 package ve.ucv.ciens.ccg.nxtar.states;
 
+import ve.ucv.ciens.ccg.nxtar.NxtARCore.game_states_t;
 import ve.ucv.ciens.ccg.nxtar.utils.ProjectConstants;
 
 import com.badlogic.gdx.Gdx;
@@ -23,6 +24,7 @@ import com.badlogic.gdx.controllers.Controller;
 import com.badlogic.gdx.controllers.PovDirection;
 import com.badlogic.gdx.controllers.mappings.Ouya;
 import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.OrthographicCamera;
 import com.badlogic.gdx.graphics.Texture;
 import com.badlogic.gdx.graphics.Texture.TextureFilter;
 import com.badlogic.gdx.graphics.Texture.TextureWrap;
@@ -34,6 +36,7 @@ import com.badlogic.gdx.graphics.g2d.TextureRegion;
 import com.badlogic.gdx.graphics.g2d.freetype.FreeTypeFontGenerator;
 import com.badlogic.gdx.graphics.glutils.ShaderProgram;
 import com.badlogic.gdx.math.Rectangle;
+import com.badlogic.gdx.math.Vector2;
 import com.badlogic.gdx.math.Vector3;
 import com.badlogic.gdx.scenes.scene2d.ui.TextButton;
 import com.badlogic.gdx.scenes.scene2d.ui.TextButton.TextButtonStyle;
@@ -49,6 +52,7 @@ public abstract class MainMenuStateBase extends BaseState{
 	// Helper fields.
 	protected boolean clientConnected;
 	private float u_scaling[];
+	protected OrthographicCamera pixelPerfectCamera;
 
 	// Buttons and other gui components.
 	protected TextButton startButton;
@@ -72,9 +76,17 @@ public abstract class MainMenuStateBase extends BaseState{
 	private Texture backgroundTexture;
 	private ShaderProgram backgroundShader;
 
+	// Button touch helper fields.
+	private Vector3 win2world;
+	protected Vector2 touchPointWorldCoords;
+	protected boolean startButtonTouched;
+	protected int startButtonTouchPointer;
+
 	public MainMenuStateBase(){
 		TextureRegion region;
 
+		this.pixelPerfectCamera = new OrthographicCamera(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
+
 		// Create the start button background.
 		startButtonEnabledTexture = new Texture(Gdx.files.internal("data/gfx/gui/Anonymous_Pill_Button_Yellow.png"));
 		startButtonEnabled9p = new NinePatch(new TextureRegion(startButtonEnabledTexture, 0, 0, startButtonEnabledTexture.getWidth(), startButtonEnabledTexture.getHeight()), 49, 49, 45, 45);
@@ -131,6 +143,12 @@ public abstract class MainMenuStateBase extends BaseState{
 		u_scaling[0] = Gdx.graphics.getWidth() > Gdx.graphics.getHeight() ? 16.0f : 9.0f;
 		u_scaling[1] = Gdx.graphics.getHeight() > Gdx.graphics.getWidth() ? 16.0f : 9.0f;
 
+
+		win2world = new Vector3(0.0f, 0.0f, 0.0f);
+		touchPointWorldCoords = new Vector2();
+		startButtonTouched = false;
+		startButtonTouchPointer = -1;
+
 		clientConnected = false;
 		stateActive = false;
 	}
@@ -139,18 +157,18 @@ public abstract class MainMenuStateBase extends BaseState{
 	public abstract void render(float delta);
 
 	@Override
-	public abstract void resize(int width, int height);
+	public void resize(int width, int height){ }
 
 	@Override
-	public abstract void show();
+	public void show(){ }
 	@Override
-	public abstract void hide();
+	public void hide(){ }
 
 	@Override
-	public abstract void pause();
+	public void pause(){ }
 
 	@Override
-	public abstract void resume();
+	public void resume(){ }
 
 	@Override
 	public void dispose(){
@@ -194,19 +212,82 @@ public abstract class MainMenuStateBase extends BaseState{
 		startButton.setDisabled(false);
 	}
 
-	/*;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	/*;;;;;;;;;;;;;;;;;;
-	  ; INPUT LISTENER METHOD STUBS ;
+	  ; HELPER METHODS ;
-	  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;*/
+	  ;;;;;;;;;;;;;;;;;;*/
+
+	protected void unprojectTouch(int screenX, int screenY){
+		win2world.set(screenX, screenY, 0.0f);
+		pixelPerfectCamera.unproject(win2world);
+		touchPointWorldCoords.set(win2world.x, win2world.y);
+	}
+
+	/*;;;;;;;;;;;;;;;;;;;;;;;;;;
+	  ; INPUT LISTENER METHODS ;
+	  ;;;;;;;;;;;;;;;;;;;;;;;;;;*/
+
+	@Override
+	public boolean touchDown(int screenX, int screenY, int pointer, int button){
+		unprojectTouch(screenX, screenY);
+
+		Gdx.app.log(TAG, CLASS_NAME + String.format(".touchDown(%d, %d, %d, %d)", screenX, screenY, pointer, button));
+		Gdx.app.log(TAG, CLASS_NAME + String.format(".touchDown() :: Unprojected touch point: (%f, %f)", touchPointWorldCoords.x, touchPointWorldCoords.y));
+
+		if(!startButton.isDisabled() && startButtonBBox.contains(touchPointWorldCoords)){
+			startButton.setChecked(true);
+			startButtonTouched = true;
+			startButtonTouchPointer = pointer;
+			Gdx.app.log(TAG, CLASS_NAME + ".touchDown() :: Start button pressed.");
+		}
+
+		return true;
+	}
+
+	@Override
+	public boolean touchUp(int screenX, int screenY, int pointer, int button){
+		unprojectTouch(screenX, screenY);
+
+		Gdx.app.log(TAG, CLASS_NAME + String.format(".touchUp(%d, %d, %d, %d)", screenX, screenY, pointer, button));
+		Gdx.app.log(TAG, CLASS_NAME + String.format(".touchUp() :: Unprojected touch point: (%f, %f)", touchPointWorldCoords.x, touchPointWorldCoords.y));
+
+		if(!startButton.isDisabled() && startButtonBBox.contains(touchPointWorldCoords)){
+			startButton.setChecked(false);
+			startButtonTouched = false;
+			startButtonTouchPointer = -1;
+			core.nextState = game_states_t.IN_GAME;
+			Gdx.app.log(TAG, CLASS_NAME + ".touchDown() :: Start button released.");
+		}
+
+		return true;
+	}
+
+	@Override
+	public boolean touchDragged(int screenX, int screenY, int pointer){
+		unprojectTouch(screenX, screenY);
+
+		if(!startButton.isDisabled() && startButtonTouched && pointer == startButtonTouchPointer && !startButtonBBox.contains(touchPointWorldCoords)){
+			startButtonTouchPointer = -1;
+			startButtonTouched = false;
+			startButton.setChecked(false);
+			Gdx.app.log(TAG, CLASS_NAME + ".touchDragged() :: Start button released.");
+		}
+
+		return true;
+	}
 
 	@Override
 	public boolean keyDown(int keycode){
 		if(keycode == Input.Keys.BACK){
-			// TODO: Go to pause state.
+			// Ignore.
 			return true;
 		}
 		return false;
 	}
 
+	/*;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	  ; INPUT LISTENER METHOD STUBS ;
+	  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;*/
+
 	@Override
 	public boolean keyUp(int keycode){
 		return false;
@@ -217,21 +298,6 @@ public abstract class MainMenuStateBase extends BaseState{
 		return false;
 	}
 
-	@Override
-	public boolean touchDown(int screenX, int screenY, int pointer, int button){
-		return false;
-	}
-
-	@Override
-	public boolean touchUp(int screenX, int screenY, int pointer, int button){
-		return false;
-	}
-
-	@Override
-	public boolean touchDragged(int screenX, int screenY, int pointer){
-		return false;
-	}
-
 	@Override
 	public boolean mouseMoved(int screenX, int screenY){
 		return false;

src/ve/ucv/ciens/ccg/nxtar/states/OuyaMainMenuState.java

@@ -22,7 +22,6 @@ import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.controllers.Controller;
 import com.badlogic.gdx.controllers.mappings.Ouya;
 import com.badlogic.gdx.graphics.GL10;
-import com.badlogic.gdx.graphics.OrthographicCamera;
 import com.badlogic.gdx.graphics.Texture;
 import com.badlogic.gdx.graphics.g2d.Sprite;
 import com.badlogic.gdx.graphics.g2d.TextureRegion;
@@ -30,14 +29,12 @@ import com.badlogic.gdx.graphics.g2d.TextureRegion;
 public class OuyaMainMenuState extends MainMenuStateBase{
 	private static final String CLASS_NAME = OuyaMainMenuState.class.getSimpleName();
 
-	private OrthographicCamera pixelPerfectCamera;
 	private Texture ouyaOButtonTexture;
 	private Sprite ouyaOButton;
 	private boolean oButtonPressed;
 
 	public OuyaMainMenuState(final NxtARCore core){
 		this.core = core;
-		this.pixelPerfectCamera = new OrthographicCamera(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
 
 		startButton.setPosition(-(startButton.getWidth() / 2), -(startButton.getHeight() / 2));
 		startButtonBBox.setPosition(startButton.getX(), startButton.getY());
@@ -53,7 +50,7 @@ public class OuyaMainMenuState extends MainMenuStateBase{
 		TextureRegion region = new TextureRegion(ouyaOButtonTexture, ouyaOButtonTexture.getWidth(), ouyaOButtonTexture.getHeight());
 		ouyaOButton = new Sprite(region);
 		ouyaOButton.setSize(ouyaOButton.getWidth() * 0.6f, ouyaOButton.getHeight() * 0.6f);
-		ouyaOButton.setPosition(startButton.getX() - ouyaOButton.getWidth() - 20, startButton.getY());
+		ouyaOButton.setPosition(startButton.getX() - ouyaOButton.getWidth() - 20, startButton.getY() + (ouyaOButton.getHeight() / 2));
 
 		oButtonPressed = false;
 	}
@@ -78,36 +75,6 @@ public class OuyaMainMenuState extends MainMenuStateBase{
 		}core.batch.end();
 	}
 
-	@Override
-	public void resize(int width, int height) {
-		// TODO Auto-generated method stub
-
-	}
-
-	@Override
-	public void show() {
-		// TODO Auto-generated method stub
-
-	}
-
-	@Override
-	public void hide() {
-		// TODO Auto-generated method stub
-
-	}
-
-	@Override
-	public void pause() {
-		// TODO Auto-generated method stub
-
-	}
-
-	@Override
-	public void resume() {
-		// TODO Auto-generated method stub
-
-	}
-
 	@Override
 	public void dispose(){
 		super.dispose();

src/ve/ucv/ciens/ccg/nxtar/states/TabletMainMenuState.java

@@ -16,37 +16,16 @@
 package ve.ucv.ciens.ccg.nxtar.states;
 
 import ve.ucv.ciens.ccg.nxtar.NxtARCore;
-import ve.ucv.ciens.ccg.nxtar.NxtARCore.game_states_t;
 
 import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.graphics.GL10;
-import com.badlogic.gdx.graphics.OrthographicCamera;
-import com.badlogic.gdx.math.Vector2;
-import com.badlogic.gdx.math.Vector3;
 
 public class TabletMainMenuState extends MainMenuStateBase{
-	private static final String CLASS_NAME = TabletMainMenuState.class.getSimpleName();
-
-	private OrthographicCamera pixelPerfectCamera;
-
-	// Button touch helper fields.
-	private Vector3 win2world;
-	private Vector2 touchPointWorldCoords;
-	private boolean startButtonTouched;
-	private int startButtonTouchPointer;
-
 	public TabletMainMenuState(final NxtARCore core){
 		this.core = core;
-		pixelPerfectCamera = new OrthographicCamera(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
 		startButton.setPosition(-(startButton.getWidth() / 2), -(startButton.getHeight() / 2));
 		startButtonBBox.setPosition(startButton.getX(), startButton.getY());
 
-		win2world = new Vector3(0.0f, 0.0f, 0.0f);
-		touchPointWorldCoords = new Vector2();
-
-		startButtonTouched = false;
-		startButtonTouchPointer = -1;
-
 		float ledYPos = (-(Gdx.graphics.getHeight() / 2) * 0.5f) + (startButton.getY() * 0.5f);
 		clientConnectedLedOn.setSize(clientConnectedLedOn.getWidth() * 0.5f, clientConnectedLedOn.getHeight() * 0.5f);
 		clientConnectedLedOn.setPosition(-(clientConnectedLedOn.getWidth() / 2), ledYPos);
@@ -74,87 +53,4 @@ public class TabletMainMenuState extends MainMenuStateBase{
 			startButton.draw(core.batch, 1.0f);
 		}core.batch.end();
 	}
-
-	@Override
-	public void resize(int width, int height){ }
-
-	@Override
-	public void show(){ }
-
-	@Override
-	public void hide(){ }
-
-	@Override
-	public void pause(){ }
-
-	@Override
-	public void resume(){ }
-
-	@Override
-	public void dispose(){
-		super.dispose();
-	}
-
-	/*;;;;;;;;;;;;;;;;;;
-	  ; HELPER METHODS ;
-	  ;;;;;;;;;;;;;;;;;;*/
-
-	private void unprojectTouch(int screenX, int screenY){
-		win2world.set(screenX, screenY, 0.0f);
-		pixelPerfectCamera.unproject(win2world);
-		touchPointWorldCoords.set(win2world.x, win2world.y);
-	}
-
-	/*;;;;;;;;;;;;;;;;;;;;;;;;;;;
-	  ; INPUT LISTENER METHODS ;
-	  ;;;;;;;;;;;;;;;;;;;;;;;;;;;*/
-
-	@Override
-	public boolean touchDown(int screenX, int screenY, int pointer, int button){
-		unprojectTouch(screenX, screenY);
-
-		Gdx.app.log(TAG, CLASS_NAME + String.format(".touchDown(%d, %d, %d, %d)", screenX, screenY, pointer, button));
-		Gdx.app.log(TAG, CLASS_NAME + String.format(".touchDown() :: Unprojected touch point: (%f, %f)", touchPointWorldCoords.x, touchPointWorldCoords.y));
-
-		if(!startButton.isDisabled() && startButtonBBox.contains(touchPointWorldCoords)){
-			startButton.setChecked(true);
-			startButtonTouched = true;
-			startButtonTouchPointer = pointer;
-			Gdx.app.log(TAG, CLASS_NAME + ".touchDown() :: Start button pressed.");
-		}
-
-		return true;
-	}
-
-	@Override
-	public boolean touchUp(int screenX, int screenY, int pointer, int button){
-		unprojectTouch(screenX, screenY);
-
-		Gdx.app.log(TAG, CLASS_NAME + String.format(".touchUp(%d, %d, %d, %d)", screenX, screenY, pointer, button));
-		Gdx.app.log(TAG, CLASS_NAME + String.format(".touchUp() :: Unprojected touch point: (%f, %f)", touchPointWorldCoords.x, touchPointWorldCoords.y));
-
-		if(!startButton.isDisabled() && startButtonBBox.contains(touchPointWorldCoords)){
-			startButton.setChecked(false);
-			startButtonTouched = false;
-			startButtonTouchPointer = -1;
-			core.nextState = game_states_t.IN_GAME;
-			Gdx.app.log(TAG, CLASS_NAME + ".touchDown() :: Start button released.");
-		}
-
-		return true;
-	}
-
-	@Override
-	public boolean touchDragged(int screenX, int screenY, int pointer){
-		unprojectTouch(screenX, screenY);
-
-		if(!startButton.isDisabled() && startButtonTouched && pointer == startButtonTouchPointer && !startButtonBBox.contains(touchPointWorldCoords)){
-			startButtonTouchPointer = -1;
-			startButtonTouched = false;
-			startButton.setChecked(false);
-			Gdx.app.log(TAG, CLASS_NAME + ".touchDragged() :: Start button released.");
-		}
-
-		return true;
-	}
 }

src/ve/ucv/ciens/ccg/nxtar/utils/ProjectConstants.java

@@ -17,11 +17,15 @@ package ve.ucv.ciens.ccg.nxtar.utils;
 
 import com.badlogic.gdx.controllers.mappings.Ouya;
 
-public abstract class ProjectConstants {
+public abstract class ProjectConstants{
-	public static final int SERVER_UDP_PORT = 8889;
+	public static final int SERVICE_DISCOVERY_PORT = 9988;
-	public static final int SERVER_TCP_PORT_1 = 9989;
+	public static final int VIDEO_STREAMING_PORT = 9989;
-	public static final int SERVER_TCP_PORT_2 = 9990;
+	public static final int MOTOR_CONTROL_PORT = 9990;
+	public static final int SENSOR_REPORT_PORT = 9991;
+	public static final int APP_CONTROL_PORT = 9992;
+
 	public static final String MULTICAST_ADDRESS = "230.0.0.1";
+
 	public static final int EXIT_SUCCESS = 0;
 	public static final int EXIT_FAILURE = 1;
 
@@ -31,8 +35,8 @@ public abstract class ProjectConstants {
 
 	public static final float OVERSCAN;
 
-	public static final String FONT_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890.,:;!?";
+	public static final String FONT_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
-	
+
 	static{
 		OVERSCAN = Ouya.runningOnOuya ? 0.9f : 1.0f;
 	}