Representar cuadrículas con matrices (código Small Basic y Visual Basic)


cuadru

Small Basic

filas=8
columnas=8
tamano= 40
GraphicsWindow.BackgroundColor= “Yellow”
For f = 1 To filas
  For c = 1 to columnas
  GraphicsWindow.BrushColor = GraphicsWindow.GetRandomColor()
  cuadrados[f][c] = Shapes.AddRectangle (tamano, tamano)
  Shapes.Move(cuadrados[f][c], c * tamano, f * tamano)
EndFor
  EndFor

 

http://empiezoinformatica.blogspot.com.ar/2013/04/representar-cuadriculas-con-matrices.html

¿Qué informática debería enseñarse a un chico de secundaria?


sec

Hemos comentado varias veces en esta columna que la asignatura de Tecnología está absolutamente mal planteada en los planes de estudio de secundaria.
En primer lugar está plagada de contenidos, que llegan al detalle en temas colaterales (por ejemplo máquinas neumáticas, o tipos de plásticos) y parecen olvidar lo esencial: que la tecnología y la ingeniería son disciplinas creativas que transforman el mundo.
En segundo lugar, la imparte un profesorado que en muchos casos no tiene demasiado interés en la materia (ojo, que también los hay excelentes, como en cualquier centro docente). El motivo de esto es variado: se considera una asignatura menos importante que las Matemáticas o la Física, muchos de sus profesores no cursaron estudios de ingeniería, sino de ciencias, y no son capaces de motivar al estudiante porque se deja de lado la faceta creativa de la tecnología, transmitiendo una visión memorística y rígida del proceso tecnológico. No se trata de entender el mundo, sino de modificarlo.
En tercer lugar, está más bien centrada en tecnologías tradicionales, ignorando que seguramente a día de hoy un porcentaje muy elevado de la asignatura de Tecnología debería estar dedicado a la Informática, porque es la disciplina tecnológica que más incide en nuestras vidas, cuenta con una enorme capacidad tractora de la sociedad y evoluciona a velocidad vertiginosa. Piensen en cuántos de los alumnos de una clase de secundaria terminarán trabajando más o menos directamente en el sector informático.
Pero, ¿qué debería enseñarse a los chicos de secundaria sobre informática? Un enorme error en el que han caído mucho centros es en enseñar ofimática, seguramente porque para las personas de otras generaciones la ofimática era algo que entrañaba alguna dificultad. Actualmente la ofimática se aprende de modo transversal, mientras se realizan trabajos para otras asignaturas, y los alumnos de secundaria (incluso los de primaria) se manejan bastante bien.
Para bien o para mal, el mundo anglosajón es el líder absoluto en desarrollo informático (para ellos Computer Science, aunque hay otras disciplinas relacionadas), así que ¿por qué no mirar qué están haciendo ellos?
Resulta que desde el año 2006 la Association for Computing Machinery (ACM), a través de su “Computer Science Teachers Association”, tiene bien definido lo que los estudiantes de primaria y secundaria deberían aprender, y además sus informes no son una foto fija, sino que son revisados periódicamente a medida que la Ciencia de la Computación avanza. Se denomina “CSTA K–12 Computer Science Standards” y es un extenso documento que centra los objetivos docentes de la enseñanza de la informática en toda la educación previa a la universitaria. Pueden consultarlo aquí.
El documento parte de la defensa de la informática como disciplina formativa general, es decir, como transmisora de valores y competencias que van mucho más allá de la tecnología, tales como la resolución de problemas o la colaboración, por citar algunos ejemplos.
También se explica que para el profesorado de secundaria, quizá la mayor fuente de confusión es que hay tres áreas principales de educación en informática:
Tecnología educativa:
• Utilización de la informática para otras disciplinas educativas, es decir, ofimática, blogs, recursos educativos tipo moodle, etc.
Tecnología de la Información, que se ocupa de:
• Instalar, mantener y personalizar software.
• Gestionar datos en mundos físicos y virtuales y ser consciente de nivel de seguridad.
• Gestionar sistemas de comunicación.
• Diseñar, implementar y gestionar recursos web.
• Desarrollar y gestionar recursos multimedia y otros contenidos digitales.
Ciencias de la computación, que se ocupa de:
• Diseñar e implementar software
• Desarrollar modos efectivos de resolución de problemas
• Descubrir nuevas aplicaciones de los ordenadores
Algunos ejemplos de las cosas sobre las que deberían pensar los estudiantes de secundaria:
• Encontrar el camino de salida de un laberinto.
• Cómo un perro captura una pelota en el aire.
• Cómo llegar a casa desde el instituto.
• Cómo ordenar una lista de palabras por orden alfabético de la mejor manera posible.
No se trata tanto de enseñar lenguajes de programación (aunque ¿por qué no?), sino de enfrentar al estudiante a un modo de pensamiento computacional, es decir, a tareas que se resuelven desarrollando un algoritmo.
Son sólo algunos ejemplos, que quizá pueden completarse con el desarrollo de pequeños programas, en scratch o en python.
Por otro lado, es importante que los estudiantes comprendan los aspectos fundamentales del funcionamiento de un ordenador: qué es un sistema operativo, qué es realmente un programa y cómo realiza sus tareas, cómo funciona la Web, etc.
Por supuesto el nivel al que se refiere ACM es inabordable en nuestro país –habría que asignar a la Informática un número de horas lectivas mayor que el que tienen las Matemáticas–, ya que no se conforman con enseñar programación básica. Fíjense como ejemplo que uno de los objetivos del curriculum de secundaria de esta organización es “Utilizar Application Program Interfaces (APIs) y bibliotecas de código para facilitar la programación de soluciones”. Ahí es nada.
No es casualidad que el gobierno británico decidiera en febrero de 2013 integrar en sus planes de estudio de secundaria la Computer Science como una disciplina básica, al mismo nivel de importancia que la Física y las Matemáticas.
Nuestro sistema educativo debería replantearse la importancia de la Informática en sus niveles básicos, de lo contrario corremos el riesgo de hacer verdad la frase de Arthur C. Clarke: “toda tecnología suficientemente avanzada es indistinguible de la magia”.

Fuente: Francisco Serradilla
http://librodenotas.com/computacion/24881/que-informatica-deberia-ensenarse-a-un-chico-de-secundaria

¿Que es VBA?


VBA

En los años 1950 se inventa un lenguaje de alto nivel llamado FORTRAN (IBM Mathematical Formula Translating System), orientado a ingeniería y ciencias, que permitía escribir código de una manera más entendible e intutiva para el ser humano que empezar a escribir en ensamblador que es un lenguaje penosamente arduo para la mayoría de las personas. Se dice que es de alto nivel porque la forma de expresar las cosas es más entendible para el ser humano, y evidentemente bajo nivel lidia más con aspectos funcionales de la máquina a niveles mucho menos intuitivos.
A partir de este lenguaje se inventa en 1964 el BASIC (Beginner’s All-purpose Symbolic Instruction Code) por parte de los húngaros John George Kemeny y Thomas Eugene Kurtz del Dartmouth College en New Hampshire, EUA para personas que no tuvieran profundos conocimientos de computadoras y ciencias.
Microsoft crea su propia versión con el lenguaje GW-BASIC y un compilador llamado BASCOM para Compaq. Un compilador sirve para traducir el código que escribe el usuario (código fuente) a lenguaje binario (lenguaje máquina) que es el que las computadoras entienden. Como el GW-BASIC no compilaba el programa para generar un archivo ejecutable, lo que hacía era “interpretarlo”, que equivale a decir que toma las instrucciones de una en una, las compila y luego las ejecuta, un proceso que hace la ejecución mucho más lenta.
Luego viene Visual Basic (VB) que es un lenguaje, tradicionalmente considerado como orientado a eventos, aunque también es capaz de manejar objetos de una forma algo básica, que se considera fácil de trabajar por el manejo de interfaces gráficas y también por lo entendible que resulta el BASIC del cual se deriva. Fue introducido en 1991 (versión 1), y ha sido objeto de mejoras con el tiempo, pero la versión que se utiliza al programar en macros de Microsoft Office pertenece a la versión 6 de 1998. Posteriormente se introduce el Visual Basic en su versión .NET que tiene importantes diferencias respecto de versiones anteriores, de modo que el código escrito en versión 5 podría no funcionar en .NET
VBA (Visual Basic for Applications) es una versión recortada de Visual Basic 6, que fue extendida con comandos de macro y objetos específicos de Microsoft Office. A diferencia del Visual Basic, no puede generar archivos ejecutables, sino que el código se debe echar a andar al estar dentro de una de las aplicaciones de Microsoft Office.
¿Cómo crear una macro?
Una macro es parecida un programa, pero se crea al grabar acciones del usuario que se representan como código. Dichas macros por sí solas solo podrían realizar secuencias fijas que empulan al pie de la letra las acciones realizadas por un usuario. Afortunadamente las macros de Officie incorporan la facilidad de usar también elementos de Visual Basic que permiten realizar procedimientos más complejos.
De esta manera puedes grabar algunas acciones (macros) y complementar el resto con instrucciones (VB) que agregas a tu gusto para cambiar todo para que se lleven a cabo los procesos que deseas realizar.
DESCARGAR EJERCICIO PROGRAMACION CON CONTROLES Y USERFORM EN EXCEL
Copy Right:
http://excelservicios.com/index.php/81-informatica/92-excel-vba-y-macros

Small Basic: Simulador Starfield (campo estelar)


Puede aumentar / disminuir la velocidad con la tecla ARRIBA / ABAJO hasta 60. Y si se llega a 31, a continuación, entrar en el hiperespacio! Y no vayas a 51 si usted tiene epilepsia! = ^)

… Para que las estrellas se mueven lentamente desde el centro y aceleran a medida que se pasa:

Código:

http://smallbasic.com/smallbasic.com/program/?JJS099

Small Basic – Control Statements (featured article)


diagrama

If statement
If statement or If clause is for making conditional branch. If you’d like to show “AM” or “PM” by checking clock, following code and chart are for that. There is another keyword “ElseIf” for this clause. For detail about “ElseIf”, see the next section.

‘ Start
hour = Clock.Hour ‘ Get hour
If hour <12 Then ' hour < 12?
TextWindow.WriteLine("AM") ' Yes: Write "AM"
Else
TextWindow.WriteLine("PM") ' No: Write "PM"
EndIf
' End

And check out the full article here: http://blogs.msdn.com/b/smallbasic/archive/2013/08/10/small-basic-control-statements-featured-article.aspx

Small Basic: Control Statements

Enjoy!
– Ninja Ed

Visual Studio 2012 Web


express2012web

Subir a los más altos estándares de la web
Los Clientes Web son ahora clientes de telefonía móvil y viceversa. Pero sin importar la plataforma que están en, todavía quieren más: más prestaciones, la interacción más intuitiva y experiencias más sensibles. Con soporte completo para los últimos estándares web, nuevas herramientas de depuración y aplicaciones que se adaptan a los móviles sobre la marcha, te darás cuenta de que la entrega de un conjunto mucho más es ahora mucho más fácil.

Desarrollar para las normas
Usuarios navegando en una aplicación web emplean una variedad de navegadores. Algunos navegadores soportan plugins, mientras que otros no lo hacen, y todos los navegadores tienen peculiaridades que afectan a la forma en que presentan un sitio. Existen estándares Web para ayudar a garantizar que las aplicaciones web se ven y funcionan correctamente independientemente del navegador utilizado. Scripts HTML, CSS y ECMA son las normas para el desarrollo de sitios web multiplataforma. Visual Studio 2012 amplía y mejora significativamente su apoyo.

Utilice las últimas capacidades de HTML5 y CSS3
Visual Studio 2012 incluye compatibilidad con IntelliSense completo para HTML5 por lo que es más fácil desarrollar conforme sitios Web. Además, el editor de código tiene nuevas características de productividad que simplifican el desarrollo web. El editor de CSS en Visual Studio 2012 ha sido actualizado para soportar el último estándar CSS3, e incorpora plenamente IntelliSense.

http://www.microsoft.com/visualstudio/eng/products/visual-studio-express-for-web#product-express-web

Clases, atributos y métodos en Visual Basic (código)


micoche

Diseñamos una clase CCoche que representa coches( carros, autos).

Incluímos los atributos marca, modelo y color, y los métodos que simulen, enviando mensajes, las acciones de arrancar el motor, cambiar de velocidad, acelerar, frenar y parar el motor.

micoche1

Que es C# (Sharp) – código ejemplo


clavef

C# es un lenguaje que pretende reunir lo mejor de los lenguajes que compilan  a nativo (C/ C++, Object Pascal, ADA, etc) y de aquellos interpretados (Java, Perl, etc) en uno solo, y que además pueda correr sobre diversos sistemas operativos

C# toma gran parte de la sintaxis de c/ C++ siendo un potente lenguaje 100% orientado a objetos.

jorgef

Tomamos un ejercicio muy simple en que se requiere al usuario, ingresar su nombre y clave para permitirle o no el acceso

Código:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

 

namespace ConsoleApplication1

{

    class Program

    {

        static void Main(string[] args)

        {

            //ejercicio 3 if

            Console.Write(“Ingrese usuario: “);

            string user = Console.ReadLine();

            Console.Write(“Ingrese clave: “);

            string pass = Console.ReadLine();

            if (user==”Jorge” & pass==”1234″)

            {

             Console.WriteLine(“Hi George!!”);

             Console.ReadKey();

            }

            else

            {

            if (user == “Jorge” & pass != “1234”)

             {

             Console.WriteLine(“El usuario no coincide con la clave!!”);

             Console.ReadKey();

             }

             else

             {

             Console.WriteLine(“No existe el usuario”);

             Console.ReadKey();

             }

            }

        }

    }

}

jogev1

Visual Basic: mostrar datos por pantalla(código)


mostrar_datos

Cap 2 pág 18

La biblioteca de Visual Basic.NET proporciona un método, System.Console.WriteLine vinculado con la salida standard, normalmente en la pantalla, que permite visualizar datos numéricos de cualquier tipo y cadena de caracteres.

Declaramos tres variables numéricas a, b y c y una referencia s a una cadena de caracteres, después asigna valores a las variables y finalmente los muestra.

mostrar_datos1

Exportar datos de un programa de VisualBasic.net a Excel


VB_a_xls

http://www.vb-mundo.com/exportar-datos-de-un-programa-de-visualbasic-net-a-excel/ 

En este artículo se muestra cómo automatizar Microsoft Excel y cómo rellenar un rango de celdas con un Textbox y con un listview.

1. Iniciaremos Microsoft Visual Studio .NET.

2. En el menú Archivo, haga clic en Nuevo y, después, en Proyecto. Seleccione Aplicación para Windows en los tipos de proyecto de Visual Basic. De forma predeterminada, se crea Form1.

VB_a_xls2

4. En el Form1 he agregado un TextBox  y un ListView que son los usare para exportar los datos a Excel. Y un botón que es el encargado de generar la acción.

VB_a_xls3

5 . En el código del botón agregare todo el código,  es bastante sencillo y lo he comentado para aclarar que funciona cada línea importante.

Visual Basic   copy code

  • ‘Variables locales
  •  
  • Dim oExcel As Object
  • Dim oBook As Object
  • Dim oSheet As Object
  •  
  • ‘Iniciar un nuevo libro en Excel
  •  
  • oExcel = CreateObject(“Excel.Application”)
  •  
  • oBook = oExcel.Workbooks.Add
  •  
  • ‘Agregar datos a las celdas de la primera hoja en el libro nuevo
  •  
  • oSheet = oBook.Worksheets(1)
  •  
  • ‘ Agregamos Los datos que queremos agregar
  •  
  • oSheet.Range(“A3”).Value = TextBox1.Text
  •  
  • ‘ Esta celda tendra los datos del textbox
  •  
  • oSheet.Range(“A10”).Value = “CODIGO”
  •  
  • ‘ estas celdas por defecto solo seran para identificar cada columna
  •  
  • oSheet.Range(“B10”).Value = “TIPO”
  •  
  • oSheet.Range(“C10”).Value = “DESCRIPCION”
  •  
  • oSheet.Range(“D10”).Value = “MODELO”
  •  
  • oSheet.Range(“E10”).Value = “REGIS”
  •  
  • oSheet.Range(“F10”).Value = “DISPO”
  •  
  • ‘Desde aqui empezaremos a exportar la lista
  •  
  • If ListView1consul2.Items.Count > 0 Then
  •  
  • ‘ primero verificamos cuantas filas tiene la lista
  •  
  • Dim col As Integer = 11 empezaremos en el libro de excel a partir de la celda 11
  •  
  • Dim i As Integer ‘ for para empezar a recorrer la lista
  •  
  • For i = 0 To ListView1consul2.Items.Count
  •  
  • If i = ListView1consul2.Items.Count Then
  •  
  • Exit For
  •  
  • End If
  •  
  • ‘ estas son las columnas que usaremos y el contador nos ira cargando una a una cada fila
  •  
  • Dim a As String = “A” + col.ToString + “”
  •  
  • Dim b As String = “B” + col.ToString + “”
  •  
  • Dim c As String = “C” + col.ToString + “”
  •  
  • Dim d As String = “D” + col.ToString + “”
  •  
  • Dim j As String = “E” + col.ToString + “”
  •  
  • Dim f As String = “F” + col.ToString + “”
  •  
  • oSheet.Range(a).Value = ListView1consul2.Items(i).SubItems.Item(0).Text.ToString
  •  
  • oSheet.Range(b).Value = ListView1consul2.Items(i).SubItems.Item(1).Text.ToString
  •  
  • oSheet.Range(c).Value = ListView1consul2.Items(i).SubItems.Item(2).Text.ToString
  •  
  • oSheet.Range(d).Value = ListView1consul2.Items(i).SubItems.Item(3).Text.ToString
  •  
  • oSheet.Range(j).Value = ListView1consul2.Items(i).SubItems.Item(4).Text.ToString
  •  
  • oSheet.Range(f).Value = ListView1consul2.Items(i).SubItems.Item(5).Text.ToString
  •  
  • col = col + 1
  •  
  • ListView1consul2.Items.Remove(ListView1consul2.Items.Item(i))
  •  
  • ‘ removemos cada el elemento esto es solo si desean hacerlo
  •  
  • ‘ otra opcion es poner el contador positivo y no eliminar el elemento de la lista
  •  
  • i = i − 1
  •  
  • Next
  •  
  • End If
  •  
  • ‘ hacemos visible el documento
  •  
  • oExcel.Visible = True
  •  
  • oExcel.UserControl = True
  •  
  • ‘Guardaremos el documento en el escritorio con el nombre prueba
  •  
  • oBook.SaveAs(Environ(“UserProfile”) & “\desktop\Prueba.xls”)

Aplicaciones de ejemplo de Visual Basic


vbasicnet

Visual Studio 2010     http://msdn.microsoft.com/es-es/library/5ekc8at3(v=vs.100).aspx

En la documentación de Visual Basic, un ejemplo es un proyecto de Visual Basic que se puede cargar y ejecutar en Visual Studio. Un ejemplo es un bloque pequeño de código que muestra una tarea de programación única y limitada.Un fragmento de código es un bloque de código insertado en el Editor de código mediante la característica Fragmentos de código IntelliSense.

Microsoft Visual Basic es un entorno de programación utilizado para crear aplicaciones gráficas de la familia Microsoft Windows de sistemas operativos. Microsoft Visual Basic 2010 es la versión actual.
Se trata de una serie de lecciones y ejemplos sobre cómo diseñar aplicaciones y crear programas informáticos que utilizan Microsoft Visual Basic 2010 Express y Microsoft Visual Studio 2010 (con el lado de Microsoft Visual Basic del medio ambiente).

Para crear un programa informático, llamado también una aplicación, se crea una serie de archivos y agruparlos en un conjunto llamado proyecto. Este contiene varios módulos, archivos, conjuntos (o librerías), y archivos de recursos.
Crear un proyecto
Una aplicación típica consiste en varios módulos, e incluso puede ser tan complejo como usted quiere. Para que sea más rápido y un poco más fácil para crear gráficamente una aplicación, que se necesita un buen ambiente de funcionamiento como Microsoft Visual Basic. Con ella, se puede crear un nuevo proyecto o abrir uno existente.
Para crear un proyecto de Visual Basic, puede mostrar el cuadro de diálogo Nuevo proyecto. Para abrir el cuadro de diálogo Nuevo proyecto:
• En la página de inicio, en la parte derecha del proyecto, haga clic en Crear …
• Si está utilizando Microsoft Visual Basic 2008 Express Edition, en el menú principal, puede hacer clic en Archivo -> Nuevo proyecto … Si está utilizando Microsoft Visual Basic 2008 Professional, en el menú principal, puede hacer clic en Archivo -> Nuevo -> Proyecto …
• En la barra de herramientas estándar, haga clic en el botón Nuevo proyecto
• Puede pulsar Ctrl + Shift + N
En el cuadro de diálogo Nuevo proyecto, seleccione Proyectos de Visual Basic, seleccione el tipo de proyecto, darle un nombre, especifique el directorio y haga clic en Aceptar.
Aprendizaje práctico: Creación de un proyecto
Ver: http://www.functionx.com/vb/Lesson02.

 

 

Mensajes y métodos en Visual Basic (código)


Ccuenta

Mensajes y métodos en Visual Basic (código)

Un programa orientado a objetos se compone solamente de objetos. Cada uno de ellos es una entidad que tiene propiedades particulares, los atributos, y unas formas de operar sobre ellos, los métodos.

Un método se escribe en una clase de objetos y determina como tiene que actuar el objeto cuando recibe el mensaje el mensaje vinculado con ese método.

Una vez escritos los métodos y propiedades necesarios, tendremos creada la clase CCuenta que se guarda en un archivo que llamamos CCuenta.vb

Código:

Class CCuenta

  ‘ Atributos

  Private _nombre As String

  Private _cuenta As String

  Private _saldo As Double

  Private _tipoDeInteres As Double

 

  ‘ Métodos

  Public Sub New()

  End Sub

 

  Public Sub New(ByVal nom As String, ByVal cue As String, _

                 ByVal sal As Double, ByVal tipo As Double)

    Nombre = nom

    Cuenta = cue

    ingreso(sal)

    TipoDeInteres = tipo

  End Sub

 

  Public Property Nombre() As String

    Get

      Return _nombre

    End Get

    Set(ByVal nom As String)

      If nom.Length = 0 Then

        System.Console.WriteLine(“Error: cadena vacía”)

      Else

        _nombre = nom

      End If

    End Set

  End Property

 

  Public Property Cuenta() As String

    Get

      Return _cuenta

    End Get

    Set(ByVal cue As String)

      If cue.Length = 0 Then

        System.Console.WriteLine(“Error: cuenta no válida”)

      Else

        _cuenta = cue

      End If

    End Set

  End Property

 

  Public ReadOnly Property Saldo() As Double

    Get

      Return _saldo

    End Get

  End Property

 

  Public Sub ingreso(ByVal cantidad As Double)

    If cantidad < 0 Then

      System.Console.WriteLine(“Error: cantidad negativa”)

    Else

      _saldo = _saldo + cantidad

    End If

  End Sub

 

  Public Sub reintegro(ByVal cantidad As Double)

    If _saldo – cantidad < 0 Then

      System.Console.WriteLine(“Error: no dispone de saldo”)

    Else

      _saldo = _saldo – cantidad

    End If

  End Sub

 

  Public Property TipoDeInteres() As Double

    Get

      Return _tipoDeInteres

    End Get

    Set(ByVal tipo As Double)

      If tipo < 0 Then

        System.Console.WriteLine(“Error: tipo no válido”)

 

            Else

                _tipoDeInteres = tipo

            End If

            System.Console.ReadKey()

 

 

 

    End Set

  End Property

End Class

Class CCuenta

  ‘ Atributos

  Private _nombre As String

  Private _cuenta As String

  Private _saldo As Double

  Private _tipoDeInteres As Double

 

  ‘ Métodos

  Public Sub New()

  End Sub

 

  Public Sub New(ByVal nom As String, ByVal cue As String, _

                 ByVal sal As Double, ByVal tipo As Double)

    Nombre = nom

    Cuenta = cue

    ingreso(sal)

    TipoDeInteres = tipo

  End Sub

 

  Public Property Nombre() As String

    Get

      Return _nombre

    End Get

    Set(ByVal nom As String)

      If nom.Length = 0 Then

        System.Console.WriteLine(“Error: cadena vacía”)

      Else

        _nombre = nom

      End If

    End Set

  End Property

 

  Public Property Cuenta() As String

    Get

      Return _cuenta

    End Get

    Set(ByVal cue As String)

      If cue.Length = 0 Then

        System.Console.WriteLine(“Error: cuenta no válida”)

      Else

        _cuenta = cue

      End If

    End Set

  End Property

 

  Public ReadOnly Property Saldo() As Double

    Get

      Return _saldo

    End Get

  End Property

 

  Public Sub ingreso(ByVal cantidad As Double)

    If cantidad < 0 Then

      System.Console.WriteLine(“Error: cantidad negativa”)

    Else

      _saldo = _saldo + cantidad

    End If

  End Sub

 

  Public Sub reintegro(ByVal cantidad As Double)

    If _saldo – cantidad < 0 Then

      System.Console.WriteLine(“Error: no dispone de saldo”)

    Else

      _saldo = _saldo – cantidad

    End If

  End Sub

 

  Public Property TipoDeInteres() As Double

    Get

      Return _tipoDeInteres

    End Get

    Set(ByVal tipo As Double)

      If tipo < 0 Then

        System.Console.WriteLine(“Error: tipo no válido”)

 

            Else

                _tipoDeInteres = tipo

            End If

            System.Console.ReadKey()

 

    End Set

  End Property

End Class

………………………………………………………………………………………………………………………………………………………………………………………………………………………………

Para poder crear objetos de esta clase y trabajar con ellos, escribimos un programa que debe tener un módulo con un procedimiento Main, puesto que éste es el punto de entrada y de salida del programa.

Entonces tenemos un archivo fuente CCuenta.vb con la clase CCuenta Añadimos en la misma carpeta otro archivo fuente, Test.vb con un módulo standard o con una clase por ejemplo Test, que incluya el procedimiento Main.

……………………………………………………………………………………………………………………………………………………………………………………………………………………………

Código:

Public Class Test

  Public Shared Sub Main()

    Dim cuenta01 As CCuenta = New CCuenta()

    Dim cuenta02 As CCuenta = New CCuenta(“Un nombre”, _

                                       “Una cuenta”, 6000, 3.5)

    cuenta01.Nombre = “Un nombre”

    cuenta01.Cuenta = “Una cuenta”

    cuenta01.TipoDeInteres = 2.5

 

    cuenta01.ingreso(6000)

    cuenta01.reintegro(3000)

 

    System.Console.WriteLine(cuenta01.Nombre)

    System.Console.WriteLine(cuenta01.Cuenta)

    System.Console.WriteLine(cuenta01.Saldo)

    System.Console.WriteLine(cuenta01.TipoDeInteres)

    System.Console.WriteLine()

    System.Console.WriteLine(cuenta02.Nombre)

    System.Console.WriteLine(cuenta02.Cuenta)

    System.Console.WriteLine(cuenta02.Saldo)

        System.Console.WriteLine(cuenta02.TipoDeInteres)

        System.Console.ReadKey()

    End Sub

End Class

PPT: Código de VB de ejemplo para crear una presentación con diapositivas personalizada


ppoint

Microsoft PowerPoint tiene una característica de presentación personalizada que le permite mostrar algunas de las diapositivas en una presentación como una presentación con diapositivas o volver a ordenar las diapositivas cuando se ejecuta una presentación con diapositivas.

Este artículo contiene un ejemplo de Visual Basic para Aplicaciones de Microsoft macro (procedimiento Sub) a la que se crea una presentación personalizada. La macro crea una presentación personalizada que incluye todas las diapositivas de la presentación activa. Puede modificar el código para seleccionar las diapositivas que desea formar parte de la presentación personalizada.

http://support.microsoft.com/kb/165217/es

Procedimiento de ejemplo de Visual Basic 

Sub CreateCustomShow()

 

   On Error Resume Next

 

   ‘Change this value to the name you want to use for your

   ‘custom slide show.

   Const strDefaultName As String = “My Custom Show”

 

   Dim lNumSlides, lSlideList(), lCount As Long

   Dim oSlide As Slide

   Dim strPrompt, strShowName As String

   Dim Continue As Boolean: Continue = False

 

   ‘Get the number of slides in the active presentation.

   lNumSlides = ActivePresentation.Slides.Count

 

   ‘Make sure at least 1 slide is in the presentation.

   If lNumSlides < 1 Then

     MsgBox “No slides in the presentation.”, vbExclamation, “No Slides”

     End

   End If

 

   ‘Initialize the counter.

   lCount = 0

 

   ‘Loop through the slides in the presentation.

   For Each oSlide In ActivePresentation.Slides

 

      ‘Make the array one element larger.

      ReDim Preserve lSlideList(lCount)

 

      ‘Add the slide id to the array.

      lSlideList(lCount) = oSlide.SlideID

 

      ‘Increment the counter.

      lCount = lCount + 1

 

   Next oSlide

 

   ‘Reset the counter

   lCount = 0

 

   ‘Set the name of the custom show to the default.

   strShowName = strDefaultName

 

   ‘Loop until a custom show is created.

   Do

 

      ‘Increment the counter.

      lCount = lCount + 1

 

      With ActivePresentation.SlideShowSettings.NamedSlideShows

 

         ‘Clear the error object.

         Err.Clear

 

         ‘Create the custom show.

         .Add strShowName, lSlideList

 

         ‘Check to see if an error occurred creating the show.

         ‘A run-time error occurs if the custom show name you specify

         ‘is already being used.

         If Err.Number <> 0 Then

 

            ‘Change the name of the custom show

            strShowName = strDefaultName & ” ” & CStr(lCount)

         Else

            Continue = True

         End If

 

      End With

 

   Loop While Continue = False

 

   ‘Create and then display message box.

   strPrompt = “Successfully created custom show named ” & strShowName _

    & “. To view the show:” & Chr(13) & Chr(13) _

    & Chr(9) _

    & “1. On the Slide Show menu, click Custom Shows.” _

    & Chr(13) & Chr(9) _

    & “2. Highlight the custom show you want to run.” _

    & Chr(13) & Chr(9) _

    & “3. Click the show button to run the show.” _

    & Chr(13) & Chr(13) _

    & “NOTE: If the Custom Shows dialog box is visible ” _

    & “when you run this macro. Close and” _

    & Chr(13) _

    & “then reopen the dialog box to see the updated custom show list.”

   MsgBox strPrompt, vbInformation, “Custom Show Created!”

 

End Sub

La programación como medio creativo


kodu2Kodu es un nuevo lenguaje de programación visual hecho específicamente para la creación de juegos. Está diseñado para ser accesible a los niños y agradable para todos.
El entorno de programación se ejecuta en la Xbox, que permite una rápida iteración de diseño utilizando sólo un dispositivo de juego para la entrada.

El núcleo del proyecto Kodu es la interfaz de usuario de programación. El lenguaje es simple y totalmente basada en iconos. Los programas se componen de páginas, que se desglosan en las normas, que se dividen en las condiciones y acciones. Las condiciones se evalúan simultáneamente.

El lenguaje de Kodu está diseñado específicamente para el desarrollo del juego y proporciona primitivas especializados derivados de escenarios de juego. Los programas se expresan en términos físicos, utilizando conceptos como la visión, el oído, y el tiempo para controlar el comportamiento de carácter. Aunque no es tan de uso general como los lenguajes de programación clásica, Kodu puede expresar conceptos avanzados de diseño de juegos de una manera simple, directa e intuitiva

kodu1

http://research.microsoft.com/en-us/projects/kodu/

Bucles anidados en VB.NET (código)


Vemos a realizar un programa  que imprima los números  z  comprendidos entre 1 y 50 que cumplan la expresión:

z²  = x²  +  y²donde z, x e y son números enteros positivos. El resultado se presentará de esta forma

Pitagoras

y la solución de este problema puede ser de la siguiente forma

Cap. 7 – Pág 145

Código Visual Basic:

Imports System

Module Pitagoras

‘ Teorema de Pitágoras

Public Sub Main()

Dim x As Integer = 1, y As Integer = 1, z As Integer = 0

Dim TH As Char = Convert.ToChar(&H9) ‘ tab horizontal

Console.WriteLine(“Z” & TH & “X” & TH & “Y”)

Console.WriteLine(“____________________”)

While (x <= 50)

‘ Calcular z. Como z es un entero, almacena

‘ la parte entera (redondeada) de la raíz cuadrada

z = Math.Sqrt(x * x + y * y)

While (y <= 50 And z <= 50)

‘ Si la raíz cuadrada anterior fue exacta,

