domingo, 14 de enero de 2018

Muestra de programa en Java. Tres en raya.

 Este es un juego típico que todo el mundo acaba realizando cuando aprende a programar. Con él coges más fluidez con los arrays y pequeños algoritmos. Por ejemplo, aquí tienes que controlar cuando es el turno del jugador y el de la máquina. También hay que tener controlado cuando se llena el tablero, cuando gana el jugador y cuando la IA. Respecto a esta última, en el juego es muy básica (lo he hecho en un día) y sólo rellena las casillas vacías por orden, pero se podría hacer que buscara las casillas vacías en el tablero y, con un número al azar, llenar una de ellas. Si la queremos hacer más "malota", podemos hacer que busque las casillas libres alrededor de la última casilla que ha llenado el jugador. De esta forma, siempre intentará evitar que el jugador haga un tres en raya.



 En un futuro quiero desarrollar más la IA y hacer que se puedan seleccionar distintos tipos de fichas (estas se pueden cargar desde el disco duro o desde una URL). La idea sería un 3 en raya temático. Por ejemplo: podrían utilizarse banderas de diferentes países, escudos de equipos de fútbol, etc. Todo aquello donde haya cierta rivalidad y establecer un modo de dos jugadores (con opciones a burlas, etc. XD). Cuanto más "pique" haya más divertido será.

 Se me olvidaba, en esta ocasión he usado imágenes (sin fondo) que he encontrado por google y el programa sabe qué casilla llenar por la posición del puntero del ratón, pero podría haber usado JButton con un icono en su interior y que muestren un efecto de hundirse al presionarlos. Ciertamente, es más cómodo de esta manera al asignar cada botón a una posición del array y el efecto es bastante cuco.

jueves, 11 de enero de 2018

Muestra de programa en Java. Marcando diferencias entre el frontend y el backend.

Aquí os dejo una muestra de algo realizado con prisas en Java:


 Como se puede ver, parece una página web mostrando algunas películas. Esto vendría a ser el frontend. Lo bonito de la programación es que lo que ves es independiente de cómo se crea. La información que se carga en pantalla puede estar grabada en ficheros txt (formato ASCII), en formato binario o en bases de datos. Va muy bien ir probando todos estos caminos según se aprende a programar. Al principio lo guardas todo en ficheros txt y lo vas cargando según lo necesites. Luego, cada película es un objeto que almacena todos sus datos y, cuando aprendes a trabajar con bases de datos, no tienes más que cargar cada fila con la información necesaria. El resultado siempre será el mismo uses el método que uses: lo que estás viendo en pantalla (lógicamente, con más tiempo y ganas, podría salir algo mucho mejor). 
 Cuando uno empieza a programar siempre lo hace todo solo, pero cuando trabajas en proyectos de mayor magnitud el trabajo suele dividirse en grupos. Uno se ocupa del frontend (lo que percibe el usuario que interactúa con la aplicación) y otro del backend (todo el código que corre detrás del frontend y que es el que consigue que todo funcione como debe). Dado que el frontend suele ejecutarse en el lado del cliente suelen buscarse soluciones rápidas (html, css, etc). que muestren la información en pantalla tal y como el desarrollador desea. Por detrás tienes todo el código que maneja las peticiones del cliente que corre en el servidor y que puede estar realizado en C# (en el caso de ASP), Java, PHP, etc. En el lado cliente, por eso, también encontramos JavaScript.
 En resumen, que si te vas a meter en el mundo del desarrollo web tienes muchas tecnologías por aprender. Ya no sólo html, css y javascript, por ejemplo, sino también frameworks con los que trabajar (angular, node, etc.).

lunes, 8 de enero de 2018

Muestra de programa en C#. Matematicas de primaria.

Este programa lo empecé desarrollando para mi primica de 5 años (bueno, ahora ya tiene más) porque ese año (o al siguiente) empezaba a dar matemáticas. Dejo aquí algunas muestras.

Pantalla principal




En la pantalla principal podemos elegir el nivel de dificultad. Va bien para los dos primeros años en que empiezas a estudiar matemáticas. Como se puede ver, WPF (Windows presentation fundation) permite degradados y cosas muy cucas.

Pantalla de juego




La pantalla de juego depende del nivel de dificultad escogido. En esta captura se nota que es el más básico. El programa nos ofrece dos operandos y un operador (en este primer nivel suele ser suma y/o resta).

Rcompensas




Para que el jugador se anime, cada 5 aciertos, aparece una ventana de diálogo que le anima. Bueno, eso es al principio, según va acumulando aciertos el programa le anima a tomarse un descanso hasta que decide cerrarse XD


