Sony y la distribución digital

El otro día me quejaba de la nueva política que las distribuidoras de juegos para consolas pretenden llevar acabo, frente al infame desnivel producido por el cambio de libra a euro. Bien, el caso es que me picó la curiosidad de ver cuanto era el ahorro que el usuario obtendría por comprar juegos de PSP en la PlayStation Store, ya que comenté el “increíble” ahorro de comprar juegos de PC en steam, por ejemplo.

Pues cual ha sido mi sorpresa hace 10 minutos, cuando entro en el portal de venta de Sony y miro a ver cuanto vale el LocoRoco 2 o el Patapon 2. ¿Qué fue lo que me encontré? Que ambos valían 29,99€. ¿Cuál es el problema? Que mismamente vas a mirar el precio en la página web de Game o el Fnac y el P.V.P. para ambos juegos es de 29,95€. Sí señores, sale más barato ir a comprarlo a la tienda que de forma digital (4 miserables céntimos más barato, pero más barato a fin de cuentas). Ni que decir tiene, que si miras en play.com la diferencia es más abrumadora, ya que el LocoRoco 2 está a 23,45€ actualmente.

Así que yo me pregunto, ¿en qué narices está pensando Sony a la hora de distribuir juegos de forma digital? ¿En que quizás los jugadores son retrasados mentales y prefieren pagar tanto o más que si fueran a ir a comprarlo a una tienda normal y corriente? De verdad que si lo del cambio de 1$ a 1€ del Steam es para darle un “premio” al que se le ocurrió, no sabría yo decir qué es lo que esto se merece, porque estamos ante la mayor de las aberraciones cósmicas que he visto en mucho tiempo.

En fin, que menudo dominio empresarial y seguro que luego se quejarán de que no venden juegos para la PSP, menudos linces están hechos estos de Sony en Europa… ¬_¬’

Los “infamous” compradores de juegos…

Ayer salió esta noticia en meristation y como toda buena prensa, sobre todo una que depende más de las empresas de las que habla que de sus seguidores, ha comentado el hecho dándole importancia a algo que no la tiene. Que un juego no tenga el doblaje en inglés puede ser jodido para otros países en europa, pero aquí en España dudo que la mayoría le importe un pimiento. Además hoy Sony ha dicho que se podrá bajar un parche para añadir el doblaje en inglés, con lo que asunto resuelto según meristation, ¿eh?

No, yo creo que no está resuelto y flaco favor le hacen a la verdad intentando desviar desde la prensa la auténtica razón de este hecho. No hace falta ser muy avispado para ver por qué ha ocurrido que la versión que se vende en UK solo esté en inglés principalmente, tan solo hay que pasarse en el caso de España por la página de Game y luego en la de Play.com, para ver la diferencia de precios entre España (69,95€) y UK (51,99€). Siendo además curioso que aquí en España que van a sacar una edición especial, vale lo mismo que la edición normal, algo que no consigo comprender todavía. Las matemáticas son bastante claras y el ahorro es de nada menos que 17,96€, unas casi 3.000 antiguas y añoradas pesetas. El comprador se da cuenta de ello y ahora también se ha dado cuenta las empresas distribuidoras de videojuegos.

Así que la solución está clara, hacer versiones específicas para los países con diferencias abrumadoras de precios para evitar que esos aprovechados paguen menos, que menudos caraduras, oiga. Porque está clara desde la inepta mente burocrática de un empresario, que si los compradores no pueden comprarlo por 52€ en UK, sin duda pasarán por caja religiosamente para soltar 70€, que cierto que si eres socio de game o del fnac, se te queda en quizás 63€. Si es que son todo quejas sobre España, primero que si no paramos de piratear, ahora que la gente compra más, que somos unos pícaros por comprarlo en UK más barato. Sí, somos unos sinvergüenzas, se nos debería caer la cara de la vergüenza… aunque espera un momento, ¿como es que en Inglaterra con unos sueldos mucho mayores que los nuestros, tienen los juegos más baratos? Hasta el punto de que me acabo de comprar el Little Big Planet por 13 euros, cuando aquí hasta hace “2 días” estaba a 70 y tan panchos. Ciertamente aquí algo huele muy mal, pero los malos siempre somos los infames usuarios.