‘ escribir z, x e y

If (z * z = x * x + y * y) Then

Console.WriteLine(z & TH & x & TH & y)

End If

y = y + 1

z = Math.Sqrt(x * x + y * y)

End While

x = x + 1 : y = x

End While

System.Console.ReadKey()

End Sub

End Module

Los tres pilares de la Programación Orientada a Objetos


OOP

Todos los lenguajes basados en objetos, deben cumplir estos tres requisitos:

  • Herencia
  • Encapsulación
  • Polimorfismo

Nota: Algunos autores añaden un cuarto requisito: la abstracción, pero este último está estrechamente ligado con la encapsulación.

Herencia

Esta es la característica más importante de la POO. Según la propia documentación de Visual Studio .NET:
“La herencia permite crear nuevas clases a partir de clases existentes. La herencia puede simplificar el diseño de la aplicación proporcionando una estructura de relaciones entre las distintas clases. También admite la reutilización de código porque sólo se debe codificar el comportamiento de clases nuevas o distintas.”.

Una relación de herencia es una relación en la que un tipo (el tipo derivado) se deriva de otro (el tipo base), de tal forma que el espacio de declaración del tipo derivado contiene implícitamente todos los miembros de tipo no constructor del tipo base.

“La herencia es la capacidad de una clase de obtener la interfaz y comportamiento de una clase existente.”

Resumiendo: Gracias a la herencia podemos ampliar cualquier clase existente, además de aprovecharnos de todo lo que esa clase haga.

Encapsulación

Según Visual Studio.NET:
“La encapsulación es la capacidad de contener y controlar el acceso a un grupo de elementos asociados. Las clases proporcionan una de las formas más comunes de encapsular elementos.”

Cuando usamos las clases, éstas tienen una serie de características (los datos que manipula) así como una serie de comportamientos (las acciones a realizar con esos datos). La encapsulación es esa capacidad de la clase de ocultarnos sus interioridades para que sólo veamos lo que tenemos que ver, sin tener que preocuparnos de cómo está codificada para que haga lo que hace… simplemente nos debe importar que lo hace.

Resumiendo: Establece la separación entre la interfaz del objeto y su implementación.

Polimorfismo

Según la documentación de Visual Studio.NET:
“El polimorfismo se refiere a la posibilidad de definir múltiples clases con funcionalidad diferente, pero con métodos o propiedades denominados de forma idéntica, que pueden utilizarse de manera intercambiable mediante código cliente en tiempo de ejecución.”

Dicho de otra manera, puede tener múltiples clases que se pueden utilizar de forma intercambiable, si bien cada clase implementa las mismas propiedades o los mismos métodos de maneras diferentes. El polimorfismo es importante en la programación orientada a objetos puesto que permite usar elementos que tienen el mismo nombre, independientemente del tipo de objeto que se esté utilizando en ese momento.

Resumiendo: Determina que el mismo nombre de método realizará diferentes acciones según el objeto sobre el que se ha aplicado

http://www.cristalab.com/tutoriales/programacion-orientada-a-objetos-en-visual-basic-.net-c273l/

Visual Basic 2010 Express – Números racionales (Código)


Pensamos a un número racional como un objeto y vemos que sus atributos son dos: numerador y denominador

Y los métodos aplicables son muchos:  suma, resta, simplificación, etc.

Añadiremos dos métodos: AsignarDatos para establecer valores al numerador y denominador y otro, VisualizarRacional, para visualizar un número racional.

Editamos la clase CRacional:

clase_racionales

Para crear objetos de esta clase  escribimos un módulo estándar que defina el procedimiento Main y llamamos a este módulo:  Racionales

modulo_racionales

Para finalizar, se compila la aplicación, se ejecuta y se observa el resultado esperado

Small Basic: Walking man (Code)


walkman

Excellent  program written by NaoChanOn

Challenge of the month July 2013 // Walking man by NaochanON

Program Code:

Shapes_Init()

Shapes_Add()

 

While (pos<1100)

   dx=6

   dy=2

   MM=MM+5

   walking()

   If -30<MM And  MM<30 Then

     NN=MM

   ElseIf 30<=MM and MM<90 Then

     NN=60-MM

   Elseif MM=90 then

     MM=-30

   EndIf

   Program.Delay(200)

endwhile

 

Sub armlegmoving

   rad=math.GetRadians(NN)

   ‘————————————– Arm & Hand —————————————————————————————

  ArmCP=”X=”+(shapes.GetLeft(shp[7][“obj”])+shp[7][“width”]/2)+”;Y=”+(shapes.Gettop(shp[7][“obj”]))

   ArmDR= shp[5][“height”]/2

   Shapes.Rotate(shp[8][“obj”],NN)                                        ‘ Left arm // backward

   Shapes.Move(shp[8][“obj”],ArmCP[“X”]- ArmDR*Math.Sin(rad), ArmCP[“Y”]+ArmDR*Math.cos(rad)-(shp[5][“y”]-shp[7][“y”]))

   Shapes.Rotate(shp[9][“obj”],NN)                                        ‘ Left hand // backward

   Shapes.Move(shp[9][“obj”],ArmCP[“X”]- 2*ArmDR*Math.Sin(rad), ArmCP[“Y”]+2*ArmDR*Math.cos(rad)+shp[6][“height”]/2)

   Shapes.Rotate(shp[5][“obj”],-NN)                                        ‘ Right arm // forward

   Shapes.Move(shp[5][“obj”],ArmCP[“X”]+ArmDR*Math.Sin(rad), ArmCP[“Y”]+ArmDR*Math.cos(rad) -(shp[8][“y”]-shp[7][“y”]) )

   Shapes.Rotate(shp[6][“obj”],-NN)                                        ‘ Right hand// forward

   Shapes.Move(shp[6][“obj”],ArmCP[“X”]+ 2*ArmDR*Math.Sin(rad), ArmCP[“Y”]+2*ArmDR*Math.cos(rad)+shp[9][“height”]/2)

   ‘————————————– Leg & Foot ————————————————————————————— —————-

  LegCP=”X=”+(shapes.GetLeft(shp[7][“obj”])+shp[7][“width”]/2-5)+”;Y=”+(shapes.Gettop(shp[7][“obj”]) +shp[7][“height”]-5) ‘ 5… adjustment

   LegDR=shp[10][“height”]/2

   Shapes.Rotate(shp[10][“obj”],NN)                                        ‘ Left leg // backward

   Shapes.Move(shp[10][“obj”],LegCP[“X”]- LegDR*Math.Sin(rad), LegCP[“Y”])

   Shapes.Rotate(shp[11][“obj”],NN)                                        ‘ Left foot // backward

   Shapes.Move(shp[11][“obj”],LegCP[“X”]- 2*LegDR*Math.Sin(rad), LegCP[“Y”]+2*LegDR*Math.cos(rad))

   Shapes.Rotate(shp[12][“obj”],-NN)                                        ‘ Right leg// forward

   Shapes.Move(shp[12][“obj”],LegCP[“X”]+ LegDR*Math.Sin(rad), LegCP[“Y”])

   Shapes.Rotate(shp[13][“obj”],-NN)                                        ‘ Left foot // forward

   Shapes.Move(shp[13][“obj”],LegCP[“X”]+ 2*LegDR*Math.Sin(rad), LegCP[“Y”]+2*LegDR*Math.cos(rad))

EndSub

 

Sub walking

   For k=1 To  Array.GetItemCount(shp)

     Shapes.Move(shp[k][“obj”],Shapes.GetLeft(shp[k][“obj”])+dx,Shapes.Gettop(shp[k][“obj”])+dy)

   endfor

   pos=Shapes.GetLeft(shp[1][“obj”])

   armlegmoving()

EndSub

 

Sub Shapes_Add

   GraphicsWindow.BackgroundColor=”Lightcyan”

   GraphicsWindow.Width=1200

   GraphicsWindow.Height=700

   For i = 1 To Array.GetItemCount(shp)

     GraphicsWindow.PenWidth = shp[i][“pw”]

     GraphicsWindow.PenColor = shp[i][“pc”]

     GraphicsWindow.BrushColor = shp[i][“bc”]

     If shp[i][“func”] = “rect” Then

       shp[i][“obj”] = shapes.AddRectangle(shp[i][“width”], shp[i][“height”])

     ElseIf shp[i][“func”] = “ell” Then

       shp[i][“obj”] = shapes.AddEllipse(shp[i][“width”], shp[i][“height”])

     ElseIf shp[i][“func”] = “tri” Then

       shp[i][“obj”] = shapes.AddTriangle(shp[i][“x1”], shp[i][“y1”], shp[i][“x2”], shp[i][“y2”], shp[i][“x3”], shp[i][“y3”] )

     ElseIf shp[i][“func”] = “line” Then

       shp[i][“obj”] = shapes.AddLine(shp[i][“x1”], shp[i][“y1”], shp[i][“x2”], shp[i][“y2”])

     EndIf

     Shapes.Move(shp[i][“obj”], X0 + shp[i][“x”], Y0 + shp[i][“y”])

     If shp[i][“angle”] <> 0 Then

       Shapes.Rotate(shp[i][“obj”], shp[i][“angle”])

     EndIf

   EndFor

EndSub

 

Sub Shapes_Init

   X0 = 10        ‘ x offset

   Y0 = 50       ‘ y offset

   shp[1] = “func=ell;x=42;y=0;width=34;height=45;bc=#EB9869;pc=#EB9869;pw=2;”               ‘ face

   shp[2] = “func=line;x=65;y=13;x1=0;y1=0;x2=8;y2=1;pc=#6A5ACD;pw=4;”                       ‘ Eye

   shp[3] = “func=line;x=65;y=29;x1=0;y1=0;x2=8;y2=3;pc=#F80800;pw=2;”                       ‘ mouse

   shp[4] = “func=tri;x=74;y=17;x1=0;y1=0;x2=10;y2=8;x3=0;y3=12;angle=0;bc=#EB9869;pc=#EB9869;pw=1;”  ‘nose

   shp[5] = “func=rect;x=53;y=50;width=8;height=60;angle=0;bc=#6A5ACD;pc=#000000;pw=1;”      ‘ Left arm

   shp[6] = “func=ell;x=53;y=110;width=13;height=22;angle=0;bc=#EB9869;pc=#EB9869;pw=8;”     ‘ Left hand

   shp[7] = “func=ell;x=40;y=42;width=33;height=103;bc=#00AA00;pc=#00AA00;pw=2;”             ‘ body

   shp[8] = “func=rect;x=53;y=50;width=8;height=60;angle=0;bc=#00BB00;pc=#000000;pw=1;”      ‘ Right arm

   shp[9] = “func=ell;x=53;y=110;width=13;height=22;angle=0;bc=#EB9869;pc=#EB9869;pw=2;”     ‘ Right hand

   shp[10] = “func=rect;x=50;y=140;width=12;height=71;angle=0;bc=#6A5ACD;pc=#6A5ACD;pw=2;”   ‘ left Leg

   shp[11] = “func=ell;x=50;y=209;width=33;height=13;angle=0;bc=#BED3CA;pc=#414C3E;pw=2;”    ‘ left foot

   shp[12] = “func=rect;x=50;y=140;width=12;height=71;angle=0;bc=#00AA00;pc=#6A5ACD;pw=2;”   ‘ Right Leg

   shp[13] = “func=ell;x=50;y=209;width=33;height=13;angle=0;bc=#1AD3CA;pc=#414C3E;pw=2;”    ‘ Right foot

EndSub

Ecuaciones (Visual Basic – Código)


La siguiente aplicación utiliza objetos de una clase CEcuacion para evaluar ecuaciones de la forma:

ax³ + bx² + cx + d

Una ecuación se puede ver como un objeto que envuelve el exponente del término de mayor grado, los coeficientes y los métodos que permitan manipularla.

Los objetos CEcuacion tendrán unos atributos que serán los coeficientes y unos métodos Ecuación y ValorPara para manipularlos.

El método ValorPara evaluará la ecuación para el valor de x pasado como argumento. Este método, utilizando la sentencia Return, devolverá como resultado el valor calculado. El tipo devuelto por el método

es Double.

Escribimos en en primer lugar  la clase CEcuacion

ecuaciones_class

Escribimos otro archivo fuente con un módulo MiSplicacion, que utilice la clas4e de objetos CEcuacion

ecuaciones

El procedimiento Main es por donde empieza a ejecutarse la aplicación.

Una vez escrito el programa se compila.

Después se ejecuta y observa los resultados

ecuaciones1

Visual Basic.NET: CLASES DE USO COMÚN (código)


intereses

C:\Users\carlos\Documents\VB-LengAplics-3Ed-Ceballos\VB-LengAplics-3Ed-Ceballos\Inicio.HTML.   Cap 6

En VB.NET las clases son la base de nuestras aplicaciones, la potencia en la práctica, del lenguaje Visual Basic viene dada por sus bibliotecas de clases.: La biclioteca .NET. Hay un espacio de nombres que destaca por las clases de propósito general que incluye: System

El espacio de nombres System contiene clases que se aplican al lenguaje mismo. Por ejemplo, estructuras que encapsulan los tipos primitivos de datos, la clase Console que proporciona los métodos para manipular la entrada/ salida (E/ S) estándard, la clase String  para manipular cadenas de caracteres, una clase Math que proporciona los métodos correspondientes a las funciones matemáticaas de uso más frecuente, etc.

La Entrada/ Salida queda reforzada con las clases aportadas por el espacio de nombres System.IO para el manejo de archivos.

Código de programa VB.NET : Intereses

Imports System

Namespace MisClases.ES ‘ espacio de nombres

PublicClassLeer    ‘ clase Leer

PublicSharedFunction datoShort() AsShort

Try

ReturnInt16.Parse(Console.ReadLine())

Catch e AsFormatException

ReturnInt16.MinValue ‘ valor más pequeño

EndTry

EndFunction

PublicSharedFunction datoInt() AsInteger

Try

ReturnInt32.Parse(Console.ReadLine())

Catch e AsFormatException

ReturnInt32.MinValue ‘ valor más pequeño

EndTry

EndFunction

PublicSharedFunction datoLong() AsLong

Try

ReturnInt64.Parse(Console.ReadLine())

Catch e AsFormatException

ReturnInt64.MinValue ‘ valor más pequeño

EndTry

EndFunction

PublicSharedFunction datoSingle() AsSingle

Try

ReturnSingle.Parse(Console.ReadLine())

Catch e AsFormatException

ReturnSingle.NaN ‘ No es un Número valor Single.

EndTry

EndFunction

PublicSharedFunction datoDouble() AsDouble

Try

ReturnDouble.Parse(Console.ReadLine())

Catch e AsFormatException

ReturnDouble.NaN ‘ No es un Número valor Double.

System.Console.ReadKey()

EndTry

EndFunction

EndClass

EndNamespace

Small Basic: How to Convert Multi-Line Text into an Array of Lines


niños

Resources For IT Professionals

                       

// United States (English)

Россия (Pусский)中国(简体中文)Brasil (Português)

  • First published by   Nonki Takahashi a private company

Small Basic: How to Convert Multi-Line Text into an Array of Lines

Small Basic can get multi-line text into a variable from multi-line input text box with Controls.GetTextBoxText() or from text file with File.ReadContents().
The following sample code shows how to convert a multi-line text into an array of lines.

Program Code:

CRLF = Text.GetCharacter(13) + Text.GetCharacter(10)

GraphicsWindow.BackgroundColor = “LightGray”

GraphicsWindow.BrushColor = “Black”

gw = GraphicsWindow.Width

gh = GraphicsWindow.Height

tb = Controls.AddMultiLineTextBox(0, 0)

Controls.SetSize(tb, gw, gh – 30)

Controls.AddButton(“Enter”, gw – 50, gh – 30)

Controls.ButtonClicked = OnButtonClicked

Sub OnButtonClicked

buf = Controls.GetTextBoxText(tb)

ConvertTextToLines()

ShowLines()

EndSub

Sub ConvertTextToLines

len = Text.GetLength(buf)

nLines = 0

ptr = 1

While ptr <= len

eol = Text.GetIndexOf(Text.GetSubTextToEnd(buf, ptr), CRLF)

If eol = 0 Then ‘ eol not found

nLines = nLines + 1

lines[nLines] = Text.GetSubTextToEnd(buf, ptr)

ptr = len + 1

Else ‘ eol found

nLines = nLines + 1

lines[nLines] = Text.GetSubText(buf, ptr, eol – 1)

ptr = ptr + eol + 1

EndIf    

EndWhile

EndSub

Sub ShowLines

For i = 1 To nLines

TextWindow.WriteLine(“lines[” + i + “]: ” + lines[i])

EndFor

EndSub

 

 

en-US, From Forum, has code, has comment, Small Basic, TechNet Guru [Edit tags]

.

Detección de colisiones (2) – Código


manzana

Utilizando el concepto de detección de colisiones, crear un juego que contenga dos objetos: un cubo y unas manzanas. Las manzanas caerán al azar desde la parte superior de la pantalla. El jugador intentará capturar las manzanas con el cubo. El juego se ejecuta durante 30 segundos. Incluya un tablero de puntuación para mostrar el número total de manzanas atrapadas por el jugador en 30 segundos. El juego debería ser algo como esto:

Código:

‘  copyright (c) Microsoft Corporation.  Todos los derechos reservados.

GraphicsWindow.Hide()

ventanaAncho = 800

ventanaAlto = 600

GraphicsWindow.CanResize = “False”

GraphicsWindow.Width  = ventanaAncho

GraphicsWindow.Height = ventanaAlto

GraphicsWindow.Top = (Desktop.Height – ventanaAlto) / 2

GraphicsWindow.Left = (Desktop.Width – ventanaAncho) / 2

GraphicsWindow.Title = “Atrapar las manzanas”

GraphicsWindow.Show()

manzanasRestantes = 30

puntuaciónJuego = 0

imagenCubo = Program.Directory + “\cubo.png”

imagenManzana = Program.Directory + “\manzana.png”

GraphicsWindow.MouseMove = AlMoverMouse

CrearInterfaz()

While manzanasRestantes > 0

SoltarManzana()

manzanasRestantes = manzanasRestantes – 1

Shapes.SetText(manzasRestantesCuadroTexto, “Manzanas restantes: ” + manzanasRestantes)

EndWhile

GraphicsWindow.ShowMessage(“Su puntuación es: ” + puntuaciónJuego, “FIN”)

Program.End()

Sub CrearInterfaz

GraphicsWindow.BackgroundColor = “LightBlue”

cubo = Shapes.AddImage(imagenCubo)

manzana = Shapes.AddImage(imagenManzana)

GraphicsWindow.BrushColor = “Gray”

GraphicsWindow.FillRectangle(1, 1, ventanaAncho, 40)

GraphicsWindow.FontName = “Verdana”

GraphicsWindow.FontSize = 18

GraphicsWindow.BrushColor = “White”

GraphicsWindow.DrawText(350, 5, “Atrapar las manzanas”)

puntuaciónCuadroTexto = Shapes.AddText(“Puntuación: 0”)

Shapes.Move(puntuaciónCuadroTexto, 650, 5)

manzasRestantesCuadroTexto = Shapes.AddText(“Manzanas restantes: ” + manzanasRestantes)

Shapes.Move(manzasRestantesCuadroTexto, 5, 5)

GraphicsWindow.PenColor = “Black”

GraphicsWindow.DrawLine(0, 50, 800, 50)

Shapes.Move(cubo, 0, ventanaAlto – 40)

Mouse.HideCursor()

EndSub

Sub AlMoverMouse

cuboX = Math.Min(GraphicsWindow.MouseX, 570)

Shapes.Move(cubo, cuboX, ventanaAlto – 40)

EndSub

Sub SoltarManzana

manzanaX = Math.GetRandomNumber(600)

manzanaY = 50

While (manzanaY < ventanaAlto + 20)

Shapes.Move(manzana, manzanaX, manzanaY)

Program.Delay(15)

DetecciónAtrapar()

manzanaY = manzanaY + 5

EndWhile

EndSub

Sub DetecciónAtrapar

If manzanaY >= ventanaAlto – 40 And manzanaX < cuboX + 50 And manzanaX >= cuboX Then

puntuaciónJuego = puntuaciónJuego + 1

Shapes.SetText(puntuaciónCuadroTexto, “Puntuación: ” + puntuaciónJuego)

manzanaY = ventanaAlto + 20

EndIf

EndSub

MS Small Basic: ¿Qué es una detección de colisiones? (código)


colision1

En general, la detección de colisiones trata de cómo determinar la intersección de dos objetos en movimiento.

La detección de colisiones en los juegos necesita de los siguientes pasos:

  •  Selección de dos objetos para la prueba de colisión.
  •  Comprobación de si se produjo una colisión entre los objetos identificados o no.
  • Se dice que dos objetos chocan cuando entran en contacto el uno con el otro. Los objetos pueden moverse después del choque o pueden detenerse, dependiendo del tipo de colisión.

La detección de colisión es un aspecto básico de los juego de dos y tres dimensiones. Los algoritmos ayudan a detectar la colisión. La mayoría de juegos utilizan detección de colisiones una vez que esta se ha producido.

El siguiente juego contiene dos objetos: la tortuga y el objetivo. El jugador tiene que hacer que la tortuga golpee el objetivo, introduciento para ello el ángulo correcto y la distancia.

Código:

  1. ‘ Copyright (c) Microsoft Corporation.  Todos los derechos reservados.
  2. GraphicsWindow.Hide()
  3. gw = 620
  4. gh = 450
  5. GraphicsWindow.BackgroundColor = “LightBlue”
  6. GraphicsWindow.CanResize = “False”
  7. GraphicsWindow.Width = gw
  8. GraphicsWindow.Height = gh
  9. GraphicsWindow.Top = ( Desktop.Height – gh ) / 2
  10. GraphicsWindow.Left = ( Desktop.Width – gw ) / 2
  11. GraphicsWindow.Title = “Dar en el blanco”
  12. GraphicsWindow.Show()
  13. Turtle.Hide()
  14. rx = 40
  15. ry = 20
  16. tortugaX = 315
  17. tortugaY = 300
  18. ancho = 550
  19. alto = 390
  20. CuadroPuntuaciónX = 400
  21. TeclaEntrar = “Return”
  22. diana = 10
  23. vidas = 3
  24. puntuación = 0
  25. GraphicsWindow.FontSize = 30
  26. GraphicsWindow.DrawText(10, 200, “¡Pulse ENTRAR para comenzar el juego!”)
  27. GraphicsWindow.KeyDown = AlPresionar
  28. Sub AlPresionar
  29. entrar = entrar + 1
  30. If GraphicsWindow.LastKey = TeclaEntrar And entrar = 1 Then
  31. GraphicsWindow.Clear()
  32. GraphicsWindow.FontSize = 12
  33. Interfaz()
  34. MoverFigura()
  35. MostrarPuntuación()
  36. Controls.ButtonClicked
    = Disparar
  37. EndIf 
  38. EndSub
  39. Sub Disparar
  40. ángulo = Math.Round(Controls.GetTextBoxText(ángulotexto))
  41. distancia = Math.Round(Controls.GetTextBoxText(distanciatexto))
  42. presionado = Controls.GetButtonCaption(Controls.LastClickedButton)
  43. If presionado = “Disparar” Then
  44. GraphicsWindow.PenWidth = 0
  45. Turtle.Angle = ángulo
  46. Turtle.Move(distancia)
  47. If Turtle.x > x and Turtle.x < x + 93 and Turtle.y > y and Turtle.y < y + 96 Then
  48. Shapes.HideShape(diana)
  49. puntuación = puntuación + 10
  50. MostrarPuntuación()
  51. Program.Delay(500)
  52. If diana = puntuación Then
    1. TerminarJuego()
    2. EndIf
    3. Controls.SetTextBoxText(ángulotexto, “”)
    4. Controls.SetTextBoxText(distanciatexto, “”)
    5. MoverFigura()
    6. Else
    7. Program.Delay(1000)
    8. If vidas > 1 Then
      1. GraphicsWindow.ShowMessage(“Haga clic en Aceptar para continuar el juego”,”Reintentar”)
      2. presionado = “Reintentar”
      3. Else     
        1. TerminarJuego()
        2. EndIf   
        3. EndIf        
        4. EndIf 
  53. If presionado = “Reintentar” Then   
  54. vidas = vidas – 1
  55. If puntuación >= 10 Then
  56. puntuación = puntuación – 5
  57. EndIf   
  58. MostrarPuntuación()
  59. Controls.SetTextBoxText(ángulotexto, “”)
  60. Controls.SetTextBoxText(distanciatexto, “”)
  61. MoverFigura()
  62. If vidas < 1 Then
  63. TerminarJuego()
  64. EndIf   
  65. EndIf
  66. EndSub
  67. Sub Interfaz
  68. imagen = Program.Directory + “\dibujo.png”
  69. GraphicsWindow.DrawRectangle(rx, ry, ancho, alto)
  70. diana = Shapes.AddImage(imagen)
  71. GraphicsWindow.BrushColor = “Black”
  72. Shapes.Move(diana, 100, 50)
  73. Turtle.Show()
  74. Turtle.X = tortugaX
  75. Turtle.y = tortugaY
  76. Turtle.Angle = 0
  77. GraphicsWindow.DrawText(rx + 5, alto – 10, “Ángulo:”)
  78. ángulotexto = Controls.AddTextBox(tortugaX – 205, tortugaY + 70)
  79. Controls.SetSize(ángulotexto, 40, 30)
  80. GraphicsWindow.DrawText(rx + 140, alto – 10, “Distancia:”)
  81. distanciatexto = Controls.AddTextBox(tortugaX – 60, tortugaY + 70)
  82. Controls.SetSize(distanciatexto, 40, 30)
  83. firebutton = Controls.AddButton(“Disparar”, tortugaX + 20, tortugaY + 70)
  84. Controls.SetSize(firebutton, 80, 30)
  85. Endsub
  86. Sub MoverFigura
  87. Shapes.ShowShape(diana)
  88. Turtle.x = tortugaX
  89. Turtle.Y = tortugaY
  90. Turtle.Angle = 0
  91. x = Math.GetRandomNumber(450)
  92. y = Math.GetRandomNumber(80)
  93. If x <= 40 Then
  94. x = 40
  95. Shapes.Animate(diana, x, y, 1000)
  96. ElseIf y <= 20 Then
  97. y = 20
  98. Shapes.Animate(diana, x, y, 1000)
  99. Else 
  100. Shapes.Animate(diana, x, y, 1000)
  101. EndIf
  102. EndSub
  103. Sub TerminarJuego
  104. GraphicsWindow.ShowMessage(“Puntuación: ” + puntuación, “FIN”)
  105. Program.End()
  106. EndSub
  107. Sub MostrarPuntuación
  108. GraphicsWindow.FontSize = 14
  109. GraphicsWindow.BrushColor = “Gray”
  110. GraphicsWindow.FillRectangle(CuadroPuntuaciónX + 50, CuadroPuntuaciónX – 65, 135, 70)
  111. GraphicsWindow.BrushColor = “White”
  112. GraphicsWindow.DrawText(CuadroPuntuaciónX + 60, CuadroPuntuaciónX – 55, “Puntuación: “)
  113. GraphicsWindow.DrawText(CuadroPuntuaciónX + 150, CuadroPuntuaciónX – 55, puntuación)
  114. GraphicsWindow.DrawText(CuadroPuntuaciónX + 60, CuadroPuntuaciónX – 20, “Vidas: “)
  115. GraphicsWindow.DrawText(CuadroPuntuaciónX + 110, CuadroPuntuaciónX – 20, vidas)
  116. EndSub

Objeto Program


program

Cuando se crean programas y se trabaja con varios objetos y operaciones que ofrece en el entorno .NET, es posible que desee controlar la ejecución de su programa. Puede utilizar el objeto Program para manipular la forma en que su programa se ejecuta

Puede controlar la ejecución de un programa mediante el objeto Program en Small Basic. Observe el ejemplo en pantalla.

  1. Primero, se usa la operación Directory para      mostrar el directorio actual del programa de ejecución. Para mostrar la      ruta al directorio, use el objeto TextWindow con la operación WriteLine.
  2. A continuación, para retrasar la ejecución      del programa por cinco segundos, se usa la operación Delay y se      define el parámetro de tiempo en milisegundos.
  3. La declaración Program.End() hace      que el programa termine.

Revise los resultados del programa haciendo clic en el botón Ejecutar de la barra de herramientas o presionando la tecla F5. La ventana de texto muestra el directorio del programa y, después de un retraso de cinco segundos, el programa termina.

TextWindow.WriteLine(“Carpeta del programa ” + Program.Directory)

TextWindow.WriteLine(“Este programa se ejecuta durante 5 segundos.”)

Program.Delay(5000)

Program.End()

Código Visual Basic graduado

program1

Variables


variable

¿Qué es una variable?

Puede utilizar una variable para almacenar diferentes tipos de información, tales como texto o un número. Una variable puede contener diferentes valores en diferentes momentos. La mayoría de las variables sólo pueden contener un valor a la vez. Sin embargo, las variables especiales, llamadas matrices, pueden contener más de un valor. Vamos a ver un programa en el que se crea una variable para almacenar el nombre del usuario.

Una variable temporal almacena un valor que el programa puede usar posteriormente. Si ejecuta el programa de nuevo pero le asigna un valor distinto a la variable, el nuevo valor de la variable reemplazará el valor antiguo.

Al ejecutar un programa también se usa el valor de la variable, tal como se especificó en el código. Puede volver a usar una variable cuantas veces lo necesite en el programa.

Código:

  1. TextWindow.Write(“¿Cómo se llama?”)
  2. nombre = TextWindow.Read()
  3. TextWindow.WriteLine(“Hola” + nombre + “.”)

Código Bisual Baqsic (graduado)

 

variable1

La operación GetRandomNumber (código)


random
En este programa dibujamos la forma ‘*’ en la ventana de gráficos con diferentes tamaños y en diferentes ubicaciones. Primero establecemos
el alto, ancho y color de fondo de la ventana de gráficos. Luego establecemos el tamaño de la fuente con la operación GetRandomNumber.
El tamaño de la fuente será un número entre
1 y 30, ya que especificamos el valor 30 como parámetro de la operación GetRandomNumber.
También empleamos esta misma operación
para establecer las coordenadas X e Y de los asteriscos.
Visual Basic 2010 Express
random1

Text Box (Código Visual Basic)


cajatxtMicrosoft Visual Basic 2010 Express

  • Un programa para mostrar un formulario sencillo, siguiendo los siguientes pasos:
  •   Agrega cajas de texto que acepten el nombre, dirección, número de teléfono y dirección de email del usuario.
  •  Agrega un botón Enviar al formulario.
  •  Una vez que el usuario introduce la información en todas las cajas de texto y hace clic en el botón Enviar, muestre el mensaje correspondiente.

 cajas_txtModule.vb

Module cajas_txtModule

Dim x, y, cuadroTextoNombre, cuadroTextoDirección, cuadroTextoFono, cuadroTextoCorreo, botónEnviar, botónCancelar, nombre, dirección, fono, correo As Primitive

Sub Main()

GraphicsWindow.Show()

GraphicsWindow.Width = 340

GraphicsWindow.Height = 250

GraphicsWindow.Top = (Desktop.Height – 450) / 2

GraphicsWindow.left = (Desktop.Width – 600) / 2

GraphicsWindow.Title = “Formulario”

x = 30

y = 37

‘Escriba el nombre

GraphicsWindow.DrawText(x, y, “Nombre:”)

cuadroTextoNombre = Controls.AddTextBox(150, 35)

Controls.SetSize(cuadroTextoNombre, 150, 20)

‘Dirección

GraphicsWindow.DrawText(x, y + 40, “Dirección:”)

cuadroTextoDirección = Controls.AddMultiLineTextBox(150, 70)

Controls.SetSize(cuadroTextoDirección, 150, 40)

‘Detalles de teléfono

GraphicsWindow.DrawText(x, y + 90, “Teléfono:”)

cuadroTextoFono = Controls.AddTextBox(150, 125)

Controls.SetSize(cuadroTextoFono, 150, 20)

‘Correo electrónico

GraphicsWindow.DrawText(x, y + 125, “Correo electrónico:”)

cuadroTextoCorreo = Controls.AddTextBox(150, 160)

Controls.SetSize(cuadroTextoCorreo, 150, 20)

‘Enviar

botónEnviar = Controls.AddButton(“Enviar”, x + 30, y + 160)

Controls.SetSize(botónEnviar, 90, 30)

‘Cancelar

botónCancelar = Controls.AddButton(“Cancelar”, x + 150, y + 160)

Controls.SetSize(botónCancelar, 70, 30)

AddHandler Controls.ButtonClicked, AddressOf EnviarFormulario

End Sub