Muestra de programa en C#. La ciudad perdida.

 Hace un tiempo, cuando aprendía a programar en C#, me animé a empezar un juego que simulaba las partidas de juegos de rol (con lápiz y papel). Era para personas que no pueden meter mucha gente en su casa o para fines de semana lluviosos. Así cada uno puede jugar desde su casa (cerca de su nevera y con su propia comida XD).
 Dado que me es imposible desarrollar el engine y, a la vez, hacer de artista, decidí crear un juego para un jugador antes de ponerme con el multijugador y que pareciera una partida real (es decir, una donde se juega con lápiz y papel y las estancias se dibujan a mano).
 También incluí un editor de personajes (empecé con un guerrero, pero el plan era añadir un mago y un pícaro) y un editor de mapas. Dejo aquí unas pantallas de muestra.

Pantalla de presentación





Las imágenes chulas, como es de suponer, no son de cosecha propia. Ésta la saqué de google.
Antes de que se me olvide. De la misma forma que no disponía de tiempo para gráficos tampoco disponía de tiempo para la historia, así que recurrí a la cantidad ingente de juegos de rol que tengo desde hace décadas. Concretamente, "La ciudad perdida"es una aventura que acompañaba a la primera edición de Dungeons & Dragons (caja roja) hará unos 25 años (o algo más).

Editor de personajes



 El editor contiene las instrucciones, te permite tirar tres dados de 6 caras para cada habilidad y reiniciar todas las tiradas (por si no estás conforme) o grabar el resultado.

Editor de habitaciones




 El editor de habitaciones te permite poner la descripción principal, la secundaria por si se descubre algo con una tirada, el tipo y cantidad de enemigos y las salidas de la habitación. Aún está en desarrollo, pues me falta que se puedan decidir las dimensiones de cada piso de la mazmorra.

Pantalla de juego




 En la pantalla de juego vemos las estancias tal como las dibujaríamos a mano (me gustaría tener un grafista para dibujar las habitaciones como Arthas manda xD y poder sacar este juego para un jugador en smartphones y tablets). También vemos la descripción principal de la habitación (que cambia si hay una secundaria), los cursores para mover al personaje y sus características y unos botones para usar pociones, bajar escaleras, etc. 

 La idea original (la del multijugador) es que alguien cree el mapa y las estancia (ya sea a mano o con el editor) para el juego (lado servidor) y que los jugadores instalen el juego (lado cliente). Desde el servidor se les enviarían los ficheros según van avanzando. Se podría jugar con micrófono (vía programas externos como se ha hecho toda la vida) o podría crear un chat de texto en el juego (aunque lo primero es mucho más realista).

 Para probar el desarrollo del programa creé un modo de un jugador y por eso hay los cursores. Desde el lado servidor se controlarían todas las acciones de los jugadores (como moverse, beber pociones, etc) que serían aprobadas por el DM (o no, todo depende de la libertad que se quiera dar al jugador).

 Espero poder terminarlo algún día y que tenga mejor cara y ojos ^_^

