Código wumpus

.classpath

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>wumpus</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

Instrucciones.txt

@@ -0,0 +1,8 @@
+Observaciones:
+- El programa está compilado con java8.
+- El programa recibe tres parametros, por este orden: dimensión, número de pozos y número de flechas.
+- Clase principal con el método main: WumpusGame.java. En esta misma clase se puede descomentar la linea tablero.printTablero() para ver la ubicación
+de los elementos sobre el tablero al inicio de la partida.
+- Las instrucciones de los movimientos aparecen al inicio de la partida. Hay que pulsar la letra inicial de la acción + enter: Avanzar, Derecha, Izquierda, Flecha y Salir.
+- Se considera como casilla inicial la que está abajo y a la izquierda del todo y que jugador sale hacia la derecha.
+- Hay 2 clases con varios test unitarios en junit 4

src/test/JugadorTest.java

@@ -0,0 +1,153 @@
+package test;
+
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import wumpus.Casilla;
+import wumpus.GameException;
+import wumpus.Jugador;
+import wumpus.Tablero;
+import wumpus.data.Percepcion;
+
+public class JugadorTest {
+
+	private void limpiarTablero(Tablero t) {
+		for (int i = 0; i < 4; i++) {
+			for (int j = 0; j < 4; j++) {
+				t.getCasillas()[i][j].setHumpus(false);
+				t.getCasillas()[i][j].setPozo(false);
+				t.getCasillas()[i][j].setLingote(false);
+			}
+		}
+	}
+
+	/**
+	 * Test para probar varias acciones sobre el Wumpus: Paso por una celda
+	 * adyacente, disparar y caer en su casilla
+	 * 
+	 * @throws GameException
+	 */
+
+	@Test
+	public void testWumpus() throws GameException {
+		Tablero t = new Tablero(4, 3);
+
+		//Limpiar Tablero
+		limpiarTablero(t);
+
+		// Marcar casilla del wumpus
+		t.getCasillas()[3][2].setHumpus(true);
+		t.setCasillaWumpus(t.getCasillas()[3][2]);
+		Jugador j = new Jugador(3, t);
+
+		// Avanzar hacia el wumpus
+		j.avanzar();
+		Assert.assertTrue(j.getPercepciones().contains(Percepcion.HEDOR));
+		j.avanzar();
+		Assert.assertTrue(j.getPercepciones().contains(Percepcion.WUMPUS));
+		//Finaliza el juego
+		Assert.assertFalse(j.isEstaVivo());
+
+		//Matar al wumpus
+		t = new Tablero(4, 3);
+		limpiarTablero(t);
+		Casilla casillaHumpus = t.getCasillas()[3][2];
+		casillaHumpus.setHumpus(true);
+		t.setCasillaWumpus(casillaHumpus);
+		Jugador j2 = new Jugador(3, t);
+		j2.lanzarFlecha();
+		Assert.assertTrue(j2.getPercepciones().contains(Percepcion.GRITO));
+		// Se mata al wumpus
+		Assert.assertTrue(j2.isWumpusRecienMuerto());
+
+		// Puede atravesar por donde estaba el humpus sin percepciones
+		t.quitarWumpus();
+
+		j2.avanzar();
+		Assert.assertFalse(j2.getPercepciones().contains(Percepcion.HEDOR));
+		j2.avanzar();
+		Assert.assertFalse(j2.getPercepciones().contains(Percepcion.WUMPUS));
+
+		Assert.assertTrue(j2.isEstaVivo());
+
+	}
+
+	/**
+	 * Test para probar el paso por un pozo
+	 * @throws GameException
+	 */
+	@Test
+	public void testPozo() throws GameException {
+		Tablero t = new Tablero(4, 3);
+
+		//Limpiar Tablero
+		limpiarTablero(t);
+
+		// Marcar casilla del wumpus
+		t.getCasillas()[3][2].setPozo(true);
+		Jugador j = new Jugador(3, t);
+		j.avanzar();
+		Assert.assertTrue(j.getPercepciones().contains(Percepcion.BRISA));
+		// Se cae por el pozo
+		j.avanzar();
+		Assert.assertFalse(j.isEstaVivo());
+
+	}
+
+	/**
+	 * Test para probar el paso por el lingote y la salida
+	 * @throws GameException
+	 */
+
+	@Test
+	public void testLingote() throws GameException {
+		Tablero t = new Tablero(4, 3);
+
+		// Limpiar Tablero
+		limpiarTablero(t);
+
+		// Marcar casilla del wumpus
+		t.getCasillas()[3][2].setLingote(true);
+		Jugador j = new Jugador(3, t);
+		j.avanzar();
+		j.avanzar();
+		Assert.assertTrue(j.getPercepciones().contains(Percepcion.BRILLO));
+		Assert.assertFalse(j.isSalirPermitido());
+		j.girarIzda();
+		j.girarIzda();
+		j.avanzar();
+		j.avanzar();
+		Assert.assertTrue(j.isSalirPermitido());
+		j.salir();
+		Assert.assertTrue(j.getCasilla() == null);
+
+	}
+
+	/**
+	 * Test para probar que tras varios giror el jugador est� en la posici�n esperada
+	 * @throws GameException
+	 */
+
+	@Test
+	public void testAccionGirar() throws GameException {
+		Tablero t = new Tablero(4, 3);
+
+		// Limpiar Tablero
+		limpiarTablero(t);
+
+		Jugador j = new Jugador(3, t);
+		j.avanzar();
+		j.girarIzda();
+		j.avanzar();
+		j.girarDrcha();
+		j.avanzar();
+		j.girarDrcha();
+		j.avanzar();
+		j.girarDrcha();
+		j.avanzar();
+		j.avanzar();
+		Assert.assertTrue(j.getCasilla().getFila() == 3 && j.getCasilla().getColumna() == 0);
+	}
+
+}