Sub EnviarFormulario()

nombre = controls.GetTextBoxText(cuadroTextoNombre)

dirección = controls.GetTextBoxText(cuadroTextoDirección)

fono = controls.GetTextBoxText(cuadroTextoFono)

correo = controls.GetTextBoxText(cuadroTextoCorreo)

If Controls.GetButtonCaption(Controls.LastClickedButton) = CType(“Enviar”, Primitive) Then

If (nombre = CType(“”, Primitive)) or (dirección = CType(“”, Primitive)) or (fono = CType(“”, Primitive)) or (correo = CType(“”, Primitive)) Then

GraphicsWindow.ShowMessage(“Complete todos los cuadros.”, “Mensaje de error”)

Else

GraphicsWindow.ShowMessage(“Sus datos fueron enviados correctamente.”, “¡Enhorabuena!”)

End If

ElseIf Controls.GetButtonCaption(Controls.LastClickedButton) = CType(“Cancelar”, Primitive) Then

Program.End()

End If

End Sub

End Module

Star Field Simulator


star_rain

Graphical Animated Small Basic Program Gallery

     Star Field Simulator  Microsoft Small Basic

     ‘ Program Listing:   GPZ070

  

  1. 5.      ‘ Krueg — Starfield — Sept. 2012

 

  1. 6.      Delay = 60        ‘Delay for smooth framrate
  2. 7.      StarQty = 80      ‘Number of stars, Too many and it slows the program
  3. 8.      SetupWindow()
  4. 9.      CreateStars()

 

  1. 10.  While (“True”)
  2. 11.  MoveStars()
  3. 12.  RefreshRate()   ‘Comment out this line to see the jerkiness of the array proccessing
  4. 13.  EndWhile

 

  1. 14.  Sub RefreshRate
  2. 15.  While Clock.ElapsedMilliseconds < FrameRate
  3. 16.  EndWhile
  4. 17.  FrameRate = Clock.ElapsedMilliseconds + Delay
  5. 18.  EndSub

 

  1. 19.  Sub MoveStars
  2. 20.  For i = 1 To StarQty
  3. 21.  StarY[i] = StarY[i] + StarHeight[i] * 1.5
  4. 22.  If StarY[i] > gh Then
  5. 23.  StarY[i] = StarY[i] – gh
  6. 24.  StarX[i] = Math.GetRandomNumber(gw – 10) + 5
  7. 25.  EndIf
  8. 26.  Shapes.Move(Star[i],StarX[i],StarY[i])      ‘Checking which moves smother, Shapes.Move or Shapes.Animate
  9. 27.  ‘Shapes.Animate(Star[i],StarX[i],StarY[i],0)
  10. 28.  EndFor
  11. 29.  EndSub

 

  1. 30.  Sub CreateStars
  2. 31.  For i = 1 To StarQty
  3. 32.  GraphicsWindow.PenColor = “White”
  4. 33.  GraphicsWindow.BrushColor = “White”
  5. 34.  StarWidth[i] = Math.GetRandomNumber(2)
  6. 35.  If i < (StarQty * .9) Then
  7. 36.  StarHeight[i] = Math.GetRandomNumber(3)   ‘Create more small stars than big
  8. 37.  Else
  9. 38.  StarHeight[i] = Math.GetRandomNumber(4)+4
  10. 39.  EndIf
  11. 40.  Star[i] = Shapes.AddEllipse(StarWidth[i],StarHeight[i])
  12. 41.  Shapes.SetOpacity(Star[i],StarHeight[i]*5+50)
  13. 42.  StarX[i] = Math.GetRandomNumber(gw – 10) + 5
  14. 43.  StarY[i] = Math.GetRandomNumber(gh)
  15. 44.  Shapes.Move(Star[i],StarX[i],StarY[i])
  16. 45.  EndFor
  17. 46.  EndSub

 

  1. 47.  Sub SetupWindow
  2. 48.  gw = 800
  3. 49.  gh = 600
  4. 50.  GraphicsWindow.Top = 5
  5. 51.  GraphicsWindow.Left = 5
  6. 52.  GraphicsWindow.Width = gw
  7. 53.  GraphicsWindow.Height = gh
  8. 54.  GraphicsWindow.BackgroundColor = “Black”
  9. 55.  EndSub

 

  1. 56.  ‘ Copyright (c) Microsoft Corporation. All rights reserved.

Small Basic: Cómo utilizar las funciones trigonométricas


Nonki Takahashi   http://social.technet.microsoft.com/wiki/contents/articles/17744.small-basic-how-to-use-trigonometric-functions.aspx

TechNet Wiki

Imaginemos para dibujar el arco.
Asumir el centro del arco como x = 200, y = 300, comienzo ángulo a1 = -30 y terminar ángulo = -60.
En matemáticas, el eje y va para arriba. Pero en Small Basic Graphicswindow, el eje y desciende. Así, el ágnulo se vuelve opuesto..

trig1

                       

Si usted no utiliza la función trigonométrica de , utilice tan sólo 0, 30, 45, 60, 90…[grados]. Entre estos bordes se puede calcular la altura s de anchura c del triángulo mientras tres ángulos del triángulo r, c, tal como la foto de abajo tiene relación r2 = s2 + c2 .

Pero para cualquier ángulo, utilice la función trigonométrica (seno, coseno).

trig2

Asegúrese de que función trigonométrica necesita [radianes] pero [grados] para el lenguaje Small Basic

Puede utilizar Math.GetRadians(degree) para convertir de [grados] a [radianes].

Siguiendo el ejemplo de código muestra cómo no utilizar o cómo usar las funciones trigonométricas  para dibujar el arco.

gw = GraphicsWindow.Width

gh = GraphicsWindow.Height

DrawGrid()

x = 200

y = 300

r = 200

DrawArcwoTrigo()

Program.Delay()3000)

GraphicsWindow.Clear()

DrawGrid()

a1 = -30

a2 = -60

DrawArcwTrigo()

Sub DrawArcwoTrigo ‘ draw arc without trigonometric functions

GraphicsWindow.Title = “Arc without Trigonometric Functions”

c1 = r * Math.SquareRoot(3) / 2 ‘ a1 = -30

c2 = r / 2 ‘ a2 = -60

r2 = Math.Power(r, 2)

For c = c1 To c2 Step -1

s = Math.SquareRoot()r2 – Math.Power(c, 2))

x2 = x + c

y2 = y – s

If c = c1 Then

GraphicsWindow.PenColor = “Gray”

GraphicsWindow.DrawLine(x, y, x2, y2)

Else

GraphicsWindow.PenColor = “Black”

GraphicsWindow.DrawLine()x1, y1, x2, y2)

EndIf

If c – 1 < c2 Then

GraphicsWindow.PenColor = “Gray”

GraphicsWindow.DrawLine(x, y, x2, y2)

EndIf

x1 = x2

y1 = y2

EndFor

EndSub

Sub DrawArcwTrigo ‘ draw arc with trigonometric functions

GraphicsWindow.Title = “Arc with Trigonometric Functions”

For a = a1 To a2 Step -0.3

x2 = x + r * Math.Cos(Math.GetRadians()a))

y2 = y + r * Math.Sin(Math.GetRadians()a))

If a = a1 Then

GraphicsWindow.PenColor = “Gray”

GraphicsWindow.DrawLine(x, y, x2, y2)

Else

GraphicsWindow.PenColor = “Black”

GraphicsWindow.DrawLine()x1, y1, x2, y2)

EndIf

If a – 0.3 < a2 Then

GraphicsWindow.PenColor = “Gray”

GraphicsWindow.DrawLine(x, y, x2, y2)

EndIf

x1 = x2

y1 = y2

EndFor

EndSub

Sub DrawGrid

GraphicsWindow.PenColor = “MediumSeaGreen”

GraphicsWindow.BrushColor = “MediumSeaGreen”

For _x = 0 To gw Step 50

GraphicsWindow.DrawLine(_x, 0, _x, gh)

If gw – 50 < _x Then

GraphicsWindow.DrawText(_x + 4, 4, “x”)

Else

GraphicsWindow.DrawText(_x + 4, 4, _x)

EndIf

EndFor

For _y = 0 To gh Step 50

GraphicsWindow.DrawLine()0, _y, gw, _y)

If gh – 50 < _y Then

GraphicsWindow.DrawText()4, _y + 4, “y”)

Else

GraphicsWindow.DrawText()4, _y + 4, _y)

EndIf

EndFor

EndSub

 

Cálculo del logaritmo (Visual Basic)


Al hacer cálculos complejos frecuentemente se necesita el valor logarítmico (en base 10) de un número en particular.

El objeto Math de ofrece la operación Log para obtener el logaritmo de un número.

En este ejemplo empleamos la operación Log para calcular el logaritmo de 22.

log1

log

Cálculo de seno y coseno de un ángulo en grados (Visual Basic)


En este ejemplo calculamos el seno y el coseno de un ángulo arbitrario mediante las operaciones Sin y Cos del objeto Math. También obtenemos el ángulo
en radianes a partir del seno mediante la operación ArcSin. A continuación convertimos el ángulo de radianes a
grados con la operación GetDegrees

angulovb

angulo

Shapes Editor – Small Basic Featured Program


shape

Small Basic  The Official Blog of Small Basic

 

Ed Price – MSFT  Microsoft      From Nonki Takahashi:

What’s New in Shapes 1.42 :

  • Supported cursor key to move a shape.
  • New UI for consecutive shapes addition.
  • Added instruction in save popup.

http://blogs.msdn.com/b/smallbasic/archive/2013/06/14/shapes-editor-small-basic-featured-program.aspx

Small Basic: How to Debug – Featured Article (II)


Small Basic  The Official Blog of Small Basic

Ed Price – MSFT Microsoft

Today’s featured article was written by…Nonki Takahashi

This article includes following tips about how to debug program written in Small Basic language.  And also this article shows you real samples for debugging with published programs.

  • Use TextWindow.WriteLine() to show contents of variables
  • Write debug code such as “If debug Then…”
  • Write test programs for subroutines
  • Write list of bugs
  • Meaning of error messages
  • Use “Graduate” and Visual Studio debugger

Use TextWindow.WriteLine() to show contents of variables

When you find something wrong in you program, how do you find the cause?  Small Basic IDE (integrated development environment) doesn’t have ability such like variable watching.  But in many cases, some variables have unexpected values in them.  To find that, let’s add TextWindow.Write() or TextWindow.WriteLine() to look in variables for debugging.

To show an array “arry”, you can simply use TextWindow.WriteLine(arry) or write code like the following code:

TextWindow.ForegroundColor = “Yellow”

num = Array.GetItemCount(arry)

index = Array.GetAllIndices(arry)

For i = 1 To num

TextWindow.WriteLine(“arry[” + index[i] + “]=” + arry[index[i]])

EndFor

TextWindow.ForegroundColor = “Gray”

For text base program debugging, changing foreground color may help you to distinguish program original outputs and debugging messages.

Write debug code such as “If debug Then…”

If you wrote a subroutine to show such like an array for debug, that code will be useful also in the future.  But, these code will be needed only when you debug.  So it is a way to use debug flag to on and off your debug routines.

Maze 0.4 (PNC833-0) is a sample which has debug flag.  Following line sets debug flag off.  And debug = “True” will turn on the flag.

27.debug = “False”

The following lines call a subroutine to show array “cell” of created maze as text.

61.If debug Then

62.  DumpMaze()

63.  TextWindow.WriteLine(title)

64.EndIf

The following lines slow down creating maze to look and show variables and pause the program using TextWindow.Read().

229.     If debug Then

230.       Program.Delay(20)

231.     EndIf

232.     ‘ 2. Add the neighboring walls of the cell to the wall list.

234.     AddWallToList()

235.     If debug Then

236.       TextWindow.WriteLine(“iWalls=” + iWalls)

237.       TextWindow.Write(“nWalls=” + nWalls)

238.       TextWindow.Read()

239.     EndIf

And after debugging is completed, these lines are easily found (with [Ctrl]+F in Small Basic IDE) and removed.  Actually these routines are removed in Maze 0.5 (not published).

Write test programs for subroutines

To write generic subroutines (for general-purpose) will help your productivity.  In my case, some subroutines for colors, maths, mouse, and etc. are reused in many programs.  But generic subroutines should be well tested and have no bugs.  No (or less) bugs will be a prior condition for productivity.

To test your subroutines, it is a reasonable way to write a test program for them.  Good test program will find bugs from your subroutines and make easy to check regression after debugging.

A program which calculate combination nCr for big n (CPQ608) has a test routine TestDiv() for a generic subroutine Div().

Following parameters were found with TestDiv() and caused problem in Div().

‘a = “434399216531770650390143258708”

‘b = “6752306690329”

‘a = “397896921587794748049229269710”

‘b = “8642083658481”

Write list of bugs

The following list was written when Shapes 1.1 (TLW744) was in debugging.  When you write lots of code, you may happen to meet many strange behaviors in your program.  If so, it will help you that you write a list that includes each phenomenon.  Because there may be many different causes of the phenomena.  And after debugging, this list will be a good test set for your program.

  • CalcOpposite() returns wrong value when shape re-sizing
    cause: variable func was not be set for the routine
  • Pinches (small circles) remain after click out of shapes
    cause: not implemented yet
  • Frame sometimes not appear when shape moving
    cause: variable i didn’t set as selectedshape
  • Pinches sometimes remain when cut and paste
    cause: duplicate as follows
  • Pinches don’t redraw after copy
    cause: pinches are not displayed after paste
  • Shape moves after mouse release
    cause: needed to keep mouse released in mouse handler
  • Other shape size and position become wrong after color change
    cause: unnecessary RegisterShapeData() called and broke variable i
  • Other shape selected after adding ellipse or triangle
    cause: cancel adding procedure (when menu item clicked) set needless variable obj
  • Sometimes shape can’t be moved
    cause: mouse released flag should be cleared

Meaning of error messages

There are two types of error messages given by Small Basic.  One is compile errors.  Another one is runtime errors.  These messages help your development.

Compile errors appear under source code just after “Run” button is clicked if your program has any syntax errors.  The following picture shows errors of a program “Fifty” (BRQ733) :

Sorry, we found some errors…
11,28: The available ‘files’ is used, but its value is not assigned.  Are you sure you have spelled it correctly?
29,24: The available ‘buf’ is used, but its value is not assigned.  Are you sure you have spelled it correctly?

debugging

Numbers mean lines and columns of source code, and you can jump into the point in source program by double clicking the error message.  These kind of compile error messages show you what happened and some advice to fix them. In this case, errors happened because lines with File.GetFiles(path) and File.ReadContents(filename) have been automatically commented out by Small Basic server.

On the other hand, a runtime error appears while a program runs but happens to meet trouble which make the program stop.  Following picture is a sample of divsion by 0 error message.

Decimal type value is too large or too small.
Location System.Decimal..ctor(Double value)
Location Microsoft.SmallBasic.Library.Math.Remainder(Primitive dividend, Primitive divisor)
Location _SmallBasicProgram._Main()

animate1

The list shown in the text box is called stack trace.  This list shows you relations which subroutine calls which subroutine at the error.  In this case, the stack trace shows that main part of the program calls Math.Remainder() and occurs error.

Use “Graduate” and Visual Studio debugger

Despite writing many debug routines, some bugs may be too complicated to find their causes.  As a last option, it will work for you to use “Graduate” button to convert Small Basic program to Visual Basic program.  This allows you to use strong Visual Studio debugger to find causes of bugs originally in your Small Basic program.

Step 1: Install Visual Basic 2010 Express if you don’t install yet.
Step 2: Push “Graduate” button and input folder name for converted Visual Basic program.
Step 3: Push [Next] or [Finish] buttons in Visual Studio conversion wizard.  Program XXX.sb (or XXX.smallbasic) will be converted to XXXModule.vb.
Step 4: Rewrite from ‘For i = 1 To n’ to ‘For i As Primitive = 1 To n’ to avoid scope error.
Step 5: Double click a source line to make the line as break point if needed.
Step 6: Push “Debug Start” button or [F5] key to start program.
Step 7: If program stops at break point, push “Step In (F8)” or “Step Over (Shift+F8)” to continue.
Step 8: See “Auto Variable”, “Local” or “Watch” tab and confirm the values of variables.
Step 9: If you find a bug, push “Stop Debugging” button and rewrite your program with comment.
Step 10: Repeat from step 6 again.

debugging2

If you confirmed a bug fix, go back to Small Basic IDE and fix program just as you did in Visual Studio.

There are some differences between Small Basic and Visual Basic syntax as listed below.

  • Array : Array notation is arry[i][j] in Small Basic but arry(i)(j) in Visual Basic.
  • Variable type : Small Basic variables are type Primitive so sometimes need type conversion such as ‘If ans = CType(“”, Primitive) Then’.
  • Boolean : Type Primitive can be used as boolean as follows:
    clicked = true ‘ or false
    If clicked Then
    If clicked = CType(false, Primitive) Then
  • Array: Setting to two dimensional array doesn’t work in Visual Basic.  So replace ‘shape(5)(“angle”) = 90’ as follows:
    saved = shape(5)
    saved(“angle”) = 90
    shape(5) = saved
  • For block variable: For control variable will cause warning about for it’s scope.  To avoid that declare module name before the variable: (We don’t need to change variables inside block.  Only in For statement.)
    Before: For i = 1 To 10
    After: For FooModule.i = 1 To 10

Conclusion

These tips are outputs from programming Small Basic within the last couple of years but not everything.  It is important to be creative with programming and debugging.  If you find good way, please add the way into this article.  Small Basic is very compact and a good language to learn programming with.   It’s easy and powerful.


Small Basic: How to Debug

How to Create Video Games in VB.Net (Windows Forms) – Code program


vbasicnet

Reed Kimble Micro Plastics, Inc.

http://social.technet.microsoft.com/wiki/contents/articles/17358.how-to-create-video-games-in-vb-net-windows-forms.aspx

I realize that this is a very popular subject, especially amongst budding developers. The drive to create games may be the reason you started working with Visual Basic in the first place. After stepping through a few samples and getting the hang of working with user controls on a form, it may be very tempting to start to throw some PictureBoxes and a Timer on a Form and start to implement some game logic. Seems easy enough, right?

To some extent, this is a true statement. You could start to do this and it would be easy enough… at first. But when you begin to try to calculate collision and animate or rotate your “sprites”, you may start to run into some difficulty. And attempts to circumvent the problems often lead to even worse issues. This can cause an endless spiral of misery which could leave you thinking VB just isn’t meant to make games! 😉

The initial problem that most people face is the desire to use a PictureBox (or any other control) as the logical “Sprite” container for the elements in the game. It makes sense since the control appears to provide a lot of the required functionality already and it’s easy to extend it with more properties as needed.

The issue though is that Windows Forms Controls are designed to be drawn statically – that is, they aren’t meant to move around in real-time. You can of course move them at run-time, but this is normally an on-demand operation (something which occurs because the user just took an action like clicking a button or menu item). Attempting to move controls in real-time puts a heavy strain on your application and can cause poor performance quickly.

There’s also the issue that a control is painted according to its own logic, so you can’t just take any old control and “rotate” it without modifying the logic which draws the control (at some level).

The other thing that Windows Forms leads you right into is using Events. So it’s natural to think to implement user input by handling key and mouse events on the PictureBox or the containing Form. But even though Windows Forms are designed to rely heavily on the Event chain, they are expecting the application to be idle most of the time, doing its work in fits and bursts. This kind of application works well even with many events and handlers.

But a game is a single long-running loop. Your Windows Forms application is technically a pre-specified Form instance started in a long-running message loop, but then you interact with the loop through the Event chain.

For the best performance, a .Net GameEngine should actually do away with the main Form and use the program’s main loop to execute the game loop functionality. But it can be acceptable to maintain the Form and a Control or Component or two and implement a GameEngine in componentized form.

However, this is where the use of controls stops. While there may be a component to house the “GameEngine” related functionality, and a “RenderCanvas” CustomControl to render the game engine display, all of the actual game elements would be class instances handled by the GameEngine component which are not controls of any kind.

Your “Sprite” class (we can debate terminology as technically a sprite is just an image resource, but for this discussion “sprite” is a game object of some sort with image and movement and collision and all) is its own custom “game object” class that you define to hold values such as location, speed, bounds, image and/or animation. The GameEngine is responsible for updating and drawing each game object once each game-loop-iteration and the RenderCanvas is responsible for rendering the last drawn frame.

Here is an example from a thread on the MSDN forums. This very simple example uses a Timer component as the “game engine” and the Form serves as the “render canvas”.

Option Strict On

Public Class Form1

‘One timer controls the entire game loop

Private WithEvents Timer1 As New Timer

‘A list of the game tile objects used by the game

Private _GameTiles As New List(Of GameTile)

‘An instance of GameTime to track running game time

Private _GameTime As New GameTime

‘Two bitmaps and a boolean used to buffer drawing and rendering

Private _Buffer1 As New Bitmap(ClientSize.width, ClientSize.height)

Private _Buffer2 As New Bitmap(_Buffer1.Width, _Buffer1.Height)

Private _BufferFlag As Boolean

Private Sub Form1_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load

‘setup the form

Me.DoubleBuffered = True

Me.FormBorderStyle = Windows.Forms.FormBorderStyle.Fixed3D

‘load some image assets to use for frames of animation

Dim imageList As New List(Of Image)

imageList.Add(SystemIcons.Application.ToBitmap)

imageList.Add(SystemIcons.Error.ToBitmap)

imageList.Add(SystemIcons.Exclamation.ToBitmap)

imageList.Add(SystemIcons.Information.ToBitmap)

imageList.Add(SystemIcons.Question.ToBitmap)

‘create a grid of tiles

For y As Integer = 0 To 7

For x As Integer = 0 To 7

Dim tile As New GameTile

tile.FrameImages.AddRange(imageList)

tile.Location = New Point(12 + (x * tile.Bounds.Width), 12 + (y * tile.Bounds.Height))

_GameTiles.Add(tile)

Next

Next

‘set the game time to 30 fps (1000ms / 30frames)

Timer1.Interval = 33

‘start the game loop

Timer1.Start()

End Sub

‘Use a stopwatch to track the execution time

Private _ElapsedTime As New Stopwatch

Private Sub Timer1_Tick(sender As Object, e As System.EventArgs) Handles Timer1.Tick

_ElapsedTime.Stop()

‘Record they time since the last loop iteration

_GameTime.Elapse(_ElapsedTime.ElapsedMilliseconds)

‘Reset the stopwatch to 0 and start tracking again

_ElapsedTime.Restart()

‘Run a loop to check input for each item.

For Each tile In _GameTiles

If MouseButtons = Windows.Forms.MouseButtons.Left Then

If tile.Bounds.Contains(PointToClient(MousePosition)) Then

tile.OnInput(_GameTime)

End If

End If

Next

‘Run a loop to draw each item after determining which

‘buffer to draw on this frame

Dim gfx As Graphics

If _BufferFlag Then

gfx = Graphics.FromImage(_Buffer1)

Else

gfx = Graphics.FromImage(_Buffer2)

End If

gfx.Clear(BackColor)

For Each tile In _GameTiles

tile.OnDraw(_GameTime, gfx)

Next

‘Cleanup and swap buffers

gfx.Dispose()

_BufferFlag = Not _BufferFlag

‘Show the drawn scene

Invalidate()

End Sub

Protected Overrides Sub OnPaint(e As System.Windows.Forms.PaintEventArgs)

MyBase.OnPaint(e)

‘Draw the approprite render buffer

If _BufferFlag Then

e.Graphics.DrawImageUnscaled(_Buffer2, Point.Empty)

Else

e.Graphics.DrawImageUnscaled(_Buffer1, Point.Empty)

End If

End Sub

End Class

Public Class GameTile

Public Property Location As Point

Public Property FrameImages As New List(Of Image)

‘this is the images per second of the animation

Public Property FrameRate As Double = 8.0

‘this is the total time to animate after recieving a click

Private _AnimationTime As Double

Public ReadOnly Property Bounds As Rectangle

Get

Return New Rectangle(Location, FrameImages(CurrentFrameIndex).Size)

End Get

End Property

Private _FrameIndex As Double

Public ReadOnly Property CurrentFrameIndex As Integer

Get

Return CInt(Math.Floor(_FrameIndex))

End Get

End Property

Public Sub OnInput(gameTime As GameTime)

‘set the remaining animation time to 3 seconds when clicked

_AnimationTime = 3.0

End Sub

Public Sub OnDraw(gameTime As GameTime, gfx As Graphics)

‘draw the current frame at its current location

gfx.DrawImageUnscaled(FrameImages(CurrentFrameIndex), Location)

‘if there is remaining animation time, then animate

If _AnimationTime > 0 Then

_FrameIndex += gameTime.LastFrame * FrameRate

If CurrentFrameIndex = FrameImages.Count Then _FrameIndex = 0.0

_AnimationTime -= gameTime.LastFrame

Else

_FrameIndex = 0.0

End If

End Sub

End Class

‘GameTime can be a simple structure or class which just tracks executed

‘game time based on what the game loop tells it

Public Structure GameTime

Public ElapsedTime As TimeSpan

Public LastFrame As Double

Public Sub Elapse(milliseconds As Long)

ElapsedTime += TimeSpan.FromMilliseconds(milliseconds)

LastFrame = milliseconds / 1000

End Sub

End Structure

Notice that the code only defines two classes other than the Form. This example defines a single “sprite” or “game object” called GameTile, and a structure called GameTime which is used to track the game engine execution time (both total time and last frame time, that is, last loop iteration time) – an important set of values in many calculations.

The GameTile class is overly-simple and just has an OnInput and OnDraw logic processing routine for the engine to call. In a more robust model, there would be additional logic processing methods which would get called at various appropriate points throughout each execution of the game engine loop.

The GameTile has very simple logic which just executes a 3 second “animation” (sequence of images) played at the frames-per-second specified by FrameRate whenever the tile is clicked.

The game engine loop itself is implemented in the Timer1_Tick event handler. As previously noted, this is not ideal as the event chain is less efficient for our purposes than running a background thread would be, but the timer keeps the example simple. Regardless of where it is run, the logic executed by this Timer1_Tick event handler lays out the general structure of the logic which needs to occur once each game loop iteration.

First, we update the time based on how long the last frame took to execute. You might do this at the end of each iteration, rather than at the beginning, but this implementation does it first because it makes the code simple to follow.

Next we update input for each game object (GameTile). Since the example is running directly off of the Form’s thread we can just cheat on input and read it in real time from the Form. A more robust game loop would maintain an Input object which was updated once per frame before beginning on game objects. So the code checks each object to see if the mouse is being held down on it, and calls the OnInput method for that object if so.

Game objects should have their input updated first, then their logic processed, and finally their positions drawn. It is important to perform separate loops for each operation so that all game objects work together in a predictable manner. This example does not use an OnUpdate method, but typically, OnInput, OnUpdate, and OnDraw are the minimum logic processing methods for a game object.

Now that all of the GameTile objects are updated, they can have their current state drawn. The example does implement buffered drawing even though this simple implementation doesn’t really require it. But it is not very complex and it makes it much more clear how to transition drawing into multiple threads.

By implementing a buffered drawing (do not confuse with DoubleBuffered property of Form – that just makes GDI behave for real-time drawing) we ensure that the image being processing by the Form thread is never the same as the image being processed by the background game engine loop. The Form renders one buffer image and the game loop draws to the other, and then flips buffers as the last operation on each frame. After the buffer has been flipped, a call can be sent off to invalidate the Form (or render control) and the game loop can continue processing and drawing the next frame (on the alternate buffer).

Once the code has selected the correct buffer for drawing this frame, it proceeds to create the graphics object which will be passed to every game object allowing it to draw itself to the buffer. When this process is complete, the graphics can be freed, the buffer can be flipped, and the render control can be informed that it needs to update.

Again, and I can’t stress enough, this is only a most basic implementation – a robust game engine has a lot more work to do. But this example should provide a simple overview of the primary concepts involved with creating a game engine.

XNA

The next most important thing to be aware of when it comes to creating games in VB.Net is that Microsoft has an official platform just for Games and Interactive Software, called XNA Framework . As of the latest refresh you can now use VB with XNA Game Studio. Although XNA can seem quite daunting at first, if you understand the basic concepts lain out above, then you are already well on your way to using it. XNA follows a similar pattern to what I’ve described here, and there are lots of examples and tutorials to get you started. There is just a lot more to it since XNA supports everything – all 2D, 3D, audio, game-pad input, multiplayer networking, Xbox Live access, etc.

Games created in XNA can also easily be written to port from Windows to Xbox to WindowsPhone7. And you can easily become a publisher and actually put your game on Xbox Live or Windows Marketplace and collect royalties for its purchases.

Now, for a fairly simple, very “classic” style 2D video game, XNA could be considered overkill. And what you can accomplish with GDI+ and some creative sound and input hooks might provide everything that your game design requires. But just keep in mind that broad support for game development is available under the XNA platform and it is incredibly powerful once you get the hang of using it (which really isn’t as bad as it first may seem if you just stick with it!).

Unity

I always feel obligated to mention this non-Microsoft-based solution because it is just so dang powerful and cool and wonderful and free (to play with anyway!). Unity3D is a complete 3D development environment; like Visual Studio only the “form designer” is a 3D world space and the toolbox is full of game objects! The AI can be developed through script plugins in multiple languages including C# and Java. So while it’s not exactly a VB solution, I still bring it up because the C# you would need to know is pretty easy to convert from VB and the Unity engine itself is truly remarkable.

In many ways what Unity does is very much like what XNA does. The main difference is that Unity goes so far as to define what a game engine is and then allows you to easily extend it, whereas XNA only provides all of the interfaces necessary for you to create your own game engine of some kind. This is what allows Unity to provide a rich editor full of drag-and-drop and property-grid-setting features.

GdiGaming API

Finally, if you still have your heart set on making a quick little game directly in VB.Net (and why shouldn’t you?! They do make such fun projects!), then you may wish to check out the GdiGaming API over on CodePlex .

This is a project I’m working on as I have time, which is meant to give a robust example of creating game engine in VB.Net using GDI as well as provide a compiled runtime which can be used as-is to quickly make little games based around the engine.

While there may still be a few bugs to work out, the API works generally as intended and is quite powerful for what it does and how it is designed.  The project is a pretty good start on a full-scale game engine based around the kind of example shown above. It is open-source (as CodePlex implies) and I’ve tried to provide fairly rich documentation and sample code. There’s still plenty to do (always a work in progress I guess!) but I believe there is enough there already for it to be of additional help if you are interested in reading more.

Conclusion

I hope that somewhere in all of this there is some useful information for those of you starting out to write games in .Net. The horizons are currently broad, and the roads become more and more well-traveled every day. The amount of information available is tremendous and I would encourage you to play with all of the technologies mentioned in this article and read all of their help files. Even if you don’t download anything yet, just go to the XNA and Untiy websites, navigate to their intro tutorials and read them. Take note of the terminology and get a general feel for what the code appears to do, even if you can’t read all of it.

The next great game is just waiting to be written, and with effort and determination in no short supply you could be the one to write it! =)

en-US, has code, has comment, has comments, VB.NET 2010, Video Games, visual basic, Windows Forms [Edit tags]

Beginning Microsoft Small Basic – Review by “Royal Little Lambs”


a1

Small Basic

The Official Blog of Small BasicMSDN Blogs > Small Basic >

Ed Price – MSFT

Microsoft

MSFT

182,282 Points 25 20 19

Recent Achievements

Better Galleries Together Forums Replies V Proposed Answerer III

Liz reviewed Computer Science for Kids and very much enjoyed learning Beginning Microsoft Small Basic.

There are 11 lessons. They range from 22-109 pages.

The lessons generally consist of

  • Review and preview
  • Small Basic (lessons)
  • Program (application: actual programming)
  • Summary

Liz quickly became very comfortable with the lessons and completed them all by herself and called me {constantly} to come see her fun little creations.
Dad downloaded and set up and looked through the curriculum to see what needed to be done. This was outta Mom’s comfort zone! Liz was bored with waiting.

Then after it was all ready, Dad showed her how to work the program a bit, and she perked up.

Elizabeth loved learning about the history of computers and programming in the first lessons. I was impressed with this narrative.

It shows pictures of the first computers – nifty. And did you know that BASIC is an acronym? (Beginner’s All-Purpose Symbolic Code) From Class 1: “Small Basic starts with a really simple programming language that gathers inspiration from the original BASIC language. It has no more than 15 keywords and is strictly imperative.”

She likes the “games.” She likes the control and learning how changing just one letter or character can change the whole program. Her analytical mind at work! I love that she is learning about computers. I know my dad is proud (it’s what he wanted me to do!).  It’s great help to her in math since she has to calculate the size of shapes or borders within the graphics.