P.D.: Por cierto, el juego lo desarrollé con Windows Forms (ya que empecé estudiando C# con la versión 2.0), pero me cambié a WPF para los siguiente proyectos (mucho mejor, donde vamos a parar XD).

P.D.2: Justo cuando aparqué el desarrollo del juego empezaba con el generador de enemigos. En cada habitación podían aparecer entre 1 y 3 enemigos (recordemos que, mientras lo desarrollaba, el juego era para un jugador).

Metodología de programación en Java. Capítulo 12. Métodos.

Métodos


Pendiente: explicar qué son argumentos y que son parámetros.

Creación


mod.de_acceso [2º mod.de_acceso] Tipo_de_dato_retornado NombreMetodo(parámetros){}
private static   void
public internal   int
protected                   string
                  double

Ejemplo:

public double Maximo(double x, double y, double z){}

No se puede hacer esto en la lista de parámetros:

public static void maximo(int x, y) {}    // Cada variable debe estar acompañada de su tipo.

Invocar o llamar a un método


double tarifa = CalcularTarifa();
double tarifa = CalcularTarifa(435.23);
double tarifa = CalcularTarifa(435.23, 5);
double tarifa = CalcularTarifa(laTarifaDiaria: 312.5); //argumentos con nombre.
double tarifa = CalcularTarifa(numDias: 5); //argumentos con nombre.

*Paso de información: cuando se invoca a un método se le puede pasar información por valor o por referencia. Por valor se copia la variable a una nueva y la original no cambia. Por referencia se pasa la dirección de memoria dónde se encuentra la variable y no se hace copia, con lo cual cambia el valor original.

Envío de argumentos por referencia


int y = 13;
Metodo(ref y);
static void Metodo(ref int a)
{
a = a + 3;
System.out.println(“\na= “ + a);
}

Sobrecarga de métodos


Es importante que las listas de parámetros sean diferentes. Ello se consigue según los tipos y el orden de estos. El valor de retorno se ignora.

public int Cuadrado(int valor, int...) {}
public double Cuadrado(double valor, double...) {}

-Creación:

private double CalcularTarifa() {} //Este método no contiene parámetros.
private double CalcularTarifa(double laTarifaDiaria) {}
private double CalcularTarifa(double laTarifaDiaria, int numDias = 1) {}

La llamada o invocación es igual.

Métodos establecer (setter) y métodos obtener (getter)


public String establecerNombreCurso(nombreCurso)
{
//Se puede utilizar para validar la información.
this.nombreCurso = nombreCurso;
}
public String obtenerNombreCurso()
{
//Se puede utilizar para presentar la información en el formato que interese.
return nombreCurso;
}

Devolver el control a la instrucción que llama al método


-Al terminar el bloque de instrucciones.
-Con return;
-Con return expresión;

Método .Parse de los tipos de datos: conversión de datos.


int number = Integer.parseInt(valor);
double number = Double.parseDouble(valor)

Metodología de programación en Java. Capítulo 11. Instrucciones de control.

Instrucciones de control


Instrucción de selección simple if


-if(condición) instrucción;
-if(condición){}
Ejemplo:
-if(calificación >= 60) { System.out.println(“Aprobado”); }


Instrucción de selección doble if…else


-If, if…else, if…else if…else // Instrucción de selección
-if(condición){}
 else{}
Ejemplo:
-if(calificación >= 60) { System.out.println (“Aprobado”); }
else { System.out.println (“Suspendido”); }

Instrucciones if…else anidadas


-if(condición){}
 else if(condición){}
 else if(condición){}
 else{}

Operador condicional


condición? elección1: elección2;
Ejemplos:
System.out.println ( (a>b) ? “A es mayor”: “B es mayor”) ;

Instrucción de selección switch 


switch(variable)
{
case variable1:
case variable2:
instrucción;
break;
case variable3:
instrucción;
break;
default:
break;:
}
Condiciones:
-No pueden repetirse dos case.
-Si dos case hacen lo mismo se pueden poner seguidos (tal y como se ve en el ejemplo).
-La instrucción default es lo que sucede si no coincide ningún case con la variable.
-Todo case con instrucciones debe contener un break (u otra instrucción de salida a menos que se quiera poner uno seguido de otro por que hacen lo mismo). default siempre incluye un break.
-Se pueden usar String en la variable y en los case.

Instrucción de repetición while


-while // Instrucción de repetición. Dicha repetición puede estar controlada por un contador o un centinela.
while(contador <= 10)
{
Contador++;
}
Ejemplo:
while(centinela != -1)
{

System.out.println (“Introduzca -1 para terminar: “);
Int respuesta = Integer.parseInt(entrada.nextInt());
}

Instrucción de repetición do… while


-do…while // Instrucción de repetición. Dicha repetición puede estar controlada por un contador o un centinela. Siempre se ejecuta, al menos, una vez.
do
{
Instrucciones;
}while(condición);
Ejemplo:
do
{
System.out.printf (“%d”, contador);
Contador++;
}while(contador < 10);
Instrucción de repetición for

Instrucción de reptición for


for( [tipo_de_dato] nombreVariable = valor; condición; incremento / decremento ){}
Ejemplo:
for( int anio = 1; anio <= 10; anio++)
{
//fórmula de cálculo.
System.out.println(“{0,4} {1,20:c}”, anio, monto);
//Esto es una cadena de texto con un formato especial.
}
IMPORTANTE: en el bucle for puede faltar alguna de las tres partes y, aún y así, funcionar sin problemas. También podemos encontrarnos con incrementos / decrementos de 2, 3, etc. o expresiones. También podemos encontrarnos con más de un increment / decremento en la variable de control.

Instrucciones break, continue, return


Instrucciones para manipular el flujo del bucle:

break: ocasiona la salida inmediata de la instrucción de repetición.
continue: omite las instrucciones estantes y salta al final del bucle para empezar la siguiente iteración.
return: devuelve el control al método anterior que lo tenía. Se usa para salir del programa en main.

Instrucción for mejorada


Es como el for, pero para arrays y demás colecciones.

for (TipoBase variable: ArrayDeTiposBase) {..}

Ejemplo:

//Creamos una lista de tipo String.
List<String> list = new ArrayList<String>();

// Añadimos elementos a la lista.
list.add("Victor");
list.add("Amaya");
list.add("Julio");

//Imprimimos cada elemento con un bucle foreach.
for (String nombre: list)
{
  System.out.println(nombre);
}

Metodología de programación en Java. Capítulo 10. Modificadores de acceso.

Modificadores de acceso


Modificadores de acceso: PUBLIC, PRIVATE, PROTECTED, DEFAULT


 Los modificadores de acceso indican el nivel de accesibilidad que tendrá un miembro o un tipo desde otros miembros que lo referencien. Existen cuatro modificadores de acceso en Java.
-public: indica que se puede acceder a él desde cualquier punto.
-protected: permite acceder a los miembros protected de una clase base a través de los miembros de esa clase base y de los miembros de sus clases derivadas. Se puede combinar con internal.
-private: indica que sólo pueden acceder a él integrantes de la misma clase. Es el modificador por defecto si no se especifica uno.
-default: Java nos da la opción de no usar un modificador de acceso y al no hacerlo, el elemento tendrá un acceso conocido como default o acceso por defecto que permite que tanto la propia clase como las clases del mismo paquete accedan a dichos componentes (de aquí la importancia de declararle siempre un paquete a nuestras clases).

Modificadores de clases y métodos: STATIC, FINAL, ABSTRACT


-final (constante): declara un campo al que sólo se le puede asignar un valor como parte de la declaración o en un constructor de la misma clase.
-final (método): no puede ser redefinido por una subclase.
-final (class): una clase final es una clase que no puede ser extendida, es decir ninguna otra clase puede ser hija de ésta, será entonces una clase única y que no tendrá herencia o herederos al no poder ser extendida.
-abstract: indica que la clase sólo se usará para ser la base de otras clases.
-static: declara un miembro (método o campo) que pertenece a la clase y no a una instancia de ésta. 
-static (variable de instancia): Si se aplica a una variable de instancia esta conserva y comparte el mismo valor en todas las instancias de la clase.
-static (método): Si se aplica a un método este es accesible sin instanciar la clase. 

Modificadores de acceso para clases


Cuando creamos una clase podemos usar los siguientes modificadores de acceso:
-public: cualquiera puede acceder a ella (instanciarse, heredarse, etc).
-default (ninguno): sólo pueden acceder a ella desde el mismo package.

Modificadores para herencia (se pueden combinar con los anteriores)


-final: la clase no puede ser heredada (no puede tener subclases). Se puede combinar con public.
-abstract: la clase no puede ser instanciada. Se puede combinar con public.

La clase no puede ser private ya que no podría accederse a ella.
Una clase no puede ser abstract y final al mismo tiempo.

Modificadores de acceso para variables de instancia


-public: se puede acceder desde cualquier otra parte del programa.
-protected: sólo puede accederse desde el mismo package u otras subclases.
-default (ninguno): sólo puede accederse desde el mismo package.
-private: sólo puede accederse desde la misma clase. En el caso de la herencia se puede acceder a una variable de instancia a través de sus métodos (setters, getters) públicos.

Modificadores para herencia (se pueden combinar con public, protected, default y private)


-final: convierte la variable en una constante. Se puede iniciar cuando se declara o desde el constructor.
-abstract: se utiliza para indicar que la clase no se puede instanciar y sólo será heredada.

Otros modificadores (se pueden combinar con public, protected, default y private)


-static: la variable pasa a tener ámbito de clase (y no de objeto o instancia). Una variable static es única para todas las instancias de ese objeto y su valor se comparte. 

Una variable no puede ser abstract por que para tener esa variable habría que instanciar el objeto.

Modificadores de acceso para métodos


-public: se puede acceder desde cualquier otra parte del programa.
-protected: sólo puede accederse desde el mismo package u otras subclases.
-default (ninguno): sólo puede accederse desde el mismo package.
-private: sólo puede accederse desde la misma clase.

Modificadores para herencia (se pueden combinar con public, protected, default y private):


-final: hace que el método no pueda sobreescribirse en una subclase.
-abstract: se utiliza para indicar que el método no será implementado y será heredado en una subclase (donde deberá ser implementado o la subclase deberá ser, también, abstracta). Si una clase contiene un método abstracto debe ser abstracta.

Otros modificadores (se pueden combinar con public, protected, default y private):


-static: el método puede ser llamado sin instanciar la clase. Un método static sólo puede acceder a variables y métodos static.

Modificadores de acceso para variables locales


-final: convierte la variable en una constante. Si creamos una constante que referencie a un objeto lo que es final es la constante, es decir, que no podemos asignarle otra referencia. El objeto en sí puede cambiar.

No pueden aplicarse los modificadores de acceso a las variables locales. No encontraremos ningún caso en el que un modificador de acceso sea aplicado a una variable local. Cualquier variable local declarada con un modificador de acceso no compilará. Solo hay un modificador que puede ser aplicado a las variables locales, y es final.

Modificadores de acceso para interfaces


 Una interfaz es un tipo de dato abstracto, similar a una clase, que define una lista de métodos public abstract que cualquier clase que implemente a la interfaz debe implementar. Una interfaz también puede incluir constantes public static final, métodos default y métodos static.

 El compilador automáticamente añade public a todos los métodos de la interfaz y abstract  a todos los métodos no-static y no-default. 

Si una interfaz sólo tiene un método public abstract es una interfaz funcional (puede tener uno o más métodos default).

 Una interfaz puede implementar métodos siempre y cuando incluya el modificador default.

Mecanismos de sincronización: VOLATILE y SYNCRHONIZED.


-volatile: indica que un campo puede ser modificado en el programa por el S.O., el hardware o un hilo concurrente en ejecución.
-synchronized: En caso de que necesitemos atomicidad podemos recurrir a synchronized o a cosas más avanzadas, como las clases del API java.util.concurrent de Java 5. synchronized se diferencia de volatile entre otras cosas en que este modificador se utiliza sobre bloques de código y métodos, y no sobre variables. Al utilizar synchronized sobre un bloque se añade entre paréntesis una referencia a un objeto que utilizaremos a modo de lock.

Ejemplos con métodos:
public static void main(string[] args){}
private int sumar(int, int){}
internal double dividir(double, double){}
protected internal void NombreMetodo(){}

Ejemplos con campos:
final tipo variable = valor;
private final tipo variable = valor; // Variable de sólo lectura. Constructor.

Metodología de programación en Java. Capítulo 9. Constantes.

Constantes


Una variable de instancia de sólo lectura debe inicializarse en su declaración o en un constructor. Una vez inicializada no se puede cambiar su valor.

mod. acceso [static] final tipo NOMBRECONSTANTE = valor; 

//static si están fuera de main en la clase principal (la que contiene el método main).

Dentro del método main no puede llevar public ni static. 

final int edad = 15;
final String nombre = "John";

Como variables de instancia sí pueden.

Ejemplos:

public static final int DIAS_SEMANAS = 7;
public static final int DIAS_LABORABLES = 5;



Metodología de programación en Java. Capítulo 8. Variables.

Variables


Uso de los diferentes tipos de variables:

-char: (acepta, ambién, unsigned char y signed char)

char nombreVariable = ‘\0’; // Cero
char nombreVariable = char(32); // Espacio en blanco.
char[] carrera = new char[71]; //array unidimensional de tipo char.
carrera[1] = ‘T’;
carrera[2] = ‘L’;

-String:

String nombreVariable = “ ”;
String nombreVariable = null;
String saludo = “Hola”;
Sstring[] nombreArray = new string[10];
nombreArray[0] = “Hola”;
nombreArray [1] = “Adios”;

*También se pueden almacenar cadenas con un formato personalizado.

-byte, short, int, long (ordenados por tamaño):

byte variable = 0;
short variable = 0;
int variable = 0;
long variable = 0;

Se pueden declarar variables del mismo tipo de esta forma: int x = 0, y; tanto en local como variables de instancia.

-boolean:

boolean variable = true;
boolean variable = false;

-float, double, decimal (valores decimals):

Para literales del tipo float hay que añadir la letra f o F detrás del número.

float variable = 0.5f;
double variable = 2235.27;
long double variable = 0.0;

Situación de la variable


-Una variable dentro de un método es una variable local. Cuando termina el método se pierde su valor. No se inicializan por defecto.

-Una variable declarada dentro de una clase, pero fuera de cualquier método, se conoce como variable de instancia o campo. Se inicializan por defecto.

-Variables boolean:

boolean queEs = (mayor > menor); // Si mayor es más grande que menor la variable queEs vale true, sino vale false.

Campos


Las variables de instancia y las variables estáticas son lo que se conocen como campos.