Small Basic versión 0.7

Los amantes del basic o los que simplemente les agradan los lenguajes variopintos y bizarros como a mi, estais de enhorabuena, pues ya ha salido la versión 0.7 de Small Basic, y lo más importante, han corregido ya el fallo que ocurría al pulsar ], que en vez de dejarnos escribir aumentaba el tamaño del texto. Eso sí, parece ser que ahora ya no funciona lo de aumentar el texto, así que tened cuidado de disminuir el tamaño de la fuente. La librería del lenguaje no parece haber sufrido grandes cambios así por encima, alguna función nueva han añadido y tal. Y la principal novedad es que ahora permite exportar los programas hechos en Small Basic a Visual Basic.Net, lo cual a alguno le podría parecer algo bastante interesante, aunque yo no soy muy amigo de VB por lo general. Así que disfrutad ahora que por fin se puede programar con arrays de forma cómoda desde el editor del IDE, jej ^_^

Small Basic versión 0.6

Pues acabo más o menos de volver a la civilización y me acabo de enterar que ha salido una nueva versión de Small Basic, la versión 0.6. Por desgracia, por lo que veo en los comentarios, todavía está el error al pulsar el ], pero bueno a ver si lo arreglan para la próxima versión. Básicamente se han añadido unas pocas nuevas operaciones, arreglado fallos, dado soporte al idioma alemán y actualizado el manual para el tema de los arrays. Por cierto, el manual ya está en castellano desde la versión anterior, así que no hará falta que me ponga a hacer artículos sobre las librerías de la nueva versión, o eso espero, jej.

Documentación de la API de Small Basic

Bueno, por fin está en castellano y accesible desde la página oficial, la documentación en castellano de la API del lenguaje. Así que ante cualquier duda acudid a la referencia oficial, en vez de a mis comentarios anteriores, aunque en los mios vienen ejemplos de como se usan las cosas. En fin, para futuras versiones que añadan cosas, simplemente me limitaré a poner ejemplos para ilustrar a los entusiastas de la programación en Small Basic.

Los arrays en Small Basic 0.5

Buenas amigos del Small Basic. La semana pasada salió la versión 0.5 del lenguaje y traía un gran cambio en su interior, que habían cambiado el manejo de los arrays, para hacerlo más similar a lenguajes como C. El autor ha creado un artículo sobre como manejar los arrays en esta nueva versión.

El caso es que la llegada de esta nueva forma de hacer las cosas ha implicado cambios en dos operaciones de la librería File, GetDirectories y GetFiles que ahora solo reciben un parámetro, la ruta de la que queremos el listado de directorios o ficheros. El caso es que antes teníamos que indicarle el nombre del array donde se tenían que almacenar, pero ahora las dos operaciones devuelven si tienen éxito un array con los datos directamente.

Esto implica que la librería Array ha tenido también que cambiar. Primero tenemos que las operaciones GetValue, RemoveValue y SetValue han dejado de ser útiles y es recomendable no utilizarlas, tan solo se han mantenido por temas de retrocompatibilidad con programas que fueran desarrollados con la versión 0.4. Aunque dicha retrocompatibilidad no es total, ya que las operaciones ContainsIndex, ContainsValue y GetItemCount no reciben ya una cadena con el nombre del array, sino una variable con el array entero.

Y esos son los cambios de la API de Small Basic en esta nueva versión. Lo único realmente malo del programa es que no se puede escribir ] sin que capture el evento de control+ que incrementa el tamaño del texto. Pero espero que lo corrijan en un futuro, de momento siempre queda el recurso de pulsar Alt+093 en el teclado numérico o usar otro editor para utilizar arrays ^_^U

Small Basic 0.5

Muy buenas noticias para todo el mundo interesado en Small Basic, ha salido oficialmente la versión 0.5 hoy mismo, aunque ayer salió un artículo sobre las novedades principales de esta versión. Además la cosa no se queda ahí, han dado soporte al español y también han traducido la documentación a nuestro querido lenguaje. Así que ahora podreis disfrutar todavía más, jej.