Then she was on her own. She was all proud of herself and showing me all these little “games” she wrote.

She self-corrected her code when they didn’t work just the way she wanted. Dad helped her change them and showed her different options. Then she ran with it.

I am thankful that we can utilize the kids’ desktop computer and my laptop so Liz could have the lessons up and do her code at the same time. It made it less frustrating for her. And that makes me happy.

The true test is that she can explain to me why the shape is filled in or outlined in a certain color and which code is needed to make it do what she wants!

I noticed yesterday that she’s completed all 11 lessons – the whole book…

Me: “If you like it, I will purchase the next book for you.”

Liz: “I thought you already had the whole program for me. I want it all!”

And that’s a good review.

A typical lesson only takes a few minutes (tweaking and playing can take much longer!) so many colors, choices, sizes, codes…it’s like a new toy! She has this last on her daily list as an incentive to complete her other work!

Beginning Microsoft Small Basic

Thanks to Philip Conrod and to Jennifer from Royal Little Lambs.

small basic, Ed Price, Guest Blogger, Philip Conrod, Small Basic E-Books

  •  

     

Visual Basic 2010 Express (código de programa)


letras

Las letras caen una por una (animación) hasta formar la frase: Hello Word 

Código Visual Basic migrado (graduado) de Small Basic

Module UntitledModule

Dim displayText, i, letter, letterShape, j As Primitive

Sub Main()

GraphicsWindow.Show()

GraphicsWindow.BackgroundColor = ” Yellow ”

displayText = “Hello World”

For i = 1 To 11

letter = Text.GetSubText(displayText, i, 1)

letterShape = Shapes.AddText(letter)

For j = 1 To 100

Shapes.Move(letterShape, 20 * i, j)

Program.Delay(10)

Next

Program.Delay(100)

Next

End Sub

End Module

Código Small Basic original:

GraphicsWindow.Show() GraphicsWindow.BackgroundColor = ” Yellow ”

displayText = “Hello World”

For i = 1 To 11

letter = Text.GetSubText(displayText,i,1)

letterShape = Shapes.AddText(letter)

For j = 1 To 100

Shapes.Move(letterShape,20*i,j)

Program.Delay(10)

EndFor

Program.Delay(100)

EndFor

Programming Tips : basic and essential for any language programming (code lines in blue)


http://social.technet.microsoft.com/wiki/contents/articles/15081.small-basic-programming-tips.aspx    By litdev Small Basic Forum Moderator

flowchart-for-modeling-data1

 

This article covers the basic ideas of structured programming, or some tips for writing better programs in Small Basic or another language.

‘Better’ is subjective and people do prefer different styles, but there are some general rules that do help, especially when your programs get more complicated.

GoTo

This is the most controversial and opinion differs.

Normally a program runs one line, then the next, progressing through the code in a logical order.  It can do For or While loops and branch into different code using If, ElseIf and EndIf.  The path taken through the code is sometimes called the ‘flow’ of the code.  We want this flow to be as clear and logical as possible.

A GoTo just jumps somewhere completely different.  This can make the code very hard to follow and virtually impossible to debug or extend if they are used indiscriminately.  However, they are a very natural concept for the starting programmer before they know much about other ways to control the flow of code.

Below is a sample code using GoTo’s too much – what is it supposed to do and why doesn’t it work?

x = 0

y = 0

For i = 1 To 100

  a:

  x = x+1

  b:

  x = x-1

  c:

If (i <10) Then

    Goto a

  Else

    y = y+1

    Goto b

  EndIf

  If (y <3) Then

    Goto c

  EndIf

EndFor

These are called ‘spaghetti’ code.

The general rule is for every GoTo that you use, you should consider very carefully if there is a better way to do it – there almost always is.  There are occasions in Small Basic where it is the best option, but they are very rare.

You should never use a GoTo to jump into or out from a subroutine or your program will crash.  This is because the call stack will be corrupted.  The call stack is an internal structure that controls where a subroutine should return to when it ends and is updated when the subroutine is called and returned from.

Subroutines

Subroutines are pieces of code that perform a specific task.  Often the task may be needed in different parts of your code and prevent duplication of code.  If you are writing very similar code for different parts of your program, then probably subroutines could help.

A subroutine in Small Basic starts with the keyword Sub and ends with EndSub.  It can then be called by using the subroutine name followed by two round braces ().

value = Math.Pi

roundResult()

writeOutput()

 

Sub roundResult

  result = 0.001*(Math.Floor(1000*value+0.5))

EndSub

Sub writeOutput

  TextWindow.WriteLine(“the current value rounded to 3 decimals is “+result)

EndSub

The subroutine code block can be placed anywhere in your code, but it is best to place them all together after you main code.

Often we can break a task into a number of sub tasks, each of which could then be a subroutine.

The length of a subroutine is not that important, don’t just subdivide a long piece of code into subroutines unless each has a specific task.  Generally it is good if the main or top-level subroutines are quite short so it is easy to follow the main logic of the program.

The key to subroutines is:

  • Making them do just one task – it may be very general like “Initialise Program” and include many sub tasks or be very specific like “Check overlap of 2 shapes”.  You should be able to describe the subroutine task in just a few words and don’t tempted to ‘just add in a little something else’.
  • Make them as general as possible – especially if you might want to reuse the code in other programs.  See the section on “Variables or constants”.

Comments

A comment in Small Basic starts with an apostrophe ‘ and is highlighted in green.  Anything after it is ignored to the end of the line.

'Calculate distance between objects

distance = Math.SquareRoot((x-a)*(x-a) + (y-b)*(y-b)) '(x,y) is the player

Comments are not just for others reading your code, they help remind you later why you did something.  More importantly they show the thinking behind the code and the ideas about how the program should work.

Try to add comments that explain something complex or why you did something one way or another.  They should remind you and help someone else understand the overall thinking you had when you wrote the program.

The ‘more comments the better’ is not good, the following comment adds nothing.

x = x+5 'Add 5 to x

Sometimes comments can be used to visually separate sections of your code like the start of subroutines.

 

Variable names

Try to use descriptive names for your variables, there is no penalty in performance or memory for long variable names.  Try not to make them too long, but be clear what they are.

There are conventions for variable naming, but most common is to mainly use lower case and capitalise each word apart from the first (that remains lower case).

For loop counters are usually just a single character, i, j, k etc.

playerTank = Shapes.AddImage(playerTankImage)

For i = 1 To numEnemy

  enemyTank[i] = Shapes.AddImage(enemyTankImage)

EndFor

Variables or constants

Sometimes in your code you use a value that is fixed, perhaps the number of enemies, or offset for positioning a shape at its centre or the text used to ask a question.

It is good practice to put all these constants in variables so that you can just change the variable without having to change the constant values throughout your code.  It can also make your code more general so that it can be re-used or subroutines used more extensively, reducing the need for duplicate code.  All the variables can be simply initialised in one subroutine at the start.

GraphicsWindow.Show()

displayText = "Hello World"

For i = 1 To 11

  letter = Text.GetSubText(displayText,i,1)

  letterShape = Shapes.AddText(letter)

  For j = 1 To 100

    Shapes.Move(letterShape,20*i,j)

    Program.Delay(10)

  EndFor

  Program.Delay(100)

EndFor)

The code above would be better written as below so we can easily change the parameters of the method if we change the font for example.

Initialise()

displayText = "Hello World"

ShowText()

 

Sub Initialise

  GraphicsWindow.Show()

  characterOffset = 20

  movingLetterSteps = 100

  delayMovingLetter = 10

  delayLetter = 100

EndSub

Sub ShowText

  For i = 1 To Text.GetLength(displayText)

    letter = Text.GetSubText(displayText,i,1)

    letterShape = Shapes.AddText(letter)

    For j = 1 To movingLetterSteps

      Shapes.Move(letterShape,characterOffset*i,j)

      Program.Delay(delayMovingLetter)

    EndFor

    Program.Delay(delayLetter)

  EndFor

EndSub

 Arrays

Use arrays where possible to group items.  For example if you have multiple buttons, put them all in an array.  In the example below all we need to do to add more buttons is add a new buttonText array element.

Initialise()

Controls.ButtonClicked = OnButtonClicked

 

Sub Initialise

  buttonText[1] = “Clear”

  buttonText[2] = “Start”

  buttonText[3] = “Run”

  buttonText[4] = “Pause”

  buttonText[5] = “Exit”

  numButton = Array.GetItemCount(buttonText)

  

  For i = 1 To numButton

 button[i] = Controls.AddButton(buttonText[i],60*i-50,GraphicsWindow.Height-40)

    Controls.SetSize(button[i],50,30) ‘Equal size to look better

  EndFor

EndSub

 

Sub OnButtonClicked

  lastButton = Controls.LastClickedButton

 For i = 1 To numButton

    If (lastButton = button[i]) Then

      GraphicsWindow.ShowMessage(buttonText[i]+” was clicked”,”Information”)

    EndIf

  EndFor

EndSub

 

Code layout

Indentation and spacing

Use the indentation feature of Small Basic to format your code.  This can be found by right clicking and select ‘Format Program’.

Also use blank lines to separate code segments, but try not to have lots of randomly placed blank lines.

layout

Code order

Place your main code at the start, then place all subroutines below the main code, perhaps separating program subroutines and event subroutines.

Perhaps also separate your main code into sections like ‘Initialisation and Setup’, ‘Main Program’ or others that may apply.

Planning

Try to think of a program structure at the start, then create the main subroutines and variables/arrays and gradually add the detail.  Test detail in small prototype programs first, then add to the main program.

The temptation is to add all the fine detail of a program at the start and then build a structure around this, but this will often lead to code that is hard to develop and debug.

Programming Tips – Small Basic Featured Article


smallavisual

Ed Price – MSFT    http://blogs.msdn.com/b/smallbasic/archive/2013/06/10/programming-tips-small-basic-featured-article.aspx

LitDev strikes again with another fantastic article on TechNet Wiki:

Small Basic: Programming Tips

This article covers the basic ideas of structured programming, or some tips for writing better programs in Small Basic.

 Subroutines

Subroutines are pieces of code that perform a specific task.  Often the task may be needed in different parts of your code and prevent duplication of code.  If you are writing very similar code for different parts of your program, then probably subroutines could help.

A subroutine in Small Basic starts with the keyword Sub and ends with EndSub.  It can then be called by using the subroutine name followed by two round braces ().

  1. value = Math.Pi
  2. roundResult()
  3. writeOutput()
  1. Sub roundResult
  2. result = 0.001*(Math.Floor(1000*value+0.5))
  3. EndSub
  1. Sub writeOutput
  2. TextWindow.WriteLine(“the current value rounded to 3 decimals is “+result)
  3. EndSub

The subroutine code block can be placed anywhere in your code, but it is best to place them all together after you main code.

Often we can break a task into a number of sub tasks, each of which could then be a subroutine.

The length of a subroutine is not that important, don’t just subdivide a long piece of code into subroutines unless each has a specific task.  Generally it is good if the main or top-level subroutines are quite short so it is easy to follow the main logic of the program.

The key to subroutines is:

  • Making them do just one task – it may be very general like “Initialise Program” and include many sub tasks or be very specific like “Check overlap of 2 shapes”.  You should be able to describe the subroutine task in just a few words and don’t tempted to ‘just add in a little something else’.
  • Make them as general as possible – especially if you might want to reuse the code in other programs.  See the section on “Variables or constants”.

Ping Pong Small Basic para pequeños (código)


pong

Small Basic   The Official Blog of Small Basic

http://blogs.msdn.com/b/smallbasic/archive/2013/06/10/small-basic-for-little-kids-series-pong.aspx
Versión 2

‘ v2
‘ bounces well, left to right

‘ make background
GraphicsWindow.Width = “700”
GraphicsWindow.Height = “500”

‘set pen
GraphicsWindow.PenColor = “gray”
GraphicsWindow.PenWidth = “50”

‘draw border
GraphicsWindow.DrawRectangle(0,0,700,500)

‘ set brush
GraphicsWindow.BrushColor = “white”

‘ make left goal, size 100, from (0,200) to (0,300)
GraphicsWindow.FillRectangle(0,200,26,100)

‘ make right goal, size 100, from (674,200) to (674,300)
GraphicsWindow.FillRectangle(674,200,26,100)

‘ set brush
GraphicsWindow.BrushColor = “black”

‘ make paddles
GraphicsWindow.FillRectangle(30,220,10,60)
GraphicsWindow.FillRectangle(664,220,10,60)

‘ draw ball
Sub DrawBall
GraphicsWindow.BrushColor = “black”
GraphicsWindow.FillEllipse(BallX,BallY,10,10)
EndSub

‘ erase ball
Sub EraseBall
GraphicsWindow.PenWidth = “2”
GraphicsWindow.BrushColor = “white”
GraphicsWindow.FillEllipse(BallX,BallY,10,10)
GraphicsWindow.PenColor = “white”
GraphicsWindow.DrawEllipse(BallX,BallY,10,10)
EndSub

‘ sleep
Timer.Interval = 1
Timer.Tick = RunGame

StepSize = 2

StepX = StepSize
StepY = 0

BallX=345
‘ BallY=245
BallY=100

LeftWallX = 27
RightWallX = 660

DrawBall()

Sub RunGame
EraseBall()
BallX = BallX + StepX
BallY = BallY + StepY

‘ Hit right wall
If BallX >= RightWallX Then
StepX = -StepSize
EndIf

‘ Hit left wall
If BallX <= LeftWallX Then
StepX = StepSize
EndIf

DrawBall()
EndSub

MS Small Basic- Simple, divertido, Gradual y Social


Ed Price – MSFT

La programación es diversión, otra vez!

Mirosoft Small Basic pone la “diversión” nuevamente dentro de la programación informática. Con un entorno de desarrollo amigable que es muy fácil de dominar, facilita para niños y adultos en el mundo de la programación.

sb1

Simple

Small Basic combina un ambiente agradable con un lenguaje muy sencillo y un conjunto rico y atractivo de bibliotecas para hacer sus programas y juegos pop. En cuestión de pocas líneas de código, usted estará bien en su camino a la creación de su propio juego!

Con un nuevo y revolucionario IntelliSense ®, Small Basic hace escribir código como una brisa.

sb2

Social

Compartir tus programas con tus amigos; que importan los programas publicados y ejecutarlos en su computadora. Utiliza el reproductor de Silverlight, incluso pueden publicar sus juegos en sus blogs y páginas web para que puedan jugar sus creaciones en el navegador.

Gradual

Aprender los conceptos de programación a partir de los fundamentos y subir tu camino. Small Basic se basa en .NET y lo que aprendes aquí podrían aplicarse fácilmente a otros lenguajes como Visual Basic de programación de .NET. Y cuando te gradúas a Visual Basic, puede traer sus programas existentes  mediante una utilidad de conversión incorporada.

Gracias a Vijaye Raji  por el contenido !

No olvides revisar el foro Small Basic:

Small Basic Forum


pmedio

Ed Price – MSFT  El compilador de Small Basic y su enviroment (entorno)  permiten  3  bibliotecas Small Basic plug in (conectarse)  y ampliar las posibilidades de lo que puede hacer desde dentro de Small Basic.

Aquí está una lista de las pequeñas extensiones básicas:

Small Basic extensions Galery

¿Quieres aprender a crear una extensión para Small Basic?

Small Basic: Cómo crear una extensión usando C# – por Liam McSherry

Small Basic: Cómo crear una extensión utilizando VB.NET – por Noah Buscher

¿Utiliza o crea  extensiones para Small Basic ? Aparecen en la galería de extensiones (enlace de arriba)?

¡ Gracias!

-Ed ninja     http://blogs.msdn.com/b/smallbasic/archive/2013/05/31/does-small-basic-support-extensions.aspx

 

Programación, bien desde el principio…!!! (2)


Si ingresamos al link:  http://smallbasic.com/

Tendremos un completo panorama de los múltiples recursos de MS Small Basic

El software se baja en forma gratuita (inglés o español) de:

“A simplified programming language and environment to help teach programming to beginners

http://www.microsoft.com/en-us/download/details.aspx?id=22961

