diff --git a/.classpath b/.classpath
new file mode 100644
index 0000000..2d74975
--- /dev/null
+++ b/.classpath
@@ -0,0 +1,7 @@
+
+
+
+
+
+
+
diff --git a/.project b/.project
new file mode 100644
index 0000000..37e8aaf
--- /dev/null
+++ b/.project
@@ -0,0 +1,17 @@
+
+
+ wumpus
+
+
+
+
+
+ org.eclipse.jdt.core.javabuilder
+
+
+
+
+
+ org.eclipse.jdt.core.javanature
+
+
diff --git a/Instrucciones.txt b/Instrucciones.txt
new file mode 100644
index 0000000..1f7f839
--- /dev/null
+++ b/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
\ No newline at end of file
diff --git a/src/test/JugadorTest.java b/src/test/JugadorTest.java
new file mode 100644
index 0000000..874a992
--- /dev/null
+++ b/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);
+ }
+
+}
diff --git a/src/test/TableroTest.java b/src/test/TableroTest.java
new file mode 100644
index 0000000..58e6ef5
--- /dev/null
+++ b/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);
+ }
+
+
+}
diff --git a/src/wumpus/Casilla.java b/src/wumpus/Casilla.java
new file mode 100644
index 0000000..2c2aa75
--- /dev/null
+++ b/src/wumpus/Casilla.java
@@ -0,0 +1,135 @@
+package wumpus;
+
+import wumpus.data.Direccion;
+
+public class Casilla {
+
+ private final int id;
+ private final int fila;
+ private final int columna;
+
+
+ private boolean inicial = false;
+ private boolean humpus = false;
+ private boolean pozo = false;
+ private boolean lingote = false;
+
+ private Casilla izda;
+ private Casilla drcha;
+ private Casilla arriba;
+ private Casilla abajo;
+
+ public Casilla(int fila, int columna, int id) {
+ this.id = id;
+ this.fila = fila;
+ this.columna = columna;
+ }
+
+ public int getId() {
+ return id;
+ }
+
+ public int getFila() {
+ return fila;
+ }
+
+ public int getColumna() {
+ return columna;
+ }
+
+ public boolean isInicial() {
+ return inicial;
+ }
+
+ public void setInicial(boolean inicial) {
+ this.inicial = inicial;
+ }
+
+ public boolean isHumpus() {
+ return humpus;
+ }
+
+ public void setHumpus(boolean humpus) {
+ this.humpus = humpus;
+ }
+
+ public boolean isPozo() {
+ return pozo;
+ }
+
+ public void setPozo(boolean pozo) {
+ this.pozo = pozo;
+ }
+
+ public boolean isLingote() {
+ return lingote;
+ }
+
+ public void setLingote(boolean lingote) {
+ this.lingote = lingote;
+ }
+
+ public Casilla getAdyacente(Direccion direccion) {
+ Casilla ret = null;
+ switch (direccion.getId()) {
+ case Direccion.ID_DRCHA:
+ ret = getDrcha();
+ break;
+ case Direccion.ID_IZDA:
+ ret = getIzda();
+ break;
+ case Direccion.ID_ARRIBA:
+ ret = getArriba();
+ break;
+ case Direccion.ID_ABAJO:
+ ret = getAbajo();
+ break;
+ }
+ return ret;
+ }
+
+ public Casilla getIzda() {
+ return izda;
+ }
+
+ public void setIzda(Casilla izda) {
+ this.izda = izda;
+ }
+
+ public Casilla getDrcha() {
+ return drcha;
+ }
+
+ public void setDrcha(Casilla drcha) {
+ this.drcha = drcha;
+ }
+
+ public Casilla getArriba() {
+ return arriba;
+ }
+
+ public void setArriba(Casilla arriba) {
+ this.arriba = arriba;
+ }
+
+ public Casilla getAbajo() {
+ return abajo;
+ }
+
+ public void setAbajo(Casilla abajo) {
+ this.abajo = abajo;
+ }
+
+ public String toString() {
+
+ if (humpus) {
+ return "W";
+ } else if (lingote) {
+ return "L";
+ } else if (pozo) {
+ return "P";
+ } else return "O";
+
+ }
+
+}
diff --git a/src/wumpus/GameException.java b/src/wumpus/GameException.java
new file mode 100644
index 0000000..1604e8f
--- /dev/null
+++ b/src/wumpus/GameException.java
@@ -0,0 +1,11 @@
+package wumpus;
+
+public class GameException extends Exception {
+
+ private static final long serialVersionUID = -5795661500484662117L;
+
+ public GameException(String message) {
+ super();
+ }
+
+}
diff --git a/src/wumpus/IPercepcionCheck.java b/src/wumpus/IPercepcionCheck.java
new file mode 100644
index 0000000..9add9f0
--- /dev/null
+++ b/src/wumpus/IPercepcionCheck.java
@@ -0,0 +1,7 @@
+package wumpus;
+
+public interface IPercepcionCheck {
+
+ boolean test(T casilla);
+
+}
diff --git a/src/wumpus/Jugador.java b/src/wumpus/Jugador.java
new file mode 100644
index 0000000..34013b3
--- /dev/null
+++ b/src/wumpus/Jugador.java
@@ -0,0 +1,216 @@
+package wumpus;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import wumpus.data.Accion;
+import wumpus.data.Direccion;
+import wumpus.data.Percepcion;
+
+public class Jugador {
+
+ private int flechas;
+ private Tablero tablero;
+ private Casilla casilla;
+ private Casilla casillaAnterior;
+ private Direccion direccion;
+ private Accion accion;
+ private boolean lingoteConseguido;
+ private boolean estaVivo;
+ private boolean wumpusRecienMuerto;
+
+ // Wumpus
+ IPercepcionCheck checkHumpus = c -> c != null && c.isHumpus();
+ // Pozo
+ IPercepcionCheck checkPozo = c -> c != null && c.isPozo();
+ // Oro
+ IPercepcionCheck checkLingote = c -> c != null && c.isLingote();
+
+ // Choque Derecha
+ IPercepcionCheck checkChoqueDrcha = c -> c != null && this.accion == Accion.AVANZAR
+ && this.direccion == Direccion.DRCHA && c.getColumna() == this.tablero.getDimension() - 1;
+
+ // Choque Izquierda
+ IPercepcionCheck checkChoqueIzda = c -> c != null && this.accion == Accion.AVANZAR
+ && this.direccion == Direccion.IZDA && c.getColumna() == 0;
+
+ // Choque Arriba
+ IPercepcionCheck checkChoqueArriba = c -> c != null && this.accion == Accion.AVANZAR
+ && this.direccion == Direccion.ARRIBA && c.getFila() == 0;
+
+ // Choque Abajo
+ IPercepcionCheck checkChoqueAbajo = c -> c != null && this.accion == Accion.AVANZAR
+ && this.direccion == Direccion.ABAJO && c.getFila() == this.tablero.getDimension() - 1;
+
+ IPercepcionCheck checkMuerteWumpus = c -> c != null && this.accion == Accion.FLECHA
+ && compruebaMuerteWumpus();
+
+ private boolean compruebaMuerteWumpus() {
+
+ boolean muerte = false;
+ Casilla casillaAux = casilla;
+
+ while (casillaAux != null && !muerte) {
+ casillaAux = casillaAux.getAdyacente(direccion);
+ muerte = checkHumpus.test(casillaAux);
+ }
+
+ return muerte;
+
+ }
+
+ public Jugador(int flechas, Tablero tablero) {
+ this.flechas = flechas;
+ this.tablero = tablero;
+ this.casilla = tablero.getCasillaInicial();
+ this.casillaAnterior = null;
+ this.direccion = Direccion.DRCHA;
+ this.accion = Accion.INICIAL;
+ this.lingoteConseguido = false;
+ this.estaVivo = true;
+ }
+
+ public int getFlechas() {
+ return flechas;
+ }
+
+ public void setFlechas(int flechas) {
+ this.flechas = flechas;
+ }
+
+ public Casilla getCasilla() {
+ return casilla;
+ }
+
+ public void setCasilla(Casilla casilla) {
+ this.casilla = casilla;
+ }
+
+ public Direccion getDireccion() {
+ return direccion;
+ }
+
+ public void setDireccion(Direccion direccion) {
+ this.direccion = direccion;
+ }
+
+ public boolean getLingoteConseguido() {
+ return this.lingoteConseguido;
+ }
+
+ public boolean isEstaVivo() {
+ return estaVivo;
+ }
+
+ public void setEstaVivo(boolean estaVivo) {
+ this.estaVivo = estaVivo;
+ }
+
+ public boolean isWumpusRecienMuerto() {
+ return wumpusRecienMuerto;
+ }
+
+ public void setWumpusRecienMuerto(boolean wumpusRecienMuerto) {
+ this.wumpusRecienMuerto = wumpusRecienMuerto;
+ }
+
+ public void avanzar() {
+
+ casillaAnterior = casilla;
+
+ Casilla adyacente = casilla.getAdyacente(direccion);
+
+ if (adyacente != null) {
+ casilla = adyacente;
+ }
+ if (!lingoteConseguido && checkLingote.test(casilla)) {
+ lingoteConseguido = true;
+ }
+ accion = Accion.AVANZAR;
+ estaVivo = !checkPozo.test(casilla) && !checkHumpus.test(casilla);
+
+ }
+
+ public void girarDrcha() {
+ direccion = direccion.getDrcha();
+ accion = Accion.GIRO_DRCHA;
+ }
+
+ public void girarIzda() {
+ direccion = direccion.getIzda();
+ accion = Accion.GIRO_IZQ;
+ }
+
+ public boolean isLanzarFlechaPermitido() {
+ return this.flechas > 0;
+ }
+
+ public void lanzarFlecha() {
+ this.flechas--;
+ accion = Accion.FLECHA;
+ wumpusRecienMuerto = checkMuerteWumpus.test(casilla);
+ }
+
+ public boolean isSalirPermitido() {
+ return casilla.isInicial();
+ }
+
+ public void salir() {
+ casillaAnterior = casilla;
+ casilla = null;
+ accion = Accion.SALIR;
+ }
+
+ /**
+ * Obtiene la lista de percepciones del jugador en función de los elementos
+ * del tablero y de la última acción realizada. Método de lectura, no actaliza variables del jugador
+ *
+ * @return
+ */
+
+ public List getPercepciones() {
+
+ List percepciones = new ArrayList();
+
+ if (checkHumpus.test(casilla)) {
+ percepciones.add(Percepcion.WUMPUS);
+ }
+
+ // Hedor del wumpus
+ if (estaVivo && (checkHumpus.test(casilla.getDrcha()) || checkHumpus.test(casilla.getIzda())
+ || checkHumpus.test(casilla.getArriba()) || checkHumpus.test(casilla.getAbajo()))) {
+ percepciones.add(Percepcion.HEDOR);
+ }
+
+ // Brisa del pozo
+ if (estaVivo && (checkPozo.test(casilla.getDrcha()) || checkPozo.test(casilla.getIzda())
+ || checkPozo.test(casilla.getArriba()) || checkPozo.test(casilla.getAbajo()))) {
+ percepciones.add(Percepcion.BRISA);
+ }
+
+ // Brillo del oro
+ if (checkLingote.test(casilla)) {
+ percepciones.add(Percepcion.BRILLO);
+ }
+
+ // Choque del muro.
+ // Comprobación sobre la casilla anterior si avanza porque la acción de
+ // avanzar ya se ha producido
+ // Si es un giro comprobar sobre la casilla actual
+ Casilla casillaComprobar = accion == Accion.AVANZAR ? casillaAnterior : casilla;
+ // Cuando avanzas en el limite casillaAnterior == casilla
+ if (checkChoqueDrcha.test(casillaComprobar) || checkChoqueIzda.test(casillaComprobar)
+ || checkChoqueArriba.test(casillaComprobar) || checkChoqueAbajo.test(casillaComprobar)) {
+ percepciones.add(Percepcion.CHOQUE);
+ }
+
+ // Grito del wumpus
+ if (checkMuerteWumpus.test(casilla)) {
+ percepciones.add(Percepcion.GRITO);
+ }
+
+ return percepciones;
+
+ }
+
+}
diff --git a/src/wumpus/Tablero.java b/src/wumpus/Tablero.java
new file mode 100644
index 0000000..3bc394b
--- /dev/null
+++ b/src/wumpus/Tablero.java
@@ -0,0 +1,189 @@
+package wumpus;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class Tablero {
+
+ private int dimension;
+ private int pozos;
+ private Casilla[][] casillas;
+
+ private Casilla casillaWumpus;
+
+ public static int FILA_INICIAL = 0;
+ public static int COLUMNA_INICIAL = 0;
+
+ public int getDimension() {
+ return dimension;
+ }
+
+ public void setDimension(int dimension) {
+ this.dimension = dimension;
+ }
+
+ public Casilla getCasillaInicial() {
+ return casillas[FILA_INICIAL][COLUMNA_INICIAL];
+ }
+
+ public Casilla getCasillaWumpus() {
+ return casillaWumpus;
+ }
+
+ public void setCasillaWumpus(Casilla casillaWumpus) {
+ this.casillaWumpus = casillaWumpus;
+ }
+
+ public Tablero(int dimension, int pozos) throws GameException {
+ this.dimension = dimension;
+ this.pozos = pozos;
+
+ // pozos + wumpus + lingote < casillas
+ if (pozos + 2 >= dimension * dimension) {
+ throw new GameException("Demasiados elementos para el tamanyo del tablero");
+ }
+
+ this.casillas = new Casilla[dimension][dimension];
+
+ // Crear casillas vacías
+ for (int i = 0; i < dimension; i++) {
+ for (int j = 0; j < dimension; j++) {
+ casillas[i][j] = new Casilla(i, j, dimension * i + j + 1);
+ }
+ }
+
+ FILA_INICIAL = dimension - 1;
+ COLUMNA_INICIAL = 0;
+ // Casilla inicial
+ casillas[FILA_INICIAL][COLUMNA_INICIAL].setInicial(true);
+
+ rellenarTablero();
+
+ calcularAdyacentes();
+ }
+
+ /**
+ * Calcula la lista de adyacentes de cada casilla y se mantiene en memoria
+ * para un acceso rápido en las acciones del jugador
+ */
+
+ private void calcularAdyacentes() {
+
+ // Se calcula de abajo a arriba
+ for (int i = 0; i < dimension; i++) {
+ for (int j = 0; j < dimension; j++) {
+
+ // Casilla izq
+ Casilla casillaIzda = j - 1 >= 0 ? casillas[i][j - 1] : null;
+ // Casilla drcha
+ Casilla casillaDrcha = j + 1 <= this.dimension - 1 ? casillas[i][j + 1] : null;
+ // Casilla arriba
+ Casilla casillaArriba = i - 1 >= 0 ? casillas[i - 1][j] : null;
+ // Casilla abajo
+ Casilla casillaAbajo = i + 1 <= this.dimension - 1 ? casillas[i + 1][j] : null;
+
+ casillas[i][j].setDrcha(casillaDrcha);
+ casillas[i][j].setIzda(casillaIzda);
+ casillas[i][j].setArriba(casillaArriba);
+ casillas[i][j].setAbajo(casillaAbajo);
+ }
+ }
+ }
+
+ /**
+ * Rellena el tablero con los elemenos indicados. Se colocan aleatoriamente
+ * sobre el tablero
+ */
+
+ private void rellenarTablero() {
+
+ int numeroCasillas = Double.valueOf(Math.pow(this.dimension, 2)).intValue();
+
+ // Generar una secuencia aleatoria de (pozos + 2) elementos entre
+ // [2...dimension^2]. En la posición inicial no se ubica ningún elemento
+ List auxList = new ArrayList();
+ for (int i = 1; i <= numeroCasillas; i++) {
+ // No establecer un elemento en la casilla inicial
+ if (i != this.getCasillaInicial().getId()) {
+ auxList.add(i);
+ }
+ }
+
+ Collections.shuffle(auxList);
+
+ for (int i = 0; i < 2 + this.pozos; i++) {
+ int fila = getFila(auxList.get(i));
+ int columna = getColumna(auxList.get(i));
+ if (i == 0) {
+ // ubicar wumus
+ casillas[fila][columna].setHumpus(true);
+ casillaWumpus = casillas[fila][columna];
+ } else if (i == 1) {
+ // ubicar lingote
+ casillas[fila][columna].setLingote(true);
+ } else {
+ // ubicar un pozo
+ casillas[fila][columna].setPozo(true);
+ }
+ }
+ }
+
+ /**
+ * A partir del identificador número de la casilla extraer la posición en la
+ * que se encuentra
+ *
+ * @param id
+ * @return
+ */
+ private int getFila(int id) {
+ int fila;
+ // Corrección para la última posición de la fila (indices de 0 a n-1)
+ if (id % this.dimension == 0) {
+ fila = id / this.dimension - 1;
+ } else {
+ fila = id / this.dimension;
+ }
+ return fila;
+ }
+
+ /**
+ *
+ * @param id
+ * @return
+ */
+ private int getColumna(int id) {
+ int columna;
+ // corrección para la ultima columna
+ if (id % this.dimension == 0) {
+ columna = this.dimension - 1;
+ } else {
+ columna = id % this.dimension - 1;
+ }
+ return columna;
+ }
+
+ public void printTablero() {
+
+ for (int i = 0; i < dimension; i++) {
+ for (int j = 0; j < dimension; j++) {
+ System.out.print(casillas[i][j].toString() + " ");
+ }
+ System.out.println();
+ }
+
+ }
+
+ public void quitarWumpus() {
+ casillaWumpus.setHumpus(false);
+ }
+
+ public Casilla[][] getCasillas() {
+ return casillas;
+ }
+
+ public void setCasillas(Casilla[][] casillas) {
+ this.casillas = casillas;
+ }
+
+}
diff --git a/src/wumpus/WumpusGame.java b/src/wumpus/WumpusGame.java
new file mode 100644
index 0000000..05e7c1b
--- /dev/null
+++ b/src/wumpus/WumpusGame.java
@@ -0,0 +1,144 @@
+package wumpus;
+
+import java.util.List;
+import java.util.Scanner;
+
+import wumpus.data.Percepcion;
+
+public class WumpusGame {
+
+ private final int dimension;
+ private final int pozos;
+ private final int flechas;
+
+ public WumpusGame(int dimension, int pozos, int flechas) throws GameException {
+
+ this.dimension = dimension;
+ this.pozos = pozos;
+ this.flechas = flechas;
+
+ }
+
+ public static void main(String[] args) throws GameException {
+
+ if (args.length != 3) {
+ System.out.println("Número de parametros incorrectos: P1=dimension, P2=pozos, P3=flechas");
+ System.exit(1);
+ }
+ int dimension = 0, pozos = 0, flechas = 0;
+
+ try {
+ dimension = Integer.valueOf(args[0]);
+ pozos = Integer.valueOf(args[1]);
+ flechas = Integer.valueOf(args[2]);
+ } catch (NumberFormatException e) {
+ System.out.println("Tipo de parametros incorrectos. Tipo Numerico");
+ System.exit(1);
+ }
+
+ WumpusGame game = new WumpusGame(dimension, pozos, flechas);
+ game.start();
+
+ }
+
+ public void start() throws GameException {
+
+ System.out.println("\n¡¡¡BIENVENIDO AL JUEGO DEL WUMPUS!!!\n\n");
+
+ Tablero tablero = new Tablero(this.dimension, this.pozos);
+
+ Jugador jugador = new Jugador(this.flechas, tablero);
+
+ imprimeOpciones();
+
+ //tablero.printTablero();
+
+ jugar(jugador, tablero);
+
+ }
+
+
+ private void imprimeOpciones() {
+ System.out.println("ACCIONES DISPONIBLES:");
+ System.out.println(" -> Avanzar: A");
+ System.out.println(" -> Girar Drcha: D");
+ System.out.println(" -> Girar Izda: I:");
+ System.out.println(" -> Lanzar flecha: F");
+ System.out.println(" -> Salir: S");
+ }
+
+ private void jugar(Jugador jugador, Tablero tablero) {
+
+ Scanner scanner = new Scanner(System.in);
+
+ bucle: while (true) {
+
+ // Percepciones
+ imprimePercepciones(jugador);
+
+ if (!jugador.isEstaVivo()) {
+ finJuego(scanner, false);
+ break bucle;
+ }
+
+ // Tras obtener las percepciones verificamos si se ha matado el wumpus en la anterior acción
+ if (jugador.isWumpusRecienMuerto()) {
+ tablero.quitarWumpus();
+ }
+
+ // Accion
+ System.out.println("\nIndica Acción");
+ String opcion = scanner.nextLine();
+
+ switch (opcion.toUpperCase()) {
+ case "A":
+ jugador.avanzar();
+ break;
+ case "D":
+ jugador.girarDrcha();
+ break;
+ case "I":
+ jugador.girarIzda();
+ break;
+ case "F":
+ if (jugador.isLanzarFlechaPermitido()) {
+ jugador.lanzarFlecha();
+ } else {
+ System.out.println("No permitido Lanzar Flecha");
+ }
+ break;
+ case "S":
+ if (jugador.isSalirPermitido()) {
+ jugador.salir();
+ finJuego(scanner, jugador.getLingoteConseguido());
+ break bucle;
+ } else {
+ System.out.println("No permitido Salir");
+ }
+ break;
+ default:
+ System.out.println("Opción Incorrecta");
+ break;
+ }
+ }
+ }
+
+ private void imprimePercepciones(Jugador jugador) {
+ List percepciones = jugador.getPercepciones();
+ if (percepciones.isEmpty()) {
+ System.out.println("\nSin Percepciones");
+ } else {
+ System.out.println("\nPercepciones: ");
+ for (Percepcion p: percepciones) {
+ System.out.print(" " + p);
+ }
+ System.out.println();
+ }
+ }
+
+ private void finJuego(Scanner scanner, boolean exito) {
+ scanner.close();
+ System.out.println("JUEGO FINALIZADO " + (exito ? "CON EL OBJETIVO" : "SIN EL OBJETIVO"));
+ }
+
+}
diff --git a/src/wumpus/data/Accion.java b/src/wumpus/data/Accion.java
new file mode 100644
index 0000000..35f0a38
--- /dev/null
+++ b/src/wumpus/data/Accion.java
@@ -0,0 +1,6 @@
+package wumpus.data;
+
+public enum Accion {
+
+ INICIAL, AVANZAR, GIRO_IZQ, GIRO_DRCHA, FLECHA, SALIR;
+}
diff --git a/src/wumpus/data/Direccion.java b/src/wumpus/data/Direccion.java
new file mode 100644
index 0000000..c68da24
--- /dev/null
+++ b/src/wumpus/data/Direccion.java
@@ -0,0 +1,58 @@
+package wumpus.data;
+
+public final class Direccion {
+
+ public static final String ID_ARRIBA = "ARRIBA";
+ public static final String ID_IZDA = "IZDA";
+ public static final String ID_DRCHA = "DRCHA";
+ public static final String ID_ABAJO = "ABAJO";
+
+ public static final Direccion ARRIBA = new Direccion(ID_ARRIBA);
+ public static final Direccion DRCHA = new Direccion(ID_DRCHA);
+ public static final Direccion IZDA = new Direccion(ID_IZDA);
+ public static final Direccion ABAJO = new Direccion(ID_ABAJO);
+
+ // Sentido de las ajujas del reloj
+ static {
+ ARRIBA.izda = IZDA;
+ ARRIBA.drcha = DRCHA;
+ DRCHA.izda = ARRIBA;
+ DRCHA.drcha = ABAJO;
+ ABAJO.izda = DRCHA;
+ ABAJO.drcha = IZDA;
+ IZDA.izda = ABAJO;
+ IZDA.drcha = ARRIBA;
+ }
+
+ private String id;
+ private Direccion izda;
+ private Direccion drcha;
+
+
+ private Direccion(String id) {
+ this.id = id;
+ }
+
+ public String getId() {
+ return id;
+ }
+ public void setId(String id) {
+ this.id = id;
+ }
+
+ public Direccion getIzda() {
+ return izda;
+ }
+ public void setIzda(Direccion izda) {
+ this.izda = izda;
+ }
+
+ public Direccion getDrcha() {
+ return drcha;
+ }
+ public void setDrcha(Direccion drcha) {
+ this.drcha = drcha;
+ }
+
+
+}
diff --git a/src/wumpus/data/Percepcion.java b/src/wumpus/data/Percepcion.java
new file mode 100644
index 0000000..89ad434
--- /dev/null
+++ b/src/wumpus/data/Percepcion.java
@@ -0,0 +1,8 @@
+package wumpus.data;
+
+public enum Percepcion {
+
+ WUMPUS, HEDOR, BRISA, BRILLO, CHOQUE, GRITO
+
+
+}
diff --git a/wumpus.jar b/wumpus.jar
new file mode 100644
index 0000000..140a9c3
Binary files /dev/null and b/wumpus.jar differ