La principal novedad de esta versión es que por fin podemos manejar arrays de forma más natural, como en otros lenguajes. También se nos avisará si estamos intentando utilizar una variable que no ha sido inicializada, para evitarnos dolores de cabeza innecesarios. En cuanto a las librerías, creo que no ha cambiado nada, por lo que sigue siendo retrocompatible, lo cual está muy bien. Así que en cuanto termine los examenes esta semana, me pondré a ver que tal va el cacharro.

PD.: Si al bajar la nueva versión os está bajando la 0.4, tendreis que limpiar la caché para poder hacerlo.

PD2.: Sí que hay algunos cambios en las librerías en lo referente a los arrays, así que la próxima semana comentaré qué ha cambiado. Y de paso actualizaré las entradas antiguas a medida que pueda.

PD3.: Por cierto que hay un pequeño problema con el IDE y es que puedes aumentar el tamaño del texto o reducirlo con control+ o control-, pero claro para poder escribir ] tienes que pulsar AltGr+ y eso envía la señal de que se está pulsando contro alt +, luego lo toma como que quieres aumentar el texto.

Extendiendo Small Basic en C#

Bueno y he aquí uno de los puntos más interesantes de Small Basic al pertenecer al .NET Framework, que podemos extender la API con nuevas funcionalidades desde otros lenguajes de la misma plataforma. Para el artículo he elegido C#, que es el que a mi más me gusta de todo .NET, ya que no tiene una sintaxis abigarrada como Visual Basic, por ejemplo.

Así que poniéndonos manos a la obra, lo primero es tener el Visual Studio 2008 o el Visual C# 2008 Express, cualquiera de los dos nos valdrá. Es posible que también funcione con las versiones del 2005, pero ya que Small Basic utiliza el .net framework 3.5, lo suyo sería utilizar como mínimo el Visual C# 2008 Express, que además es gratuito y no cuesta demasiado bajárselo uno mismo. Así que abrimos el Visual C# y seguimos los siguientes pasos:

1. Creamos un nuevo proyecto de tipo “Biblioteca de clases“.
2. Añadimos como referencia el fichero “SmallBasicLibrary.dll” que se encuentra dentro de la carpeta de Small Basic.
3. Creamos una nueva clase estática:
   [SmallBasicType]
   public static class MiExtension { /* … */ }
4. Añadimos con using en el código la librería: Microsoft.SmallBasic.Library
5. Configuramos las propiedades del proyecto para generar la documentación en XML: Propiedades -> Generar -> Archivo de documentación XML.
6. Generamos la solución entera y copiamos la dll y el xml generados en la carpeta release de nuestro proyecto, a la carpeta lib del directorio de Small Basic (“C:\Archivos de programa\Microsoft\Small Basic\lib”). Hay que tener en cuenta que por defecto no existe la carpeta lib, por lo que hay que crearla de forma manual.

Y con estos pasos ya podemos empezar a trabajar para crear una extensión. Pero hay que tener en cuenta algunas cosas como que no está soportada la sobrecarga de funciones, por lo que no podemos tener dos funciones con el mismo nombre aunque reciban distintos parámetros. Todas las variables responden al tipo Primitive de la API interna del lenguaje, por lo que no podemos trabajar directamente con tipos de datos como int o string. Sabiendo esto aquí tenemos un esquema básico de como sería una extensión y sus tres diferentes tipos de elementos:

using Microsoft.SmallBasic.Library;
namespace MisExtensiones {
  [SmallBasicType]
  public static class MiExtension {
    // Para definir variables:
    public static Primitive Propiedad=new Primitive();

    // Para definir métodos:
    public static void Metodo1() {
      // Código del método...
    }
    public static void Metodo2(Primitive param) {
      // Código del método...
    }
    public static Primitive Metodo3() {
      // Código del método...
    }
    public static Primitive Metodo4(Primitive param) {
      // Código del método...
    }

    // Para definir manejadores de eventos:
    public static event SmallBasicCallback Evento=null;
  }
}

