Alters

A buscar M!nas: Conceptos previos

Buenas otra vez!

Esta es la primera entrada con respecto a la programación. Con este punto daremos por finalizado el tema de construir el juego usando VB.net.

Creo que me voy a arriesgar y haré el punto de conceptos previos como una sola entrada...

  • Conceptos previos
    • Estructuración de código
    • "Multi-handler"
    • Controles dinámicos (en tiempo de ejecución)
Estructuración de código

A la hora de programar con orientación a sucesos u orientación a objetos, es muy común la segregación de código, es decir, "aislar" el código por zonas o por utilidades.

Yo soy partidario de estas separaciones, de manera que, en VB.net me gusta tener separado el código propio de las llamadas a eventos de la función del evento. Para ello uso módulos, que son archivos planos destinados a estas mismas funciones.

En dichos módulos se "apilan" las funciones, como (por ejemplo) se pueden "apilar" en un include de PHP.

El comportamiento de los módulos es sencillo: llamas a una función o sub, se ejecuta, y retorna el control. También se pueden comportar como objetos, si así lo deseamos. ¿Cómo? Simplemente creando, en vez de un módulo, una clase. El tipo de archivo es el mismo (*.vb), pero cambian los encabezados del archivo.

Realmente no veo mucha diferencia entre un objeto simple (sin herencia ni nada similar) con un módulo bien definido, por lo que generalmente (siempre que no tenga que usar herencia o cosas más típicas de objetos) uso siempre módulos con estructura de objetos, es decir:

Module mi_modulo
    private var1 as String
    private var2 as Integer
    public var3 as Object

    public sub setVar1(byVal str as String)
        var1 = str
    End Sub

    public function getVar1() as String
        return var1
    End Function
End Module

Parece un objeto en su definición, pero es un simple módulo. A efectos prácticos básicos nos sirve igual.

Otra división que suelo hacer es la siguiente: en un módulo incluyo todas las variables "globales" que va a usar el programa, y en otro todas las funciones "globales".

En el primer módulo hago todas las variables privadas, y les creo "getters" y "setters", tal como sería en una OOP. El segundo módulo tiene partes privadas y partes públicas, por el tema del encapsulamiento.

Para dejar el asunto como zanjado, en este proyecto usaré la jerarquía que muestra la imágen "img1"

img1
Adicionalmente, para que todo quede completo, debéis dirigiros al directorio de la aplicación (BuscaminaX/BuscaminaX/bin/debug/) y crear el directorio "BX_IMG". Ahí tenéis que subir 25 imágenes, a saber:

 - 12 imágenes para la primera opción (a)
 - 12 imágenes para la segunda opción (b)
 - 1 imágen para el fallo (c)

La nomenclatura que yo uso es:

(a) BX_0 hasta BX_11
(b) BX_12 hasta BX_23
(c) Fail

En el SplashScreen, como fondo va la imágen "Fail". Esto creará un link en el explorador de soluciones (img1), en la carpeta "bin > debug> BX_IMG > Fail".

Multi-handler

El tema de los multi-handler consiste en asociar más de un evento a un mismo sub. En JAVA, usando AWT sería como asignar varios controles a un Listener.

En VB.net podemos hacerlo de una manera sencilla. Para ver cómo se consigue lo haremos mediante un ejemplo:

Supongamos que tenemos el siguiente evento genérico:

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
    'Cosas que hacer
End Sub

Revisemos la sintaxis:


  • Private Sub: crea un Sub, con visibilidad privada
  • Button1_Click: nombre genérico para el sub. Éste se crea mediante la fórmula nombreObjeto_Evento
  • ByVal sender As System.Object: primer parámetro llamado "sender", pasado por valor, como un Objeto
  • ByVal e as System.EventArgs: segundo parámetro llamado "e", pasado por valor, como un objeto
  • Handles Button1.Click: ¡OJO!, aquí está el meollo del asunto. Esta cláusula "junta" el evento Click de Button1 con este sub.
Ahora imaginad que tenemos un Button2, y queremos que se incluya en este sub. Sería tan sencillo como añadir "Button2.Click" al final de este sub.

Podemos añadir cualquier evento a un mismo Handles, siempre separados por comas. Pero, ¿De qué puede servir?

Bien, imaginad 10 buttons, llamados b0  a b9, respectivamente. Podríamos poner los diez Buttons en el mismo handler, y hacer algo como:

Me.TextBox1.Text += sender.substring(1)

Y automáticamente se va el número al TextBox. El otro aspecto del multi-handler es el parámetro "e".

"e" es un parámetro al que podemos acceder para saber la acción que se ha realizado sobre el objeto "sender". Un ejemplo es (sacado del juego):

If e.Button = MouseButtons.Left Then

Esta línea sirve para saber si es un "click" derecho o izquierdo.

Con esto queda por concluido el tema de multi-handler

Controles dinámicos (en tiempo de ejecución)

Crear controles en tiempo de ejecución es un alivio para todas esas circunstancias en las que no sabemos qué tendremos que generar (como en nuestro juego, ya que los controles varían dependiendo de la dificultad).

Crear un control no es demasiado difícil. El tema está en saber tratarlo, adecuarlo e incrustarlo en el panel que toca.

 o = New Label()

 o.Top = t
 o.Left = l
 o.Height = h
 o.Width = w
 o.Name = "L" + i.ToString
 o.Visible = True
 o.BackColor = Color.Transparent
 o.Font = New Font("Times new Roman", 10, FontStyle.Regular, GraphicsUnit.Pixel)

Esta parte debería sonar de la entrada anterior... Comentemos:

La Label se crea en la primera línea, llamando a su constructor. Adicionalmente se le cambian atributos, como el nombre, el ancho, el largo...

Hay un par de sentencias que son prácticamente obligatorias, que son el Visible = True, el Top y el Left.

No obstante, con estas líneas no se agrega al contenedor. Para ello podemos usar algo como

MiForm.Controls.Add(Control)

o

MiForm.Controls.AddRange(Array(Control))

Con esto estamos añadiendo el control (o controles) al formulario especificado.

Y, con este último apartado ha concluido el tema de los conceptos previos.

En la próxima entrega programaremos y os dejaré un link de descarga.

Hasta la próxima!