src/test/TableroTest.java

@@ -0,0 +1,107 @@
+package test;
+
+import static org.junit.Assert.*;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import wumpus.Casilla;
+import wumpus.GameException;
+import wumpus.Tablero;
+
+public class TableroTest {
+
+
+	@Test
+	public void testTableroDimensionCorrecta() {
+
+		// correctas
+		try {
+			int n = 4;
+			new Tablero(n, n*n - 3);
+			new Tablero(n, n*n - 4);
+			new Tablero(n, 0);
+			n = 8;
+			new Tablero(n, n*n - 4);
+			new Tablero(n, n*n - 5);
+		} catch (GameException ex) {
+			fail();
+		}
+
+		//Incorrectas
+		try {
+			new Tablero(4, 16);
+			fail();
+		} catch (GameException ex) {
+		}
+
+		try {
+			new Tablero(8, 63);
+			fail();
+		} catch (GameException ex) {
+		}
+
+	}
+
+	@Test
+	public void testCondicionesTablero() throws GameException {
+
+		Tablero t = null;
+		for (int i = 4; i < 8; i++) {
+			try {
+				t = new Tablero(i, 2*i);
+			} catch (GameException ex) {
+				fail();
+			}
+			compruebaTablero(t, i);	
+		}
+	}
+
+	private void compruebaTablero(Tablero t, int n) {
+		// Dimension nxn
+		Assert.assertEquals(t.getCasillas().length, n);
+		for (int i = 0; i < n; i++) {
+			Assert.assertEquals(t.getCasillas()[i].length, n);
+		}
+
+		//Adyacentes para posiciones [0,0], [n,n], [1,1]
+		Casilla casilla0 = t.getCasillas()[0][0];
+		Assert.assertTrue(casilla0.getDrcha() != null 
+				&& casilla0.getAbajo() != null
+				&& casilla0.getArriba() == null
+				&& casilla0.getIzda() == null);
+
+		Casilla casilla1 = t.getCasillas()[1][1];
+		Assert.assertTrue(casilla1.getDrcha() != null 
+				&& casilla1.getAbajo() != null
+				&& casilla1.getArriba() != null
+				&& casilla1.getIzda() != null);
+
+		Casilla casillaN = t.getCasillas()[n-1][n-1];
+		Assert.assertTrue(casillaN.getDrcha() == null 
+				&& casillaN.getAbajo() == null
+				&& casillaN.getArriba() != null
+				&& casillaN.getIzda() != null);
+
+		//Comprobar que hay 2*n pozos, 1 lingote y el Wumpus
+		int pozos = 0, lingotes = 0, wumpus = 0;
+		for (int i = 0; i < n; i++) {
+			for (int j = 0; j < n; j++) {
+				if (t.getCasillas()[i][j].isPozo()) {
+					pozos++;
+				}
+				if (t.getCasillas()[i][j].isLingote()) {
+					lingotes++;
+				}
+				if (t.getCasillas()[i][j].isHumpus()) {
+					wumpus++;
+				}
+			}
+		}
+		Assert.assertEquals(pozos, 2*n);
+		Assert.assertEquals(lingotes, 1);
+		Assert.assertEquals(wumpus, 1);
+	}
+
+
+}