De esta forma al generar la dll del proyecto y añadirla al directorio de librerías de Small Basic, tendremos una nueva librería llamada MiExtension, con en este caso una propiedad, un manejador de eventos y cuatro funciones. Las posibilidades de esto son por decirlo de algún modo infinitas. Podemos añadir todo lo que queramos al lenguaje, teniendo en cuenta que no podemos repetir identificadores ya que ello confundiría a Small Basic. Por cierto que en este caso para la variable no hemos usado una propiedad de C#, pero podríamos haberla usado perfectamente y con ello podríamos limitar su escritura para hacerla solo de lectura, ya que hay cosas que no tiene sentido que el usuario las cambie de valor.

Con esto ya está de momento cubierto el lenguaje y la mayoría de sus puntos, por lo que a partir de aquí, hasta que salga una nueva versión de Small Basic, me pondré a hacer alguna que otra extensión y/o juego que colgaré en esta web cuando lo tenga listo y terminado. Aunque de momento hasta que termine junio, estaré con los exámenes para terminar la carrera y ello me va a tener bastante liado, por lo que seguramente no haya mucho movimiento por aquí hasta la última semana de junio. Así que a estudiar, jej.

Pintando con la tortuga en Small Basic

Por último para terminar con el modo ventana tenemos la librería Turtle, que sirve para pintar rectas como si estuviéramos usando un lápiz sobre un papel. Es una forma sencilla para pintar cosas, que se utilizó bastante hace unas cuantas décadas. Sus atributos y operaciones son:

• Angle: Permite obtener y cambiar el ángulo actual de la tortuga, los cambios son aplicados al instante. El ángulo se indica en grados donde el Norte es 0º, el Este 90º, el Sur 180º y el Oeste son 270º.
• Speed: Permite obtener y cambiar la velocidad de movimiento. Esta va de 1 a 10, donde 10 es el valor más rápido porque realiza las operaciones de forma instantánea.
• X: Permite obtener y cambiar la coordenada X de la tortuga de forma instantánea.
• Y: Permite obtener y cambiar la coordenada Y de la tortuga de forma instantánea.
• Show(): Muestra la tortuga en la ventana.
• Hide(): Oculta la tortuga en la ventana.
• PenDown(): Baja el lápiz de la tortuga para que cuando esta se mueva se vaya pintando en pantalla.
• PenUp(): Sube el lápiz de la tortuga para evitar que al moverse se vaya pintando en pantalla.
• Move(distancia): Mueve la tortuga una distancia especificada. Si el lápiz está bajado se dibujará una línea al moverse.
• MoveTo(x, y): Mueve la tortuga un punto especificado. Si el lápiz está bajado se dibujará una línea al moverse.
• Turn(ángulo): Gira la tortuga en base al ángulo en grados especificado. Si el ángulo es positivo gira a la derecha y si es negativo a la izquierda.
• TurnLeft(): Gira la tortuga 90º a la izquierda.
• TurnRight(): Gira la tortuga 90º a la derecha.

Y tras ver las operaciones y atributos de la librería Turtle, aquí tenéis un bonito programa de ejemplo donde se pintan unas cuantas formas usando esta librería, entre ellas un bonito círculo:

'----------------------------------------------------
' Prueba con turtle
'----------------------------------------------------
GraphicsWindow.Title = "Prueba con turtle"
GraphicsWindow.BackgroundColor = "White"
GraphicsWindow.PenColor = "SteelBlue"
GraphicsWindow.KeyDown = OnKeyDown
'----------------------------------------------------
Sub OnKeyDown
  If GraphicsWindow.LastKey = "S" Then
    Turtle.Show()
  ElseIf GraphicsWindow.LastKey = "H" Then
    Turtle.Hide()
  ElseIf GraphicsWindow.LastKey = "C" Then
    GraphicsWindow.Clear()
  ElseIf GraphicsWindow.LastKey = "Escape" Then
    Program.End()
  ElseIf GraphicsWindow.LastKey = "D1" Then
    Paint1()
  ElseIf GraphicsWindow.LastKey = "D2" Then
    Paint2()
  ElseIf GraphicsWindow.LastKey = "D3" Then
    Paint3()
  ElseIf GraphicsWindow.LastKey = "D4" Then
    lines = 6
    PaintCircle()
  ElseIf GraphicsWindow.LastKey = "D5" Then
    lines = 8
    PaintCircle()
  ElseIf GraphicsWindow.LastKey = "D6" Then
    lines = 16
    PaintCircle()
  ElseIf GraphicsWindow.LastKey = "D7" Then
    lines = 32
    PaintCircle()
  ElseIf GraphicsWindow.LastKey = "D8" Then
    lines = 64
    PaintCircle()
  ElseIf GraphicsWindow.LastKey = "D9" Then
    lines = 128
    PaintCircle()
  ElseIf GraphicsWindow.LastKey = "D0" Then
    lines = 256
    PaintCircle()
  EndIf