Como está dentro de .NET Framework (como VB.NET y C#) tambien bajamos sin cargo: .Net Framework 3.5SP1

También están disponibles dos tutoriales sin cargo, y en distintos idiomas:

  • Small Basic: Introducción a la programación. Que enseña con claridad los conceptos básicos de programación (variables, ciclos y subrutinas, condiciones y bifurcaciones,  construcción de un videogame sencillo, etc)
  • Curriculum: un tutorial más completo con innumerables programas de ejmplo con el código escrito para que el estudiante los siga con facilidad
  • Es de destacar que Small Basic tiene una función “Graduar” que convierte a este programa en un projecto Visual Basic, listo para ejecutar.

El alumno que se inicie con Small Basic obtendrá a posteriori, una curva de aprendizaje muy corta para lenguajes más complejos como  Visual Basic  y C#, que junto a Small Basic están en el entorno de .NET Framework

Y po sobre todo, es muy divertido…

Vea el tutorial de introducción, en el idioma que elija en

http://msdn.microsoft.com/en-us/ff423682

¿Qué es realmente un programa de ordenador?

Un programa es un conjunto de instrucciones para el ordenador. Dichas instrucciones indican con precisión al ordenador lo que hacer y el ordenador siempre las sigue. Al igual que la gente, los ordenadores sólo siguen instrucciones si se especifican en un idioma o lenguaje que puedan entender. Estos se denominan lenguajes de programación. Hay muchos lenguajes que los ordenadores entienden y Small Basic es uno de ellos.

Imagine una conversación entre usted y un amigo. Usted y su amigo utilizan palabras, organizadas en frases para intercambiar información. De la misma manera, los lenguajes de programación contienen conjuntos de palabras que pueden organizarse en frases para transmitir información al ordenador. Los programas son básicamente grupos de frases (algunas veces unas pocas y otras miles) que, juntas, tienen sentido por igual tanto para el programador como para el ordenador.

Los programas de Small Basic

Un programa típico de Small Basic consiste en un conjunto de instrucciones. Cada línea del programa representa una instrucción y cada instrucción es una orden para el ordenador. Cuando pedimos al ordenador que ejecute un programa de Small Basic, lee la primera instrucción del programa. Entiende lo que le pedimos y ejecuta la instrucción. Una vez que ha ejecutado la primera instrucción, vuelve al programa para leer y ejecutar la segunda instrucción. Y así continúa hasta alcanzar el final del programa. Es entonces cuando nuestro programa termina.

Nuestro segundo programa

Ahora que ya hemos examinado nuestro primer programa, vamos a darle una nota de color.

(Nuestro segundo programa (para el 1º programa busque en: http://www.empiezoinformatica.wordpress.com  )

TextWindow.ForegroundColor = “Yellow”

TextWindow.WriteLine(“Hola mundo”)

sb1

Cuando ejecute el programa anterior, notará que imprime el mismo mensaje que antes (“Hola mundo”) dentro de la ventana de texto (TextWindow), pero esta vez la imprime en amarillo (Yellow) en lugar de en gris.

sb2

Para ello, hemos agregado una nueva instrucción al programa original. Utiliza una nueva palabra ForegroundColor (color de fondo) al que se le asigna “Yellow” (amarillo). Esto significa que se asigna “Yellow” a ForegroundColor. La diferencia entre las operaciones ForegroundColor y WriteLine es que ForegroundColor no admite ningún parámetro y, por tanto, no necesita paréntesis. En su lugar, le sigue un símbolo igual que (=) y una palabra. ForegroundColor se define como una propiedad de TextWindow. He aquí una lista de valores que son válidos para la propiedad ForegroundColor. Reemplace “Yellow” con uno de los siguientes valores y observe los resultados. No se olvide de las comillas ya que son imprescindibles.

El tutorial completo en:   http://msdn.microsoft.com/en-us/ff423682

Programación, bien desde el principio…!!!


La programación

En informática, se define la programación como el proceso de crear aplicaciones para ordenador utilizando lenguajes de programación. De la misma manera que los humanos hablamos y entendemos inglés, español o francés, los ordenadores entienden programas escritos en ciertos lenguajes.

Estos se denominan lenguajes de programación. Al principio sólo había unos pocos lenguajes de programación y eran muy fáciles de aprender y entender. Pero a medida que los ordenadores y el software se han vuelto cada vez más sofisticados, los lenguajes de programación evolucionaron rápidamente, volviéndose cada vez más complejos. El resultado es que los más modernos lenguajes de programación y sus conceptos son bastante difíciles de comprender para un principiante. Esto ha desalentado a muchas personas a aprender o intentar programar.

Small Basic es un lenguaje de programación que está diseñado para hacer la programación muy sencilla, accesible y divertida para los principiantes. El objetivo de Small Basic es romper cualquier barrera y servir de piedra angular para el increíble mundo de la programación.

El entorno de Small Basic

Empecemos con una breve introducción al entorno de Small Basic. Cuando lance SB.exe por primera vez, se encontrará con una ventana parecida a la siguiente figura.

sb1

Este es el entorno de Small Basic, donde escribiremos y ejecutaremos los programas de Small Basic. Este entorno contiene varios elementos distintos identificados con números.

El Editor, identificado con [1], es el lugar donde escribiremos nuestros programas de Small Basic. Cuando abra un programa de ejemplo u otro guardado previamente, aparecerá en el editor. Una vez abierto, puede modificarlo y guardarlo para usos posteriores.

También puede abrir y trabajar con más de un programa a la vez. Cada programa aparecerá en un editor distinto. El editor que contiene el programa en el que está trabajando se denomina editor activo.

La Barra de herramientas, identificada con [2], se utiliza para emitir comandos bien al editor activo o al entorno. Veremos los distintos comandos de la barra de herramientas según vayamos avanzando.

La Superficie, identificada con [3], es el lugar donde se encuentran todas las ventanas del editor.

Nuestro primer programa

Ahora que ya se encuentra familiarizado con el entorno de Small Basic, empecemos a programar en él. Como se indicó anteriormente, el editor es el lugar donde escribiremos nuestros programas. Escriba la siguiente línea en el editor.

TextWindow.WriteLine(“Hola mundo”)

 

Este es nuestro primer programa de Small Basic. Si lo ha tecleado correctamente, verá algo parecido a la siguiente figura.

sb2

Ahora que hemos escrito nuestro primer programa, vamos a ejecutarlo y ver qué pasa. Podemos ejecutar un programa bien haciendo clic en el botón Ejecutar de la barra de herramientas o utilizando la tecla de método abreviado F5 del teclado. Si todo va bien, nuestro programa debería ejecutarse con el resultado siguiente.

sb3

¡Enhorabuena! Acaba de escribir y ejecutar su primer programa de Small Basic. Es cierto que es un programa pequeño y sencillo, ¡pero es un gran paso para convertirse en un verdadero programador informático! Sólo un detalle más antes de crear programas más grandes. Necesita entender qué es lo que hemos hecho. ¿Qué le hemos dicho al ordenador que haga y cómo sabía el ordenador qué hacer? En el siguiente capítulo analizaremos el programa que acabamos de escribir para poder alcanzar dicho entendimiento.

sb4

Guardando nuestro programa

Si desea cerrar Small Basic y volver más tarde al programa que acaba de escribir, tiene que guardarlo. Es una buena práctica guardar los programas de vez en cuando, para no perder ninguna información en el caso de que el ordenador se apague accidentalmente o haya un corte de luz. Puede guardar el programa actual haciendo clic en el icono Guardar de la barra de herramientas o utilizando el método abreviado “CTRL+S” (pulse la tecla “S” mientras mantiene pulsada la tecla CTRL).

http://msdn.microsoft.com/en-us/ff423682

Small Basic: depuración (debugging) de un programa ( código)


aaaabbbb

Small Basic: TextWindow.WriteLine como ayuda de depuración

¿Cómo detectamos el error? Es hora de depurar el código otra vez…modificar
Puede el programa y usar TextWindow.WriteLine para mostrar el valor que devuelve la operación CopyFile en la ventana de texto – la cual puede ser SUCCESS o FAILED.

De esta manera, si el programa no es capaz de ejecutarse por un error en la operación CopyFile ¡lo sabrá inmediatamente!

Código:

GraphicsWindow.Width = 600

GraphicsWindow.Height = 450

GraphicsWindow.Top = (Desktop.Height-450) / 2

GraphicsWindow.left = (Desktop.Width-600) / 2

GraphicsWindow.Title = “Imágenes”

RutaImagen = “C:\Users\carlos\Pictures\aaaabbbb.jpg”

GUI()

ImagenSmallBasic = File.GetFiles(RutaImagen)

GraphicsWindow.DrawResizedImage(ImagenSmallBasic[i], 50, 50, 500, 300)

Controls.ButtonClicked = SlideShow

Sub GUI

GraphicsWindow.BackgroundColor =”LightSlateGray”

GraphicsWindow.FontSize=25

botónSgte = Controls.AddButton(“<“,50,370)

botónAtr = Controls.AddButton(“>”,500,370)

Controls.SetSize(botónSgte, 50, 50)

Controls.SetSize(botónAtr, 50, 50)

EndSub

Sub SlideShow

If Controls.GetButtonCaption(Controls.LastClickedButton) = “>” Then

If i < Array.GetItemCount(ImagenSmallBasic) Then

i = i + 1

imágenes[i] = ImageList.LoadImage(ImagenSmallBasic[i])

GraphicsWindow.DrawResizedImage(imágenes[i], 50, 50, 500, 300)

TextWindow.WriteLine(“Nombre de imagen: ” + ImagenSmallBasic[i])

EndIf

EndIf

If Controls.GetButtonCaption(Controls.LastClickedButton) = “<” Then

If i > 1 Then

i = i – 1

imágenes[i] = ImageList.LoadImage(ImagenSmallBasic[i])

GraphicsWindow.DrawResizedImage(imágenes[i], 50, 50, 500, 300)

TextWindow.WriteLine(“Nombre de imagen: ” + ImagenSmallBasic[i])

EndIf

EndIf

EndSub

¿Qué lecciones pueden los estudiantes aprender en Small Basic? (Comunidad de Kodu Spotlight: parte 1)


lecciones

MSDN Blogs > Small Basic > ¿Qué lecciones pueden los estudiantes aprender en Small Basic ? (Comunidad de Kodu Spotlight: parte 1  Ed Price – MSFT

Aprenderás los conceptos básicos rápidamente y fácilmente porque lo haráss en el ambiente más simple. BASIC se inició en 1964 y está parado para el código de instrucciones simbólicas multiuso para principiantes. Fue creado para enseñar el desarrollo de software. Así que hemos proporcionado una versión aún más simplificado y más adecuado para conseguir en correr, escribir su propio código y entender conceptos de programación de base, incluso más rápido. Estos conceptos básicos incluyen Variables, condiciones y ramificación, lazos, gráficos, formas, subrutinas, arreglos de discosy eventos & interactividad.

Seguir a uno de nuestros tutoriales, y probablemente a recoger estos conceptos mucho más rápidamente por su cuenta (y aún más rápido con un mentor ayudarle) que lo haría en un aula, donde puede aprender los conceptos por primera vez, en un lenguaje más complicado. Usted aprenderá todos los pilares fundacionales de lenguajes como Visual Basic, C++, C# y muchos más.

En su opinión, ¿cuál es la cosa más fresca sobre Small Basic ?

 

Small Basic fue diseñado originalmente por Vijaye Raji, y su éxito se deriva de los tres pilares del valor.

En primer lugar, es Simple. Small Basic es imperativo y no utilice ni lo exponga a principiantes a conceptos como la orientación a objetos, tipos, alcances, etc.. La lengua se compone de sólo 14 palabras clave. Hay un sistema de tipo. Puede crear cadena y constantes numéricas y asignarlas a variables. Las operaciones realizadas en estas variables se interpretará según el contenido. Todas las variables son globales y se inicializan siempre. Puede ser utilizados antes de que asignó! Puede crear un sub-routine y asignarlo a un evento. Las bibliotecas proporcionan estáticos “objetos” las operaciones del grupo, propiedades y eventos.

Nuevas bibliotecas pueden crearse utilizando otros lenguajes .net y añadidas al tiempo de ejecución pequeño básico. Si eres nuevo en programación, esto no suena muy simple. Muchos de estos detalles son lo que ayuda a hace pequeñas básicas fáciles de aprender y usted puede leer más en Small Basic FAQ

En segundo lugar, es Social. Compartir tus programas con tus amigos; que importar los programas publicados y ejecutarlos en su computadora. Incluso puedes publicar tus juegos en sus blogs y páginas web para que puedan jugar sus creaciones en el navegador! Visita ely Small Basic  program Galery, listados por categoría para ejemplos. Después de colaborar en la fabricación de su juego, puede discutirlo con el
comunidad en el Foro de MSDN básica pequeño. Y entonces nosotros podríamos cuentan en el Blog de MSDN Small Basic.

En tercer lugar, es Gradual. Small Basic se basa en .NET y lo que aprendes aquí podrían aplicarse fácilmente a otros lenguajes como Visual Basic de programación de .NET. Para “graduar” a Visual Basic, simplemente haga clic en el botón graduar, y puede traer sus programas existentes  en Small Basic a Visual Basic mediante la descarga gratuita de Visual Studio Express. Mediante este sistema, usted puede aprender Visual Basic,
C++ y C#, sin jamás gastar un centavo.

Gracias al equipo de producto para la entrevista!

-Ed Price

Fácil, divertido, corto e ilustrativo (Código MS Small Basic)


facil

 

Usted puede publicar su código fuente de ejemplo interesante (y una pantalla opcional del programa) aquí. Si es lo suficientemente interesante, vamos Ofrecemos a usted ya su código fuente en nuestros blogs (http://blogs.msdn.com/smallbasic). Aquí hay algo para empezar.

Código:

GraphicsWindow.Show()

pic = Flickr.GetRandomPicture(“lightning”)

gw = GraphicsWindow.Width

gh = GraphicsWindow.Height

GraphicsWindow.DrawResizedImage(pic, 0, 0, gw, gh)

distance = 50

Turtle.Speed = 9

For sides = 3 To 20

DrawPolygon()

EndFor

Sub DrawPolygon

angle = 360 / sides

For i = 1 To sides

GraphicsWindow.PenColor = GraphicsWindow.GetRandomColor()

Turtle.Move(distance)

Turtle.Turn(angle)

EndFor

EndSub

Pilas y matrices en programación (explicación y código)


matriz                       pila

Trabajo de litdev (Scotland) Moderador Small Basic Forum

http://social.technet.microsoft.com/wiki/contents/articles/15066.small-basic-stack-basics.aspx

Queremos crear una matriz con todos los archivos de imagen jpg de un directorio y todos los subdirectorios, buscando todas las carpetas de forma recursiva.
Primero creamos un array (matriz) vacío para almacenar las rutas de los archivos de imagen y el número de archivos en el mismo (cero para empezar). También establecemos la carpeta de empezar a buscar y agregarlo a una pila que llamamos “folders” (carpetas). En este ejemplo, la ubicación de la carpeta de inicio es la carpeta donde está guardado el archivo Small Basic fuente (Program.Directory

images = “”

imageCount = 0

startFolder = Program.Directory

Stack.PushValue(“folders”,startFolder)

Ahora vamos a seguir trabajando mientras nosotros tenemos carpetas todavía para comprobar, o la pila todavía tiene algunas carpetas en el mismo. Nosotros usamos un bucle while para esto. Dentro del bucle, mientras que nosotros queremos  procesar la última carpeta añadida, por lo que se metió primero

While Stack.GetCount(“folders”) > 0

currentFolder = Stack.PopValue(“folders”)

‘ More work to do here

EndWhile

Ahora queremos procesar esta carpeta, primero tenemos todas las subcarpetas, de la carpeta de trabajo actual y empujar a estos en la pila para su posterior comprobación de que las while repite.

folders = File.GetDirectories(currentFolder)

For i = 1 To Array.GetItemCount(folders)

Stack.PushValue(“folders”,folders[i])

EndFor

Después de haber añadido las sub-carpetas para comprobar más tarde como se desenrolla la pila, nos encontramos con todos los archivos en la carpeta de trabajo actual y añadir otras que terminan en “. Jpg” a la lista de Array (matriz). Comprobamos el archivo por primera conversión a minúsculas, con el fin de incluir todas las variantes de caja de jpg a JPG etc

files = File.GetFiles(currentFolder)

For i = 1 To Array.GetItemCount(files)

fileName = files[i]

fileNameLower = Text.ConvertToLowerCase(fileName)

If (Text.EndsWith(fileNameLower,”.jpg”)) Then

imageCount = imageCount+1

images[imageCount] = fileName

EndIf

EndFor

 

Por último, imprimir los resultados, y por ahora es todo.

 

images = “”

imageCount = 0

startFolder = Program.Directory

Stack.PushValue(“folders”,startFolder)

While Stack.GetCount(“folders”) > 0

currentFolder = Stack.PopValue(“folders”)

folders = File.GetDirectories(currentFolder)

For i = 1 To Array.GetItemCount(folders)

Stack.PushValue(“folders”,folders[i])

EndFor

files = File.GetFiles(currentFolder)

For i = 1 To Array.GetItemCount(files)

fileName = files[i]

fileNameLower = Text.ConvertToLowerCase(fileName)

If (Text.EndsWith(fileNameLower,”.jpg”)) Then

imageCount = imageCount+1

images[imageCount] = fileName

EndIf

EndFor

EndWhile

For i = 1 To Array.GetItemCount(images)

TextWindow.WriteLine(images[i])

EndFor

Ciclos en Small Basic (código)


while

 

En general, se utiliza un ciclo For..EndFor (Para…Fin del Para) para ejecutar el mismo código un número específico de veces. Para manejar este tipo de ciclo, se crea una variable que sigue las veces que el ciclo se haya ejecutado.

Si no sabe el número de repeticiones del ciclo antes de escribir un programa, puede crear un ciclo While (Mientras) en lugar de un ciclo For.

Cuando se crea un ciclo While, se especifica una condición que ocurre cuando comienza el ciclo. Sin embargo, el ordenador evalúa la condición cada vez que se repite el ciclo. Cuando la condición ya no se cumple, el ciclo se detiene.

  1. Textwindow.Title =”Ciclos en Small Basic”
  2. a  = 10
  3. While (a <= 100)
  4. TextWindow.WriteLine(a)
  5. a = a +10
  6. EndWhile

Small Basic: What is a Stack ? (code example)


a1

This article covers the basic use of the Small Basic Stack, with an example recursively finding all jpg image files in and below an initial directory.

What is a Stack

A stack is an ordered list where entries are added (pushed) and retrieved (popped) in a last-in first-out order.  The name stack come from the fact that it is like a stack of plates.  When we add a plate it goes on the top and when we remove a plate it is the last one added that is removed.

A stack is useful to store things that we want process gradually as we unwind the stack, retrieving things to process.  Often the things to add to the stack are not known at the start, but are the result of processing previous stack values.  If we knew them all at the start we could just put them in an array.

Stack methods

Only three methods are present, they are:

  • count = GetCount(stackName) – the number of items present in the stack.
  • PushValue(stackName, value) – add a value to the stack.
  • value = PopValue(stackName) – retrieve a value and remove it from the stack.

The stackName is a string, that is something enclosed in double quotes, for example “my_stack”.  The value may be any Small Basic variable or value.

Example

We want to create an array with all of the jpg image files in a directory and all sub-directories, searching all folders recursively.

First we create an empty array to store the image file paths and the number of files in it (zero to start with).  We also set the starting folder to search and add it to a stack we call “folders”.  In this example the starting folder location is the folder where the Small Basic source file is saved (Program.Directory).

images = “”

imageCount = 0

startFolder = Program.Directory

Stack.PushValue(“folders”,startFolder)

Next we want to keep working while we have folders still to check, or the stack still has some folders in it.  We use a while loop for this.  Inside the while loop we want to process the last folder added, so it will be popped first.

While Stack.GetCount(“folders”) > 0

currentFolder = Stack.PopValue(“folders”)

‘ More work to do here

EndWhile

We now want to process this folder; first we get all the sub-folders in the current working folder and push these onto the stack for later checking as the while loop repeats.

folders = File.GetDirectories(currentFolder)

For i = 1 To Array.GetItemCount(folders)

Stack.PushValue(“folders”,folders[i])

EndFor

Having added the sub-folders to check later as the stack unwinds, we find all the files in the current working folder and add ones ending in “.jpg” to the array list.  We check the file by first converting to lower case, in order to include all case variants of jpg JPG etc.

files = File.GetFiles(currentFolder)

For i = 1 To Array.GetItemCount(files)

fileName = files[i]

fileNameLower = Text.ConvertToLowerCase(fileName)

If (Text.EndsWith(fileNameLower,”.jpg”)) Then

imageCount = imageCount+1

images[imageCount] = fileName

EndIf

EndFor

Finally we print out the results, and below is the whole thing.

images = “”

imageCount = 0

startFolder = Program.Directory

Stack.PushValue(“folders”,startFolder)

While Stack.GetCount(“folders”) > 0

currentFolder = Stack.PopValue(“folders”)

folders = File.GetDirectories(currentFolder)

For i = 1 To Array.GetItemCount(folders)

Stack.PushValue(“folders”,folders[i])

EndFor

files = File.GetFiles(currentFolder)

For i = 1 To Array.GetItemCount(files)

fileName = files[i]

fileNameLower = Text.ConvertToLowerCase(fileName)

If (Text.EndsWith(fileNameLower,”.jpg”)) Then

imageCount = imageCount+1

images[imageCount] = fileName

EndIf

EndFor

EndWhile

For i = 1 To Array.GetItemCount(images)

TextWindow.WriteLine(images[i])

EndFor

http://social.technet.microsoft.com/wiki/contents/articles/15066.small-basic-stack-basics.aspx

Aprende a programar con el lenguaje más sencillo (Softonic)


a2

La enseñanza de la programación puede seguir dos vías distintas: una pasa por el uso de metáforas gráficas, mientras que la otra prefiere código simplificado.

Microsoft Small Basic apuesta por este último camino, presentando un dialecto de Basic reducido a tan solo 15 funciones para dibujo bidimensional, la reproducción de sonidos y cálculos aritméticos. Para instalarlo en español, hay que elegir el paquete de idioma durante la instalación.

Es un programa muy util y sencillo para introducir a las personas que no tienen conocimiento, previo alguno.

  • Usabilidad   10
  • Estabilidad 8,7
  • Instalación 10
  • Funciones  6,2
  • Apariencia 10

http://microsoft-small-basic.softonic.com/

Small Basic: Text Basics – Featured Article


TICFind the latest and complete version of this article here, on TechNet Wiki:

Small Basic: Text Basics

Introduction

Text is a series of characters, often called a string in computing.  A string can be a constant (or literal) enclosed within a set of double quotes, or a variable can be assigned to hold a string.

txt = “Hello World”

Above, txt is a variable that contains the string literal “Hello World”.

As stated, the string contains a set or characters, in the example above there are 11 characters, ‘H’, ‘e’, ‘l’, ‘l’, ‘o’, ‘ ‘, ‘W’, ‘o’, ‘r’, ‘l’ and ‘d’.

A string can also be a series of numbers such as “3.14159”, or even contain special characters like backspace, newline, ‘♥’ or even a system beep.  These are not to be confused with the different representations of the characters that different fonts can provide, including different language fonts like the symbol font.

Each character is identified internally by a ‘character code’ or number, often called ASCII or UNICODE number.

We often want to form one string from others or query a string to see what it contains.

See more in    http://blogs.msdn.com/b/smallbasic/archive/2013/05/28/small-basic-text-basics-featured-article.aspx

Small Basic: Challenge of the Month – May 2013


tennis_ball

Tennis Ball   ‘Copyright (c) 2013 Nonki Takahashi. All rights reserved.

  • Physics Challenge

Back to basics – write a program where a ball can roll down an inclined slope – use an image for the ball and show it rotating as it accelerates while rolling.  To make it tougher try the ball on different angled slopes – it should accelerate faster on the steeper slopes.

Download this program from

http://smallbasic.com/program/?NZR510

Small Basic: juego on- line en 3D


3D

3D RayCaster Maze – Featured Small Basic Game

Echa un vistazo a este fantástico juego de 3D ​​en tiempo real (que se ejecuta en línea).  Por Old Basic Coder  ( tester de software)

http://blogs.msdn.com/b/smallbasic/archive/2013/05/27/3d-raycaster-maze-featured-small-basic-game.aspx

Hice un programa de tipo “3D Maze” como ejercicio. No había nada programado para unos 25 años, nos apetecía volver a estar en ella, y descargar la versión gratuita de Visual Studio. Se apareció con la opción de SmallBASIC, así que pensé que empezaría el primero.
Descarga el código del programa de : http://smallbasic.com/program/?DWV967

Small Basic: eventos de teclado (código de ´programa)


key

Usamos la operación Move (desplaza al rectángulo) y Keydown y Keyup que lo gira 90 grados y después lo vuelve a su lugar, usando cualquier tecla

  1. GraphicsWindow.Height =300
  2. GraphicsWindow.Width = 300
  3. GraphicsWindow.BackgroundColor = “Yellow”
  4. forma1 = Shapes.AddRectangle(100,50)
  5. Program.Delay(1000)
  6. Shapes.Move(forma1, 100,125)
  7. return = “Return”
  8. GraphicsWindow.KeyDown = keydown
  9. GraphicsWindow.KeyUp = keyup
  10. Sub keydown
  11.   If GraphicsWindow.LastKey = return Then
  12.     Shapes.Rotate(forma1, 90)
  13.   EndIf
  14. EndSub
  15. Sub keyup
  16.   If GraphicsWindow.LastKey = return Then
  17.     Shapes.Rotate(forma1, 0)
  18.   EndIf
  19.   EndSub

Un nuevo blog se presentó a MS Small Basic


a1
Asunto: Campamentos Básicas de aprendizaje en la Academia Main Stem – Verano 2013
Por: Ed Price – MSFT
Enlace:

http://www.mainstemacademy.com/

Marck McDonald en Main Stem Academia, está enseñando pequeños campos básicos. Cada campamento es impulsado por un tutorial. Los niños pueden inscribirse en cualquier momento o ir a toda la serie. Si asisten a toda la serie, que tendrán el reto con nuevos tutoriales y escenarios cada semana. Ellos usarán técnicas ágiles de gestión de proyectos. Los niños aprenderán cómo diseñar, construir algoritmos, gestionar un proyecto y trabajar algoritmos en un ambiente de equipo, la construcción de una valiosa experiencia para un mundo real, el medio ambiente profesional business.
Visite la página de campamento Small Basic de la página web Academia Tallo principal de información de precios y para registrarse:
http://www.mainstemacademy.com/small-basic/
Aquí están los campamentos de verano 2013:

Campo I (8 de julio – 12)
Campo II (15 de julio – 19)
Campo III (12 de agosto – 16)
Campo IV (19 de agosto – 23)

Para cada campo, los estudiantes pueden asistir el día completo o medio día (por la mañana o por la tarde). Vea el enlace de arriba para las diferencias de precios.

INSTRUCTOR

Mark pasó 28 años en el desarrollo de software, gestión de proyectos y productos, y las implementaciones de software empresarial. Es un Scrum Master y autor de libros de tecnología Certified. Su base de consultoría incluye Boeing, Microsoft, JD Edwards, Chase, Broderbund, CB Richard Ellis, Marina de los EE.UU., Servicio Forestal de los EE.UU., NBBJ, Swedish Medical Center y muchas otras compañías y organizaciones. Le gusta enseñar y ver a los jóvenes a aprender programación, la gestión y el emprendimiento de proyectos.

¿Cuáles son las características únicas del lenguaje Microsoft Small Basic?


Sin título2

MSDN Blogs > Small Basic > What are the unique features of the Small Basic language?

Ed Price – MSFT Microsoft

Originalmente escrito por el creador de Small Basic, Vijaye Raji …
Aquí están las características únicas del lenguaje Small Basic
Imperativo:

Al igual que las primeras variantes de BASIC, Small Basic es imperativo y no utiliza o expone a los principiantes, a conceptos como ámbitos, tipos, orientación a objetos, etcétera
Tamaño:

El lenguaje Small Basic consta de sólo 14 palabras clave. (keywords)
Tipo de sistema:
Hoy en realidad no lo es. Puede crear cadenas y constantes numéricas y
asignarlos a variables. Las operaciones realizadas en estas variables serán
interpretado de acuerdo con el contenido.

Variables:
Todas las variables son globales y siempre están inicializadas

Pueden ser utilizados antes que están asignadas

.
Eventos

Puede crear una sub-rutina y asignarla a un evento. Esto la llevaría hacia arriba
hasta un evento.
Libreías
Las librerías ofrecen “Objetos” estáticos que el del grupo, propiedades y eventos..

Se pueden crear nuevas librerías  utilizando otros lenguajes de  .NET Framework  y se añaden a la Runtime Small Basic.

http://blogs.msdn.com/b/smallbasic/archive/2013/05/25/what-are-the-unique-features-of-the-small-basic-language.aspx

small basic, Ed Price, Vijaye Raji

El problema de las 8 reinas (código en Small Basic)


chess

El problema 8-Queens en el ajedrez es colocar 8 reinas en un tablero de ajedrez de tal manera que ninguna de las reinas es una amenaza cualquiera de las otras. El problema es que a la entrada de las 8 columnas de las reinas en las filas de un tablero de ajedrez, donde 1 es la primera columna y 8 la última, por ejemplo, 1 2 3 4 5 6 7 8 significa que las reinas están a lo largo de la diagonal, lo cual no sería una solución válida.

http://blogs.msdn.com/b/smallbasic/archive/2013/01/11/queens-chess-challenge-small-basic.aspx

Más información   http://en.wikipedia.org/wiki/Eight_queens_puzzle

Program Listing:  QDX521    http://smallbasic.com/program/?QDX521

1.Principio del formulario

‘ 8-Queens 0.2
‘ Copyright (c) 2012 Nonki Takahashi

‘ History :
‘ 0.2 2013/01/03 Rewrote for 8-Queens probrem. ()
‘ 0.1 2012/08/04 Code for chessmen written in hexadecimal.
‘ 0.0 2012/08/04 25-line version created. (CLP327)

GraphicsWindow.Title = “8-Queens 0.2”
GraphicsWindow.BackgroundColor = “#004C00”
GraphicsWindow.BrushColor = “Black”
oNum = Controls.AddTextBox(440, 30)
num = 12345678
Controls.SetTextBoxText(oNum, num)
InitBoard()
CheckValid()
DrawBoard()
Controls.TextTyped = OnTextTyped

Sub OnTextTyped
num = Controls.GetTextBoxText(oNum)
len = Text.GetLength(num)
correct = “False”
If len = 8 Then
correct = “True”
For i = 1 To 8
If Text.IsSubText(num, Text.GetSubText(“12345678”, i, 1)) = “False” Then
correct = “False”
EndIf
EndFor
EndIf
If correct Then
board = “”
For c = 1 To 8
board[Text.GetSubText(num, c, 1)][Text.GetSubText(“abcdefgh”, c, 1)] = “BQ”
EndFor
CheckValid()
DrawBoard()
EndIf
EndSub

Sub CheckValid
valid = “True”
For c1 = 1 To 8
For c2 = c1 + 1 To 8
r1 = Text.GetSubText(num, c1, 1)
r2 = Text.GetSubText(num, c2, 1)
dc = Math.Abs(c2 – c1)
dr = Math.Abs(r2 – r1)
If dc = dr Then
valid = “False”
board[r1][Text.GetSubText(“abcdefgh”, c1, 1)] = “RQ”
board[r2][Text.GetSubText(“abcdefgh”, c2, 1)] = “RQ”
EndIf
EndFor
EndFor
EndSub

Sub DrawBoard
For r = 8 To 1 Step – 1
y = pos[“y0”] + (8 – r) * size
For c = 1 To 8
x = pos[“x0”] + (c – 1) * size
GraphicsWindow.BrushColor = color[Math.Remainder((c + r), 2)]
GraphicsWindow.FillRectangle(x, y, size, size)
p = board[r][Text.GetSubText(“abcdefgh”, c, 1)]
If p <> “” Then
GraphicsWindow.BrushColor = color[Text.GetSubText(p, 1, 1)]
sHex = pieces[Text.GetSubText(p, 2, 1)]
Math_Hex2Dec()
GraphicsWindow.DrawText(x, y – size * 0.12, Text.GetCharacter(iDec))
EndIF
EndFor
EndFor
EndSub

Sub InitChessmen
size = 48   ‘ font height and square size
GraphicsWindow.FontSize = size
pieces = “P=265F;N=265E;B=265D;R=265C;Q=265B;K=265A;”
EndSub

Sub InitBoard
pos = “x0=30;y0=30;” ‘ left, top
For c = 1 To 8
board[c][Text.GetSubText(“abcdefgh”, c, 1)] = “BQ”
EndFor
color = “W=White;B=Black;R=Red;0=SaddleBrown;1=BurlyWood;”
InitChessmen()
EndSub

Sub Math_Hex2Dec
‘ Math | Convert sHex to iDec
iDec = 0
iLen = Text.GetLength(sHex)
For iPtr = 1 To iLen
iDec = iDec * 16 + Text.GetIndexOf(“0123456789ABCDEF”, Text.GetSubText(sHex, iPtr, 1)) – 1
EndFor
EndSub

Sub DumpBoard
For r = 8 To 1 Step -1
For c = 1 To 8
If board[r][Text.GetSubText(“abcdefgh”, c, 1)] <> “” Then
TextWindow.Write(board[r][Text.GetSubText(“abcdefgh”, c, 1)] + ” “)
Else
TextWindow.Write(” “)
EndIf
EndFor
TextWindow.WriteLine(“”)
EndFor
EndSub

Microsoft Small Basic (código de programa)


mariposa

 

 

Dibujando mariposas y corazones … USANDO SOLO CÓDIGO – Pequeños programas destacados básicos

ACTUALIZACIONES: Añadido corazón de Nonki como el corazón # 3 el 2/13. Añadido mariposa de Nonki como mariposa # 3 el 2/11.

español

 

‘Challenge of the Month — February 2013
‘Small Challenge 2
‘Copyright (c) Math Man 2013
width = GraphicsWindow.Width
height = GraphicsWindow.Height
scale = 0.8
InitEllipses()
DrawButterfly()

Sub InitEllipses
ellipse[1] = “pen=Black;brush=Orange;x=”+(width/3-70*scale)+”;y=”+(height/8*5-160*scale)+”;width=”+(140*scale)+”;height=”+(320*scale)+”;angle=60;”
ellipse[2] = “pen=Black;brush=Orange;x=”+(width/3-70*scale)+”;y=”+(height/8*3-160*scale)+”;width=”+(140*scale)+”;height=”+(320*scale)+”;angle=120;”
ellipse[3] = “pen=Black;brush=Orange;x=”+(width/3*2-70*scale)+”;y=”+(height/8*5-160*scale)+”;width=”+(140*scale)+”;height=”+(320*scale)+”;angle=120;”
ellipse[4] = “pen=Black;brush=Orange;x=”+(width/3*2-70*scale)+”;y=”+(height/8*3-160*scale)+”;width=”+(140*scale)+”;height=”+(320*scale)+”;angle=60;”
ellipse[5] = “pen=Black;brush=Black;x=”+(width/3-50*scale)+”;y=”+(height/8*5-170*scale)+”;width=”+(70*scale)+”;height=”+(70*scale)
ellipse[6] = “pen=Black;brush=Black;x=”+(width/3*2-30*scale)+”;y=”+(height/8*5-170*scale)+”;width=”+(70*scale)+”;height=”+(70*scale)
‘ellipse[2] = “pen=;brush=;x=;y=;width=;height=”+”;angle=135;”
‘ellipse[3] = “pen=;brush=;x=;y=;width=;height=”+”;angle=135;”
‘ellipse[4] = “pen=;brush=;x=;y=;width=;height=”+”;angle=45;”
‘ellipse[5] = “pen=;brush=;x=;y=;width=;height=”+”;angle=45;”
‘ellipse[6] = “pen=;brush=;x=;y=;width=;height=”+”;angle=45;”

ellipse[7] = “pen=Black;brush=Black;x=”+(width/2-25*scale)+”;y=”+(height/2-150*scale)+”;width=”+(50*scale)+”;height=”+(300*scale)+”;angle=0″
ellipse[8] = “pen=Black;brush=Black;x=”+(width/2-40*scale)+”;y=”+(height/2-150*scale-40*scale)+”;width=”+(80*scale)+”;height=”+(80*scale)+”;angle=0″
ellipse[9] = “pen=Black;brush=Black;x=”+(width/2-50*scale)+”;y=”+(height/2-150*scale-40*scale-35*scale)+”;width=”+(10*scale)+”;height=”+(90*scale)+”;angle=140″
ellipse[10] = “pen=Black;brush=Black;x=”+(width/2+40*scale)+”;y=”+(height/2-150*scale-40*scale-35*scale)+”;width=”+(10*scale)+”;height=”+(90*scale)+”;angle=40″
numEllipse = Array.GetItemCount(ellipse)
EndSub

Sub DrawButterfly
For i = 1 To numEllipse
GraphicsWindow.PenWidth = 4
GraphicsWindow.PenColor = ellipse[i][“pen”]
GraphicsWindow.BrushColor = ellipse[i][“brush”]
ellipse[i][“shape”] = Shapes.AddEllipse(ellipse[i][“width”],ellipse[i][“height”])
Shapes.Move(ellipse[i][“shape”],ellipse[i][“x”],ellipse[i][“y”])
Shapes.Rotate(ellipse[i][“shape”],ellipse[i][“angle”])
EndFor
EndSub

//

Copyright (c) Microsoft Corporation. All rights reserved.

 

Small Basic: El objeto Controls – Diccionario (código)


 

diccionario

 

Vamos a escribir un simple programa usando el objeto Controls. Este programa puede usarse para saber las definiciones de una palabra dada.

  1. GraphicsWindow.Title = “Diccionario”
  2. GraphicsWindow.Height = 600
  3. GraphicsWindow.Width = 600
  4. GraphicsWindow.DrawText(50, 80, “Escriba una palabra en inglés o francés: “)
  5. cuadroTexto = Controls.AddTextBox(50, 100)
  6. Controls.SetSize(cuadroTexto, 100, 30)
  7. Controls.SetTextBoxText(cuadroTexto, “”)
  8. GraphicsWindow.DrawText(50, 140, “Significados según el diccionario: “)
  9. multitxt = Controls.AddMultiLineTextBox(50, 160)
  10. Controls.SetSize(multitxt, 500, 400)
  11. obtenerDef = Controls.AddButton(“Buscar”, 200, 100)
  12. GraphicsWindow.DrawText(80, 80, “”)
  13. significado = Dictionary.GetDefinition(Controls.GetTextBoxText(cuadroTexto))
  14. Controls.SetTextBoxText(multitxt, significado)
  15. Controls.ButtonClicked = MostrarSignificado
  16. Sub MostrarSignificado
  17. If Controls.GetButtonCaption(obtenerDef) = “Buscar” Then
  18. significado = Dictionary.GetDefinition(Controls.GetTextBoxText(cuadroTexto))
  19. Controls.SetTextBoxText(multitxt, significado)
  20. EndIf
  21. EndSub

¿Cuál es el mejor lenguaje de programación para aprender ?


Jiba
Por Jibba Jabba (Rick Murphy)  http://social.msdn.microsoft.com/Forums/en-US/smallbasic/thread/e22ddc96-a46c-4df6-a066-cef92f47ad30
• Después de hacer un poco de lectura parece una gran cantidad de docentes de todos los niveles, la escuela hasta la universidad / colegio, han observado que una de las preguntas más comunes que un estudiante pregunta es:
“¿Cuál es el mejor lenguaje de programación para aprender?”
Hasta ahora (como un novato para 4 meses) he aprendido una pregunta más útil preguntar sería? “¿Qué se necesita del lenguaje para hacerlo?”
Definir y clarificar su objetivo a continuación, seleccione un lenguaje diseñado para ese tipo de tarea. Lo más probable es ir a aprender varios lenguajes adecuados para diferentes propósitos (paradigmas) y cada uno se hará más fácil de aprender si su experiencia se basa. Practica + Experiencia.
Por ejemplo si desea codificar firmware para un nuevo televisor 3D o algo así, entonces podría elegir un lenguaje como C, ya que está cerca del hardware. Pero este tipo de lenguaje requiere mucha habilidad y experiencia previa para codificar
Así que si su objetivo es aprender a ser un buen programador y usted es nuevo en el maravilloso mundo de la programación o de regresar después de un periodo considerable, entonces es aconsejable seleccionar un lenguaje diseñado específicamente para esa tarea.
Small Basic es un lenguaje de alto nivel y de gran alcance considerablemente simplificado para ese propósito. Se simplifica y, en consecuencia hace que el programador pueda encontrar formas de hacer las cosas que de otra manera podrían ser una característica en otro lenguaje. Proporciona una buena base para las habilidades que usted necesita para ser un buen programador. Totalmente apto para todas las edades.
________________________________________
Debes tener un sueño para que puedas levantarse por la mañana. – Billy Wilder

How is Small Basic different from QBASIC and VB.Net?


a1

Small Basic   The Official Blog of Small Basic

http://blogs.msdn.com/b/smallbasic/archive/2013/05/21/how-is-small-basic-different-from-qbasic-and-vb-net.aspx

 

Ed Price – MSFT Microsoft MSFT

The answer comes from the creator of Small Basic, Vijaye Raji…

How is Small Basic different from QBASIC?

  • Unlike QBASIC, Small Basic is based on .Net and can consume (not produce) “Objects”.
  • It supports distinct Operations, Properties and Events.
  • It doesn’t have GOSUB 🙂

How is it different from VB.Net?

Small Basic is small – much smaller than VB and supports just a subset of what VB.Net supports. Besides, you can actually write a compiler using VB.Net.

Got any other explanations as to how Small Basic is different from QBASIC and VB.NET? Is there anything else we should compare/contrast it to? Leave a comment with your answers!

Thanks!

– Ninja Ed

Small Basic: •Challenge of the Month – May 2013


challengemay

 

 

MS Small Basic: el objeto Controls (código)


controls1Hemos aprendido a usar diferentes objetos en Small Basic, como GraphicsWindow, Shapes, File y Math.

Usando el objeto Controls, puede insertar controles simples como cajas de texto y botones en la ventana de gráficos.

AddTextBox (agregar caja de texto): Agrega una caja de texto a la ventana de gráficos. Debe especificar las coordenadas X e Y de la caja de texto como parámetros.

AddButton (agregar botón):

Agrega un botón a la ventana de gráficos. Debe especificar el título del botón y sus coordenadas X e Y.

GetButtonCaption (obtener título del botón):
Obtiene el título de un botón. Debe especificar el nombre apropiado del botón como parámetro.

SetButtonCaption (establecer título del botón): Cambia el título de un botón. Debes especificar el nombre del botón y el nuevo título como parámetros.

GetTextBoxText (obtener texto de la caja de texto): Obtiene el texto presente en la caja de texto dando el nombre de la caja de texto como parámetro de esta operación.

SetTextBoxText (establecer texto de la caja de texto): Define el texto que aparece en la caja de texto. Debe especificar el nombre de la caja de texto y el texto requerido como parámetros.

Exploremos el objeto Controls con la ayuda de un ejemplo.

  1. GraphicsWindow.Title = “El      objeto Controls”
  2. GraphicsWindow.DrawText(50,      100, “Escriba su nombre:”)
  3. nombre =      Controls.AddTextBox(200, 100)
  4. GraphicsWindow.DrawText(50,      150, “Escriba su apellido:”)
  5. apellido =      Controls.AddTextBox(200, 150)
  6. botónMostrar =      Controls.AddButton(“Mostrar mensaje”, 150, 200)
  7. mensaje =      Controls.AddMultiLineTextBox(50, 250)
  8. Controls.SetSize(mensaje, 310,      50)
  1. Controls.ButtonClicked =      MostrarMensaje
  1. Sub MostrarMensaje
  2. If      Controls.GetButtonCaption(botónMostrar) = “Mostrar mensaje”      Then
  3. Controls.SetTextBoxText(mensaje,”Hola      ” + Controls.GetTextBoxText(nombre) + ” ” +      Controls.GetTextBoxText(apellido))
  4. EndIf
  5. EndSub

Small Basic Program Gallery


drawimage

Ed Price – MSFT  Microsoft  MSFT      El objetivo buscado, es que esta lista contiene ya una gran cantidad de pequeños programas básicos. Estamos buscando a los programas interactivos que son fáciles de usar, divertidos y tienen poca o ninguna curva de aprendizaje.

Para ver una mayor variedad de programas que se enumeran categóricamente, ver Small Gallery Program Basic – Listado por categoría. Las categorías incluyen juegos, gráfico, matemáticas, física, aplicaciones de productividad, Ciencias (Otros), sonido y texto.

http://blogs.msdn.com/b/smallbasic/archive/2012/10/12/small-basic-extensions-gallery.aspx

También deben volver recurrentemente, ya que la lista va  evolucionando con el tiempo, rápidamente.

Chomper (pack-man) – Small Basic Featured Game


avatar

Small Basic   The Official Blog of Small Basic

Chomper (Packman) – by Anthony Yarrell/QbasicLover

BFN681 (import code)  http://blogs.msdn.com/b/smallbasic/archive/2012/10/06/small-basic-program-gallery.aspx

http://social.msdn.microsoft.com/Forums/en-US/smallbasic/thread/c75994be-5ecd-4f72-83a5-39ce66ebadfb

MS Small Basic: overview of stack and matrix (code of Flight Reservation program)


reservavuelos

Of the Tutorial Small Basic Curriculum (3.2) , we take that :
An array (Array) can be multidimensional, but a stack (Stack object) has only one dimension. You can directly access any element of an array, but can only access the top element of the stack. That is, if you want to access the last element of the stack, you have to go through all the elements from the beginning.
An array is a variable type that can store multiple values ​​at once. If you want to store the names of five users, rather than to create 5 variables, you can use only one variable to store the five names
And remember that in Small Basic the Stack object  is used to store data as if it will stack plates. This object follows the principle: first in, first out

Let’s use the Array object, to write a program “Flight Reservation” (excellent example) that executes the following steps:

Reserve seating for 10 passengers.
 Display the name of each passenger and seat number
 Display the total number of seats available.
code:

  1. TextWindow.WriteLine(“Reservas de vuelos”)
  2. TotalAsientos = 10
  3. For i = 1 To TotalAsientos
  4.   TextWindow.Write(“Introduzca el nombre del pasajero: “)
  5.   nombre[i] = TextWindow.Read() 
  6.   TextWindow.WriteLine(“El número de asiento ” + i + ” está reservado para ” + nombre[i])
  7.   ObtenerDetalles()
  8. EndFor
  9.  
  10. Sub ObtenerDetalles
  11.   If Array.GetItemCount(nombre) = TotalAsientos Then
  12.     TextWindow.WriteLine(“¡No hay más asientos disponibles!”)
  13.   Else
  14.     Array.GetItemCount(nombre)
  15.     AsientosDisponibles = TotalAsientos – Array.GetItemCount(nombre)   
  16.     TextWindow.WriteLine(“Número de asientos disponibles: “+ AsientosDisponibles)
  17.     TextWindow.WriteLine(“”)   
  18.   EndIf
  19. EndSub

Small Basic : operaciones del objeto Stack (código)


stack

El objeto Stack en Small Basic se usa para almacenar datos al igual que si apilara platos. Este objeto sigue el principio: primero en entrar, primero en salir.

Por ejemplo, si mira hacia abajo una pila de platos, sólo se ve el plato superior. Para ver el siguiente plato, tendrá que quitar el plato superior. No se puede tomar un plato de la mitad de la pila hasta que se hayan quitado todos los platos que tiene encima.

El objeto Stack tiene tres operaciones:

  • PushValue (empujar valor)
  • PopValue (quitar valor)
  • GetCount (obtener cuenta)

La operación PushValue es igual que agregar un nuevo plato encima de la pila de platos. Con la ayuda de esta operación, puede agregar un valor en la pila especificada

La operación PopValue es como recoger un plato de la parte superior de la pila. Use esta operación para obtener un valor de una pila especificada.

La operación GetCount proporciona el número total de platos en una pila. Use esta operación para determinar la cantidad de elementos en una pila específica.

La operación PushValue no devuelve nada.

La operación PopValue devuelve el valor de la pila.

La operación GetCount devuelve el número de elementos en una pila especificada.

En este ejemplo, se usa la operación PushValue operation para empujar 50 platos dentro de un contenedor vacío. Después, usando la operación PopValue, se toman 8 platos de la pila. Ahora, usamos la operación GetCount para obtener el número total de platos en el contenedor. Además muestra el valor del plato superior.

  1. TextWindow.Title = “Platos”
  2. contenedor =”vacío”
  3.  
  4. For i = 0 To 50
  5.   Stack.PushValue(contenedor , ” plato número ” + i)      
  6. EndFor
  7. TextWindow.WriteLine(“El número de platos en el contenedor es ” + Stack.GetCount(contenedor))
  8.  
  9. For i = 0 To 8
  10.   Stack.PopValue(contenedor)       
  11. EndFor
  12.  
  13. TextWindow.WriteLine(“Después de tomar 8 platos, el número total de platos es ” + Stack.GetCount(contenedor))
  14. TextWindow.WriteLine(“El plato superior en el contenedor es ” + Stack.PopValue(contenedor))

Small Basic: operaciones del objeto Array (codigo)


array

¿ cómo podemos usar estas operaciones en un programa?

Asignaturas es una matriz que almacena los nombres de cinco diferentes asignaturas. Puede usar la operación IsArray para verificar si Asignaturas es una matriz. Asimismo, puedes usar la operación ContainsIndex para verificar la disponibilidad del índice Asignaturas[4] en el array Asignaturas. Al final puede usar la operación ContainsValue para ver si el valor “Matematica” está disponibile en el array Asignaturas.

  1. Asignaturas[1] = “Espanol”
  2. Asignaturas[2] = “Historia”
  3. Asignaturas[3] = “Informatica”
  4. Asignaturas[4] = “Ciencias”
  5. Asignaturas[5] = “Matematica” 
  6. TextWindow.WriteLine(” Asignaturas es una matriz:  ” + Array.IsArray(Asignaturas))
  7. TextWindow.WriteLine(” Asignaturas esta disponible: ” + Array.ContainsIndex(Asignaturas, 4))
  8. TextWindow.WriteLine(“Matematica esta disponible: ” + Array.ContainsValue(Asignaturas, “Matematica”))
  9. Array.GetItemCount(Asignaturas)

Small Basic Wiki ( en español)


Modificado el 01/31/2012 12:42 por 80.254.75.12 categorizado como adam, IDE … • Acerca de Small Basic Small Basic es un proyecto que está destinado a traer de vuelta a la “diversión” a la programación. Al proporcionar un lenguaje de programación de pequeño y fácil de aprender en un entorno de desarrollo y acogedor, Small Basic hace que la programación de una brisa. Ideal para niños y adultos por igual, Small Basic ayuda a los principiantes a dar el primer paso en el maravilloso mundo de la programación.
• El  lenguaje Small Basic se inspira en el lenguaje de programación BASIC original, y se basa en la plataforma Microsoft Net.. Es muy pequeño, con sólo 15 palabras clave y utiliza conceptos mínimos para mantener la barrera de entrada lo más bajo posible.
• El entorno de Small Basic desarrollo es simple, pero ofrece potentes funciones ambientales modernas como Intellisense ™ y ayuda sensible al contexto inmediato.
• Small Basic permite a las bibliotecas de terceros para ser conectado con facilidad, por lo que es posible que la comunidad de extender la experiencia de maneras divertidas e interesantes.
Más Recursos
He aquí algunos ejemplos que ilustran las capacidades de Small Basic. Siéntase libre de añadir más a esta lista por favor.Turtle Plus Flickr • Blackboard • Flickr collage • Game of Life • JetLag • Snake
• Arrays • GameGraphics You can also find some sample here for the Fremy’s Extension for SmallBasic • FremyExtensionVer más

Welcome to Small Basic Wiki


 

 

http://wiki.smallbasic.com/addimage

The small Basic Language derives its inspiration from the original BASIC programming language, and is based on the Microsoft .Net platform. It is really small with just 15 keywords and uses minimal concepts to keep the barrier to entry as low as possible.

•The Small Basic development environment is simple, yet provides powerful modern environment features like Intellisense™ and instant context sensitive help.

•Small Basic allows third-party libraries to be plugged in with ease, making it possible for the community to extend the experience in fun and interesting ways.

More Resources

Here are some samples that illustrate the capabilities of Small Basic. Please feel free to add more to this list.

 

 

 

http://wiki.smallbasic.com/

 

Navigation

 

 

 

Quick Search
// »
Advanced Search »

                       

// Edit

Print

RSS

 

Small Basic: Challenge of the Month – May 2013 (code)


numeros

 

Excellent program!.  Animation and sound
High level programming Nonki. congratulations

Program Listing VXK727 –  http://smallbasic.com/program/?VXK727

……………………………………………………………………………….

‘ 30-second Animation  Edited  ‘Nonki Takahashi
gw = GraphicsWindow.Width
gh = GraphicsWindow.Height
dx = gw / 6
dy = gh / 3
fs = 60
x0 = dx – fs / 2
y0 = dy – fs
GraphicsWindow.FontSize = fs
GraphicsWindow.BrushColor = “Orange”
t0 = Clock.ElapsedMilliseconds
For i = 1 To 10
obj[i] = Shapes.AddText(i)
x[i] = x0 + dx * Math.Remainder(i – 1, 5)
y[i] = y0 + dy * Math.Floor((i – 1) / 5)
Shapes.Move(obj[i], gw + fs, y[i])
EndFor
song1 = “O4C4C8C8C4C8C8E4G8G8E4C4D4D8D8D4D8D8O3B4O4D8D8O3B4G4”
song2 = “O4C4C8C8C4C8C8E4G8G8E4C4G4F4E4D4C1”
int = 770
Timer.Interval = int
f = 0
Timer.Tick = OnTick
Sound.PlayMusic(song1)
Sound.PlayMusic(song2)
Sound.PlayMusic(song1)
Sound.PlayMusic(song2)
Sub OnTick
t1 = Clock.ElapsedMilliseconds
f = f + 1
sec = Math.Floor((t1 – t0) / 1000)
GraphicsWindow.Title = sec + “[sec]”
MoveObj()
EndSub
Sub MoveObj
If f <= 3 Then ‘ 1, 2, 3
Shapes.Animate(obj[f], x[f], y[f], int)
ElseIf f = 4 Then
ElseIf f <= 7 Then ‘ 4, 5, 6
Shapes.Animate(obj[f – 1], x[f – 1], y[f – 1], int)
ElseIf f = 8 Then
ElseIf f <= 11 Then ‘ 7, 8, 9
Shapes.Animate(obj[f – 2], x[f – 2], y[f – 2], int)
ElseIf f = 12 Then
ElseIf f = 13 Then ‘ 10
Shapes.Animate(obj[f – 3], x[f – 3], y[f – 3], int)
ElseIf f <= 17 Then
ElseIf f <= 19 Then ‘ 10, 9
Shapes.Animate(obj[28 – f], -fs * 2, y[27 – f], int)
ElseIf f = 20 Then
ElseIf f <= 23 Then ‘ 8, 7, 6
Shapes.Animate(obj[29 – f], -fs * 2, y[29 – f], int)
ElseIf f = 24 Then
ElseIf f <= 27 Then ‘ 5, 4, 3
Shapes.Animate(obj[30 – f], -fs * 2, y[30 – f], int)
ElseIf f = 28 Then
ElseIf f = 29 Then ‘ 2
Shapes.Animate(obj[2], -fs * 2, y[2], int)
ElseIf f <= 37 Then
ElseIf f = 38 Then ‘ 1
Shapes.Animate(obj[1], -fs * 2, y[1], int)
Else
Timer.Pause()
GraphicsWindow.BrushColor = “DimGray”
GraphicsWindow.DrawText(gw / 2 – fs ,gh / 2 – fs, “End”)
EndIf
EndSub

‘ Copyright (c) Microsoft Corporation. All rights reserved.

 

MS Small Basic: files and directories (code)


file3

To learn programming, you must program, program and program.
I took several short exercises of the Curriculum and wrote these into a single program.
This exercise includes objects: ImageList; Network and File
Chapters 2.6 and 3.1 of the Curriculum Tutorial

  1. GraphicsWindow.Title = “Imagen”
  2. rutaImagen = “C:\Users\carlos\Pictures\conchilas.jpg”
  3. Imagen = ImageList.LoadImage(rutaImagen)
  4. GraphicsWindow.Width=ImageList.GetWidthOfImage(rutaImagen)
  5. GraphicsWindow.Height=ImageList.GetHeightOfImage(rutaImagen)
  6. GraphicsWindow.DrawImage(Imagen, 0, 0)
  7. ‘ Fin
  8.  
  9. rutaarchivo1= “http://download.microsoft.com/download/9/0/6/90616372-C4BF-4628-BC82-BD709635220D/Introducing%20Small%20Basic.pdf&#8221;
  10. ArchivoDescargado= Network.DownloadFile(rutaarchivo1)
  11. TextWindow.WriteLine(” Archivo descargado:   ” + ArchivoDescargado)
  12. ‘ Fin
  13.  
  14. rutaarchivo2= “http://download.microsoft.com/&#8221;
  15. ContenidoPaginaWeb = Network.GetWebPageContents(rutaarchivo2)
  16. TextWindow.WriteLine(“Contenido de la pagina:  “)
  17. TextWindow.WriteLine(ContenidoPaginaWeb)
  18. ‘ Fin
  19.  
  20. TextWindow.WriteLine(” El objeto File  “)
  21. rutaarchivo3= “c:\Users\carlos\temp\SubdirectorioTemp\mio.txt”
  22. TextWindow.WriteLine(“Escribir Contenido” + File.WriteLine(rutaarchivo3, 1, “Boca es un gran equipo de futbol”))
  23. TextWindow.WriteLine(“Agregar contenido” + File.AppendContents(rutaarchivo3, ” y ademas gano muchos trofeos”))
  24. TextWindow.WriteLine(“Leer contenido=  ” + File.ReadContents(rutaarchivo3))
  25. ‘ Fin
  26.  
  27. As Nonki says, to learn programming, program and program.
    I took several short exercises of the Curriculum and wrote these into a single program.
    This exercise includes objects: ImageList; Network
    and File
    Chapters 2.6 and 3.1 of the Curriculum
    Keep in mind that the paths of the files and directories must be such as we have in our physician C:
    Perhaps someone more novice than me, this will serve.
    regards
  28.  
  29.  
  30. rutaArchivoOrigen = “c:\Users\carlos\temp\SubdirectorioTemp\mio.txt”
  31. rutaArchivoDestino = “C:\Users\carlos\temp\SubdirectorioTemp\mover.txt”
  32. rutaDirectorio= “C:\Users\carlos\temp\SubdirectorioTemp”
  33. TextWindow.WriteLine(“Copiar archivo de operacion: ” +File.CopyFile(rutaArchivoOrigen,rutaArchivoDestino))
  34. TextWindow.WriteLine(” Archivos en el directorio:  ” + File.GetFiles(rutaDirectorio))
  35. ‘ Fin
  36.  
  37. rutaDirectorio1 = “C:\Users\carlos\temp\Small Basic”
  38. TextWindow.WriteLine(“Crear directorio:  ” + File.CreateDirectory(rutaDirectorio1))
  39. rutaDirectorio2 = “C:\Users\carlos\temp”
  40. TextWindow.WriteLine(“Directorios:  “+ File.GetDirectories(rutaDirectorio2))
  41. ‘ Fin
  42. TextWindow.WriteLine(” Ultimo error “)
  43. rutaarchivo4 = “c:\Users\carlos\temp\SubdirectorioTemp\mio.txt”
  44. TextWindow.WriteLine(” Operacion WriteLine: ” + File.WriteLine(rutaarchivo4, 1, ” como esta ? “))
  45. If File.LastError = ” ” Then
  46.   TextWindow.WriteLine(“La operacion se completo con exito”)
  47. Else
  48.   TextWindow.WriteLine(File.LastError)
  49. EndIf
  50. ‘Fin

Windows Forms for Small Basic v2 (Old thread)


extension

 

                      

                       

                              gungan37 – (IndyDev Software)

Hello guys! I have spent the past couple of days writing a new extension for Small Basic. Here is a screenshot of a program made with it:

 

  • The extension adds the following Windows Forms controls to Small Basic (** means that no other extension supports the control):

– Button

– RadioButton

– CheckBox

– ** Chart **

– Label

– ** LinkLabel **

– **NumericUpDown**

– **DateTimePicker**

– **MonthCalendar**

– ProgressBar

– TrackBar

– **RichTextBox**

– PictureBox

– **MaskedTextBox***

– **NotificationIcon***

– **ComboBox**

– **TreeView**

– **ListView**

Plus, it is 100% event driven! It is super easy to use! Just call WindowsFormsForSmallBasic.Setup() before you start and WindowsFormsForSmallBasic.InitializeForm() when all the controls are placed— this shows the form and hands off control to it. You may not modify the controls after this or write any more code outside of the event handlers. However, your event handlers can preform these operations.

Here is a sample (outdated, for v1): HMD046

And download link for the extension (outdated, for v1): http://www.mediafire.com/download.php?b8w679cqs6mpusr

Please ask any questions you make have and suggestions / bug reports are welcome too! I expect to add some more controls to the extension soon!

 

MS Small Basic: What are the Keywords of Small Basic?


Sin título2Examples:

If, Then, EndIf

If (Clock.Hour < 12) Then
TextWindow.WriteLine(“Good Morning World”)
EndIf

Else

We can shorten two if..then..endif statements to be just one by using a new word, else.

If we were to rewrite that program using else, this is how it will look:

If (Clock.Hour < 12) Then

TextWindow.WriteLine(“Good Morning World”)

Else TextWindow.WriteLine(“Good Evening World”)

EndIf

Goto

If (i < 25) Then

Goto start

EndIf

For, To, EndFor

For..EndFor is, in programming terms, called a loop.  It allows you to take a variable, give it an initial and an end value and let the computer increment the variable for you.  Every time the computer increments the variable, it runs the statements between For and EndFor.

This program prints out numbers from 1 to 24 in order:

For i = 1 To 24

TextWindow.WriteLine(i)

EndFor

Step

But if you wanted the variable to be incremented by 2 instead of 1 (like say, you wanted to print out all the odd numbers between 1 and 24), you can use the loop to do that too.

For i = 1 To 24 Step 2

TextWindow.WriteLine(i)

EndFor

While, EndWhile

The While loop is yet another looping method, that is useful especially when the loop count is not known ahead of time.  Whereas a For loop runs for a pre-defined number of times, the While loop runs until a given condition is true. In the example below, we’re halving a number until the result is greater than 1.

number = 100

While (number > 1)

TextWindow.WriteLine(number) number = number / 2

EndWhile

Sub, EndSub

A subroutine is a portion of code within a larger program that usually does something very specific, and that can be called from anywhere in the program.  Subroutines are identified by a name that follows the Sub keyword and are terminated by the EndSub keyword. Below is a program that includes the subroutine and calls it from various places.

PrintTime()

TextWindow.Write(“Enter your name: “)

name = TextWindow.Read()

TextWindow.Write(name + “, the time now is: “)

PrintTime()

Sub PrintTime

TextWindow.WriteLine(Clock.Time)

EndSub

And, ElseIf

If  percentage >= 75 Then

TextWindow.WriteLine(“The student’s grade is A.”)

  ElseIf  percentage < 75 And percentage >= 60  Then

TextWindow.WriteLine(“The student’s grade is B.”)

ElseIf  percentage < 60 And percentage >= 35 Then

TextWindow.WriteLine(“The student’s grade is C.”)

Else

TextWindow.WriteLine(“The student’s grade is D.”)

EndIf
Or

Sub subRainyCount

If Rainy = “y” Or Rainy = “Y” Then

RainyCount = RainyCount + 1

EndIf

EndSub

El objeto Network en MS Small Basic (código)


html

Se utiliza la operación GetWebPageContents (obtener contenido de la página web) del objeto Network para obtener el contenido de una página web indicada.

En este caso, la ventana de resultados muestra el código HTML (HyperText Markup Language) de la página web “https://empiezoinformatica.wordpress.com/&#8221;.

  1. rutaArchivo = “https://empiezoinformatica.wordpress.com/&#8221;
  2. ContenidoPáginaWeb = Network.GetWebPageContents(rutaArchivo)
  3. TextWindow.Title =”Página web”
  4. TextWindow.WriteLine(“Contenido de la página:”)
  5. TextWindow.WriteLine(ContenidoPáginaWeb)

Small Basic: El objeto ImageList (código)


cocnhillas1

Veamos cómo se pueden utilizar las diversas operaciones del objeto ImageList

La altura y el ancho de la imagen se recuperan mediante el uso de las operaciones GetHeightOfImage (obtener altura de la imagen) y GetWidthOfImage (obtener ancho de la imagen).

Se cambia el tamaño de GraphicsWindow al mismo tamaño de la imagen.

Dibujamos la imagen cargada en la ventana de gráficos.

  1. GraphicsWindow.Title = “Imagen”
  2. rutaImagen = “C:\Users\carlos\Pictures\cocnhillas.jpg”
  3. Imagen = ImageList.LoadImage(rutaImagen)
  4. Ancho = ImageList.GetWidthOfImage(rutaImagen)
  5. Alto= ImageList.GetHeightOfImage(rutaImagen)
  6. GraphicsWindow.Width = Ancho
  7. GraphicsWindow.Height= Alto
  8. GraphicsWindow.DrawImage(Imagen, 0, 0)

Preguntas sobre MS Small Basic


microsoft_small_basic

¿Qué es Small Basic?

http://smallbasic.com/faq.aspx

Small Basic es un proyecto que se centra en la fabricación de programación accesible y fácil para los principiantes. Se compone de tres partes bien diferenciadas:
• El Idioma
• El entorno de programación
• Bibliotecas

El lenguaje se inspira en una variante temprana de BASIC, pero se basa en la moderna. Plataforma Net Framework. El medio ambiente es sencillo, pero rico en características, ofreciendo principiantes varios de los beneficios que los programadores profesionales han llegado a esperar de un IDE digna. Un amplio conjunto de bibliotecas ayudan a los principiantes a aprender escribiendo programas atractivos e interesantes.

Para quién es Small Basic ?

Small Basic está diseñado para principiantes que quieren aprender a programar. En nuestras pruebas internas que hemos tenido éxito con los niños entre las edades de 10 y 16. Sin embargo, no se limita sólo a los niños, incluso los adultos que tenían una inclinación a la programación han encontrado Small Basic muy útil para dar ese primer paso.

¿Por qué otro lenguaje Basic?

¿Por qué no? Según Wikipedia, hay más de 230 dialectos diferentes documentados de BASIC.

¿Cuál es el futuro de Small Basic?

El futuro de Small Basic depende de ustedes. Si la idea y el proyecto se reciben bien, vamos a seguir invirtiendo en el desarrollo de nuevas versiones y apoyando las características más solicitadas.

El veterano BASIC


basic1

En la programación de computadoras, el BASIC, siglas de Beginner’s All-purpose Symbolic Instruction Code[1] (Código simbólico de instrucciones de propósito general para principiantes en español), es una familia de lenguajes de programación de alto nivel.

BASIC está disponible para casi todas las plataformas y sistemas operativos existentes. Una implementación gratuita que cumple con estándares y es multiplataforma es Bywater BASIC (bwBASIC). El intérprete está escrito en C y viene bajo la licencia GNU. Está diseñado para interfaz de texto o consola (no gráfica), no incluye soporte para crear interfaces gráficas de usuario (GUI’s, Graphical User Interface). Hay un BASIC gratuito que si incluye soporte para GUI, es similar a Visual Basic y se ejecuta en Windows y GNU/Linux, es Phoenix Object BASIC.

Las versiones de intérpretes/compiladores más conocidos son la línea de productos Quick BASIC y QBASIC, éste último es sólo intérprete, ambos son de Microsoft. En la actualidad lo es el moderno Visual BASIC, que Microsoft ha tratado de mantener al menos mínimamente compatible con incluso las primeras versiones de sus BASIC (en realidad es escasamente compatible), si bien existe FreeBASIC que es un compilador libre, compatible en sintaxis con QBASIC/QuickBASIC.

Otras versiones comerciales incluyen PowerBASIC de PowerBASIC, PureBasic de Fantaisie Software, así como TrueBASIC de TrueBASIC, que cumple con los últimos estándares oficiales de BASIC. (True BASIC Inc. fue fundada por los creadores originales de Dartmouth BASIC.)

REALbasic es una variante disponible para Mac OS Classic, Mac OS X, Microsoft Windows y GNU/Linux, comercializada por los actuales propietarios de Rapid-Q, otra implementación inicialmente libre de BASIC actualmente abandonada. Una versión de un dialecto simple de BASIC para la parrot virtual machine, muestra cómo se implementa un intérprete de BASIC en un lenguaje similar al ensamblador. SmallBASIC es un dialecto que ejecuta en muchas plataformas (Win32, DOS, GNU/Linux y PalmOS) y viene bajo la licencia GNU (GPL).

Existen muchas implementaciones de BASIC freeware o GNU, como BCX, YaBasic, HBasic, XBasic, Gambas o Just BASIC, entre otras.

Ilustrativo juego en MS Small Basic (código)


mines

Microsoft Small Basic    Program Listing: FMN979-0 – by Nonki Takahashi

Challenge of the Month – May 2013

‘ Minesweeper for Small Basic 0.2
‘ Copyright (c) 2013 Nonki Takahashi. All rights reserved.

‘ History:
‘ 0.2 13/05/2013 Supported mouse right button. (FMN979-0)
‘ 0.1b 07/05/2013 Created. (FMN979)

GraphicsWindow.Title = “Minesweeper for Small Basic 0.2”
Init()
While “True”
Game()
playing = “True”
While playing
Program.Delay(500)
EndWhile
EndWhile
Sub Init
CRLF = Text.GetCharacter(13) + Text.GetCharacter(10)
nMines = 10
nCols = 9
nRows = 9
bgColor = “#949FB5”
cellColor = “#D6E3F3”
coverColor = “#4A64CF”
frameColor = “#222323”
markColor = “White”
flagColor = “Red”
color = “1=#414FBD;2=#206602;3=#AA0406;4=#020282;5=#790101;6=#06787F;7=#A70604;8=#AA0808;✸=Black;”
GraphicsWindow.BackgroundColor = bgColor
x0 = 31
y0 = 30
sizeX = 31
sizeY = 30
GraphicsWindow.Width = (nCols + 2) * sizeX
GraphicsWindow.Height = (nRows + 3) * sizeY
GraphicsWindow.BrushColor = “Black”
x = x0
y = y0 + (nRows + 0.5) * sizeY
GraphicsWindow.FontSize = sizeY
GraphicsWindow.DrawText(x, y – 0.12 * sizeY, “◯”)
GraphicsWindow.FontSize = sizeY * 0.8
GraphicsWindow.DrawText(x + 0.09 * sizeX, y + 0.02 * sizeY, “└”)
GraphicsWindow.FontSize = sizeY
x = x0 + (nCols – 1) * sizeX
GraphicsWindow.DrawText(x, y – 0.12 * sizeY, “✸”)
x = x0 + sizeX
GraphicsWindow.FontSize = sizeY * 0.6
oTime = Controls.AddTextBox(x, y)
Controls.SetSize(oTime, 2 * sizeX, sizeY)
x = x0 + (nCols – 3) * sizeX
oMines = Controls.AddTextBox(x, y)
GraphicsWindow.FontSize = sizeY
Controls.SetSize(oMines, 2 * sizeX, sizeY)
dirCol = “1=1;2=1;3=0;4=-1;5=-1;6=-1;7=0;8=1;”
dirRow = “1=0;2=-1;3=-1;4=-1;5=0;6=1;7=1;8=1;”
‘ The following line could be harmful and has been automatically commented.
‘ path = File.GetSettingsFilePath()
‘ The following line could be harmful and has been automatically commented.
‘ settings = File.ReadContents(path)
If settings[“nWins”] = “” Then
settings[“nWins”] = 0
EndIf
If settings[“nPlays”] = “” Then
settings[“nPlays”] = 0
EndIf
If settings[“record”] = “” Then
settings[“record”] = 999
EndIf
‘ The following line could be harmful and has been automatically commented.
‘ File.WriteContents(path, settings)
EndSub
Sub Game
time = 0
remain = nMines
covered = nCols * nRows
Controls.SetTextBoxText(oTime, time)
Controls.SetTextBoxText(oMines, remain)
CreateStage()
ShowStage()
waiting = “True”
Timer.Interval = 1000
Timer.Pause()
GraphicsWindow.MouseDown = OnMouseDown
EndSub
Sub OnMouseDown
GraphicsWindow.MouseDown = DoNothing
x = GraphicsWindow.MouseX
y = GraphicsWindow.MouseY
iCol = Math.Floor((x – x0) / sizeX) + 1
iRow = Math.Floor((y – y0) / sizeY) + 1
If cover[iCol][iRow] <> “” Then
If waiting Then
waiting = “False”
Timer.Tick = OnTick
Timer.Resume()
EndIf
If Mouse.IsLeftButtonDown Then
If toggle[iCol][iRow] <> 1 Then
OpenCover()
EndIf
Else
ToggleMark()
EndIf
EndIf
GraphicsWindow.MouseDown = OnMouseDown
EndSub
Sub DoNothing
OnMouseDown = “”
EndSub
Sub OnTick
time = time + 1
Controls.SetTextBoxText(oTime, time)
EndSub
Sub OpenCover
Shapes.Remove(question[iCol][iRow])
Shapes.Remove(flag[iCol][iRow])
Shapes.Remove(pole[iCol][iRow])
Shapes.Remove(cover[iCol][iRow])
cover[iCol][iRow] = “”
covered = covered – 1
If stage[iCol][iRow] = “” Then
If nMines < covered Then
checked = “”
OpenAdjacents()
EndIf
If nMines = covered Then
Win()
EndIf
ElseIf stage[iCol][iRow] = “✸” Then
Lose()
Else ‘ numbers
If covered = nMines Then
Win()
EndIf
EndIf
EndSub
Sub ToggleMark
toggle[iCol][iRow] = toggle[iCol][iRow] + 1
If toggle[iCol][iRow] = 3 Then
toggle[iCol][iRow] = 0
EndIf
If toggle[iCol][iRow] = 0 Then
Shapes.HideShape(question[iCol][iRow])
ElseIf toggle[iCol][iRow] = 1 Then
Shapes.ShowShape(flag[iCol][iRow])
Shapes.ShowShape(pole[iCol][iRow])
remain = remain – 1
Controls.SetTextBoxText(oMines, remain)
ElseIf toggle[iCol][iRow] = 2 Then
Shapes.HideShape(flag[iCol][iRow])
Shapes.HideShape(pole[iCol][iRow])
Shapes.ShowShape(question[iCol][iRow])
remain = remain + 1
Controls.SetTextBoxText(oMines, remain)
EndIf
EndSub
Sub Win
Timer.Pause()
If time < settings[“record”] Then
settings[“record”] = time
EndIf
settings[“nWins”] = settings[“nWins”] + 1
settings[“nPlays”] = settings[“nPlays”] + 1
‘ The following line could be harmful and has been automatically commented.
‘ File.WriteContents(path, settings)
SetMessage()
GraphicsWindow.ShowMessage(msg, “You win”)
time = 0
playing = “False”
EndSub
Sub Lose
Timer.Pause()
OpenMines()
settings[“nPlays”] = settings[“nPlays”] + 1
‘ The following line could be harmful and has been automatically commented.
‘ File.WriteContents(path, settings)
SetMessage()
GraphicsWindow.ShowMessage(msg, “You lose”)
time = 0
playing = “False”
EndSub
Sub SetMessage
msg = “Time: ” + time + ” sec” + CRLF
msg = msg + “High Score: ” + settings[“record”] + ” sec” + CRLF
msg = msg + “Game Play Times: ” + settings[“nPlays”] + CRLF
msg = msg + “Wins: ” + settings[“nWins”] + CRLF
msg = msg + “Rate: ” + Math.Floor(settings[“nWins”] / settings[“nPlays”] * 100) + ” %”
EndSub
Sub OpenAdjacents
‘ param iCol, iRow – space cell
checked[iCol][iRow] = “True”
For dir = 1 To 8
Stack.PushValue(“local”, iCol)
Stack.PushValue(“local”, iRow)
Stack.PushValue(“local”, dir)
iCol = iCol + dirCol[dir]
iRow = iRow + dirRow[dir]
If (1 <= iCol) And (iCol <= nCols) And (1 <= iRow) And (iRow <= nRows) Then
If checked[iCol][iRow] = “” Then
If cover[iCol][iRow] <> “” And toggle[iCol][iRow] <> 1 Then
Shapes.Remove(question[iCol][iRow])
Shapes.Remove(flag[iCol][iRow])
Shapes.Remove(pole[iCol][iRow])
Shapes.Remove(cover[iCol][iRow])
cover[iCol][iRow] = “”
covered = covered – 1
EndIf
If stage[iCol][iRow] = “” Then
OpenAdjacents()
Else
checked[iCol][iRow] = “True”
EndIf
EndIf
EndIf
dir = Stack.PopValue(“local”)
iRow = Stack.PopValue(“local”)
iCol = Stack.PopValue(“local”)
EndFor
EndSub
Sub OpenMines
For iRow = 1 To nRows
For iCol = 1 To nCols
If stage[iCol][iRow] = “✸” Then
Shapes.HideShape(cover[iCol][iRow])
EndIf
EndFor
EndFor
EndSub
Sub CreateStage
stage = “”
toggle = “”
For iMine = 1 To nMines
iCol = Math.GetRandomNumber(nCols)
iRow = Math.GetRandomNumber(nRows)
While stage[iCol][iRow] = “✸”
iCol = Math.GetRandomNumber(nCols)
iRow = Math.GetRandomNumber(nRows)
EndWhile
stage[iCol][iRow] = “✸”
EndFor
For iRow = 1 To nRows
For iCol = 1 To nCols
AddNumbers()
EndFor
EndFor
EndSub
Sub AddNumbers
If stage[iCol][iRow] = “✸” Then
For dir = 1 To 8
jCol = iCol + dirCol[dir]
jRow = iRow + dirRow[dir]
If (1 <= jCol) And (jCol <= nCols) And (1 <= jRow) And (jRow <= nRows) And (stage[jCol][jRow] <> “✸”) Then
stage[jCol][jRow] = stage[jCol][jRow] + 1
EndIf
EndFor
EndIf
EndSub
Sub ShowStage
GraphicsWindow.FontSize = sizeY
For iRow = 1 To nRows
For iCol = 1 To nCols
x = x0 + (iCol – 1) * sizeX
y = y0 + (iRow – 1) * sizeY
ShowCover()
ShowCell()
EndFor
EndFor
EndSub
Sub ShowCover
‘ param iCol, iRow – to show
‘ param x, y – left top coordinate
If cover[iCol][iRow] = “” Then
GraphicsWindow.BrushColor = coverColor
GraphicsWindow.PenWidth = 2
GraphicsWindow.PenColor = frameColor
cover[iCol][iRow] = Shapes.AddRectangle(sizeX, sizeY)
Shapes.HideShape(cover[iCol][iRow])
Shapes.Move(cover[iCol][iRow], x, y)
GraphicsWindow.BrushColor = flagColor
GraphicsWindow.PenWidth = 0
flag[iCol][iRow] = Shapes.AddTriangle(0, 0.2 * sizeY, 0.6 * sizeX, 0, 0.6 * sizeX, 0.4 * sizeY)
Shapes.HideShape(flag[iCol][iRow])
Shapes.Move(flag[iCol][iRow], x + 0.2 * sizeX, y + 0.2 * sizeY)
GraphicsWindow.BrushColor = markColor
pole[iCol][iRow] = Shapes.AddRectangle(0.1 * sizeX, 0.6 * sizeY)
Shapes.HideShape(pole[iCol][iRow])
Shapes.Move(pole[iCol][iRow], x + 0.7 * sizeX, y + 0.2 * sizeY)
question[iCol][iRow] = Shapes.AddText(“?”)
Shapes.HideShape(question[iCol][iRow])
Shapes.Move(question[iCol][iRow], x + 0.2 * sizeX, y – 0.12 * sizeY)
Else
Shapes.HideShape(flag[iCol][iRow])
Shapes.HideShape(pole[iCol][iRow])
Shapes.HideShape(question[iCol][iRow])
EndIf
Shapes.ShowShape(cover[iCol][iRow])
EndSub
Sub ShowCell
‘ param iCol, iRow – to show
‘ param x, y – left top coordinate
GraphicsWindow.BrushColor = cellColor
GraphicsWindow.FillRectangle(x, y, sizeX, sizeY)
GraphicsWindow.PenWidth = 2
GraphicsWindow.PenColor = frameColor
GraphicsWindow.DrawRectangle(x, y, sizeX, sizeY)
GraphicsWindow.BrushColor = color[stage[iCol][iRow]]
If stage[iCol][iRow] = “✸” Then
dx = 0
Else
dx = 0.2 * sizeX
EndIf
GraphicsWindow.DrawText(x + dx, y – 0.12 * sizeY, stage[iCol][iRow])
EndSub

‘ C opyright (c) Microsoft Corporation. All rights reserved.

Small Basic: Propiedades y operaciones del objeto File


directorios

Usar propiedades del objeto File.

  • LastError

Usar operaciones del objeto File.

  • CreateDirectory
  • GetDirectories (obtener directorios)

Cree un directorio de acuerdo con un nombre introducido por el usuario.

Descargue un archivo de la red y lo copie en el directorio que ha creado.

Muestre el contenido del archivo descargado en la ventana de texto.

Acepte contenido adicional del usuario y agregue ese contenido al archivo.

Muestre el contenido final del archivo en la ventana de texto.

 

 

 

Nota: El archivo tiene que existir en la ruta de red especificada para que la solución funcione.

 

Solución:

TextWindow.Write(“Escriba el nombre del nuevo directorio: “)

NombreDirectorio = TextWindow.Read()

File.CreateDirectory(NombreDirectorio)

rutaarchivo = “\\mum-9785sm\Compartido\ArchivoEntradaSalidaO.txt”

rutadescarga = Network.DownloadFile(rutaarchivo)

If File.CopyFile(rutadescarga, NombreDirectorio) = “SUCCESS” Then

TextWindow.WriteLine(“El archivo ha sido descargado de la red y copiado a: ” + NombreDirectorio )

archivos= File.GetFiles(NombreDirectorio)

TextWindow.WriteLine(“Este es el contenido del archivo: “)

TextWindow.WriteLine(File.ReadContents(archivos[1]))

TextWindow.Write(“Escriba los datos para agregarlos en el archivo: “)

DatosAgregados = TextWindow.Read()

File.AppendContents(archivos[1],” ” + DatosAgregados)

TextWindow.WriteLine(“El contenido del archivo después de agregar los datos es como sigue: “)

TextWindow.WriteLine(File.ReadContents(archivos[1]))

EndIf

Small Basic: Intermediate Challenge 1 (Sushi restaurant)


sushiNao

Program Listing:    JWF370    http://social.msdn.microsoft.com/Forums/en-US/smallbasic/thread/bce001cb-ce65-4d23-8645-466098928115/

Intermediate Challenge 1

Write a program to display a menu that a till operator might use in a restaurant.  They click on the items the customer wants and it works out the bill.

………………………………………………………………………………………………………………………….

Code:

‘  Challenge of the month  May 2013     Restaurant  menu order   by  NaochanON

 

InitData()

GUI()

Controls.ButtonClicked=EnterData

Sub EnterData

btnnmb=Controls.LastClickedButton

nm=controls.GetButtonCaption(btnnmb)

if text.IsSubText(Btns,nm) Then  ‘

DNMB= Text.GetSubTextToEnd(btnnmb,7)                     ‘

Newconts= Menu[DNMB]

NewPrice= Price[DNMB]

DataEnter()

elseif  text.IsSubText(Newconts,nm) then

searchNo()

NN=NN+1

Order=order+NN+”: “+nm+”    “+Price[DNMB][PNMB]+CRLF

TotPrice=TotPrice+Price[DNMB][PNMB]

Mes=Order+CRLF+”   Price      = “+Totprice+CRLF

tax=math.floor(5*Totprice)/100

Mes=Mes+”   Tax(5%) = “+tax+CRLF

Mes=Mes+”   Total      = “+(Totprice+tax)+CRLF+CRLF+”   Thank you !”

Controls.SetTextBoxText(receipt,Mes)

EndIf

endsub

sub searchNo

For j=1 To Array.GetItemCount(Newconts)

If nm= Newconts[j] Then

PNMB=j

j=Array.GetItemCount(Newconts)

endif

EndFor

EndSub

Sub DataEnter

If NMB2<>0 Then

For j=1 To NMB2

Controls.HideControl(btn2[j])                  ‘

Controls.HideControl(btn3[j])

EndFor

EndIf

Shapes.Move(redrect,10,130+75*(DNMB-1))                            ‘  Red mark

‘————————————————————————————————————————-

NMB=Array.GetItemCount(Newconts)

GRXY=”W=500;H=”+(NMB*45)

GrayBox()

‘————————————————————————————————————————-

GraphicsWindow.BrushColor=”Navy”

For i=1 To NMB

btn2[i]=Controls.AddButton(Newconts[i],440,135+40*(i-1))         ‘  menu

btn3[i]=Controls.AddButton(“US$ “+NewPrice[i],760,135+40*(i-1))  ‘  price

Controls.SetSize(btn2[i],280,35)

Controls.SetSize(btn3[i],120,35)

EndFor

‘————————————————————————————————————————-

NMB2=NMB                                               ‘

endsub

Sub GrayBox

Shapes.Remove(GRBOX)

GraphicsWindow.BrushColor=”Lightgray”

GRBOX=Shapes.AddRectangle(GRXY[“W”],GRXY[“H”])           ‘  gray  box

Shapes.Move(GRBOX,400,120)

Shapes.SetOpacity(GRBOX,60)

EndSub

Sub GUI

GraphicsWindow.Width=Desktop.Width

GraphicsWindow.Height=Desktop.Height

GraphicsWindow.Top=0

GraphicsWindow.Left=0

GraphicsWindow.FontName=”Gergia”

GraphicsWindow.FontItalic=”true”

GraphicsWindow.DrawImage(back,0,0)                       ‘  background image

‘————————————————————————————————————————-

photo=Shapes.AddImage(Img)                               ‘  Sushi photo

Shapes.Zoom(photo,550/imgw,350/imgh)

Shapes.Move(photo,400,380)

Shapes.SetOpacity(photo,60)

‘————————————————————————————————————————-

GraphicsWindow.penColor=”Red”

GraphicsWindow.BrushColor=”Red”

redrect= Shapes.AddRectangle(30,30)

Shapes.Move(redrect,10,-100)

GraphicsWindow.FontSize=25

TTL=Shapes.AddText(” Sushi Restaurent  Order System  “)  ‘  Title

Shapes.Move(TTL,500,10)

‘————————————————————————————————————————-

GraphicsWindow.FontSize=25

GraphicsWindow.BrushColor=”Navy”

For i=1 To array.GetItemCount(Btns)

btn[i]= Controls.AddButton(Btns[i],50,125+75*(i-1))    ‘   Menu

Controls.SetSize(btn[i],250,55)

EndFor

‘————————————————————————————————————————-

GraphicsWindow.FontSize=16

receipt=Controls.AddMultiLineTextBox(1000,125)           ‘   receipt box

Controls.SetSize(receipt,350,600)

Shapes.SetOpacity(receipt,70)

EndSub

Sub InitData

back=ImageList.LoadImage(“C:\Windows\Web\Wallpaper\Scenes\img29.jpg”)

url= “http://farm7.static.flickr.com/6109/6245861119_1f06dabea8.jpg&#8221;

‘url=Flickr.GetRandomPicture(“Sushi”)

img= imagelist.LoadImage(url)

imgw= ImageList.GetWidthOfImage(img)

imgh= ImageList.GetHeightOfImage(img)

Btns=”1=Hot Appetizer;2=Cold Appetizer;3=Nigiri;4=Special Rolls;5=Sea Food;6=Dinner;7=Deserts&Beverage ”

‘————————————————————————————————————————-

Menu[1]=”1=Japanese Eggplant;2=Tempura;3=Softshell Crab;4=Crab Cake;5=Oyster Saute”

Menu[2]=”1=Crab and Shrimp Sunomono;2=Aji tako Salad;3=Salmon radish Roll;4=Tuna with rice Biscuit”

Menu[3]=”1=Crab;2=Eel Sea;3=Halibut;4=Mackerel;5=Octopus;6=Omelet;7=Salmon;8=Salmon Roe;9=Scallop;10=Sea Urchin;11=Squid;12=Tuna”

Menu[4]=”1=Alaskan Roll;2=Hawaian Roll;3=Mexican Roll;4=Eel Roll;5=Avocado Roll”

Menu[5]=”1=Salmon;2=Scallops;3=Sea Bass;4=Tuna;5=Monk Fish;6=Black Cod;7=Yellow tail”

Menu[6]=”1=Chicken Teriyaki;2=Assorted Tempura;3=Sushi Deluxe;4=Assorted Sashimi Plate;5=Chirashi Sushi”

Menu[7]=”1=Ice Cream;2=Soda;3=Cola;4=Hot Tea;5=Cold Tea”

‘————————————————————————————————————————-

Price[1]=”1=7.00;2=7.00;3=8.50;4=9.50;5=7.00″

Price[2]=”1=7.00;2=9.50;3=9.50;4=10.50″

Price[3]=”1=3.50;2=5.00;3=4.50;4=3.50;5=4.00;6=3.00;7=4.00;8=5.00;9=4.50;10=7.50;11=3.75;12=4.50″

Price[4]=”1=12.00;2=12.50;3=11.50;4=10.50;5=7.50″

Price[5]=”1=12.00;2=14.00;3=16.50;4=15.50;5=13.00;6=13.50;7=14.50″

Price[6]=”1=12.00;2=13.00;3=22.00;4=24.50;5=22.50″

Price[7]=”1=2.50;2=1.50;3=1.50;4=2.00;5=1.50″

CRLF= Text.GetCharacter(13)+Text.GetCharacter(10)

EndSub

Small Basic: operaciones del objeto File (codigo)


File2

Simplicidad en el manejo de Archivos y Directorios. Veamos cómo podemos usar estas operaciones…
Como ve, primero se usa la operación CreateDirectory para crear un directorio.
Luego se usa la operación GetDirectories para conseguir la ruta de todos los directorios presentes en el destino especificado.
 
 
  1. TextWindow.Title = “El objeto File “
  2. rutaDirectorio1 =  “C:\Users\carlos\temp\Small Basic”
  3. TextWindow.WriteLine(” Crear directorio:  ” + File.CreateDirectory(rutaDirectorio1))
  4. rutaDirectorio2 = “C:\Users\carlos\temp”
  5. TextWindow.WriteLine(” Directorios: ” + File.GetDirectories(rutaDirectorio2))
 

Small Basic: entrada y salida con el objeto File (código)


file1

Con la ayuda del objeto File (archivo) en Small Basic, puede acceder a información de un archivo almacenado en el equipo. Además puede leer y escribir información desde y hacia el archivo.

El objeto File incluye varias operaciones y propiedades, tales como:

CreateDirectory          : Crear Directorio

AppendContents        : Agregar Contenidos

GetFiles                      : Obtener Archivos

GetDirectories            : Obtener Directorios

ReadContents : Leer Contenidos

LastError                    : Último Error

WriteLine                   : Escribir Línea

CopyFile                     : Copiar Archivo

DeleteDirectory          : Eliminar Directorio

Escribamos un programa para entender mejor estas operaciones:

  1. TextWindow.Title      = “El objeto File”
  2. rutaDirectorio1      = “C:\Users\carlos\temp\Small Basic”
  3. TextWindow.WriteLine(“Crear      directorio: “+ File.CreateDirectory(rutadirectorio1))
  4. rutadirectorio2      = “C:\Users\carlos\temp”
  5. TextWindow.WriteLine(“Directorios:      ” + File.GetDirectories(rutaDirectorio2))

Resolver ecuaciones cuadráticas. ax ² + bx + c = 0 (código Small. Basic)


cuadrática1

Small Basic   by Sam Christy

………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………………..

TextWindow.Title=”Quadratic Equation Solver© – Brought to you by Sam Christy”

TextWindow.BackgroundColor = “Yellow”

TextWindow.ForegroundColor=”Black ”

TextWindow.WriteLine(“ax² + bx + c = 0”)

start:

TextWindow.WriteLine(“”)

TextWindow.Write(“a: “)

a=TextWindow.ReadNumber()

If a = 0 Then

TextWindow.WriteLine(“”)

TextWindow.WriteLine(“ERROR: Equation invalid, a = “+a+”, a cannot = 0.”)

TextWindow.WriteLine(“Please try again…”)

TextWindow.PauseWithoutMessage()

Goto start

EndIf

TextWindow.Write(“b: “)

b=TextWindow.ReadNumber()

TextWindow.Write(“c: “)

c=TextWindow.ReadNumber()

TextWindow.WriteLine(“”)

TextWindow.WriteLine(“Equation: “+a+”x² + “+b+”x + “+c+” = 0″)

TextWindow.WriteLine(“”)

delta=Math.Power(b,2)-4*a*c

If delta < 0 Then

TextWindow.WriteLine(“ERROR: Equation invalid, Delta (b² – 4ac) = “+delta+”, Delta cannot be less than 0.”)

TextWindow.WriteLine(“Please try again…”)

TextWindow.PauseWithoutMessage()

Goto start

Else

If delta = 0 Then

solution1 =(-b+Math.SquareRoot(Math.Power(b,2)-4*a*c))/(2*a)

TextWindow.WriteLine(“x: ” + solution1)

Else

solution1 =(-b+Math.SquareRoot(Math.Power(b,2)-4*a*c))/(2*a)

solution2 =(-b-Math.SquareRoot(Math.Power(b,2)-4*a*C))/(2*a)

TextWindow.WriteLine(“x: ” + solution1)

TextWindow.WriteLine(“x: ” + solution2)

EndIf

EndIf

TextWindow.WriteLine(“”)

TextWindow.WriteLine(“Would you like to perform another calculation? (Y or N)”)

answer=TextWindow.Read()

If answer = “Y” Or answer = “y” Then

Goto start

Else

TextWindow.Clear()

TextWindow.WriteLine(“I hope you have enjoyed using my program!”)

TextWindow.WriteLine(“©Copyright Sam Christy 2010”)

TextWindow.WriteLine(“”)

TextWindow.WriteLine(“Simply press any key to exit…”)

TextWindow.PauseWithoutMessage()

Program.End()

EndIf

Small Basic: Triángulos y punto medio de una recta (código)


pendiente

Trazado de triángulos con base en la recta que pasa (corta) a otra recta por su punto medio

código:

  1. ‘ x1 < o > x2
  2. TextWindow.WriteLine(“Input      x1”)
  3. x1 = TextWindow.ReadNumber()
  4. TextWindow.WriteLine(“Input      y1”)
  5. y1 = TextWindow.ReadNumber()
  6. TextWindow.WriteLine(“Input      x2”)
  7. x2 = TextWindow.ReadNumber()
  8. TextWindow.WriteLine(“Input      y2”)
  9. y2 = TextWindow.ReadNumber()
  10. ‘ m is the slope of the line
  11. m =      (y2-y1) / (x2-x1)
  12. x =      (x1 + x2)/2
  13. y=      (y1 + y2)/2
  14. TextWindow.WriteLine(“the      slope of the line is :  ” + m)
  15. GraphicsWindow.PenWidth = 1
  16. GraphicsWindow.PenColor =      “Red”
  17. GraphicsWindow.DrawLine(x1, y1,      x2, y2)
  18. GraphicsWindow.PenWidth= 1
  19. GraphicsWindow.PenColor=      “Blue)
  20. GraphicsWindow.DrawEllipse(x1,y1,      10,10)
  21. GraphicsWindow.DrawEllipse(x2,y2,      10,10)
  22. GraphicsWindow.PenWidth = 1
  23. GraphicsWindow.PenColor =      “Red”
  24. GraphicsWindow.DrawBoundText(x,      y,20, ” medio “)
  25. GraphicsWindow.DrawLine(x, y, x      + 200, y)
  26. GraphicsWindow.DrawLine(x, y, x      – 200, y)
  27. GraphicsWindow.PenColor =      “Cyan”
  28. GraphicsWindow.DrawLine(x +      200, y, x1, y1)
  29. GraphicsWindow.DrawLine(x –      200, y, x1, y1)
  30. GraphicsWindow.DrawLine(x +      200, y, x2, y2)
  31. GraphicsWindow.DrawLine(x –      200, y, x2, y2)
  32. ‘ slope = m = (y2 – y1) / (x2 –      x1) = elevation / traveled.  for x1      different from  x2
  33. tangent      = y2-y1 / x2-x1
  34. ‘      distance = d
  35. a= Math.Power(x2- x1, 2)
  36. b =      Math.Power(y2-y1, 2)
  37. c = a + b
  38. d = Math.SquareRoot(c)
  39. TextWindow.WriteLine(“the      distance is : “

Small Basic: cálculo del punto medio de una recta, dadas sus coordenas


pmedio1

Escribir un programa en Small Basic, que calcule el punto medio de cualquier recta, dadas sus coordenas. La manera de obtener geométricamente el punto medio de una recta es Dado un segmento, cuyos extremos tienen por coordenadas:
(x1, y1) , (x2, y2) … el punto medio tendrá por coordenadas
.                           (x, y) = ( x1+x2)/ 2 , (y1+y2) / 2 )

 

TextWindow.WriteLine(“INPUT x1”)
x1= TextWindow.ReadNumber()
TextWindow.WriteLine(“INPUT y1”)
y1= TextWindow.ReadNumber()
TextWindow.WriteLine(“INPUT x2”)
x2= TextWindow.ReadNumber()
TextWindow.WriteLine(“INPUT y2”)
y2= TextWindow.ReadNumber()
x = (x1 + x2)/2
y= (y1 + y2)/2
TextWindow.WriteLine(“x =  ” + x + ”   y = ” + y)
GraphicsWindow.Width = 240
GraphicsWindow.Height = 240
GraphicsWindow.PenColor = “Blue”
GraphicsWindow.DrawLine(x1, y1, x2, y2)
GraphicsWindow.PenWidth = 10
GraphicsWindow.PenColor = “Red”
GraphicsWindow.DrawEllipse(x, y, 20, 20)

Visual Basic: Area de un triángulo (código)


areatri1

Se pide ingresar la base y altura de un triángulo, y el programa calcula el área y lo grafica.  Graduado (convertido)  del programa en  Small Basic  WGZ319   Editado por  Nonki Takahashi

  1. Module areatriModule
  2. Dim base, height, area, cm, size, x, y, k, pxBase, pxHeight, x1, y1, x2, y2, x3, y3, triangle As Primitive
  3. Sub Main()
    1. ‘Area of a triangle
    2. TextWindow.Write(“enter the value of the base of the triangle: “)
    3. base = TextWindow.ReadNumber()
    4. TextWindow.Write(“enter the value of the height of the triangle: “)
    5. height = TextWindow.ReadNumber()
    6. area = (base * height) / 2
    7. TextWindow.WriteLine(“The area is ” + Area)
  4. cm = 24 ‘ [px/cm]
  5. size = 12 ‘ [cm]
  6. GraphicsWindow.Width = cm * size
  7. GraphicsWindow.Height = cm * size
  8. GraphicsWindow.Top = TextWindow.Top + 150
  9. GraphicsWindow.Left = TextWindow.Left + 50
  10. GraphicsWindow.BackgroundColor = “LightGray”
  11. DrawGrid()
  12. DrawTriangle()
  13. End Sub
  14. Sub DrawGrid()
    1. GraphicsWindow.PenColor = “DimGray”
    2. For x = 0 To cm * size Step cm

i.   GraphicsWindow.DrawLine(x, 0, x, cm * size)

  1. Next
  2. For y = 0 To cm * size Step cm

i.   GraphicsWindow.DrawLine(0, y, cm * size, y)

  1. Next
  2. End Sub
  3. Sub DrawTriangle()
    1. GraphicsWindow.PenColor = “Black”
    2. GraphicsWindow.BrushColor = “MediumSeaGreen”
    3. k = 0.3 ‘ 0 <= k <= 1
    4. pxBase = base * cm
    5. pxHeight = height * cm
    6. x1 = pxBase * k
    7. y1 = 0
    8. x2 = pxBase
    9. y2 = pxHeight
    10. x3 = 0
    11. y3 = y2
    12. triangle = Shapes.AddTriangle(x1, y1, x2, y2, x3, y3)
    13. Shapes.Move(triangle, cm, cm)
    14. End Sub
    15. End Module

Small Basic: Area de un triángulo (código)


areatri

Se pide ingresar la base y altura de un triángulo, y el programa calcula el área y lo grafica.  Edited by Nonki Takahashi

  1. ‘  Program Listing WGZ319
  1. ‘Area of a triangle
  2. TextWindow.Write(“enter the value of the base of the triangle: “)
  3. base = TextWindow.ReadNumber()
  4. TextWindow.Write(“enter the value of the height of the triangle: “)
  5. height = TextWindow.ReadNumber()
  6. area = (base * height) / 2
  7. TextWindow.WriteLine(“The area is ” + Area)
  1. cm = 24 ‘ [px/cm]
  2. size = 12 ‘ [cm]
  3. GraphicsWindow.Width = cm * size
  4. GraphicsWindow.Height = cm * size
  5. GraphicsWindow.Top = TextWindow.Top + 150
  6. GraphicsWindow.Left = TextWindow.Left + 50
  7. GraphicsWindow.BackgroundColor = “LightGray”
  8. DrawGrid()
  9. DrawTriangle()
  1. Sub DrawGrid
  2. GraphicsWindow.PenColor = “DimGray”
  3. For x = 0 To cm * size Step cm
  4. GraphicsWindow.DrawLine(x, 0, x, cm * size)
  5. EndFor
  6. For y = 0 To cm * size Step cm
  7. GraphicsWindow.DrawLine(0, y, cm * size, y)
  8. EndFor
  9. EndSub
  1. Sub DrawTriangle
  2. GraphicsWindow.PenColor = “Black”
  3. GraphicsWindow.BrushColor = “MediumSeaGreen”
  4. k = 0.3 ‘ 0 <= k <= 1
  5. pxBase = base * cm
  6. pxHeight = height * cm
  7. x1 = pxBase * k
  8. y1 = 0
  9. x2 = pxBase
  10. y2 = pxHeight
  11. x3 = 0
  12. y3 = y2
  13. triangle = Shapes.AddTriangle(x1, y1, x2, y2, x3, y3)
  14. Shapes.Move(triangle, cm, cm)
  15. EndSub

Small basic and tablet compatibility


tablet

know if the small basic is compatible tablets equipped with windows 7 or 8.

Windows 7 tablets: run Small Basic fine on the desktop / with Silverlight

Windows 8 tablets (except ARM): run Small Basic fine on the desktop / with Silverlight

Windows 8 ARM tablets: do not run Small Basic at all (even with Silverlight)

Edited by gungan37

Proposed As Answer by litdevMicrosoft Community Contributor

Marked As Answer by Ed Price – MSFTMicrosoft Employee

http://social.msdn.microsoft.com/Forums/en-US/smallbasic/thread/cfdb6219-ea5b-4722-82b7-729888074993

Otros recursos adicionales en Small Basic


examplesb
Si desea avanzar a la programación en C # o VB.NET sin dejar de utilizar sus habilidades de SB estos tutoriales le muestran cómo.

by NaochanON Wednesday Editado, 27 de febrero 2013 07:58
Hice 2 manuales y 2 listas de programas de ejemplo (continuación).
1) Para los usuarios japoneses. Manual Japonés (日本语) * corregida ver1.01
https://docs.google.com/file/d/0B8mzGh2PVjd-RnRQZHdYRE42THc/edit
2) Para el resto de los usuarios. Inglés Manual * corregida ver1.01
https://docs.google.com/file/d/0B8mzGh2PVjd-bjlxVjVnV3lsNlE/edit
3) programas de ejemplo (hecho por NaochanON)
https://docs.google.com/file/d/0B8mzGh2PVjd-eTlYSDNBX1lXd2s/edit
La extensión no se utiliza en los programas escritos en el manual básicamente.
La próxima vez voy a crear ejemplo con la extensión.
4) los programas publicados en este tema “Pon su código fuente de ejemplo aquí y rasgos de nuestros blogs!”

https://docs.google.com/file/d/0B8mzGh2PVjd-UEd2S3NWUWFvV2c/edit
Espero que estos manuales ayuden a su programación.

gracias.

http://social.msdn.microsoft.com/Forums/en-US/smallbasic/thread/8b995743-071a-4eb0-abe3-2d05de90c018

La ecuación de la línea recta que muestra los ejes X e Y


easy

Pregunta:   Después de resolver la ecuación y = ax + b, ¿cómo puede Gráficor una línea recta en los ejes X e Y como Excel? – carlosfmur1948

Respuesta:   Tienes que dibujar cada segmento de línea y los ejes y etiquetado etc usando GraphicsWindow.DrawLine, y dando las coordenadas en píxeles – esto puede requerir un poco de conversión. Es necesario para calcular las coordenadas de los dos extremos del segmento de línea que se está dibujando, usando la ecuación o cualquier otro método es el adecuado.
Casualmente, yo estaba pensando en escribir una extensión de trazado simple en lugar de vertimiento datos a Excel a través de un archivo de texto que es lo que tengo que hacer si quiero una parcela de SmallBASIC.
Easy Graph  por NaoChanON

http://social.msdn.microsoft.com/Forums/en-US/smallbasic/thread/4f6b079a-c2c2-41f2-b38d-85ebcf9981ef/

Empezando con Small Basic


a2

Microsoft Small Basic pone la diversión en la programación de computadoras. Con un entorno de desarrollo que es muy fácil de dominar, que facilita a los estudiantes de todas las edades en el mundo de la programación

Lea el FAQ Small Basic

Descarga Small Basic

Utilice la Guía de inicio para comenzar a aprender Small Basic

Utilice el programa de estudios para ampliar su conocimiento

Lea los capítulos de muestra de libros electrónicos a bucear profundamente en Small Basic

Hacer preguntas en los foros

Manténgase informado acerca de Small Basic leyendo nuestro blog

http://social.technet.microsoft.com/wiki/contents/articles/15889.get-started-with-small-basic.aspx

El objeto Flickr en Small Basic (código)


a2

Un ejercicio agradable
Con el objeto de Flickr obtenemos imágenes aleatorias.
Cambian 10 veces las imágenes con un delay = 200 msegundos
Y se ajusta el tamaño de la pantalla con el tamaño de cada imagen
Divertido !

  1. GraphicsWindow.Title =      “imagen”
  2. For i = 1 To 10
  3. img =      Flickr.GetRandomPicture(“animals”)
  4. Ancho =      ImageList.GetWidthOfImage(img)
  5. Alto =      ImageList.GetHeightOfImage(img)
  6. GraphicsWindow.Width = Ancho
  7. GraphicsWindow.Height = Alto
  8. GraphicsWindow.DrawResizedImage(img,      0, 0, Ancho, Alto)
  9. Program.Delay(200)
  10. EndFor

Small Basic Desafío mes de Abril/ 2013 (código)


a2

  1. 1.      Community Suggestion 2 (By Nonki)
  2. http://social.msdn.microsoft.com/Forums/en-US/smallbasic/thread/7239821c-161c-4328-b29d-7c55e40b11b9
  3. 3.      Draw a picture of  cars  (Moving)   TJV532 

 

 ´ Challenge of the month April 2013 Moving Cars by NaochanON

shapecars()
shapes_Add()

While “true”
L_Cars_Moving()
R_Cars_Moving()
Program.Delay(50)
endwhile

Sub L_Cars_Moving
For L=1 To 5
For i=1 To 9
Shapes.Move(SHP[L][i][“obj”],Shapes.GetLeft(SHP[L][i][“obj”])-Vx[L],Shapes.GetTop(SHP[L][i][“obj”]))
EndFor
If Shapes.GetLeft(SHP[L][1][“obj”])<-200 Then
DDX=Math.GetRandomNumber(400)
For i=1 To 9
Shapes.Move(SHP[L][i][“obj”],Shapes.GetLeft(SHP[L][i][“obj”])+1300+DDX,Shapes.GetTop(SHP[L][i][“obj”]))
EndFor
EndIf
EndFor
EndSub

Sub R_Cars_Moving
For L=6 To 10
For i=1 To 9
Shapes.Move(SHP[L][i][“obj”],Shapes.GetLeft(SHP[L][i][“obj”])+Vx[L],Shapes.GetTop(SHP[L][i][“obj”]))
EndFor
If Shapes.GetLeft(SHP[L][1][“obj”])>1300 Then
DDX=Math.GetRandomNumber(400)
For i=1 To 9
Shapes.Move(SHP[L][i][“obj”],Shapes.GetLeft(SHP[L][i][“obj”])-1400-DDX,Shapes.GetTop(SHP[L][i][“obj”]))
EndFor
EndIf
EndFor
EndSub

Sub shapecars
GraphicsWindow.BackgroundColor=”Darkgreen”
GraphicsWindow.Width=1200
GraphicsWindow.Height=700
GraphicsWindow.Top=0
GraphicsWindow.Left=20
GraphicsWindow.Hide()
X0 = 0  ‘ x offset
Y0 = 0  ‘ y offset
‘————————————– Left oriented cars ——————————————————————————–
s=0.55
start=1
End=9
For L=1 To 5
shp[L][1] = “func=rect;x=4;y=23;width=130;height=25;bc=#00F0CA;pc=#000000;pw=2;”
shp[L][2] = “func=ell;x=20;y=33;width=23;height=23;bc=#9D756A;pc=#000000;pw=2;”
shp[L][3] = “func=ell;x=95;y=32;width=23;height=23;bc=#9D756A;pc=#000000;pw=2;”
shp[L][4] = “func=rect;x=48;y=2;width=54;height=23;bc=#E0F0CA;pc=#000000;pw=2;”
shp[L][5] = “func=tri;x=41;y=5;x1=7;y1=0;x2=0;y2=17;x3=15;y3=17;bc=#E0F0CA;pc=#E0F0CA;pw=2;”
shp[L][6] = “func=tri;x=91;y=5;x1=9;y1=0;x2=0;y2=17;x3=18;y3=17;bc=#E0F0CA;pc=#E0F0CA;pw=2;”
shp[L][7] = “func=ell;x=0;y=26;width=11;height=12;bc=#FFFF00;pc=#FF0000;pw=2;”
shp[L][8] = “func=ell;x=58;y=5;width=10;height=15;bc=#6A5ACD;pc=#6A5ACD;pw=4;”
shp[L][9] = “func=rect;x=56;y=20;width=15;height=10;bc=#FF5ACD;pc=#6A5ACD;pw=4;”
Shapes_Add()
DX=Math.GetRandomNumber(L+2)*130
Y_Pos()
For i=start To end
shapes.Move(SHP[L][i][“obj”],Shapes.GetLeft(SHP[L][i][“obj”])+100+DX,Shapes.GetTop(SHP[L][i][“obj”])+DY-30)
EndFor
Vx[L]=2.5+Math.GetRandomNumber(20)/10
EndFor
‘————————————– Right oriented cars ——————————————————————————–
For L=6 To 10
shp[L][1] = “func=rect;x=6;y=83;width=130;height=25;bc=#E000CA;pc=#000000;pw=2;”
shp[L][2] = “func=ell;x=20;y=93;width=23;height=23;bc=#9D756A;pc=#000000;pw=2;”
shp[L][3] = “func=ell;x=95;y=92;width=23;height=23;bc=#9D756A;pc=#000000;pw=2;”
shp[L][4] = “func=rect;x=48;y=62;width=54;height=23;bc=#E0F0CA;pc=#000000;pw=2;”
shp[L][5] = “func=tri;x=41;y=65;x1=7;y1=0;x2=0;y2=17;x3=15;y3=17;bc=#E0F0CA;pc=#E0F0CA;pw=2;”
shp[L][6] = “func=tri;x=91;y=65;x1=9;y1=0;x2=0;y2=17;x3=18;y3=17;bc=#E0F0CA;pc=#E0F0CA;pw=2;”
shp[L][7] = “func=ell;x=128;y=86;width=11;height=12;bc=#FFFF00;pc=#FF0000;pw=2;”
shp[L][8] = “func=ell;x=85;y=61;width=10;height=15;bc=#6A5ACD;pc=#6A5ACD;pw=4;”
shp[L][9] = “func=rect;x=82;y=76;width=15;height=10;bc=#FF5ACD;pc=#6A5ACD;pw=4;”
Shapes_Add()
DX=Math.GetRandomNumber(L-3)*130
Y_Pos()
For i=start To end
shapes.Move(SHP[L][i][“obj”],Shapes.GetLeft(SHP[L][i][“obj”])+500-DX,Shapes.GetTop(SHP[L][i][“obj”])+DY-30)
EndFor
Vx[L]=2.5+Math.GetRandomNumber(20)/10
EndFor
‘ ‘———————————————————————————————————————-
GraphicsWindow.Show()
EndSub

Sub shapes_Add
For i = start To End
GraphicsWindow.PenWidth = SHP[L][i][“pw”]*s
GraphicsWindow.PenColor = SHP[L][i][“pc”]
GraphicsWindow.BrushColor = SHP[L][i][“bc”]
If SHP[L][i][“func”] = “rect” Then
SHP[L][i][“obj”] = Shapes.AddRectangle(SHP[L][i][“width”]*s, SHP[L][i][“height”]*s)
ElseIf SHP[L][i][“func”] = “ell” Then
SHP[L][i][“obj”] = Shapes.AddEllipse(SHP[L][i][“width”]*s, SHP[L][i][“height”]*s)
ElseIf SHP[L][i][“func”] = “tri” Then
SHP[L][i][“obj”] = Shapes.AddTriangle(SHP[L][i][“x1”]*s, SHP[L][i][“y1”]*s, SHP[L][i][“x2”]*s, SHP[L][i][“y2”]*s, SHP[L][i][“x3”]*s, SHP[L][i][“y3”]*s)
ElseIf SHP[L][i][“func”] = “line” Then
SHP[L][i][“obj”] = Shapes.AddLine(SHP[L][i][“x1”]*s, SHP[L][i][“y1”]*s, SHP[L][i][“x2”]*s, SHP[L][i][“y2”]*s)
EndIf
Shapes.Move(SHP[L][i][“obj”], X0 + SHP[L][i][“x”]*s, Y0 + SHP[L][i][“y”]*s)
Shapes.Rotate(SHP[L][i][“obj”], SHP[L][i][“angle”])
EndFor
endsub

Sub Y_Pos
Again:
DY=(Math.GetRandomNumber(12)-1)*60
If Text.IsSubText(SDY,DY) Then
Goto Again
EndIf
SDY=SDY+DY+”;”
endsub

Small Basic Forum – Desafío del Mes – abril 2013


a2

Editado por litdev  Microsoft Community Contributor, Moderador Lunes, 01 de abril 2013 17:41
Sugerencia Comunidad 2 (Por Nonki)
(1) Dibuje la red de un dado (dados).
(2) Haz un dibujo de una flor.
(3) Haz un dibujo de un coche
Esta es mi muestra de Sugerencia Comunidad 2 (1):
Program Listing MDB491. Nonki Takahashi.

http://social.msdn.microsoft.com/Forums/en-US/smallbasic/thread/7239821c-161c-4328-b29d-7c55e40b11b9

Bienvenidos al Desafío mensual SmallBASIC! (Abril/ 2013)- código


trafico
Desafío Física: Editado por litdevMicrosoft Community Contributor, Moderador
http://social.msdn.microsoft.com/Forums/en-US/smallbasic/thread/7239821c-161c-4328-b29d-7c55e40b11b9
Escriba un programa para controlar un semáforo en un cruce donde los coches llegan de diferentes direcciones a diferentes velocidades. Si quieres un reto aún más luego añadir unas cruces de la red de carreteras y controlar  todas las luces. Las luces se pueden detectar cuando una cola se está acumulando.
Un reto difícil para algunos de ustedes puede que deseen trabajar juntos en esto.

Programa Listing TRK448-1    Editado por NaochanON

  1. ‘  Challenge of the month April 2013  …   Physics Challenge   //  Trafic  ….     by  NaochanON
  2. ‘  TRK448-1
  3. Shapes_Init()
  4. GUI()
  5. shapecars()
  1. While “true”
  2. L_Cars_Moving()
  3. R_Cars_Moving()
  4. Up_Cars_Moving()
  5. Down_Cars_Moving()
  6. RemainTime()
  7. Program.Delay(50)
  8. endwhile
  1. Sub  X_AvoidCollision
  2. For LL=(DN+2) To (DN+cars+1)
  3. If  LL<>L Then
  4. If Math.abs(Shapes.GetLeft(SHP[LL][1][“obj”])-Shapes.GetLeft(SHP[L][1][“obj”]))<160*s Then ‘  next car
  5. Vx[LL]=Vx[L]            ‘  same speed // avoid collision
  6. EndIf
  7. EndIf
  8. EndFor
  9. EndSub
  1. Sub  Y_AvoidCollision
  2. For LL=(2*cars+2+DN) To (3*cars+1+DN)
  3. If  LL<>L Then
  4. If Math.abs( Shapes.Gettop(SHP[LL][1][“obj”]) – Shapes.Gettop(SHP[L][1][“obj”]) )<140*s Then ‘  next car
  5. Vy[LL]=Vy[L]            ‘  same speed // avoid collision
  6. EndIf
  7. EndIf
  8. EndFor
  9. EndSub
  1. Sub RNDXSpeed
  2. Vx[L]= Vx[L-1]+Math.GetRandomNumber(10)/10
  3. Vx[DN+2]=4.5
  4. EndSub
  1. Sub RNDYSpeed
  2. Vy[L]= Vy[L-1]+Math.GetRandomNumber(10)/10
  3. Vy[DN+2*cars+2]=3.5
  4. EndSub
  1. Sub L_Cars_Moving
  2. DN=0
  3. For L=2 To (cars+1)
  4. Xpos[L]=Shapes.GetLeft(SHP[L][1][“obj”])
  5. ‘———————————————   Restart  ———————————————————————————————–
  6. If  LRNotice=”OK” And  -2000<Xpos[L] and Vx[L]<0.35 then        ‘    if   signal becomes “Blue”
  7. RNDXSpeed()                                                   ‘   new speed
  8. EndIf
  9. ‘———————————————   Yellow Signal  ——————————————————————————————-
  10. If  LRNotice=”Notice” And RemTime<=24 and  625<Xpos[L]  and Xpos[L]<675  then ‘//  Notice Area
  11. Vx[L]=Vx[L]*0.5                                                  ‘   speed down
  12. elseIf  LRNotice=”Notice” And  550<Xpos[L]  and Xpos[L]<625  then   ‘    Signal = “Yellow”
  13. Vx[L]=Vx[L]+0.75                                                 ‘   speed down
  14. EndIf
  15. ‘———————————————   Red Signal  ——————————————————————————————-
  16. If  LRNotice=”NG” And  625<Xpos[L]  and Xpos[L]<675  then       ‘    Signal = “Red”
  17. Vx[L]=0                                                       ‘   speed down
  18. EndIf
  19. ‘———————————————   car move  // avoid collision   ———————————————————————–
  20. For i=start To end
  21. Shapes.Move(SHP[L][i][“obj”],Shapes.GetLeft(SHP[L][i][“obj”])-Vx[L],Shapes.GetTop(SHP[L][i][“obj”]))
  22. EndFor
  23. X_AvoidCollision()                                              ‘   speed  control
  24. ‘———————————————–   go over left    next position  ————————————————————————-
  25. If Xpos[L]<-(300+135*L) Then
  26. RNDX=1300 -Xpos[L]+ 135*L*2
  27. For i=start To end
  28. shapes.Move(SHP[L][i][“obj”],Shapes.GetLeft(SHP[L][i][“obj”])+Rndx,Shapes.GetTop(SHP[L][i][“obj”]))
  29. endfor
  30. RNDXSpeed()
  31. endif
  32. EndFor
  33. EndSub
  1. Sub R_Cars_Moving
  2. DN=cars
  3. For L=(cars+2) To (2*cars+1)
  4. Xpos[L]=Shapes.GetLeft(SHP[L][1][“obj”])
  5. ‘———————————————   Restart  ———————————————————————————————–
  6. If  LRNotice=”OK” And  -2000<Xpos[L] and Vx[L]<0.35 then       ‘    if   signal becomes “Blue”
  7. RNDXSpeed()                                                  ‘   new speed
  8. EndIf
  9. ‘———————————————   Yellow Signal  ——————————————————————————————-
  10. If  LRNotice=”Notice” And RemTime<=24 and  370<Xpos[L]  and Xpos[L]<400  then  ‘    Notice area
  11. Vx[L]=Vx[L]*0.5                                              ‘   speed down
  12. elseIf  LRNotice=”Notice” And  345<Xpos[L]  and Xpos[L]<420  then
  13. Vx[L]=Vx[L]+0.75                                             ‘   speed down
  14. EndIf
  15. ‘———————————————   Red Signal  ——————————————————————————————-
  16. If  LRNotice=”NG” And  365<Xpos[L]  and Xpos[L]<390  then      ‘    Signal = “Red”
  17. Vx[L]=0                                                      ‘   speed down
  18. EndIf
  19. ‘———————————————   car move  // avoid collision   ———————————————————————–
  20. For i=start To end
  21. Shapes.Move(SHP[L][i][“obj”],Shapes.GetLeft(SHP[L][i][“obj”])+Vx[L],Shapes.GetTop(SHP[L][i][“obj”]))
  22. EndFor
  23. X_AvoidCollision()                                             ‘   speed  control
  24. ‘———————————————–   go over left    next position  ————————————————————————-
  25. If 1000+135*L<Xpos[L] Then
  26. RNDX=-(Xpos[L]+ 135*L*2)
  27. For i=start To end
  28. shapes.Move(SHP[L][i][“obj”],Shapes.GetLeft(SHP[L][i][“obj”])+Rndx,Shapes.GetTop(SHP[L][i][“obj”]))
  29. endfor
  30. RNDXSpeed()
  31. endif
  32. EndFor
  33. EndSub
  1. Sub Up_Cars_Moving
  2. DN=0
  3. For L=(2*cars+2) To (3*cars+1)
  4. Ypos[L]=Shapes.Gettop(SHP[L][1][“obj”])
  5. ‘———————————————   Restart  ———————————————————————————————–
  6. If  UDNotice=”OK” And  -2000<Ypos[L] and Vy[L]<0.35 then        ‘    if   signal becomes “Blue”
  7. RNDYSpeed()                                                   ‘   new speed
  8. EndIf
  9. ‘———————————————   Yellow Signal  ——————————————————————————————-
  10. If  UDNotice=”Notice” And RemTime<=3 and  425<Ypos[L]  and Ypos[L]<450  then  ‘    Notice Area
  11. Vy[L]=Vy[L]*0.75                                              ‘   speed down
  12. elseIf  UDNotice=”Notice” And  350<Ypos[L]  and Ypos[L]<440  then  ‘    Signal = “Yellow”
  13. Vy[L]=Vy[L]+0.75                                              ‘   speed down
  14. EndIf
  15. ‘———————————————   Red Signal  ——————————————————————————————-
  16. If  UDNotice=”NG” And  425<Ypos[L]  and Ypos[L]<450  then       ‘    Signal = “Red”
  17. Vy[L]=0                                                       ‘   speed down
  18. EndIf
  19. ‘———————————————   car move  // avoid collision   ———————————————————————–
  20. For i=1 To 8
  21. Shapes.Move(SHP[L][i][“obj”],Shapes.GetLeft(SHP[L][i][“obj”]),Shapes.GetTop(SHP[L][i][“obj”])-VY[L])
  22. EndFor
  23. Y_AvoidCollision()                                              ‘   speed  control
  24. ‘———————————————–   go over left    next position  ————————————————————————-
  25. If Ypos[L]< -135*(L-2*cars) Then
  26. RNDY=600 -Ypos[L]+ 135*(L-2*cars)*2
  27. For i=start To end-1
  28. shapes.Move(SHP[L][i][“obj”],Shapes.GetLeft(SHP[L][i][“obj”]),Shapes.GetTop(SHP[L][i][“obj”])+RNDY)
  29. endfor
  30. RNDYSpeed()
  31. endif
  32. EndFor
  33. EndSub
  1. Sub Down_Cars_Moving
  2. DN=cars
  3. For L=(3*cars+2) To (4*cars+1)
  4. Ypos[L]=Shapes.Gettop(SHP[L][1][“obj”])
  5. ‘———————————————   Restart  ———————————————————————————————–
  6. If  UDNotice=”OK” And  -2000<Ypos[L] and Vy[L]<0.35 then       ‘    if   signal becomes “Blue”
  7. RNDYSpeed()                                                  ‘   new speed
  8. EndIf
  9. ‘———————————————   Yellow Signal  ——————————————————————————————-
  10. If  UDNotice=”Notice” And RemTime<=3 and  180<Ypos[L]  and Ypos[L]<205  then  ‘   Notice Area
  11. Vy[L]=Vy[L]*0.75                                             ‘   speed down
  12. elseIf  UDNotice=”Notice” And  165<Ypos[L]  and Ypos[L]<250  then  ‘    Signal = “Yellow”
  13. Vy[L]=Vy[L]+0.75                                             ‘   speed down
  14. EndIf
  15. ‘———————————————   Red Signal  ——————————————————————————————-
  16. If  UDNotice=”NG” And  180<Ypos[L]  and Ypos[L]<205  then      ‘    Signal = “Red”
  17. Vy[L]=0                                                      ‘   speed down
  18. EndIf
  19. ‘———————————————   car move  // avoid collision   ———————————————————————–
  20. For i=1 To 8
  21. Shapes.Move(SHP[L][i][“obj”],Shapes.GetLeft(SHP[L][i][“obj”]),Shapes.GetTop(SHP[L][i][“obj”])+VY[L])
  22. EndFor
  23. Y_AvoidCollision()                                             ‘   speed  control
  24. ‘———————————————–   go over left    next position  ————————————————————————-
  25. If Ypos[L]> 700+135*(L-3*cars-1) Then
  26. RNDY=-Ypos[L]- 135*(L-3*cars-1)*2
  27. For i=start To end-1
  28. shapes.Move(SHP[L][i][“obj”],Shapes.GetLeft(SHP[L][i][“obj”]),Shapes.GetTop(SHP[L][i][“obj”])+RNDY)
  29. endfor
  30. RNDYSpeed()
  31. endif
  32. EndFor
  33. EndSub
  1. Sub RemainTime
  2. CycleTime=40                                                ‘    LR ; 40 sec   UD ; 40 sec
  3. DT=(Clock.ElapsedMilliseconds-t0)/1000                      ‘   Elapsed time ;  sec
  4. RemTime=text.GetSubText(1000+math.round(CycleTime-DT),2,3)  ‘   Remained time  ( Count down)
  5. For k=21 To 24
  6. Shapes.SetText( SHP[1][K][“obj”],RemTime)                 ‘   show  remained time
  7. EndFor
  8. If (CycleTime/2>DT and DT>=CycleTime/2-10)  Then            ‘   LR trafic  ;  Yellow signal blinking
  9. blink_LR_Yellow()
  10. elseIf (CycleTime>DT and DT>=CycleTime-10)  Then            ‘   UD trafic  ;  Yellow signal blinking
  11. blink_UD_Yellow()
  12. elseIf CycleTime/2+1>DT and DT>=CycleTime/2 Then            ‘  UD trafic  ;  Can Go !  Signals for UD  :Blue
  13. UD_Trafic_Go()
  14. elseIf CycleTime+1>DT and DT>=CycleTime Then                ‘  LR trafic  ;  Can Go !   Signals for LR  :Blue
  15. LR_Trafic_Go()
  16. t0= Clock.ElapsedMilliseconds                             ‘  CycleTime reset
  17. DT=0
  18. EndIf
  19. endsub
  1. Sub LR_Trafic_Go
  2. LRNotice=”OK”
  3. UDNotice=”NG”
  4. ON[“R”]=”1=1;2=1;3=0;4=0″
  5. ON[“Y”]=”1=0;2=0;3=0;4=0″
  6. ON[“B”]=”1=0;2=0;3=1;4=1″
  7. LightON()
  8. endsub
  1. Sub blink_LR_Yellow
  2. LRNotice=”Notice”
  3. UDNotice=”NG”
  4. ON[“R”]=”1=1;2=1;3=0;4=0″
  5. ON[“Y”]=”1=0;2=0;3=1;4=1″   ‘  for  LR
  6. ON[“B”]=”1=0;2=0;3=0;4=0″
  7. LightON()
  8. Program.Delay(20)
  9. ON[“Y”]=”1=0;2=0;3=0;4=0″   ‘
  10. LightON()
  11. EndSub
  1. Sub blink_UD_Yellow
  2. LRNotice=”NG”
  3. UDNotice=”Notice”
  4. ON[“R”]=”1=0;2=0;3=1;4=1″
  5. ON[“Y”]=”1=1;2=1;3=0;4=0″  ‘  for UD
  6. ON[“B”]=”1=0;2=0;3=0;4=0″
  7. LightON()
  8. Program.Delay(20)
  9. ON[“Y”]=”1=0;2=0;3=0;4=0″   ‘
  10. LightON()
  11. EndSub
  1. Sub UD_Trafic_Go
  2. LRNotice=”NG”
  3. UDNotice=”OK”
  4. ON[“R”]=”1=0;2=0;3=1;4=1″
  5. ON[“Y”]=”1=0;2=0;3=0;4=0″
  6. ON[“B”]=”1=1;2=1;3=0;4=0″
  7. LightON()
  8. endsub
  1. Sub AllClear
  2. ON[“R”]=”1=0;2=0;3=0;4=0″
  3. ON[“Y”]=”1=0;2=0;3=0;4=0″
  4. ON[“B”]=”1=0;2=0;3=0;4=0″
  5. LightON()
  6. endsub
  1. Sub LightON
  2. For k=1 To 4     ‘  1,2   Left  Upper &  Right Lower    3 ,4  Right  Upper &  Left Lower
  3. shapes.SetOpacity(SHP[1][5*(K-1)+3][“obj”],10+90*ON[“R”][K])  ‘  Red
  4. shapes.SetOpacity(SHP[1][5*(K-1)+4][“obj”],10+90*ON[“Y”][K])  ‘  Yellow
  5. shapes.SetOpacity(SHP[1][5*(K-1)+5][“obj”],10+90*ON[“B”][K])  ‘  Blue
  6. endfor
  7. EndSub
  1. Sub Shapes_Init
  2. X0 = 250  ‘ x offset
  3. Y0 = 150  ‘ y offset
  4. ‘———————————————————————————————————————-
  5. shp[1][1] = “func=rect;x=213;y=50;width=26;height=85;bc=#3B9440;pc=#3B9440;pw=2;”   ‘  Left  Upper
  6. shp[1][2] = “func=rect;x=224;y=135;width=8;height=16;bc=#000000;pc=#000000;pw=2;”   ‘  Pole
  7. shp[1][3] = “func=ell;x=220;y=80;width=14;height=15;bc=#FF0000;pc=#FF0000;pw=2;”    ‘  Red
  8. shp[1][4] = “func=ell;x=220;y=98;width=14;height=15;bc=#FFFF00;pc=#FFFF00;pw=2;”    ‘  Yellow
  9. shp[1][5] = “func=ell;x=220;y=116;width=14;height=14;bc=#0000FF;pc=#0000FF;pw=2;”   ‘  Blue
  10. ‘———————————————————————————————————————-
  11. shp[1][6] = “func=rect;x=364;y=269;width=26;height=85;bc=#3B9440;pc=#3B9440;pw=2;”  ‘  Right Lower
  12. shp[1][7] = “func=rect;x=373;y=252;width=8;height=16;bc=#000000;pc=#000000;pw=2;”
  13. shp[1][8] = “func=ell;x=371;y=310;width=14;height=14;bc=#FF0000;pc=#FF0000;pw=2;”   ‘  Red
  14. shp[1][9] = “func=ell;x=371;y=292;width=14;height=14;bc=#FFFF00;pc=#FFFF00;pw=2;”   ‘  Yellow
  15. shp[1][10] = “func=ell;x=371;y=274;width=14;height=14;bc=#0000FF;pc=#0000FF;pw=2;”  ‘  Blue
  16. ‘———————————————————————————————————————-
  17. shp[1][11] = “func=rect;x=378;y=116;width=85;height=20;bc=#3B9440;pc=#3B9440;pw=2;”  ‘  Right Upper
  18. shp[1][12] = “func=rect;x=355;y=124;width=22;height=8;bc=#000000;pc=#000000;pw=2;”
  19. shp[1][13] = “func=ell;x=418;y=119;width=14;height=14;bc=#FF0000;pc=#FF0000;pw=2;”   ‘  Red
  20. shp[1][14] = “func=ell;x=400;y=119;width=14;height=14;bc=#FFFF00;pc=#FFFF00;pw=2;”   ‘  Yellow
  21. shp[1][15] = “func=ell;x=382;y=119;width=14;height=14;bc=#0000FF;pc=#0000FF;pw=2;”   ‘  Blue
  22. ‘———————————————————————————————————————-
  23. shp[1][16] = “func=rect;x=145;y=259;width=85;height=24;bc=#3B9440;pc=#3B9440;pw=2;”  ‘  Left  Lower
  24. shp[1][17] = “func=rect;x=231;y=267;width=16;height=8;bc=#000000;pc=#000000;pw=2;”
  25. shp[1][18] = “func=ell;x=177;y=263;width=14;height=14;bc=#FF0000;pc=#FF0000;pw=2;”   ‘  Red
  26. shp[1][19] = “func=ell;x=194;y=263;width=14;height=14;bc=#FFFF00;pc=#FFFF00;pw=2;”   ‘  Yellow
  27. shp[1][20] = “func=ell;x=213;y=263;width=14;height=14;bc=#0000FF;pc=#0000FF;pw=2;”   ‘  Blue
  28. ‘———————————————————————————————————————-
  29. shp[1][21] = “func=text;x=216;y=60;text=120;bc=#FF0000;fs=14;fn=Coulier New;”        ‘   Remaining time  #1  Left Upper
  30. shp[1][22] = “func=text;x=366;y=330;text=120;bc=#FF0000;fs=14;fn=Coulier New;”       ‘   Remaining time  #1  Right Lower
  31. shp[1][23] = “func=text;x=438;y=116;text=120;bc=#FF0000;fs=14;fn=Coulier New;”        ‘   Remaining time  #2  Right Upper
  32. shp[1][24] = “func=text;x=151;y=262;text=120;bc=#FF0000;fs=14;fn=Coulier New;”        ‘   Remaining time  #1  Left Lowerer
  33. EndSub
  1. Sub shapecars
  2. ‘————————————–  Left oriented cars ——————————————————————————–
  3. s=0.55
  4. start=1
  5. End=9
  6. cars=5
  7. For L=2 To (cars+1)
  8. shp[L][1] = “func=rect;x=4;y=23;width=130;height=25;bc=#00F0CA;pc=#000000;pw=2;”
  9. shp[L][2] = “func=ell;x=20;y=33;width=23;height=23;bc=#9D756A;pc=#000000;pw=2;”
  10. shp[L][3] = “func=ell;x=95;y=32;width=23;height=23;bc=#9D756A;pc=#000000;pw=2;”
  11. shp[L][4] = “func=rect;x=48;y=2;width=54;height=23;bc=#E0F0CA;pc=#000000;pw=2;”
  12. shp[L][5] = “func=tri;x=41;y=5;x1=7;y1=0;x2=0;y2=17;x3=15;y3=17;bc=#E0F0CA;pc=#E0F0CA;pw=2;”
  13. shp[L][6] = “func=tri;x=91;y=5;x1=9;y1=0;x2=0;y2=17;x3=18;y3=17;bc=#E0F0CA;pc=#E0F0CA;pw=2;”
  14. shp[L][7] = “func=ell;x=0;y=26;width=11;height=12;bc=#FFFF00;pc=#FF0000;pw=2;”
  15. shp[L][8] = “func=ell;x=58;y=5;width=10;height=15;bc=#6A5ACD;pc=#6A5ACD;pw=4;”
  16. shp[L][9] = “func=text;x=80;y=5;text=”+(L-1)+”;bc=#FF0000;fs=22;fn=Coulier New;”
  17. Shapes_Add()
  18. For i=start To end
  19. shapes.Move(SHP[L][i][“obj”],Shapes.GetLeft(SHP[L][i][“obj”])+700+(L-2)*160,Shapes.GetTop(SHP[L][i][“obj”])+210)
  20. EndFor
  21. RNDXSpeed()
  22. EndFor
  23. ‘————————————– Right oriented cars ——————————————————————————–
  24. For L=(cars+2) To (2*cars+1)
  25. shp[L][1] = “func=rect;x=6;y=83;width=130;height=25;bc=#E000CA;pc=#000000;pw=2;”
  26. shp[L][2] = “func=ell;x=20;y=93;width=23;height=23;bc=#9D756A;pc=#000000;pw=2;”
  27. shp[L][3] = “func=ell;x=95;y=92;width=23;height=23;bc=#9D756A;pc=#000000;pw=2;”
  28. shp[L][4] = “func=rect;x=48;y=62;width=54;height=23;bc=#E0F0CA;pc=#000000;pw=2;”
  29. shp[L][5] = “func=tri;x=41;y=65;x1=7;y1=0;x2=0;y2=17;x3=15;y3=17;bc=#E0F0CA;pc=#E0F0CA;pw=2;”
  30. shp[L][6] = “func=tri;x=91;y=65;x1=9;y1=0;x2=0;y2=17;x3=18;y3=17;bc=#E0F0CA;pc=#E0F0CA;pw=2;”
  31. shp[L][7] = “func=ell;x=128;y=86;width=11;height=12;bc=#FFFF00;pc=#FF0000;pw=2;”
  32. shp[L][8] = “func=ell;x=85;y=61;width=10;height=15;bc=#6A5ACD;pc=#6A5ACD;pw=4;”
  33. shp[L][9] = “func=text;x=60;y=60;text=”+(L-cars-1)+”;bc=#FF0000;fs=22;fn=Coulier New;”
  34. Shapes_Add()
  35. For i=start To end
  36. shapes.Move(SHP[L][i][“obj”],Shapes.GetLeft(SHP[L][i][“obj”])-200-(L-cars-2)*160,Shapes.GetTop(SHP[L][i][“obj”])+125)
  37. EndFor
  38. RNDXSpeed()
  39. EndFor
  40. ‘—————————————Up oriented cars ——————————————————————————-
  41. end2=8
  42. For L=(2*cars+2) To (3*cars+1)
  43. shp[L][1] = “func=ell;x=2;y=0;width=34;height=93;bc=#DBD229;pc=#DBD229;pw=2;”
  44. shp[L][2] = “func=ell;x=2;y=7;width=11;height=7;bc=#FF0000;pc=#FF0000;pw=2;”
  45. shp[L][3] = “func=ell;x=25;y=7;width=11;height=7;bc=#FF0000;pc=#FF0000;pw=2;”
  46. shp[L][4] = “func=rect;x=31;y=19;width=6;height=14;bc=#000000;pc=#6A5ACD;pw=2;”
  47. shp[L][5] = “func=rect;x=1;y=19;width=6;height=14;bc=#000000;pc=#6A5ACD;pw=2;”
  48. shp[L][6] = “func=rect;x=0;y=60;width=6;height=14;bc=#000000;pc=#6A5ACD;pw=2;”
  49. shp[L][7] = “func=rect;x=31;y=60;width=6;height=14;bc=#000000;pc=#6A5ACD;pw=2;”
  50. shp[L][8] = “func=text;x=12;y=35;text=”+(L-2*cars-1)+”;bc=#FF0000;fs=22;fn=Coulier New;”
  51. Shapes_Add()
  52. For i=start To end2
  53. shapes.Move(SHP[L][i][“obj”],Shapes.GetLeft(SHP[L][i][“obj”])+260,Shapes.GetTop(SHP[L][i][“obj”])+500+(L-(2*cars+2))*160)
  54. EndFor
  55. RNDYSpeed()
  56. EndFor
  57. ‘—————————————Down oriented cars ——————————————————————————-
  58. For L=(3*cars+2) To (4*cars+1)
  59. shp[L][1] = “func=ell;x=2;y=0;width=34;height=93;bc=#E090CA;pc=#DBD229;pw=2;”
  60. shp[L][2] = “func=ell;x=2;y=77;width=11;height=7;bc=#FF0000;pc=#FF0000;pw=2;”
  61. shp[L][3] = “func=ell;x=25;y=77;width=11;height=7;bc=#FF0000;pc=#FF0000;pw=2;”
  62. shp[L][4] = “func=rect;x=31;y=19;width=6;height=14;bc=#000000;pc=#6A5ACD;pw=2;”
  63. shp[L][5] = “func=rect;x=1;y=19;width=6;height=14;bc=#000000;pc=#6A5ACD;pw=2;”
  64. shp[L][6] = “func=rect;x=0;y=60;width=6;height=14;bc=#000000;pc=#6A5ACD;pw=2;”
  65. shp[L][7] = “func=rect;x=31;y=60;width=6;height=14;bc=#000000;pc=#6A5ACD;pw=2;”
  66. shp[L][8] = “func=text;x=12;y=40;text=”+(L-3*cars-1)+”;bc=#FF0000;fs=22;fn=Coulier New;”
  67. Shapes_Add()
  68. For i=start To end2
  69. shapes.Move(SHP[L][i][“obj”],Shapes.GetLeft(SHP[L][i][“obj”])+320,Shapes.GetTop(SHP[L][i][“obj”])-130-( L – (3*cars+2) )*160)
  70. EndFor
  71. RNDYSpeed()
  72. EndFor
  73. ‘ ‘———————————————————————————————————————-
  74. GraphicsWindow.Show()
  75. t0= Clock.ElapsedMilliseconds   ‘   start tim
  76. EndSub
  1. Sub GUI
  2. GraphicsWindow.Title=” Trafic Signals and Car action  “
  3. GraphicsWindow.top=10
  4. GraphicsWindow.Left=20
  5. GraphicsWindow.Hide()
  6. GraphicsWindow.Width=1200
  7. GraphicsWindow.Height=700
  8. GraphicsWindow.BackgroundColor=”DarkGreen”
  9. GraphicsWindow.BrushColor=”Gray”
  10. GraphicsWindow.PenColor=”Gray”
  11. GraphicsWindow.FillEllipse(50,-50,1000,770)
  12. GraphicsWindow.BrushColor=”DarkGreen”
  13. GraphicsWindow.PenColor=”DarkGreen”
  14. GraphicsWindow.FillEllipse(100,-10,900,680)
  15. GraphicsWindow.BrushColor=”Gray”
  16. GraphicsWindow.PenColor=”Gray”
  17. GraphicsWindow.FillRectangle(-100,300,1400,100)
  18. GraphicsWindow.FillRectangle(500,-100,100,1000)
  1. GraphicsWindow.BrushColor=”White”
  2. GraphicsWindow.PenColor=”White”
  3. For i=1 To 20
  4. GraphicsWindow.FillRectangle(30+(i-1)*100,350-5,30,5)
  5. GraphicsWindow.FillRectangle(550,-30+(i-1)*80,5,30)
  6. endfor
  7. GraphicsWindow.FillRectangle(475,300,5,30)
  8. GraphicsWindow.FillRectangle(625,370,5,30)
  9. GraphicsWindow.FillRectangle(500,418,35,5)
  10. GraphicsWindow.FillRectangle(565,275,35,5)
  11. STPX=”1=475;2=625;3=500;4=565″      ‘  stop Line
  12. STPY=”1=300;2=370;3=418;4=275″
  13. ‘———————————————————————————————————————-
  14. s=1
  15. L=1
  16. start=1
  17. End=24
  18. Shapes_Add()
  19. AllClear()
  20. LR_Trafic_Go()
  21. EndSub
  1. Sub shapes_Add
  2. For i = start To End
  3. GraphicsWindow.PenWidth = SHP[L][i][“pw”]*s
  4. GraphicsWindow.PenColor = SHP[L][i][“pc”]
  5. GraphicsWindow.BrushColor = SHP[L][i][“bc”]
  6. If SHP[L][i][“func”] = “rect” Then
  7. SHP[L][i][“obj”] = Shapes.AddRectangle(SHP[L][i][“width”]*s, SHP[L][i][“height”]*s)
  8. ElseIf SHP[L][i][“func”] = “ell” Then
  9. SHP[L][i][“obj”] = Shapes.AddEllipse(SHP[L][i][“width”]*s, SHP[L][i][“height”]*s)
  10. ElseIf SHP[L][i][“func”] = “tri” Then
  11. SHP[L][i][“obj”] = Shapes.AddTriangle(SHP[L][i][“x1”]*s, SHP[L][i][“y1”]*s, SHP[L][i][“x2”]*s, SHP[L][i][“y2”]*s, SHP[L][i][“x3”]*s, SHP[L][i][“y3”]*s)
  12. ElseIf shp[L][i][“func”] = “text” Then
  13. fs = shp[L][i][“fs”]
  14. GraphicsWindow.FontSize = fs * s
  15. GraphicsWindow.FontName = shp[L][i][“fn”]
  16. shp[L][i][“obj”] = Shapes.AddText(shp[L][i][“text”])
  17. EndIf

Shapes.Move(SHP[L][i][“obj”], X0 + SHP[L][i][“x”]*s, Y0 + SHP[L][i][“y”]*s)

EndFor

endsub

Tancraft (Desarrollado con Small Basic)


a24
Aquí hay otro juego que hice con pequeña base. La llamé Tancraft. Es un juego de 2 jugadores se puede jugar con uno de tus amigos.

Estoy muy agradecido a litdev por sus impresionantes extensiones. Usé su extensión para usar una imagen animada (la explosión de los tanques) en mi juego.

Al principio cada jugador coloca sus tanques en cualquier lugar en su propia tierra (tierras están separadas con la línea roja), y luego a partir del mejor jugador hace clic en algún lugar que poseen tierras. Una vez que se hace clic allí el punto correspondiente en el otro lado de la línea roja  será destruído. Si hay tanque del enemigo allí el tanque explotaría.

Puedes descargar el juego desde aquí (en la parte superior de la página)
Behnam Azizi

http://gallery.technet.microsoft.com/Tanks-Game-a619a22a