first commit

src/battleship/barco.ts

@@ -0,0 +1,29 @@
+export const BarcoTipo = Object.freeze({
+  FRAGATA: 1,
+  DESTRUCTOR: 2,
+  ACORAZADO: 3,
+  PORTAAVIONES: 4,
+});
+
+export default class Barco {
+  constructor(
+    public id: number,
+    public x: number,
+    public y: number,
+    public longitud: number,
+    public orientacion: string,
+    public impactos: number = 0,
+    public destruido = false,
+  ) {}
+
+  recibirImpacto() {
+    this.impactos++;
+    if (this.impactos >= this.longitud) {
+      this.destruido = true;
+    }
+  }
+
+  haSidoDestruido(): boolean {
+    return this.destruido;
+  }
+}

src/battleship/battleship.ts

@@ -0,0 +1,57 @@
+import Jugador from './jugador';
+
+export default class BattleshipGame{
+    public jugadorA: Jugador;
+    public jugadorB: Jugador;
+ 
+    turnoActual: Jugador | null;
+    
+  constructor(
+    public idPartida: string,
+  ) {
+    this.turnoActual = null;
+  }
+
+  setJugadorA(jugador:Jugador){
+    this.jugadorA=jugador;
+  }
+
+  setJugadorB(jugador:Jugador){
+    this.jugadorB=jugador;
+  }
+
+  iniciaPartida() {
+    this.turnoActual = this.jugadorA;
+    // Iniciar el primer turno
+    this.realizarTurno();
+  }
+  realizarTurno() {
+    // Realizar las acciones correspondientes al turno actual
+    // Por ejemplo, mostrar el mapa del turno actual, solicitar un disparo, etc.
+    // Implementa esta parte según sea necesario
+
+    // Luego, alternar el turno al otro jugador
+    this.turnoActual =
+      this.turnoActual === this.jugadorA ? this.jugadorB : this.jugadorA;
+
+    // Verificar si se ha alcanzado el final del juego
+    if (this.haFinalizado()) {
+      this.finalizaPartida();
+    } else {
+      // Si no ha finalizado, continuar con el próximo turno
+      this.realizarTurno();
+    }
+  }
+  haFinalizado(): boolean {
+    // Aquí debes implementar la lógica para verificar si el juego ha finalizado
+    // Por ejemplo, si todos los barcos de uno de los jugadores han sido destruidos
+    // Devuelve true si el juego ha finalizado, de lo contrario, devuelve false
+    // Implementa esta parte según sea necesario
+    return false;
+  }
+  finalizaPartida() {
+    // Aquí debes implementar la lógica para finalizar el juego
+    // Por ejemplo, mostrar el resultado (quién ganó, etc.)
+    // Implementa esta parte según sea necesario
+  }
+}

src/battleship/jugador.ts

@@ -0,0 +1,49 @@
+import Barco, { BarcoTipo } from './barco';
+import Mapa, { EstadoCelda } from './mapa';
+
+export default class Jugador {
+  public mapaFlota: Mapa = new Mapa();
+  public mapaDeAtaques: Mapa = new Mapa();
+
+  public jugadorPreparado: boolean = false;
+
+  public barcos: Barco[] = [
+    new Barco(1, 0, 0, BarcoTipo.PORTAAVIONES, 'VERTICAL'),
+    new Barco(2, 1, 0, BarcoTipo.ACORAZADO, 'VERTICAL'),
+    new Barco(3, 2, 0, BarcoTipo.ACORAZADO, 'VERTICAL'),
+    new Barco(4, 3, 0, BarcoTipo.ACORAZADO, 'VERTICAL'),
+    new Barco(5, 4, 0, BarcoTipo.DESTRUCTOR, 'VERTICAL'),
+    new Barco(6, 5, 0, BarcoTipo.DESTRUCTOR, 'VERTICAL'),
+    new Barco(7, 6, 0, BarcoTipo.DESTRUCTOR, 'VERTICAL'),
+    new Barco(8, 7, 0, BarcoTipo.FRAGATA, 'VERTICAL'),
+    new Barco(9, 8, 0, BarcoTipo.FRAGATA, 'VERTICAL'),
+  ];
+
+  constructor(public nickname: string) {}
+
+  prepararFlota(barcos: Barco[]) {
+    this.barcos = barcos;
+    this.mapaFlota.setBarcos(this.barcos);
+    this.jugadorPreparado = true;
+  }
+
+  setBarcos(barcos: Barco[]) {
+    this.mapaFlota.setBarcos(barcos);
+  }
+  
+  realizarDisparo(x: number, y: number, rival: Jugador): boolean {
+    const acierto = rival.mapaFlota.verificaDisparo(x, y);
+    this.mapaDeAtaques.marcaDisparo(x,y,acierto ? EstadoCelda.Golpe : EstadoCelda.Agua);
+    return acierto;
+  }
+
+  haPerdido(): boolean {
+    for (const barco of this.barcos) {
+      if (!barco.destruido) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+}

src/battleship/mapa.ts

@@ -0,0 +1,68 @@
+import Barco, { BarcoTipo } from './barco';
+
+export enum EstadoCelda {
+  Vacio = 0,
+  Agua = -1,
+  Golpe = -2,
+}
+
+export default class Mapa {
+  celdas: number[][] = [];
+  barcosMapa: Map<number, Barco> = new Map<number, Barco>();
+  constructor() {
+    for (let i = 0; i < 10; i++) {
+      this.celdas[i] = [];
+      for (let j = 0; j < 10; j++) {
+        this.celdas[i][j] = 0;
+      }
+    }
+  }
+
+  setBarcos(barcos: Barco | Barco[]) {
+    const barcosArray = Array.isArray(barcos) ? barcos : [barcos];
+    for (const barco of barcosArray) {
+      const incFila = barco.orientacion === 'VERTICAL' ? 1 : 0;
+      const incColumna = barco.orientacion === 'HORIZONTAL' ? 1 : 0;
+      for (let i = 0; i < barco.longitud; i++) {
+        const fila = barco.y + i * incFila;
+        const columna = barco.x + i * incColumna;
+        this.celdas[fila][columna] = barco.id;
+      }
+      this.barcosMapa.set(barco.id, barco);
+    }
+  }
+
+  getEstadoCelda(x: number, y: number): EstadoCelda {
+    return this.celdas[x][y];
+  }
+
+  getBarcoEnCelda(x: number, y: number): Barco | null {
+    const barcoId = this.celdas[x][y];
+    if (barcoId > 0) {
+      return this.barcosMapa.get(barcoId) || null;
+    }
+    return null;
+  }
+
+  marcaDisparo(x:number,y:number,valor:number){
+    this.celdas[x][y]=valor;
+  }
+
+  getInformacionBarcos(): Barco[] {
+    return Array.from(this.barcosMapa.values());
+  }
+
+  verificaDisparo(x: number, y: number): boolean {
+    if (this.celdas[x][y] > 0) {
+      const barco = this.getBarcoEnCelda(x,y);
+      if (barco) {
+        barco.recibirImpacto();
+        this.celdas[x][y] = EstadoCelda.Golpe;
+        return true;
+      }
+    } else {
+      this.celdas[x][y] = EstadoCelda.Agua;
+    }
+    return false;
+  }
+}