Así que será mejor aprovechar a comprar todos los juegos que queden sin ser exclusivamente en inglés y mientras la libra lo permita. Porque mucho me temo que en un año todos los juegos importantes van a cercenarlos para evitar la picaresca europea (que no es solo España la única que se dedica a comprar en UK). ¿Y qué se hará en España? Pues de primeras un buen conjunto de personas que les interesaba el Infamous pero no demasiado, definitivamente no lo comprarán (bravo por Sony), otros que dominan el inglés se lo comprarán en inglés y que a Sony la den, muchos otros más cogerán y comprarán el juego de segunda mano recibiendo Sony por ello cero euros (bravissimo), y quedaría otro grupo mucho más numeroso que como la PS3 no es pirateable de momento pues no tienen cabida aún en este circo.

En definitiva que Sony cree que va a ganar más dinero así y quizás en el fondo tenga razón o quizás es la cabezonería de los empresarios que casi siempre tienen miras de vistas muy cortas. ¿O quizás el problema no es tanto de Sony sino de las tiendas en España? ¿Por qué nosotros pagamos del orden de 20 euros más, que en un país donde ganan más dinero? (Y eso que no hablamos de USA o Japón donde están todavía más baratos…) De todas formas, en unos años, toda la distribución será digital y ahí sí que nos vamos a reír un montón… Con esos precios tan “bajos” (5€ más barato el Fallout 3 en el steam que en la tienda, woooow super-ahorro… ¬_¬) y eso que no tienen que pagar a una tienda por almacenarlo, ni pagar los costes del soporte o de distribución… Y luego las conversiones entre yenes, dólares y euros, jej.

En fin, que al final son los usuarios los infames pícaros que parecen estar robando día sí y día también a las pobres empresas, incluso cuando pagamos por los juegos de forma legal.

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.

Tus gestos “cuentan” algo de ti…

Estaba mirando internet cuando me encuentro el siguiente artículo, en el que hablan sobre las entrevistas de trabajo y qué clase de gestos no se deben hacer. Hace meses estuve haciendo entrevistas y francamente el recuerdo que tengo de todas ellas es pésimo y muy negativo. Y recuerdo a todo el mundo diciéndome que no hiciera según que gestos, como si pudiera controlar con naturalidad esa clase de cosas. Resulta ridículo como unos manuales sobre “comportamiento” ahora se han convertido en algo así como el protocolo de conducta en las entrevistas, parece un chiste retorcido en el que si eres capaz de saber engañar a los que te entrevistan eres el candidato idóneo. Porque al final como todo, hecha la ley, hecha la trampa.

Sí, al final las empresas están formadas por personas capaces en su mayoría de mentir, engañar y tener la convicción de que eso es moralmente admisible. La mentira por delante, sería su lema, en vez de la verdad. A mi sin embargo creo recordar que me enseñaron que mentir estaba mal, pero nuevamente como los mártires cristianos, uno es pisoteado por obrar bien, por aquellos malvados sin moral alguna. La conclusión, ser el más cabrón hijo de puta del mundo.

Y así están las empresas llenas de personas incompetentes y/o perversas en su mayoría. Algo ideal para fomentar el supuesto buen espíritu que buscan tener las empresas, porque creen que sabiendo tu forma de ser con todos esos profesionales de recursos humanos que dicen haber estudiado psicología, pueden seleccionar a un perfil psicológico de gente enrollada, simpática y servicial. Y al final todos son bombas de relojería, a la espera de explotar y llenar todo de mierda, por lo que nadie se fía de nadie y así van muchas empresas ancladas en formas arcaicas de hacer cosas, porque no se fían en lo más mínimo de sus empleados… Porque al final el ladrón cree que son todos de su condición.

“Descansando” un poquito del blog…

He estado bastante activo con mi página web últimamente, pero debido a la proximidad de los exámenes de junio y a la práctica de Ingeniería del Software que tengo que entregar este mes, estas próximas semanas no creo que pueda dedicarle mucho tiempo al blog. Eso sí, la próxima semana espero poder añadir un artículo sobre como extender la API de Small Basic, a no ser que el proyecto de la asignatura de Ingeniería del Software se tuerza mucho.

Un saludo,
Gorka Suárez.

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

Manejando formas con Small Basic

Y aquí tenemos otra entrega más sobre el maravilloso lenguaje Small Basic, que es cierto que no es la panacea precisamente, pero sigo pensando que tiene su encanto. El caso es que ahora vamos a hablar de la librería Shapes que sirve para pintar formas geométricas e imágenes en una ventana y poder aplicarle operaciones un tanto complejas, como rotar o mover de sitio estas formas. Las operaciones que tiene la librería son:

