Mensajes

No se puede esperar que la gente cede toda su privacidad a google (sobretodo para Android) y que los demás no exijan nada. Así ahora Microsoft, copia la idea.

Yo afirmo que si los usuarios estan autenticados, aumenta la gravedad de la seguridad. mientras sea anónimo, un intruso no sabe con quien se las está viendo, ni si ese es un objetivo 'deseable'... estando autenticados, incluso se puede hacer 'búsquedas'...

La escalada en la gravedad de la seguridad, suma y sigue... Cada vez falta menos para que "1984" sea una realidad absoluta.... (obra basada después de todo en la propia Biblia ("nadie si no aquellos que tenían la marca de la Bestia, podía comprar ni..." )... que ya expresaba el control absoluto de los individuos.

[elegir al azar casillas, pero solo entre las que aún están libres.]

No dupliques todo el contenido de un mensaje si no vas a citar nada, si has de referirte a una persona simplemente copia su alias (y lo pones en negrita para llamar con claridad su atención) y responde simplemente... Imagina que ahora yo cito todo tu mensaje, y luego tu otra vez el mío... al anidarse los mensajes sería engorroso y largo (mucho scroll) para llegar al texto que uno escribe.



Ayer, olvide´al final, poner como se llemaba , aunque es claro... aprovecho, para resumir la lógica...
La lógica de un modo escuesta (más claro ahora que se sabe que aplicas la regla de espacio entre barcos):

Resultado solo debeiera tener dos valores: Agua o tocado, luego mejor un buleano para esto. Si ya fue tocado con anteroridad en sucesivas veces esa casilla debe devolver agua.
Como usamos una variable llamada 'tocado' al parámetro lo llamamos agua y entra con TRUe cuando se el resultado es 'agua' y con FALSE, cuando el resutado fue 'tocar la casilla a la que se disparó'.

Código [Seleccionar] Expandir


buleano = Funcion SiguienteDisparo(buleano Agua, byte x, byte y)  
   Si (agua = FALSE)
       Si (Tocado > 0)             
           Aumentar tocado              // Otra casilla tocada de la nave (o de una nave contigua)          
           Avanzar la cordenada en la que se está  (según cada caso).          
           Si (ConsultarBarcoHundido(Tocado) = TRUE)
                Tocado = 0
                 Devolver FALSE
            Fin si
       Sino                                    // aquí hay un buque (lo acabamos de descubrir)... insistiremos hasta hundirlo.            
           Tocado = 1            
           Orientacion = 1            
           Avanzar cordenada x              
       Fin si      
       Devolver TRUE

   Sino  // agua = TRUE
       Si (Tocado > 0)              // un disparo previo acertó?,                                    
           Orientacion += 1      // cambiamos de orientación a la siguiente
           Cambiar las cordenadas a la casilla adhiacente a la 'arroba' en la orientación actual (que acabamos de saltar).        
           Devolver TRUE          
       Sino        
           Devolver FALSE
       Fin si
   Fin si
Fin funcion

Y la función sería invocada así:

Código [Seleccionar] Expandir


   buleano agua, seguirPista

   Si (seguirPista = FALSE)
       x = Random(entre 0 y maxColumna)
       y = Random(entre 0 y maxFila)
   //Sino
       // 'x' e 'y', fueron actualizadas en la función SiguienteDisparo, se usan esos valores actualizados.
   Fin si
   agua = Disparar(x, y)
   seguirPista = SiguienteDisparo(agua, x, y)
   
...y para ser más precisos, elegir 'x' e 'y' de forma aleatoria, no debe ser del todo exacto, puede resultar muy costoso, ya que a medida que se juega, ya hay casillas que fueron elegidas, por tanto no tiene sentido volverlas a elegir... cuantas menos queden, más costará tomar al azar una casilla libre... no es nada óptimo.

Aquí la solución, si no la entiendes pregunta...:


1º Mantener datos de las casillas. Se crea un array con el número de casillas totales. y una variable indica cuanto son estas.
 
Al comenzar la partida, se meten todas las casillas en un array, que luego es barajado.

Código [Seleccionar] Expandir


   ArrayEntero Casillas()
   entero maxCasillas, maxFilas, maxColumnas

   Funcion NuevaPartida(filas, columnas)
       entero k
   
       maxFilas =filas
       maxColumnas = columnas
       maxCasillas = ((filas * columnas) -1)  // -1 aquí, para evitar en todas partes poner -1...

       Alojar espacio para Casillas(0 a maxCasillas)
       Bucle para k desde 0 a maxCasillas
           Casillas(k) = k
       Siguiente
       
       BarajarCasillas        

       ... otras cosas en esta función necesarias antes de empezar la partida (como posicionar las flotas)
   fin funcion

2º La función BarajarCasillas, reordena de forma aleatoria el contenido en el array.

Código [Seleccionar] Expandir

Funcion BarajarCasillas
   entero k, j, i

   Bucle para k desde maxCasillas hasta 1 hacia atrás
       j = Random(entre 0 y k)
       i = Casillas(j)
       Casillas(j) = Casillas(k)
       Casillas(k) = i
   Siguiente
Fin funcion


3º Elegir una casilla al azar entre las disponibles, luego la última disponible ocupa la posición de la tomada, y se descuenta 1 de las disponibles. Si no hay casillas disponibles daría error, pero eso implica que quedan barcos sin hundir pero se ha disparado a todas las casillas, luego hay un error de lógica en el juego (por ello no se contempla en lafunción que no haya casillas disponbles, el juego debe acabar antes que eso ocurra).

Código [Seleccionar] Expandir


   entero = Funcion CasillaRandom
       entero z
       z = Random(entre 0 y maxCasillas)   // Elegir una casilla al azar entre las disponibles.

       Casillas(z) = Casillas(maxCasillas-1)  // movemos la última disponible al hueco de la casilla a devolver.
       maxCasillas -= 1                             // una casilla libre menos.

       Devolver z                                     // entregamos la casilla elegida (una libre)
   fin funcion

4º Derivar la casilla a las cordenadas que toque:
Básicamente es convertir un índice de un array unidimensional en los índices de un array bidimensional.

Código [Seleccionar] Expandir

Funcion GetCordenadasFromCasilla (casilla, x, y)  // 'x' e 'y' son de salida...
   x = (casilla modulo maxFilas)  
   y = (casilla \ maxFilas)   // el '/' es una división entera, o bien una división (flotante) a la que se le retiran los decimales (convenrtido en entero)
Fin Funcion


Y por fin modificamos el fragmento de pseudocódigo de más arriba para elegir al azar casillas, pero solo entre las que aún están libres.

Código [Seleccionar] Expandir


   buleano agua, seguirPista
   entero casilla

   Si (seguirPista = FALSE)
       casilla =  CasillaRandom
       GetCordenadasFromCasilla(casilla, x, y)
   Fin si

   agua = Disparar(x, y)
   seguirPista = SiguienteDisparo(agua, x, y)

A ver... yo te puse eso de "te llevará a la declaración de la variale, si lo es... (aunque es algo que tu debieras saber (los demás no, porque no vemos declaraciones de variables por ningún lado en tu código escueto).", e smás una crítica que otra cosa. Por la mala costumbre de no poner las declraciones y que tengamos que jugar a adivinar que tipo es una variable.

Está claro que es  (o debiera ser) un Recordset, para recibir la asignación de la línea:

Código (vb) [Seleccionar] Expandir

inversorx = Rs.Fields.Item(1)
No lo declares como Variant si sabes el tipo que va a recibir. Ralentiza mucho las operaciones con Variant y debe usarse exclusivamente cuando un parámetro ha de recibir diferentes tipos... éste no parece ser el caso.

Luego, como te fallan las comillas, venía decirte que si no estás seguro de si lo has hecho correctamente, una forma de saber si por error, lo tratas como un literal, en vez de como variable, es reclamar su "definición", si la variable está declarada, irá a la línea donde aparece declarada, si no lo está o está descrita como un literal, te indiará que 'no se reconoce como un identificador (nombre de variable, función, propiedad, clase, constante, etc...)

...pero ya te dije que corrigieras las comillas como corresponde... y si no tienes claro donde falla exactamente, ejecuta el programa paso a paso, en la función donde esté ese fragemnto de código (pon una línea de pausa (con F9), al comienzo de ese código, y luego ejecuta paso a paso (con F8), mirando tras la ejecución de cada paso, si las variables contienen el valor que cabe esperar... Y si precisas evaluar una expresión, en vez de una variable suelta, selecciona la expresión 'completa' y con el ratón selecciona "inspección rápida" ( ó SHIFT+F9)... así logras llegar fácilmente al punto donde no está como corresponde.

...en fin, tienes que aprender algo sobre depuración del código usando el propio entorno de programación. VB6 es muy completo al caso.

Siempre con las mismas tonterías:

esta empresa dice que su dispositivo no se vende con ningún contenido no autorizado o ilegal, por lo que los usuarios pueden optar por descargar e instalar programas de terceros a través de los cuales pueden buscar y ver contenidos no autorizados, pero eso no es su culpa. Por tanto, argumenta que TickBox no puede ser considerada responsable bajo la teoría de la infracción contributiva o la inducción a la piratería, ya que, si bien su dispositivo puede ser programado para infringir la ley, es el software de terceros los que hacen todo el trabajo sucio, el producto en sí no tiene nada que ver con ellos.

En efecto, es lo mismo que un coche... que los ladrones prefieran usar una furgoneta para cargar más cantidad de botín en los robos, es absurdo pretender que las 'furgonaetas' inducen al robo...

Es paradójico además el doble rasero con las cuestione slegales en USA. Unarma sirve solo para matar, pero según ellos el peligro no está en el arma, si no en lo que hace la persona, así las armas son legales y solo se condena a los que las usen indebidamente... ¿¿¿no es esto exactamente lo mismo, pero sin el agravante de que nadie muere ????.

El código resulta un poco espagueti, por la vaguedad en los nombres, pero bueno...

Según tú...: ...where inversor = 'inversorx'
Pero ausmo que inversorX es una variable no una cadena de texto literal...

es decir si fuera una cadena de texto literal, hubieras puesto:

Código (vb) [Seleccionar] Expandir


 ...where inversor = "'inversorx'"  
Pero si es una variable debe poner:

Código (vb) [Seleccionar] Expandir


...where inversor = inversorx
Y si el contenido de  inversorx, debe estrar entre comillas simples deberías poner:

Código (vb) [Seleccionar] Expandir


inversorX = "'" & inversorX & "'"  ' en alguna parte pondrías esto
 ...
...where inversor = inversorX   ' par al final hacer esto


...en fin apunta el ratón en la palabra inversorx, y con el otro botón del ratón da click, y cuando emerja el menú flotante, selecciona: 'definición' y te llevará a la declaración de la variale, si lo es... (aunque es algo que tu debieras saber (los demás no, porque no vemos declaraciones de variables por ningún lado en tu código escueto).

Corrige las comillas según lo que sea (uno de los 3 casos antedichos).


p.d.: también si encerraras tu código entre etiquetas GeSHi, el coloreado del texto, lo haría más legible...

[Si quieres evitar esos casos molestos]

Simplemente debes tener una estructura (sencilla) donde mantener dicha info, para seguir indagando.


Una imagen para que hagas una idea de como queda y luego la estructura, detrás las explicaciones

Cerco:

.|0 1 2 3 4 5 6
A|X X X 4 X X X
B|X X X 4 X X X
C|X X X 4 X X X
D|2 2 2 @ 1 1 1
E|X X X 3 X X X
F|X X X 3 X X X
G|X X X 3 X X X



Finalmente tendrías una estructura para mantener junto los datos tal que así:

Código [Seleccionar] Expandir


Estructura DatosDisparo    
    byte Tocado                     // indica cuando se toca por vez primera una nave, y luego con cada nuevo 'tocado' aumenta en uno. asi este valor hasta hundirlo.
    byte Orientacion              // indica a qué lado estamos disparando del cerco.
    //byte cX                        // cordenada 'x' del primer tocado en la nave.
    //byte cY                        // cordenada 'y' del primer tocado en la nave.
    //arrayBytes Cerco(7,7)  // Array imaginario, operamos sobre un área de 7x7 (dado un tamaño de nave de 4 casillas)
Fin estructura

DatosDisparo dDisparo     // instancia de la estructura.


La arroba, representa tu primer disparo con acierto. Tocado se pone a 1, Luego siempre sigues la dirección del reloj, empiezas por donde quieras, yo he puesto 1 al este... si aciertas de nuevo sumas 1 a tocado y se avanza en la orientacion y sentido que lleva. Así si es 1, sigues en 1... pero si falla, continúa en la misma dirección pero en el otro sentido, y el valor de orientación se actualiza como toca...
El orden de 1,2,3 y 4, obedece a facilitar el código... otras maneras son posibles, pr supuesto.

La estrategia es que si el disparo ha tocado un buque (valor 2 en tu caso), por primera vez, se consdiera una zona centrada en dicha posición, del mapa de disparos,  centrnado el disparo en dicho array, es decir Cerco(3,3) = 2 // tocado
Y estableces un valor buleano Tocado=1, ahora la posición donde disparar la siguiente vez, va condicionado...

Voy mejor con pseudocódigo, sino con tantos condicionantes es fácil perderse...

Código [Seleccionar] Expandir


buleano = Funcion SiguienteDisparo(byte resultado, byte x, byte y)  //tu llama la función como te dé la gana... o atendiendo a como te reclamen.  
   Si (resultado = 2)   // Tocado
       Si (dDisparo.Tocado > 0)
           Si (dDisparo.Tocado < 4)  
               dDisparo.Tocado += 1              // Otra casilla tocada de la nave (o de una nave contigua)
         
               Si (dDisparo.Orientacion = 1)    // avanzamos a derecha
                   x += 1
               OSi (dDisparo.Orientacion = 2)   // avanzamos hacia izquierda                
                   x -= 1                  
               OSi (dDisparo.Orientacion = 3)   // avanzamos hacia abajo                    
                   y += 1                              
               OSi (dDisparo.Orientacion = 4)   // avanzamos hacia arriba
                   y -= 1
               Fin si              
           Si no    
               dDisparo.Tocado = 0      
               Devolver FALSE          
               // NOTA2:  Si se ha tocado tantas veces como casillas tiene la nave mayor, cabe decir que hay un buque contiguo a éste (o más)...  
               // no se ha hundido, porque sino, se hubiera recibido un resultado 3.
               // Es decir: al menos dos buques tienen casillas en este área y están tocándose
               // Luego la suma de 'dDisparo.tocado' ha tocado casillas de al menos dos naves,...
               // Resolver este caso, lo dejo a tu esfuerzo y consideración...
           Fin si
       Sino  // aquí hay un buque (lo acabamos de descubrir)... insistiremos hasta hundirlo.
           // Reset valores de la estructura.
           dDisparo.Tocado = 1            
           dDisparo.Orientacion = 1
           //dDisparo.cX = x
           //dDisparo.cY = y
           //CopiarParteDelMapaACerco
           
           x += 1   // orientación: 1, avanzamos a derecha, 'y' no cambia.              
       Fin si      
       Devolver TRUE
   Osi (Resultado = 3)                // Hundido, se supone ya restada una nave.        
       dDisparo.Tocado = 0          // si esta nave está hundida, retiramos la marca para seguir buscando alrededor...
       Devolver FALSE
   Sino
       Si (dDisparo.Tocado > 0)              // un disparo previo acertó,                         
           Si (dDisparo.Orientacion < 4)      // si no se han agotado todas las posibilidades.
               dDisparo.Orientacion += 1      // cambiamos de orientación.
               Si (dDisparo.Orientacion = 2)  // ---> cambia de sentido en horizontal...  hacia izquierda                
                   x -= (dDisparo.Tocado + 1)  // 'y' no cambia                  
               OSi (dDisparo.Orientacion = 3) // ---> cambia a vertical abajo
                   x -= dDisparo.Tocado          // vuelve a la cordenada central (de Cerco) en el eje 'x'
                   y +=1                                // y baja una fila
               OSi (dDisparo.Orientacion = 4) // ---> cambia de sentido en vertical... hacia arriba...
                   y -= (dDisparo.Tocado + 1)  // 'x' no cambia.
               Fin si
               Devolver TRUE
           Sino                                                                              
               dDisparo.Tocado = 0      
               Devolver FALSE
               // NOTA2:  Agotada todas las orientaciones cabe decir que hay un buque contiguo a éste...  
               // no se ha hundido, porque sino, se hubiera recibido un resultado 3.
               // Es decir: al menos dos buques tienen casillas en este área y están tocándose
               // Luego la suma de 'dDisparo.tocado' ha tocado casillas de al menos dos naves,...
               // Resolver este caso, lo dejo a tu esfuerzo y consideración...
           Fin si
       Sino        
           Devolver FALSE
       Fin si
   Fin si
Fin funcion

Observa que en realidad el array 'cerco', no lo usamos para nada, ni copiamos ni escribimos, ni leemos de él, es una idealización para saber que estamos haciendo y 'no perder el norte'...
Los parámetros 'x' e 'y' son de entrada y salida...
La función devuelve un buleano, para indicar si el próximo disparo debe dirigirse el disparo a los valores x,y devueltos si la función devuelve TRUE, si devuelve false, se debe elegir otra posición... pero devlviendo TRUE, 'x' e 'y', contiene la dirección donde disparar para cercar al buque tocado hasta hundirlo.

- Una vez que se ha tocado, un barco, sigue la estrategia de recorrer en la misma orientación hasta el fallo, en cuyo caso se recorre en el sentido opuesto, acabado el otro sentido, cambia la orientación a vertical y finalmente invierte el sentido de este... ese es el orden de recorrido.

- Nota que caben posibilidades de que haya 2 o más naves que estén contiguas (paralelas), por lo que puede darse falso positivo (tocar dos naves distintas y no dos casillas de la misma nave (incluso 3, 4 naves...), con dos disparos seguidos). He dejado un comentario de //NOTA1 y //NOTA2, donde esto sucede... y aún puede darse un caso de NOTA3...

// NOTA2: al caso dDisparo.Tocado contiene el valor de cuantas naves han sido tocadas y la orientación actual descubre que están en una orientación atravesada.
//NOTA1: También cabe la posibilidad de una nave pongamos vertical (que tocamos con 'dDisparo.Tocado = 1, el centro del 'Cerco'), incluso alguna más también en vertical y luego otra en horizontal a continuación de áquella última tocada, luego llegamos a 4 tocados, pero no hay ninguna nave hundida (hubiéramos recibido un valor de resultado = 3)... luego hay que continuar la dirección más allá de las medidas de 'Cerco', para hundirlo y tras hundirlo regresar sus casillas hacia atrás, y continuar en otra dirección...
Ambos casos, los dejo en el limbo, a tu esfuerzo... es más de lo mismo, puede resolverse descontando los Tocados de la nave hundida y cambiar en la otra dirección vertical desde la posición previa (descontada en dicho eje de la nave hundida) //NOTA3: Todavía existe el caso de que dos naves estén colocadas 'a testa' una de otra, también dejo a tu esfuerzo incluso donde va este caso dentro del árbol de decisiones....

Si quieres evitar esos casos molestos, basta que añadas una regla al juego: dos naves no pueden posicionarse  tocándose, siempre debe haber al menos un casilla de espacio entre ellas (con la excusa de que eso impediría el movimiento en un caso real   ). Esto elimina todas esa complicaciones...

Cerco:

.|0 1 2 3 4 5 6
A|X X X 4 X X X
B|X X X 4 X X X
C|X X X 4 X X X
D|2 2 2 @ 1 1 1
E|X X X 3 X X X
F|X X X 3 X X X
G|X X X 3 X X X


Nota que habiendo tocado una casilla y considerando a dicha casilla como el centro de un cerco, basta tocar otras 3, para hundir el barco más grande que haya (supuesto el caso de naves de tamaño 4  como máximo), sin embargo, el cerco aunque sea imaginario de 4 casillas en una dimensión en realidad queda determinado por el valor de Tocado... es decir mientras se toque en una dirección se avanza en ella, así podría a llegar a 5, 6, 10... con lo que en realidad no importa el tamaño de las naves. Pero es preciso, hacer siempre una idealización razonada y cuando procede un dibujo...
Para hacer el pseudocódigo independiente del tamaño de las naves habría que tener una variable donde está línea, para el valor 4, con el valor propio de casillas que tenga la nave de mayor tamaño.
Si (dDisparo.Tocado < 4)

Como el pseudocódigo está escrito al aire (sobre la marcha), es posible que se haya escapado algún gazapo...

-----------------------
Todo lo previo, respecto de tu interés, y ahora respecto de otras observaciones que pareces obviar...
- El valor de: "casilla repetida = 0", es absurdo... es obligado llevar dos mapas (por flota), aunque en realidad el segundo mapa de una flota, es el primero de la otra, luego pueden compartirse parcialmente.
Me explico: ¿quién en su sano juicio tira dos 'bombas' al mismo sitio, si ya fue agua, o tocado???. Y se sabe que fue agua o tocado, porque... en efecto llevas un mapa de donde has tirado previamente, no llevar un mapa es carecer de memoria, luego una IA, no tiene sentido donde no hay ni persistencia de la memoria. La IA es precisamente operar en consideración  de la memoria, de la 'experiencia', mediante la retroalimentación... si no hay memoria, no hay nada que retroalimentar... por eso mantener una estructura de lo que ha sucedido previamente es la IA mínima que se puede prestar...

Así los dos mapas son: Donde yo tiro a la flota enemiga y 2º, donde el enemigo me tira a mi.  es inverso para el caso del enemigo, excepto en que en el mapa propio, están todas las naves y 'el enemigo solo ve', lo que ha tocado o hundido, es decir... si tenemos un valor de nave intacta en el mapa, para el enemigo, se le reprseenta como agua... y si no, toca mantener dos mapas independientes por cada flota.

Es abusrdo hablar de IA, si luego uno va a volver a tirar a casillas a las que ya ha tirado. Hay un caso donde esto es posible, y es en una versión más compleja del juego, donde en cada turno, el que tira mueve una de sus naves (la que quiera) una casilla en uno de los dos sentidos de la orientación que tiene, por lo que en efecto, podrá dispararse a casillas ya disparadas, porque las flotas 'se mueven', pero es una regla que hace el juego mucho más complejo...
---------------

Siento todo el párrafo del mensaje anterior, que al parecer te resulta innecesario,  porque al hacer preguntas, los usuarios a menudo os dejais en el tintero detalles importantes... como "ya tengo listo todo lo demás, me falta solo esto". ...pero bueno, a alguien podrá servirle.

Al margen de como muestres por pantalla el mapa, es acertado que en tu array mantengas lo más coherente los datos referentes al estado del mapa.

No sé si te piden-puedes crear clases o si va todo en 'spaguetticode'... yo creraría una clase llamada mapa, que al inicio, al crearse recibe como parámetros el tamaño del mapa, y un array indicando cuantos buques tendrá y de qué tamaño... pero al caso puedes dejar las funciones fuera si no usas clases, duplicando datos para cada jugador...


Las ideas:
- Un array Mapa, contiene el estado del mapa, incialmente sus valoren valen 0, es decir todo agua, las casillas 'tocadas se marcan con valor 255, cualquier otro valor corresponde a la nave x.
- Un array de Naves, tiene tantos elementos como naves se alojarán en el mapa, y el valor de cada ínidice, indica cuantas casillas ocupa la nave... por ejmplo:
NavesA(0) = 2
NavesA(1) = 3
NavesA(2) = 3
NavesA(3) = 4
...etc... hay dos naves de 3 casillas, 1 de 2 casillas y una de 4... (no importa el orden en que estén).
- Hay dos flotas, luego hay dos arrays con el mapa de estado de cada jugador y del estado de sus naves.

Esto se refleja en el siguiente pseudocodigo.

Código [Seleccionar] Expandir


// Datos jugador A
arrayBytes MapJA(x,y)    //x,y expresa dos dimensiones
arrayBytes NavesA()
entero NumNavesA

// Datos Jugador B
arrayBytes MapB(x,y)
arrayBytes NavesB()
entero NumNavesB


Funcion NuevoMapa(ancho, alto, buques() )
   alojar tamaño para MapA(ancho, alto)
   alojar tamaño para MapB(ancho, alto)

   numNavesA = buques.count  
   numNavesB = buques.count

   NavesA = buques
   NavesB = buques
Fin Funcion

- Cuando se posiciona una nave en el mapa, por ejemplo la nave de 4 casillas, donde se ubique en el mapa, tales casillas ocupadas, se rellenan con el valor del índice de dicho buque. por ejemplo: 3 3 3 3. Señala que la nave de índice 3 (NavesA(3), está ubicado en esas casillas).
- Cuando se toca una casilla de la nave, en el mapa se marca (por ejemplo), 255 (tocado), y  se resta una casilla en la nave.
- Cuando la nave llega a 0 casillas, la nave está hundida, se resta una nave del jugador.
- Cuando un jugador se queda sin naves, la partida acaba.

Esas reglas se reúnen en este fragmento de pseudocódigo:

Código [Seleccionar] Expandir


entero = Funcion Disparar(x,y, Jugador)
   byte estado

   Si (jugador = 0) luego  // A dispara a B
       estado = MapB(x,y)  // valor de estado del mapa para esa casilla.

       Si ((estado > 0) y (estado < 255) )  // se acaba de tocar un barco.
           MapB(x,y) = 255            // casilla tocada, se marca en el mapa, el nuevo estado.
           NavesB(estado) -=1       // se resta una casilla a este barco.
           Si (NavesB(estado) = 0)  //Hundido, cuando a una nave no le quedan casillas, se considera hundido
               numNaves  -=1
               Si (numNaves = 0)   // no le quedan naves. 'jugador' ganó la partida.        
                   Devolver -1
               Fin si
           Fin si            
           Devolver 1 // esto es 'tocado/hundido' jugador sigue tirando, sigue en su turno.
      fin si
      Devolver 0  // 'agua' o ya tocada.
  Sino // jugador =1, B dispara a A
     // igual que arriba pero cambiando B, por A
  Fin si
Fin funcion


El bucle principal del juego (simplificado al máximo)...

Código [Seleccionar] Expandir


funcion MainPartida
   entero d, t, n     //d=resultado del disparo, t=turno de qué jugador.

   DecidirTamañoMapa(x,y)  // jugadores indican que tamaño tendrá el mapa.
   ArrayBytes Buques = DecidirNumeroNavesYTamaños
   NuevoMapa(x,y, buques)
   
   PosicionarFlota(buques, 0) // 0=Jugador A, se le pide que posicione sus buques en el mapa.
   PosicionarFlota(buques, 1) // 0=Jugador B,    "          "

   t = ElegirTurnoalAzar(entre 0 y 1) //t indica el jugador que tiene el turno

   // Bucle del juego hasta fin de partida.
   Hacer
       ElegirNuevasCordenadasDeDisparo(t,x,y) // se usa 't', para que el jugador específico elija las cordenadas.
       d = Disparar(x,y, t)  //t hace referencia a que mapa del jugador afecta,
                                   // con clases 't' en vez de ser un parámetro sería un objeto y disparo un método de dicho objeto.
       Si (d = -1) luego
           llamar FinalPartida("Perdiste, no te quedan naves. Ganó el jugador xxxx (que tiene el turno de disparo"
       Osi (d = 0) luego // tocado o hundido
           //CambiarTurnoJugador
           t = ValorAbsoluto(1 - t) //cambiamos el turno de jugador: esto alterna cada vez entre 0,1,0,1,0,1,0,1
       sino
           // el jugador que tiene el turno, sigue disparando hasta que falle (d=0), o no queden naves (d=-1)
       Fin si
       n += 1
   Repetir mientras ( d<> -1) //  '<>' distinto de // ó: mientras FinalPartida(d) = False

   MostrarMensaje (La partida precisó 'n' disparos para llegar a su fin...) //no es ni mucho menos la estadística que requieres,
                       // pero no cuesta constar los disparos realizados por ambos jugadores.
Fin funcion


Queda a tu esfuerzo, el resto de funciones:
- DecidirTamañoMapa, DecidirNumeroNavesYTamaños: El trabajo de estas funciones podría quedar fijado por diseño o inicializarse con unos valores y al inicio de cada partida pedir al usuario si quiere cambiarlo.

- Con los valores previos establecidos (de las dos previas funciones), la función: NuevoMapa ya está descrita en pseudocódigo...

- PosicionarFlota: esta función se invoca dos veces. En cada una se pide al jugador que posicione sus naves en el mapa. Dicha función marcará en el mapa las casillas que ocupa cada nave, metiendo el valor de la nave que ahí se aloja.
 Debe impedirse que una nave solape otra, o que no quepa... ...luego es imprescindible que para ubicar una nave en el mapa, se consulte si la posición 'x,y' que indica el usuario como 'punto central de la nave' (o de comienzo) cabe la nave (dado su tamaño), en vertical u horizontal, contando las casillas 'agua' adhiacentes a la marcada, si cabe tanto en vertical como horizontal, luego pedir al usuario que decida la orientación, si solo cabe en una orientación se deja en esa, y al final se exige que pulse 'intro' para confirmar, o 'esc' para reposicionar en otro lado. Si pulsa 'esc', se borran las casillas marcadas para ese buque. Si pulsa intro, se avanza en el array para posicionar la siguiente nave.
 Cuando todas las naves en el array estén alojadas en el mapa, también se pedirá si confirmar con intro o si se desea cambiar una nave específica, para ello pulsar el índice de la misma....

- ElegirTurnoalAzar: esta función simplemente decide que jugador empieza a jugar. 0 = representa al jugador A, y es su turno y 1 =representa al jugador B y será su turno.
- CambiarTurnoJugador: es una función tan simple que ni se crea, se alterna siempre del uno al otro, luego una línea de código basta...

- ElegirNuevasCordenadasDeDisparo: Esta función es la que puede entretenerte un poco más, ya que es donde tu reparas en como operar sobre ella.
Cuando juega la máquina contra la máquina, una estrategia de disparar al azar, puede ser aceptable incialmente, sin embargo una mejor estrategia es elegir zonas y sobre zonas, una casilla en la zona... entendiendo por zonas la división del mapa en cuadrantes, del tamaño de la nave mayor, es decir supongamos que el mapa tiene 16x16 casillas y que la nave mayor ocupa 4 casillas, entonces sería útil considerar al mapa dividido en 4x4 zonas, entonces si disparas a distancias de zona, vas asegurando que tocarás la nave mayor si o sí, de forma más coherente que al azar. linea 3, linea 7, 11 y 15 verticales y horizontales. Una vez cubierto así el mapa habrás dado con todas las de 4, se divide cada zona en la mitad y así... naturalmente cuando tocas una nave, te ciñes sobre ella hasta hundirla...
 Al caso para cada jugador deberías guardar como va la estrategia. Como por ejemplo copia de donde ha disparado previamente el jugador, para no repetir disparos... es decir se elige al azar, pero si ya se disparó allí se elige otra posición.
Diseñado con objetos sería más sencillo de hacer y mantener el código.

- Disparar: Esta función evalúa sobre el mapa el resultado que afecta a la flota contra la que se dispara, y el resultado del disparo se evalúa tras dicha función como parte del bucle principal del juego.

- FinalPartida: En el pseudocódigo se usa para indicar un mensaje del resultado de la partida, pero podría trasladarse allí parte del código del bucle principal... y sería quien evaluara si al jugador le quedan naves o no...

En fin, ya tienes un planteamiento general y la distribución de funciones, ahora solo toca rellenar el código para cada función y probarlo...

[vuelvan]

La unión en un solo dispositivo del teléfono y el ordenador, es algo que se esperaba desde comienzo de los 90 (incluso antes), y no hay duda que es algo muy acertado, sin embargo debeiera mantenerse la separación absokuta de las características.
En un mismo dispositivo?: SÍ. compartiendo todo en común?: NO. Pero los fabricantes solo atienden a cifras de negocio, les importa un egg, la seguridad ni nada de nada. Los cambios forzados, solo lo son por quejas que pueden producir la inestabilidad de la empresa... es decir porcos o nulos, si al final los vehiculan con falsedades (como acostumbran a hacer).

En ese sentido, por tanto que vuelvan a existir teléfonos 'unSmart', es todo un paradójico avance en la seguridad. Qué necesitas seguridad ante todo?. Pasas de un dudoso Smart-phone... Qué necesitas hacer un poco de todo?. Regreso a un PC, o incluso a un miniPC.

Frente a la abochornable, insoportable, insufrible ilimitadas opciones, serivcios y programas innecesarios (para el usuario doméstico) de los PC con Microsoft al frente y en el otro frente, la nula capacidad de control auténtico (sin hacer root y jugártela con una ROM hackeada y pérdida de garantías) de los teléfonos móviles (con Google o peor con Apple), podría sacarse un término medio, donde el usuario tenga opción y control de todo, pero donde no vengan preinstalado nada inútil... que exista, vale, pero que venga preinstalado no. En fin, un dispositivo así, creo que se llevaría la palma al menos para todo usuario entendido en tecnología... y con una separación clara y definida de lo que es el teléfono y lo que es el resto. Que no venga a suceder que un maldito intruso se haga dueño del teléfono, algo solo posible cuando la fusión es absoluta. Con cierta separación en funciones, nada de eso pasaría...

Mal hecho...

Debieran empezar aprendiendo con pseudocodigo, sin ni siquiera tocar el ordenador.

Repartir simples papeles con los nombres d elos meses o los días d ela semana, y por ejemplo sugerirles que creen órdenes parar ordenar los meses dados en un desorden específico que el profesor (por ejemplo), escribiese en la pizarra...

El alumno, lo primero que debe aprender (de programación), es a pensar a expresar sus ideas de forma cabal y ordenada. E incidir en ello, unos 3 meses. Más adelante será solo cuestión de traducir el pseudocódigo a los términos de lenguaje que se pretenda usar para enseñar al alumno.

De todos modos, creo que lo ideal es que en la Universidad y con fines didácticos, se creara y usara un lenguaje específico para tales propósitos, el aprendizaje. Un lenguaje bastante limitado, pero que toque todos los palos (desde el manejo de datos básicos hasta estructuras complejas, desde manejo con ficheros a manejo en red (aunque sea sólo local), desde ordenar arrays hasta cifrado y compresión.
... y la razón es que los lenguajes modernos, son hoy día una auténtica jungla imposible de abarcar (ya) por nadie, entonces enfrentar a un novato a algo tan gigantesco, puede causarles frustración muy fácilmente

...esta es la razón, por la que las dos generaciones previas, aprendieron mucho mejor desde algo tan simple como el BASIC, tan denostado hoy día. A pesar de que luego los que no se profesionalizaron se quedaron en el mismo BASIC que aprendieron.

El primer lenguaje debe ser uno que permita al docente centrarse en el tema que trata de enseñar y al aprendiz centrarse en el problema para entenderlo y dominarlo, alejado de la problemática propia que encierra el propio lenguaje (abstraerse de todo lo que no sea aprender la lección en curso, de cosas por ahora innecesarias pero que consumen tiempo, esfuerzo y expectativas). A medida que se tenga un dominio práctico de dicho lenguaje académico y que se vea al alumno fluído en entender y aplicar sus conocimientos, es cuando puede pasarse a un lenguaje de producción.

...por eso hoy día las Universidades son una de las principales fuentes generadoras de frustración e incluso entre los que salen adelante de crear personas susceptibles a la ansiedad en edades muy tempranas.

No es exactamente eso. La idea que no se si va en serio o no, es la siguiente:

Tu ajustas con más precisión, pero es lo de siempre. El dinero.

Pero insisto que es como digo... ya que dentro de esa misma supuesta nueva comunidad, también habrá alguna población en concreto que destaque del resto y CON LOS MISMOS ARGUMENTOS, también pretenda que sus impuestos sean solo para ellos... pero, no acabaría ahía la cosa, dentro de la misma población también hay barrios y siempre habrá uno o dos barrios más ricos, y media docena mucho más pobres, luego el problema y la solución se repiten hasta llegar a "Casalandia", donde mi sola casa sea una comunidad autónoma-país (alcaso es lo mismo de absurdo, aunque ciertamente la legalidad puede diferir), y donde mis impuestos sean solo para mi...

...la pregunta pertinente entonces es: ¿Para qué sirven los impuestos , si al final cada uno va a tener devuelta exactamente los mismos impuestos que pagó?. El fundamento de la comunidad, es que nos ayudemos entre todos, el que más gana, favoreciendo al que menos gana, y desde luego no es un favorecimiento 'gratuito'. El que más gana, lo hace por que las leyes lo permiten, porque las leyes son laxas en la forma y cantidad de conseguir riqueza, luego hay que colocar siempre los dos platillos en la balanza: el de lo que suma y el de lo que resta, y no solamente el que suma... Ahí, ese el el pozo donde acaba toda la hipocresía del 'todo para mi', del 'no quiero-queremos repartir los impuestos'... en ver solo la parte d elas leyes, donde puede enriquecerse de mil maneras a costa de los demás, pero donde se niegan en rotundo a ver donde PARTE de ello ,es devuelto a todos en forma de impuestos.

...es lo mismo de siempre, egoísmo pesetero (aunque la peseta, quede en la Historia ya como moneda aparacada, sigue procediendo de 'peso' y esto siempre estará en el presente.).