EndSub
'----------------------------------------------------
Sub Paint1
  GraphicsWindow.Clear()
  Turtle.X = GraphicsWindow.Width / 2
  Turtle.Y = GraphicsWindow.Height / 2
  Turtle.Speed = 8
  Turtle.Angle = 0
  Turtle.PenDown()
  For i = 1 To 21
    Turtle.Move(10 * i)
    Turtle.TurnRight()
  EndFor
  Turtle.PenUp()
EndSub
'----------------------------------------------------
Sub Paint2
  GraphicsWindow.Clear()
  Turtle.X = 100
  Turtle.Y = 100
  Turtle.Speed = 8
  Turtle.Angle = 180
  paint = "True"
  w = GraphicsWindow.Width - 200
  h = GraphicsWindow.Height - 200
  distance = 10

  lines = h / distance
  PaintStepLine()
  Turtle.TurnLeft()

  lines = w / distance
  PaintStepLine()
  Turtle.TurnLeft()

  lines = h / distance
  PaintStepLine()
  Turtle.TurnLeft()

  lines = w / distance
  PaintStepLine()
  Turtle.TurnLeft()
EndSub
'----------------------------------------------------
Sub PaintStepLine
  For i = 1 To lines
    If paint Then
      Turtle.PenDown()
      paint = "False"
    Else
      Turtle.PenUp()
      paint = "True"
    EndIf
    Turtle.Move(distance)
  EndFor
EndSub
'----------------------------------------------------
Sub Paint3
  GraphicsWindow.Clear()
  Turtle.X = GraphicsWindow.Width / 2
  Turtle.Y = GraphicsWindow.Height / 2
  Turtle.Speed = 8
  Turtle.Angle = 0
  Turtle.PenDown()
  For i = 1 To 21
    Turtle.Move(10 * i)
    Turtle.Turn(45)
  EndFor
  Turtle.PenUp()
EndSub
'----------------------------------------------------
Sub PaintCircle
  GraphicsWindow.Clear()
  cx = GraphicsWindow.Width / 2
  cy = GraphicsWindow.Height / 2
  radius = cy * 0.8

  Turtle.X = cx - radius
  Turtle.Y = cy
  Turtle.Speed = 8
  Turtle.Angle = 0
  Turtle.PenDown()

  angle = Math.Pi * 2 / lines
  For i = 1 To lines
    x = cx - Math.Cos(angle * i) * radius
    y = cy - Math.Sin(angle * i) * radius
    Turtle.MoveTo(x, y)
  EndFor
  Turtle.PenUp()
EndSub