• AddLine(x1, y1, x2, y2): Añade una línea y devuelve un identificador de la forma.
• AddEllipse(ancho, alto): Añade una elipse y devuelve un identificador de la forma.
• AddTriangle(x1, y1, x2, y2, x3, y3): Añade un triángulo y devuelve un identificador de la forma.
• AddRectangle(ancho, alto): Añade un rectángulo y devuelve un identificador de la forma.
• AddImage(nombreImagen): Añade una imagen y devuelve un identificador de la forma.
• GetLeft(nombreForma): Devuelve la coordenada X de la forma. Hay que tener en cuenta que al ser creadas las formas, la coordenada X será siempre 0 y da igual que sea una línea o un triángulo al que le hayamos indicado unas coordenadas para darle forma.
• GetTop(nombreForma): Devuelve la coordenada Y de la forma. Hay que tener en cuenta que al ser creadas las formas, la coordenada Y será siempre 0 y da igual que sea una línea o un triángulo al que le hayamos indicado unas coordenadas para darle forma.
• Animate(nombreForma, x, y, duración): Mueve una forma desde su punto actual a uno que le indiquemos. Además no lo hará de forma inmediata, sino que lo irá moviendo con una velocidad que calculará en base al tiempo en milisegundos que le hayamos asignado para realizar el movimiento.
• Move(nombreForma, x, y): Mueve una forma desde su punto actual a uno que le indiquemos de forma inmediata.
• Rotate(nombreForma, ángulo): Rota una forma el ángulo indicado en grados.
• Remove(nombreForma): Borra una forma de la ventana.

Y que mejor para ilustrar lo que acabamos de exponer que un bonito ejemplo de como funciona todo esto:

'----------------------------------------------------
' Prueba con formas
'----------------------------------------------------
GraphicsWindow.Title = "Prueba con formas"
GraphicsWindow.BackgroundColor = "White"

path = Program.Directory + "\"
path = path + "image.jpg"
img = ImageList.LoadImage(path)
angle = 0

GraphicsWindow.KeyDown = OnKeyDown
GraphicsWindow.MouseMove = OnMouseMove
'----------------------------------------------------
GraphicsWindow.PenColor = "Red"
GraphicsWindow.BrushColor = "LightGray"
triang = Shapes.AddTriangle(0, -10, -10, 10, 10, 10)
Shapes.Move(triang, 100, 50)
'----------------------------------------------------
GraphicsWindow.PenColor = "Green"
GraphicsWindow.BrushColor = "LightGray"
square = Shapes.AddRectangle(42, 42)
Shapes.Move(square, 20, 100)
'----------------------------------------------------
surface = Shapes.AddImage(img)
Shapes.Move(surface, 50, 200)
'----------------------------------------------------
GraphicsWindow.PenColor = "Blue"
GraphicsWindow.BrushColor = "LightGray"
circle = Shapes.AddEllipse(42, 42)
Shapes.Move(circle, 299, 219)
'----------------------------------------------------
GraphicsWindow.PenColor = "Black"
GraphicsWindow.BrushColor = "Black"
index = 0
line = Shapes.AddLine(0, 0, 100, 0)
Array.SetValue("lines", index, line)
Shapes.Move(line, 400, 10)
'----------------------------------------------------
Sub OnKeyDown
  If GraphicsWindow.LastKey = "R" Then
    Shapes.Rotate(triang, angle)
    Shapes.Rotate(square, angle)
    Shapes.Rotate(surface, angle)
    angle = angle + 5

  ElseIf GraphicsWindow.LastKey = "M" Then
    index = index + 1
    left = Shapes.GetLeft(line)
    top = Shapes.GetTop(line) + index * 10
    id = Shapes.AddLine(left, top, left + 100, top)
    Array.SetValue("lines", index, id)

  ElseIf GraphicsWindow.LastKey = "L" Then
    If index > 0 Then
      id = Array.GetValue("lines", index)
      Shapes.Remove(id)
      index = index - 1
    EndIf
  EndIf
EndSub
'----------------------------------------------------
Sub OnMouseMove
  x = GraphicsWindow.MouseX - 21
  y = GraphicsWindow.MouseY - 21
  Shapes.Animate(circle, x, y, 500)
EndSub

Vista ya la librería, con ejemplo incluido, ya nos queda poco para terminar con la API de Small Basic, tan solo hablar sobre las dos librerías que quedan del modo ventana y comentar un poco sobre las que faltan que son curiosas, pero realmente no son demasiado útiles. De todos modos eso será a partir de la próxima semana seguramente.