Y con esto damos por terminada la API de Small Basic. Aunque lo cierto es que hay más librerías como comenté en la introducción a la API, pero francamente no son especialmente útiles y en caso de tener curiosidad sobre ellas siempre queda la ayuda en línea del IDE para solventar la mayoría de las dudas, eso y la experimentación claro. ¿Quiere decir todo esto que ya se han acabado los artículos sobre Small Basic? Pues la verdad es que no, ya que todavía me queda una cosa muy importante que comentar (como extender la API desde C#) y seguramente haga algún juego que otro con este lenguaje, por lo que seguiré escribiendo más artículos sobre Small Basic. Así que mientras tanto seguid practicando y ánimo.

El ratón y Small Basic

Como hemos visto en la librería GraphicsWindow tenemos unas propiedades para saber donde está el ratón en base a las coordenadas de la ventana, pero tan solo eso, no sabemos si hemos pulsado un botón, ni tenemos la opción de poder ocultar el cursor para utilizar nosotros otro en la aplicación con alguna imagen, ¿verdad? Pues por eso existe la librería Mouse en Small Basic, que nos pone a nuestro alcance nuevas propiedades y operaciones para darle un mejor uso en nuestros programas:

• IsLeftButtonDown: Permite obtener si el botón izquierdo del ratón está pulsado (“True”) o no (“False”).
• IsRightButtonDown: Permite obtener si el botón derecho del ratón está pulsado (“True”) o no (“False”).
• MouseX: Permite obtener y cambiar la posición global del ratón en la coordenada X. No es lo mismo que la posición local que GraphicsWindow.MouseX nos da.
• MouseY: Permite obtener y cambiar la posición global del ratón en la coordenada Y. No es lo mismo que la posición local que GraphicsWindow.MouseY nos da.
• HideCursor(): Esconde el cursor del ratón.
• ShowCursor(): Muestra el cursor del ratón.

Y aquí tenemos un ejemplo donde utilizaremos el ratón para mover un cuadrado por la ventana, haciendo click sobre este ítem cuando lo queramos arrastrar:

'----------------------------------------------------
' Prueba con el ratón
'----------------------------------------------------
GraphicsWindow.Title = "Prueba con el ratón"
GraphicsWindow.BackgroundColor = "White"
'----------------------------------------------------
isMovingBox = "False"
size = 42
sep = size / 2
'----------------------------------------------------
x = GraphicsWindow.Width / 2 - sep
y = GraphicsWindow.Height / 2 - sep
GraphicsWindow.PenColor = "Black"
GraphicsWindow.BrushColor = "SteelBlue"
square = Shapes.AddRectangle(42, 42)
Shapes.Move(square, x, y)
'----------------------------------------------------
GraphicsWindow.KeyDown = OnKeyDown
GraphicsWindow.MouseMove = OnMouseMove
GraphicsWindow.MouseDown = OnMouseDown
GraphicsWindow.MouseUp = OnMouseUp
'----------------------------------------------------
Sub OnKeyDown
  If GraphicsWindow.LastKey = "S" Then
    Mouse.ShowCursor()
  ElseIf GraphicsWindow.LastKey = "H" Then
    Mouse.HideCursor()
  ElseIf GraphicsWindow.LastKey = "Up" Then
    Mouse.MouseY = Mouse.MouseY - 10
  ElseIf GraphicsWindow.LastKey = "Down" Then
    Mouse.MouseY = Mouse.MouseY + 10
  ElseIf GraphicsWindow.LastKey = "Left" Then
    Mouse.MouseX = Mouse.MouseX - 10
  ElseIf GraphicsWindow.LastKey = "Right" Then
    Mouse.MouseX = Mouse.MouseX + 10
  EndIf
EndSub
'----------------------------------------------------
Sub OnMouseMove
  If isMovingBox Then
    x = GraphicsWindow.MouseX - distx
    y = GraphicsWindow.MouseY - disty
    Shapes.Move(square, x, y)
  EndIf
EndSub
'----------------------------------------------------
Sub OnMouseDown
  If Mouse.IsLeftButtonDown Then
    ActivateMove()
  ElseIf Mouse.IsRightButtonDown Then
    endl = Text.GetCharacter(13)
    endl = endl + Text.GetCharacter(10)
    aux = "Global mouse coords"+endl
    aux = aux+"X = "+Mouse.MouseX+endl
    aux = aux+"Y = "+Mouse.MouseY+endl
    aux = aux+"Local mouse coords" + endl
    aux = aux+"X = "+GraphicsWindow.MouseX+endl
    aux = aux+"Y = "+GraphicsWindow.MouseY
    GraphicsWindow.ShowMessage(aux, "Mouse Info")
  EndIf
EndSub
'----------------------------------------------------
Sub ActivateMove
  x1 = Shapes.GetLeft(square)
  y1 = Shapes.GetTop(square)
  x2 = x1 + size
  y2 = y1 + size
  mx = GraphicsWindow.MouseX
  my = GraphicsWindow.MouseY
  If x1<=mx And mx<=x2 And y1<=my And my<=y2 Then
    distx = mx - x1
    disty = my - y1
    isMovingBox = "True"
  EndIf
EndSub
'----------------------------------------------------
Sub OnMouseUp
  isMovingBox = "False"
EndSub