Diagramas de componentes de UML


diagramasuml

Microsoft.VisualStudio.Uml.Components (Espacio de nombres)

Un componente UML describe una unidad modular de un sistema de software con interfaces bien definidas, diseñado normalmente para poder ser fácilmente reemplazado o usado en distintas combinaciones con otros componentes.

Para obtener más información sobre cómo los componentes se componen de partes, vea Microsoft.VisualStudio.Uml.CompositeStructures.

Para obtener más información sobre el modelo de componentes en Visual Studio Ultimate, vea Diagramas de componentes de UML: Referencia y Diagramas de componentes de UML: Instrucciones. Para obtener más información acerca de la UML API, vea Ampliar modelos y diagramas UML.

Las propiedades y los tipos definidos en este espacio de nombres se corresponden con los definidos en la especificación de UML. Además, los métodos de extensión se definen en muchos de los tipos de este espacio de nombres. Para obtener más información, vea Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml.

Interfaces


 

Interfaz

Descripción

IComponent Parte modular de un sistema con interfaces proporcionadas y necesarias   definidas explícitamente.

Enumeraciones


 

Enumeración

Descripción

ConnectorKind Describe un conector dentro de un componente.

Guía de Microsoft Visio 2010 para principiantes


a23

Existen muchos tipos de diagramas de Visio, pero puede usar los mismos tres pasos básicos para crear casi todos ellos:

  1. Elegir y abrir una plantilla.
  2. Arrastrar y conectar formas.
  3. Agregar texto a las formas.

En este artículo


Paso 1: elegir y abrir una plantilla

Paso 2: arrastrar y conectar formas

Paso 3: agregar texto a las formas

Formas

Galerías de símbolos

Plantillas

http://office.microsoft.com/es-ar/visio-help/guia-de-visio-2010-para-principiantes-HA010357067.aspx

Microsoft Visio


a24

 

Microsoft Visio es un software de dibujo vectorial para Microsoft Windows. Visio comenzó a formar parte de los productos de Microsoft cuando fue adquirida la compañía Visio en el año 2000.

Las herramientas que lo componen permiten realizar diagramas de oficinas, diagramas de bases de datos, diagramas de flujo de programas, UML, y más, que permiten iniciar al usuario en los lenguajes de programación.

El navegador Internet Explorer incluye un visor de diagramas Visio, cuya extensión es vsd, llamado Visio Viewer.

http://es.wikipedia.org/wiki/Microsoft_Visio

Visio

Desarrollador

Microsoft
[1]

Información   general

Última   versión estable 14.0.6123.5001 (SP1)
24 de junio de 2011
Género Ingeniería de   Software
Sistema operativo Windows   XP Windows Vista Windows 7 Windows Server 2008 Windows   8 Windows Server 2012
Licencia Propietaria
En español

 

pseudocódigo (falso lenguaje)


a22

Un pseudocódigo (falso lenguaje), es una serie de normas léxicas y gramaticales parecidas a la mayoría de los lenguajes de programación, pero sin llegar a la rigidez de sintaxis de estos ni a la fluidez del lenguaje coloquial. Esto permite codificar un programa con mayor agilidad que en cualquier lenguaje de programación, con la misma validez semántica, normalmente se utiliza en las fases de análisis o diseño de Software, o en el estudio de un algoritmo. Forma parte de las distintas herramientas de la ingeniería de software. No hay ningún compilador o intérprete de pseudocódigo informático (en el caso de que lo hubiera serían los lectores de dicho pseudocódigo informático, por ej. una idea de un jefe de programación al su personal), y por tanto no puede ser ejecutado en un ordenador, pero las similitudes con la mayoría de los lenguajes informáticos lo hacen fácilmente convertible. El pseudocódigo describe un algoritmo utilizando una mezcla de frases en lenguaje común, instrucciones de programación y palabras clave que definen las estructuras básicas. Su objetivo es permitir que el programador se centre en los aspectos lógicos de la solución a un problema. No siendo el pseudocódigo un lenguaje formal, varían de un programador a otro, es decir, no hay una estructura semántica ni arquitectura estándar. Es una herramienta ágil para el estudio y diseño de aplicaciones, veamos un ejemplo, que podríamos definir como: lenguaje imperativo, de tercera generación, según el método de programación estructurada.

El pseudocódigo describe un algoritmo utilizando una mezcla de frases en lenguaje común, instrucciones de programación y palabras clave que definen las estructuras básicas. Su objetivo es permitir que el programador se centre en los aspectos lógicos de la solución a un problema. No siendo el pseudocódigo un lenguaje formal, varían de un programador a otro, es decir, no hay una estructura semántica ni arquitectura estándar. Es una herramienta ágil para el estudio y diseño de aplicaciones, veamos un ejemplo, que podríamos definir como: lenguaje imperativo, de tercera generación, según el método de programación estructurada.

DEFINICION DE DATOS DEL PSEUDOCOGIGO
La definición de datos se da por supuesta, sobre todo en las variables sencillas, si se emplea formaciones: pilas, colas, vectores o registros, se pueden definir en la cabecera del algoritmo, y naturalmente cuando empleemos el pseudocódigo para definir estructuras de datos, esta parte la desarrollaremos adecuadamente.

DEFINICION DE ESTRUCTURAS DE CONTROL
Como se había mencionado antes, cada autor usa su propio pseudocódigo con sus respectivas convenciones. Por ejemplo, considere la instrucción “Reemplace el valor de la variable x por el valor de la variable y”; algunas de las posibles sintaxis para indicar lo anterior podrían ser: asigne a el valor de Sin embargo, independientemente de estas diferencias, muchos autores consideran tres estructuras de control para desarrollar los procedimientos:

SECUENCIAL
Las instrucciones se siguen en una secuencia fija que normalmente viene dada por el número de renglón. Es decir que las instrucciones se ejecutan de arriba hacia abajo. Instrucción1 Instrucción2 Instrucción3 Instrucciónn

FUNCIONES Y PROCEDIMIENTOS
Muchas personas prefieren distinguir entre funciones y procedimientos. Una función, al igual que una función matemática, recibe un valor de entrada y regresa una salida mientras que un procedimiento recibe una entrada pero no genera una salida. En ambos casos es necesario dejar en claro cuáles son las entradas para el algoritmo, esto se hace comunmente colocando estos valores entre paréntesis al principio o bien declarándolo explicitamente con un enunciado. En el caso de las funciones, es necesario colocar una palabra como regresar o devolver para indicar cuál es la salida generada por el algoritmo. Por ejemplo, el pseudocódigo de una función que

VENTAJAS AL UTILIZAR PSEUDOCODIGO
Permite representar de forma fácil operaciones repetitivas complejas. Es más sencilla la tarea de pasar de pseudocódigo a un lenguaje de programación formal. Si se siguen las reglas de identación se puede observar claramente los niveles en la estructura del programa. En los procesos de aprendizaje de los alumnos de programación, estos están más cerca del paso siguiente (codificación en un lenguaje determinado, que los que se inician en esto con la modalidad Diagramas de Flujo) Obtenido de

http://es.wikipedia.org/wiki/Pseudoc%C3%B3digo”

http://pseudocodigobasico.galeon.com/

Diagrama de flujo ( flowchart) que encuentra la suma de los primeros 50 numeros naturales


a21

Introducción.

Los diagramas de flujo son una manera de representar visualmente el flujo de datos a travéz de sistemas de tratamiento de información. Los diagramas de flujo describen que operaciónes y en que secuencia se requieren para solucionar un problema dado.

Un diagrama de flujo u organigrama es una representación diagramática que ilustra la secuencia de las operaciones que se realizarán para conseguir la solución de un problema. Los diagramas de flujo se dibujan generalmente antes de comenzar a programar el código frente a la computadora. Los diagramas de flujo facilitan la comunicación entre los programadores y la gente del negocio. Estos diagramas de flujo desempeñan un papel vital en la programación de un problema y facilitan la comprensión de problemas complicados y sobre todo muy largos. Una vez que se dibuja el diagrama de flujo, llega a ser fácil escribír el programa en cualquier idióma de alto nivel. Vemos a menudo cómo los diagramas de flujo nos dan ventaja al momento de explicar el programa a otros. Por lo tanto, está correcto decir que un diagrama de flujo es una necesidad para la documentación mejor de un programa complejo.

Reglas para dibujar un diagramas de flujo.

Los Diagramas de flujo se dibujan generalmente usando algunos símbolos estándares; sin embargo, algunos símbolos especiales pueden también ser desarrollados cuando séan requeridos. Algunos símbolos estándares, que se requieren con frecuencia para diagramar programas de computadora se muestran a continuación:

 

¿ Para qué es Small Basic ? A quién va dirigido?. Entrevista con litdev (fragmento)


a1

litdev : affiliations Microsoft Community Contributor   Website   litdev.hostoi.com
¿Para qué es es Small Basic ? A quién va dirigido?
Small Basic es para todos (jóvenes o viejos) que apenas está interesada en “cómo funciona”. Creo que hay tanta tecnología que usamos todos los días, y la mayoría de la gente tiene muy poca idea de cómo funciona, y no tienen idea de lo que se requiere imaginación y el grado de satisfacción puede venir de ser creativo con las computadoras.

Creo que es muy importante que los niños tengan la oportunidad de aprender algo acerca de una parte muy importante de cómo funciona nuestra sociedad. Aun cuando no se conviertan en programadores, deben tener la oportunidad de ver cómo imaginativo y divertido que no se puede simplemente utilizando la tecnología, pero sabiendo cómo funciona. Esto incluye la programación, sino también la física y las matemáticas.

Graficar con varios Anchos de pluma (código Small Basic y Visual Basic


a20
Mediante el uso de los bucles , se puede escribir fácilmente un programa que dibuja varias líneas con el aumento de grosor de la pluma.
La parte interesante de este programa es el bucle, donde se aumenta la PenWidth cada vez que el bucle se ejecuta y luego dibujar una nueva línea debajo de la anterior.

Small Basic

  1. GraphicsWindow.BackgroundColor = “Black”
  2. GraphicsWindow.Width = 200
  3. GraphicsWindow.Height = 160
  4. GraphicsWindow.PenColor = “Blue”
  5. For i = 1 To 10
  6. GraphicsWindow.PenWidth = i
  7. GraphicsWindow.DrawLine(20, i * 15, 180, i * 15)
  8. Endfor

Visual Basic

  1. Module UntitledModule
  2. Dim i As Primitive
  3. Sub Main()
    1. GraphicsWindow.BackgroundColor = “Black”
    2. GraphicsWindow.Width = 200
    3. GraphicsWindow.Height = 160
    4. GraphicsWindow.PenColor = “Blue”
  1. For i = 1 To 10

i.   GraphicsWindow.PenWidth = i

ii.   GraphicsWindow.DrawLine(20, i * 15, 180, i * 15)

  1. Next
  2. End Sub
  3. End Module

Bajar juegos, construír y compartir…


a19

Disfrutar de decenas de juegos, construír los propios y compartirlos  accedemos al link 

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

Bajaremos en forma gratuita y rápida  Microsoft .NET Framework 3.5 que es requerido por Small Basic para ejecutarse

Luego en download tendremo el producto instalado y listo a usar

Sin título1

Los tutoriales y manuales se bajan gratis y están en inglés y castellano

En  http://social.msdn.microsoft.com/Forums/en-US/smallbasic/threads nos encontramos con un foro muy rico y cooperativo. Allí hacemos consultas y también compartimos código.

y en  Small Basic Program Gallery

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

tenemos una enorme catálogo de programas, por orden alfabético que podemos bajar y usar

Guerra aérea – 1942 (código)


aer1

Microsoft Small Basic  Program Listing:   ID: KJW676  http://smallbasic.com/smallbasic.com/program/?ZZD394

  1. ‘ 1942 like Game ID: KJW676
    ‘ Copyright (C) 2010, Laurent GIRAUD laurent.giraud1@free.fr
    ‘ License: MIT license http://www.opensource.org/licenses/mit-license.php
    ‘most of Game artwork created by Ari Feldman ari@arifeldman.com”
    ‘ and others grabed from free web sprites‘————————-
    ‘replace by your directory path
    ‘Path =”file://C:/Users/Laurent/Desktop/small basic/images1942/”
    Path= “http://imode.free.fr/images1942/”
    ‘replace by your directory path
    ‘————————-‘ Game area controls
    gameWidth  = 640
    gameHeight = 480
    fps = 50
    bgs = 2 ‘backgroundspeed
    Player_Lives = 10

    nbrisland = 5 ‘nomber of island images
    islandcount = 5 ‘nomber of island in the wall field

    ‘ Window title
    gameTitle = “1942, Score: ”

    GraphicsWindow.Hide()
    GraphicsWindow.Title = gameTitle + “0”
    GraphicsWindow.CanResize = “False”
    GraphicsWindow.Width = gameWidth
    GraphicsWindow.Height = gameHeight

    ‘Presentation
    ‘ todo

    ‘ Start game
    Init()
    define_paths()
    TimePlay = 0
    pathNBR = 1
    ‘create_enemies1()
    Play()

    ‘ Setup world
    Sub Init
    GraphicsWindow.Hide()

    Mouse.HideCursor()
    ‘ addImage in the right order is needed to define the shapes depth

    island4= ImageList.LoadImage(Path + “island4.png”)
    island1= ImageList.LoadImage(Path + “island1.png”)
    island2= ImageList.LoadImage(Path + “island2.png”)
    island3= ImageList.LoadImage(Path + “island3.png”)
    island5= ImageList.LoadImage(Path + “island5.png”)
    player0 = ImageList.LoadImage(Path + “myplane1.png”)
    background = ImageList.LoadImage(Path + “fond.png”)
    bullet0 = ImageList.LoadImage(Path + “bullet.png”)
    enemy= ImageList.LoadImage(Path + “enemy1.png”)
    enemy2 = ImageList.LoadImage(Path + “enemy2.png”)
    enemy_expl1=ImageList.LoadImage(Path + “explo1.png”)
    enemy_expl2=ImageList.LoadImage(Path + “explo2.png”)
    player_expl=ImageList.LoadImage(Path + “explo2.png”)
    Enemy_bullet=ImageList.LoadImage(Path + “E_bullet.png”)
    end = ImageList.LoadImage(Path + “End.png”)

    enemy_Array = “EnemyArray” ‘Array that contain all the enemies
    ‘ every enemy in tha array has 5 informations
    ‘ TimeLine: each enemy has its own timeline
    ‘ PathNBR: the precalculated path defineing the movement
    ‘ the movement is decomposed in LineNbr differents lines
    ‘ each line is define in the enemy_path table with rotation, deltaY and deltaY
    ‘ PositonX, PositonY: position in space


    enemy_TimeLine = “EnemyTimeLine”
    enemy_line = “enemyLineNbr”
    enemy_PosX = “enemyPositonX”
    enemy_PosY = “enemyPositonY”
    enemy_PathNBR=”enemy_PathNBR”

    enemy_Nbr = 6
    enemy_Count = 0
    enemy_speed = 4
    ‘enemy_NextRemove = 1
    enemy_Life = 10
    player_size= 65
    enemy_size = 32
    enemy_ammo_size = 8
    player_bullet_size = 32

    island_Array = “Island array”
    IslandsPosition()
    create_level1()

    fond= Shapes.AddImage(background)
    Array.SetValue(island_Array,1,Shapes.AddImage(island1))
    Array.SetValue(island_Array,2,Shapes.AddImage(island2))
    Array.SetValue(island_Array,3,Shapes.AddImage(island3))
    Array.SetValue(island_Array,4,Shapes.AddImage(island4))
    Array.SetValue(island_Array,5,Shapes.AddImage(island5))
    For i = 6 to  islandcount
    Array.SetValue(island_Array,i,Array.getValue(island_Array,Math.Remainder(i,4)))
    Endfor

    player = Shapes.AddImage(player0)
    GraphicsWindow.FontSize = 20
    GraphicsWindow.BackgroundColor = “Grey”
    GraphicsWindow.PenColor = “Yellow”

    Player_Ammo = “Player_AmmoArray”
    Player_AmmoAge = “Player_AmmoAge”
    Player_AmmoMax = 50
    Player_AmmoCount = 0
    Player_Ammospeed = bgs +4
    Player_AmmoLife = 100

    Enemy_Ammo = “Enemy_AmmoArray”
    Enemy_AmmoAge = “Enemy_AmmoAge”
    Enemy_Ammo_Angle=”Enemy_Ammo_Angle”
    Enemy_AmmoMax = 30
    Enemy_AmmoCount = 0
    Enemy_Ammospeed = bgs +4
    Enemy_AmmoLife = 50
    Enemy_Agresivity = 200
    score = 0
    EndSub

    ‘ Main gane routine
    Sub Play
    GraphicsWindow.Show()

    ‘ Main loop
    play = 1
    pause = 0
    incx =0   ‘ X-axis increment for background
    incy = 0  ‘ Y-axis increment for background
    incbx = 0  ‘increment for bullets and all objects on X
    incby = 0 ‘increment for bullets and all objects on Y
    squadron = 1
    ‘ Island initial position
    j= 0

    For i= 1 To islandcount
    j=Math.Remainder(i,6)
    posy[i]= islandPos[j][2]
    posx[i]= islandPos[j][3]
    incislandx[i] = 0
    incislandy[i] = 0
    EndFor
    TimePlay = 0
    Shapes.Move(player, gameWidth/2 , gameHeight -80 )
    While(play = 1)
    Program.Delay(1000/fps)
    TimePlay = TimePlay +1

    If (pause = 0) Then
    If (TimePlay = level1[squadron][1]) then

    pathNBR = level1[squadron][2]
    enemyPosX1 = level1[squadron][3]  ‘X position
    enemyPosY1 = level1[squadron][4]  ‘Y position
    enemy_Nbr = level1[squadron][6]
    enemy_type = level1[squadron][7]
    if (level1[squadron][5]=1) then
    create_enemies_left()
    Else
    create_enemies_right()
    endif
    squadron = squadron + 1
    endif
    If (TimePlay > 4000) then
    Shapes.Move(Shapes.addImage(end), 230,200)
    Program.Delay(5000)
    Program.End()
    Endif
    moveall()

    GraphicsWindow.MouseMove = OnMouseMove
    GraphicsWindow.MouseDown = OnMouseDown

    AgePlayer_Ammo()

    EndIf
    EndWhile

    EndSub

    Sub OnMouseMove
    paddleX = GraphicsWindow.MouseX – player_size/2
    paddleY = GraphicsWindow.MouseY- player_size

    If (paddleX < 0) then
    paddleX = 0
    endif
    Shapes.Move(player, paddleX , paddleY )
    EndSub
    Sub OnMouseDown
    ShootX = GraphicsWindow.MouseX – 15 ‘ in order to be from the neck of the plane
    ShootY = GraphicsWindow.MouseY – 80
    Fire()
    EndSub

    Sub moveall
    incbx = 0
    incby =0
    GraphicsWindow.Title = gameTitle + score +” Lives:”+Player_Lives

    If (paddleX >(gameWidth-62) ) Then
    incx = incx – bgs
    incbx = incbx – bgs
    For i= 1 To islandcount
    incislandx[i] = incislandx[i] – bgs
    EndFor
    If (incx = -32 ) Then
    incx =0
    Endif
    Endif
    If (paddleX < 64 ) Then
    incx = incx + bgs
    incbx = incbx + bgs
    For i= 1 To islandcount
    incislandx[i] = incislandx[i] + bgs
    EndFor
    If (incx = 32 ) Then
    incx =0
    Endif
    Endif
    Shapes.Move(fond,incx -32 ,incy – 32)

    For i= 1 To islandcount
    islx = posx[i]+incislandx[i]
    isly = posy[i]+incislandy[i]
    Shapes.Move(Array.GetValue(island_Array,i),islx,isly)
    EndFor

    incy = incy + bgs
    incby = incby+ bgs
    For i= 1 To islandcount
    incislandy[i] = incislandy[i] + bgs
    EndFor

    If (incy = 32) Then
    incy =0
    Endif

    For i= 1 To islandcount
    If ((posy[i]+incislandy[i]) > (gameHeight+15)) Then ‘relaunch island if no more visible
    R= Math.Round(Math.GetRandomNumber(nbrisland))
    AA = Math.Remainder(TimePlay,6)
    ‘give new coordinates
    posx[i]= islandPos[AA][2]
    posy[i]= islandPos[AA][3]
    Shapes.move(Array.GetValue(island_Array,R),posx[i],posy[i])
    incislandy[i]=0
    incislandx[i]=0
    EndIf
    ENDFOR
    ‘ Move playerammo
    For i = 1 To Player_AmmoCount
    Player_Ammox = Shapes.GetLeft(Array.GetValue(Player_Ammo, i)) +incbx
    Player_Ammoy = Shapes.GetTop(Array.GetValue(Player_Ammo, i)) – Player_Ammospeed
    Shapes.Move(Array.GetValue(Player_Ammo, i), Player_Ammox, Player_Ammoy)
    Array.SetValue(Player_AmmoAge, i, Array.GetValue(Player_AmmoAge, i) + 1)
    EndFor
    ‘ Move Enemy ammo
    For iea = 1 To Enemy_AmmoCount
    dx =(Math.Sin((Array.GetValue(Enemy_Ammo_Angle, iea) )) * Enemy_Ammospeed)
    dy =(Math.Cos((Array.GetValue(Enemy_Ammo_Angle, iea) ))* Enemy_Ammospeed)
    Enemy_Ammox = Shapes.GetLeft(Array.GetValue(Enemy_Ammo, iea)) +dx+incbx
    Enemy_Ammoy = Shapes.GetTop(Array.GetValue(Enemy_Ammo, iea)) +dy+incby*0.1
    Shapes.Move(Array.GetValue(Enemy_Ammo, iea), Enemy_Ammox, Enemy_Ammoy)
    Array.SetValue(Enemy_AmmoAge, iea, Array.GetValue(Enemy_AmmoAge, iea) + 1)
    EndFor

    ‘ move ennemies
    For i=1 To enemy_Count
    ‘ move as TimeLine and Path say
    eNBR= Array.GetValue(enemy_PathNBR,i)
    uu =Array.GetValue(enemy_line,i)
    Time= Array.GetValue(enemy_TimeLine, i)
    etl=enemyPath[eNBR][1][uu]  ‘enemy own timeLine
    IF (Time=etl) Then  ‘it’s time to rotate enemy
    rr = enemyPath[eNBR][2][uu+1]
    Shapes.Rotate(Array.GetValue(enemy_Array,i),rr)
    EndIf
    IF (Time > etl)  Then
    uu = uu+1
    Array.SetValue(enemy_line,i,uu)    ‘ next line for enemy move
    EndIf
    xx1=Array.GetValue(enemy_PosX,i)
    yy1= Array.GetValue(enemy_PosY,i)
    xx = xx1+enemyPath[eNBR][3][uu]+incbx
    yy = yy1+enemyPath[eNBR][4][uu]+incby*0.1
    ‘ Randomly fire-enemy
    If (Math.GetRandomNumber(Enemy_Agresivity)=1) Then
    Enemy_ShootX = xx1 + 16
    Enemy_ShootY = yy1 + 4
    If (yy1 > 0 AND xx1 > 0 And yy1< gameHeight And xx1 < gameWidth) then
    ‘this avoid enemy fire from outside the screen
    fire_Enemy()
    Endif
    EndIf

    Shapes.Move(Array.GetValue(enemy_Array,i),xx,yy)
    Array.SetValue(enemy_PosX,i,xx)
    Array.SetValue(enemy_PosY,i,yy)
    Array.SetValue(enemy_TimeLine, i, Time + 1)
    If ((uu > enemyPath[eNBR][0][0]) And (Time > etl)) Then ‘ if last timelife remove the enemy sprite
    next_enemy_remove = i
    remove_enemy()
    endif
    Collision_pbe()
    Collision_ep()
    EndFor

    EndSub

    Sub RemovePlayer_Ammo
    Shapes.Remove(Array.GetValue(Player_Ammo, Player_Ammo_nextRemove))
    For iz = Player_Ammo_nextRemove To Player_AmmoCount – 1
    Array.SetValue(Player_Ammo, iz, Array.GetValue(Player_Ammo, iz+1))
    Array.SetValue(Player_AmmoAge, iz, Array.GetValue(Player_AmmoAge, iz+1))
    EndFor
    Array.RemoveValue(Player_Ammo, Player_AmmoCount)
    Array.RemoveValue(Player_AmmoAge, Player_AmmoCount)
    Player_AmmoCount = Player_AmmoCount – 1
    EndSub

    Sub RemoveEnemy_Ammo
    Shapes.Remove(Array.GetValue(Enemy_Ammo, Enemy_Ammo_nextRemove))
    For irea = Enemy_Ammo_nextRemove To Enemy_AmmoCount – 1
    Array.SetValue(Enemy_Ammo, irea, Array.GetValue(Enemy_Ammo, irea+1))
    Array.SetValue(Enemy_AmmoAge, irea, Array.GetValue(Enemy_AmmoAge, irea+1))
    Array.SetValue(Enemy_Ammo_Angle, irea, Array.GetValue(Enemy_Ammo_Angle,irea+1))

    EndFor
    Array.RemoveValue(Enemy_Ammo, Enemy_AmmoCount)
    Array.RemoveValue(Enemy_AmmoAge, Enemy_AmmoCount)
    Array.RemoveValue(Enemy_Ammo_Angle,Enemy_AmmoCount)
    Enemy_AmmoCount = Enemy_AmmoCount – 1
    EndSub

    Sub fire
    ‘ Remove additional player Ammo
    While(Player_AmmoCount > Player_AmmoMax )
    Player_Ammo_nextRemove = 1
    RemovePlayer_Ammo()
    EndWhile

    ‘ Add the player Ammo

    Player_AmmoCount = Player_AmmoCount + 1
    Array.SetValue(Player_Ammo, Player_AmmoCount, Shapes.AddImage(bullet0))
    Shapes.Move(Array.GetValue(Player_Ammo, Player_AmmoCount), ShootX, ShootY)
    EndSub

    Sub fire_Enemy
    ‘ Remove additional Enemy Ammo
    While(Enemy_AmmoCount > (Enemy_AmmoMax – 1))
    Enemy_Ammo_nextRemove = 1
    RemoveEnemy_Ammo()
    EndWhile

    ‘ Add the Enemy Ammo

    Enemy_AmmoCount = Enemy_AmmoCount + 1
    Array.SetValue(Enemy_Ammo, Enemy_AmmoCount, Shapes.AddImage(Enemy_bullet))
    Array.SetValue(Enemy_Ammo_Angle, Enemy_AmmoCount,Math.ArcTan((paddleX- Enemy_ShootX+player_size/2)/(paddleY-Enemy_ShootY)))
    Shapes.Move(Array.GetValue(Enemy_Ammo, Enemy_AmmoCount), Enemy_ShootX, Enemy_ShootY)
    EndSub

    ‘Check playerammo age
    Sub AgePlayer_Ammo
    While (Array.GetValue(Player_AmmoAge, 1) > Player_AmmoLife)
    Player_Ammo_nextRemove = 1
    RemovePlayer_Ammo()
    EndWhile
    EndSub
    ‘Check enemy ammo age
    Sub AgeEnemy_Ammo
    While (Array.GetValue(Enemy_AmmoAge, 1) > Enemy_AmmoLife)
    Enemy_Ammo_nextRemove = 1
    RemoveEnemy_Ammo()
    EndWhile
    EndSub

    Sub remove_enemy
    Shapes.remove(Array.GetValue(enemy_Array,next_enemy_remove))
    ‘ Remove all references from the arrays
    For ii = next_enemy_remove To enemy_Count – 1
    Array.SetValue(enemy_Array, ii, Array.GetValue(enemy_Array, ii+1))
    Array.SetValue(enemy_line, ii, Array.GetValue(enemy_line, ii+1))
    Array.SetValue(enemy_PosX, ii, Array.GetValue(enemy_PosX, ii+1))
    Array.SetValue(enemy_PosY, ii, Array.GetValue(enemy_PosY, ii+1))
    Array.SetValue(enemy_TimeLine, ii, Array.GetValue(enemy_TimeLine, ii+1))
    Array.SetValue(enemy_PathNBR, ii , Array.GetValue(enemy_PathNBR, ii+1))
    EndFor
    Array.RemoveValue(enemy_Array, enemy_Count)
    Array.RemoveValue(enemy_line, enemy_Count)
    Array.RemoveValue(enemy_PosX, enemy_Count)
    Array.RemoveValue(enemy_PosY, enemy_Count)
    Array.RemoveValue(enemy_TimeLine, enemy_Count)
    Array.RemoveValue(enemy_PathNBR,enemy_Count)
    enemy_Count = enemy_Count – 1
    EndSub

    Sub create_enemies_left

    TimeLine1 =0
    For i=1 To enemy_Nbr
    enemy_Count= enemy_Count + 1
    Array.SetValue(enemy_PathNBR,enemy_Count,pathNBR)
    If (enemy_type = 2) Then
    Array.SetValue(enemy_Array, enemy_Count,Shapes.AddImage(enemy2))
    Else
    Array.SetValue(enemy_Array, enemy_Count,Shapes.AddImage(enemy))
    EndIf
    Array.SetValue(enemy_line,enemy_Count,1)
    Array.SetValue(enemy_PosX, enemy_Count,enemyPosX1)
    Array.SetValue(enemy_PosY, enemy_Count,enemyPosY1)
    Array.SetValue(enemy_TimeLine, enemy_Count, TimeLine1)

    enemyPosX1 = enemyPosX1 – 64 ‘distance between ennemies
    TimeLine1 = TimeLine1 – 64 / enemy_speed
    EndFor
    For i=(enemy_Count-enemy_Nbr+1) To enemy_Count
    xxx=Array.GetValue(enemy_PosX,i)
    yyy= Array.GetValue(enemy_PosY,i)
    Shapes.Move(Array.GetValue(enemy_Array,i),xxx,yyy)
    EndFor
    EndSub
    Sub create_enemies_right

    TimeLine1 =0
    For i=1 To enemy_Nbr
    enemy_Count= enemy_Count + 1
    Array.SetValue(enemy_PathNBR,enemy_Count,pathNBR)
    Array.SetValue(enemy_Array, enemy_Count,Shapes.AddImage(enemy))
    Array.SetValue(enemy_line,enemy_Count,1)
    Array.SetValue(enemy_PosX, enemy_Count,enemyPosX1)
    Array.SetValue(enemy_PosY, enemy_Count,enemyPosY1)
    Array.SetValue(enemy_TimeLine, enemy_Count, TimeLine1)

    enemyPosX1 = enemyPosX1 + 64 ‘distance between ennemies
    TimeLine1 = TimeLine1 – 64 / enemy_speed
    EndFor
    For i=(enemy_Count-enemy_Nbr+1) To enemy_Count
    xxx=Array.GetValue(enemy_PosX,i)
    yyy= Array.GetValue(enemy_PosY,i)
    Shapes.Move(Array.GetValue(enemy_Array,i),xxx,yyy)
    EndFor
    EndSub
    Sub Collision_pbe   ‘for player-bullet and enemies

    For i1 = 1 To Player_AmmoCount
    ‘ player bullet position
    Player_Ammox = Shapes.GetLeft(Array.GetValue(Player_Ammo, i1))
    Player_Ammoy = Shapes.GetTop(Array.GetValue(Player_Ammo, i1))
    px1=Player_Ammox+player_bullet_size/3   ‘in order to have a more precise collison than the bullet image size
    py1=Player_Ammoy+player_bullet_size/3
    px2=px1+2*player_bullet_size/3
    py2=py1+2*player_bullet_size/3

    For i2 = 1 to enemy_Count
    ‘ enemy position

    ax1=Array.GetValue(enemy_PosX,i2)+enemy_size/4
    ay1=Array.GetValue(enemy_PosY,i2)+enemy_size/4

    ax2=ax1+3*enemy_size/4
    ay2=ay1+3*enemy_size/4

    If ( (ax1 < px1 And ax2 > px1) Or (ax1 < px2 And ax2 > px2) ) Then
    If ( (ay1 < py1 And ay2 > py1) Or (ay1 < py2 And ay2 > py2) ) Then
    ‘ collision between enemy nbr i2 and player bullet i
    ‘ remove bullet i and animate explosion and remove enemy i2
    Player_Ammo_nextRemove = i1
    RemovePlayer_Ammo()
    next_enemy_remove = i2
    remove_enemy()
    ‘ begin animation for explosion at coordinate ax1, ay1
    toto= Shapes.AddImage(enemy_expl1)
    Shapes.move(toto,ax1,ay1)
    Program.Delay(30)
    Shapes.Remove(toto)
    toto= Shapes.AddImage(enemy_expl2)
    Shapes.move(toto,ax1,ay1)
    Program.Delay(30)
    Shapes.Remove(toto)
    score = score +100
    EndIf
    EndIf
    EndFor

    Endfor

    EndSub

    Sub Collision_ep   ‘for enemies and player
    px1 = Shapes.GetLeft(player)
    py1 = Shapes.GetTop(player)
    px2 = px1 + player_size
    py2 = py1 + player_size

    ‘Shapes.Move(Shapes.AddRectangle(px2-px1 ,py2-py1), px1, py1)
    For i2 = 1 to enemy_Count
    ‘ enemy position

    ax1=Array.GetValue(enemy_PosX,i2)
    ay1=Array.GetValue(enemy_PosY,i2)

    ax2=ax1+enemy_size
    ay2=ay1+enemy_size
    ‘Shapes.Move(Shapes.AddRectangle(ax2-ax1 ,ay2-ay1), ax1, ay1)

    If ( (px1 < ax1 And px2 > ax1) Or (px1 < ax2 And px2 > ax2) ) Then
    If ( (py1 < ay1 And py2 > ay1) Or (py1 < ay2 And py2 > ay2) ) Then
    ‘ collision between enemy nbr i2 and player
    ‘ animate explosion and decrease lives
    next_enemy_remove = i2
    remove_enemy()
    ‘ begin animation for explosion at coordinate ax1, ay1
    toto= Shapes.AddImage(enemy_expl1)
    Shapes.move(toto,ax1,ay1)
    Program.Delay(30)
    Shapes.Remove(toto)
    toto= Shapes.AddImage(player_expl)
    Shapes.move(toto,ax1,ay1)
    Program.Delay(300)
    Shapes.Remove(toto)
    Player_Lives = Player_Lives -1
    If (Player_Lives = 0) THEN
    Program.End()
    EndIf
    EndIf
    EndIf
    EndFor
    px1 = paddleX
    py1 = paddleY
    px2 = px1 + player_size
    py2 = py1 + player_size
    ‘Shapes.Move(Shapes.AddRectangle(px2-px1 ,py2-py1), px1, py1)
    For i3 = 1 to Enemy_AmmoCount
    ‘ enemy position

    ax1=Shapes.GetLeft(Array.GetValue(enemy_Ammo,i3))
    ay1=Shapes.GetTop(Array.GetValue(enemy_Ammo,i3))

    ax2=ax1+enemy_ammo_size
    ay2=ay1+enemy_ammo_size
    ‘Shapes.Move(Shapes.AddRectangle(ax2-ax1 ,ay2-ay1), ax1, ay1)

    If ( (px1 < ax1 And px2 > ax1) Or (px1 < ax2 And px2 > ax2) ) Then
    If ( (py1 < ay1 And py2 > ay1) Or (py1 < ay2 And py2 > ay2) ) Then
    ‘ collision between enemy ammo nbr i3 and player
    ‘ animate explosion and decrease lives
    Enemy_Ammo_nextRemove = i3
    RemoveEnemy_Ammo()

    ‘ begin animation for explosion at coordinate ax1, ay1
    toto= Shapes.AddImage(enemy_expl1)
    Shapes.move(toto,paddleX+ player_size/2,paddleY+ player_size/2)
    Program.Delay(30)
    Shapes.Remove(toto)
    toto= Shapes.AddImage(player_expl)
    Shapes.move(toto,paddleX+ player_size/2,paddleY+ player_size/2)
    Program.Delay(300)
    Shapes.Remove(toto)
    Player_Lives = Player_Lives -1
    If (Player_Lives = 0) THEN
    Program.End()
    EndIf
    EndIf
    EndIf
    EndFor

    EndSub

    Sub IslandsPosition
    ‘ island positions, avoid randomGeneration and islands overlap
    islandPos[0][1]=1
    islandPos[0][2]=0
    islandPos[0][3]=-150

    islandPos[1][1]=1
    islandPos[1][2]=-Math.Round(gameWidth/2)
    islandPos[1][3]=-150

    islandPos[2][1]=2
    islandPos[2][2]=-2*Math.Round(gameWidth/3)
    islandPos[2][3]=-150

    islandPos[3][1]=1
    islandPos[3][2]=2*Math.Round(gameWidth/3)
    islandPos[3][3]=-150

    islandPos[4][1]=2
    islandPos[4][2]=gameWidth
    islandPos[4][3]=-150

    islandPos[5][1]=3
    islandPos[5][2]=Math.Round(gameWidth/3)
    islandPos[5][3]=-150

    islandPos[6][1]=3
    islandPos[6][2]=-gameWidth
    islandPos[6][3]=-150
    EndSub

    Sub define_paths
    enemyPath[0][0][0] = 3  ‘nbr of strait lines of path
    enemyPath[0][1][1] = 30  ‘from 0 to this in timeline
    enemyPath[0][1][2] = 100 ‘ from this to next in timeline
    enemyPath[0][1][3] = 400   ‘sprite goes up

    enemyPath[0][2][1] = 0 ‘first line rotation = 0
    enemyPath[0][2][2] = 45 ‘ second line rotation = 45
    enemyPath[0][2][3] = 45

    enemyPath[0][3][1] = enemy_speed ‘ first line x movment
    enemyPath[0][3][2] = enemy_speed ‘second line x movment
    enemyPath[0][3][3] = enemy_speed ‘ third line …

    enemyPath[0][4][1] = 0 ‘ first line y movment
    enemyPath[0][4][2] = enemy_speed
    enemyPath[0][4][3] = enemy_speed
    ‘———- second path
    enemyPath[1][0][0] = 4
    enemyPath[1][1][1] = 1
    enemyPath[1][1][2] = 1
    enemyPath[1][1][3] = 100
    enemyPath[1][1][4] = 400

    enemyPath[1][2][1] = 180
    enemyPath[1][2][2] = 135
    enemyPath[1][2][3] = 135
    enemyPath[1][2][4] = 90

    enemyPath[1][3][1] = -enemy_speed
    enemyPath[1][3][2] = -enemy_speed
    enemyPath[1][3][3] = -enemy_speed
    enemyPath[1][3][4] = 0

    enemyPath[1][4][1] = 0
    enemyPath[1][4][2] = 0
    enemyPath[1][4][3] = enemy_speed
    enemyPath[1][4][4] = enemy_speed
    ‘round r=5
    enemyPath[2][0][0]=21
    enemyPath[2][1][1]=50
    enemyPath[2][1][2]=55
    enemyPath[2][1][3]=60
    enemyPath[2][1][4]=65
    enemyPath[2][1][5]=70
    enemyPath[2][1][6]=75
    enemyPath[2][1][7]=80
    enemyPath[2][1][8]=85
    enemyPath[2][1][9]=90
    enemyPath[2][1][10]=95
    enemyPath[2][1][11]=100
    enemyPath[2][1][12]=105
    enemyPath[2][1][13]=110
    enemyPath[2][1][14]=115
    enemyPath[2][1][15]=120
    enemyPath[2][1][16]=125
    enemyPath[2][1][17]=130
    enemyPath[2][1][18]=135
    enemyPath[2][1][19]=140
    enemyPath[2][1][20]=145
    enemyPath[2][1][21]=350
    enemyPath[2][2][1]=0
    enemyPath[2][2][2]=18
    enemyPath[2][2][3]=36
    enemyPath[2][2][4]=54
    enemyPath[2][2][5]=72
    enemyPath[2][2][6]=90
    enemyPath[2][2][7]=108
    enemyPath[2][2][8]=126
    enemyPath[2][2][9]=144
    enemyPath[2][2][10]=162
    enemyPath[2][2][11]=180
    enemyPath[2][2][12]=198
    enemyPath[2][2][13]=216
    enemyPath[2][2][14]=234
    enemyPath[2][2][15]=252
    enemyPath[2][2][16]=-90
    enemyPath[2][2][17]=-72
    enemyPath[2][2][18]=-54
    enemyPath[2][2][19]=-36
    enemyPath[2][2][20]=-18
    enemyPath[2][2][21]=0
    enemyPath[2][3][1]=enemy_speed
    enemyPath[2][3][2]=0.95*enemy_speed
    enemyPath[2][3][3]=0.81*enemy_speed
    enemyPath[2][3][4]=0.59*enemy_speed
    enemyPath[2][3][5]=0.31*enemy_speed
    enemyPath[2][3][6]=0
    enemyPath[2][3][7]=-0.31*enemy_speed
    enemyPath[2][3][8]=-0.59*enemy_speed
    enemyPath[2][3][9]=-0.81*enemy_speed
    enemyPath[2][3][10]=-0.95*enemy_speed
    enemyPath[2][3][11]=-enemy_speed
    enemyPath[2][3][12]=-0.95*enemy_speed
    enemyPath[2][3][13]=-0.81*enemy_speed
    enemyPath[2][3][14]=-0.59*enemy_speed
    enemyPath[2][3][15]=-0.31*enemy_speed
    enemyPath[2][3][16]=0
    enemyPath[2][3][17]=0.31*enemy_speed
    enemyPath[2][3][18]=0.59*enemy_speed
    enemyPath[2][3][19]=0.81*enemy_speed
    enemyPath[2][3][20]=0.95*enemy_speed
    enemyPath[2][3][21]=enemy_speed
    enemyPath[2][4][1]=0
    enemyPath[2][4][2]=0.31*enemy_speed
    enemyPath[2][4][3]=0.59*enemy_speed
    enemyPath[2][4][4]=0.81*enemy_speed
    enemyPath[2][4][5]=0.95*enemy_speed
    enemyPath[2][4][6]=enemy_speed
    enemyPath[2][4][7]=0.95*enemy_speed
    enemyPath[2][4][8]=0.81*enemy_speed
    enemyPath[2][4][9]=0.59*enemy_speed
    enemyPath[2][4][10]=0.31*enemy_speed
    enemyPath[2][4][11]=0
    enemyPath[2][4][12]=-0.31*enemy_speed
    enemyPath[2][4][13]=-0.59*enemy_speed
    enemyPath[2][4][14]=-0.81*enemy_speed
    enemyPath[2][4][15]=-0.95*enemy_speed
    enemyPath[2][4][16]=-enemy_speed
    enemyPath[2][4][17]=-0.95*enemy_speed
    enemyPath[2][4][18]=-0.81*enemy_speed
    enemyPath[2][4][19]=-0.59*enemy_speed
    enemyPath[2][4][20]=-0.31*enemy_speed
    enemyPath[2][4][21]=0
    ‘round r=20
    enemyPath[3][0][0]=21
    enemyPath[3][1][1]=120
    enemyPath[3][1][2]=140
    enemyPath[3][1][3]=160
    enemyPath[3][1][4]=180
    enemyPath[3][1][5]=200
    enemyPath[3][1][6]=220
    enemyPath[3][1][7]=240
    enemyPath[3][1][8]=260
    enemyPath[3][1][9]=280
    enemyPath[3][1][10]=300
    enemyPath[3][1][11]=320
    enemyPath[3][1][12]=340
    enemyPath[3][1][13]=360
    enemyPath[3][1][14]=380
    enemyPath[3][1][15]=400
    enemyPath[3][1][16]=420
    enemyPath[3][1][17]=440
    enemyPath[3][1][18]=460
    enemyPath[3][1][19]=480
    enemyPath[3][1][20]=500
    enemyPath[3][1][21]=600
    enemyPath[3][2][1]=0
    enemyPath[3][2][2]=18
    enemyPath[3][2][3]=36
    enemyPath[3][2][4]=54
    enemyPath[3][2][5]=72
    enemyPath[3][2][6]=90
    enemyPath[3][2][7]=108
    enemyPath[3][2][8]=126
    enemyPath[3][2][9]=144
    enemyPath[3][2][10]=162
    enemyPath[3][2][11]=180
    enemyPath[3][2][12]=198
    enemyPath[3][2][13]=216
    enemyPath[3][2][14]=234
    enemyPath[3][2][15]=252
    enemyPath[3][2][16]=-90
    enemyPath[3][2][17]=-72
    enemyPath[3][2][18]=-54
    enemyPath[3][2][19]=-36
    enemyPath[3][2][20]=-18
    enemyPath[3][2][21]=0
    enemyPath[3][3][1]=enemy_speed
    enemyPath[3][3][2]=0.95*enemy_speed
    enemyPath[3][3][3]=0.81*enemy_speed
    enemyPath[3][3][4]=0.59*enemy_speed
    enemyPath[3][3][5]=0.31*enemy_speed
    enemyPath[3][3][6]=0
    enemyPath[3][3][7]=-0.31*enemy_speed
    enemyPath[3][3][8]=-0.59*enemy_speed
    enemyPath[3][3][9]=-0.81*enemy_speed
    enemyPath[3][3][10]=-0.95*enemy_speed
    enemyPath[3][3][11]=-enemy_speed
    enemyPath[3][3][12]=-0.95*enemy_speed
    enemyPath[3][3][13]=-0.81*enemy_speed
    enemyPath[3][3][14]=-0.59*enemy_speed
    enemyPath[3][3][15]=-0.31*enemy_speed
    enemyPath[3][3][16]=0
    enemyPath[3][3][17]=0.31*enemy_speed
    enemyPath[3][3][18]=0.59*enemy_speed
    enemyPath[3][3][19]=0.81*enemy_speed
    enemyPath[3][3][20]=0.95*enemy_speed
    enemyPath[3][3][21]=enemy_speed
    enemyPath[3][4][1]=0
    enemyPath[3][4][2]=0.31*enemy_speed
    enemyPath[3][4][3]=0.59*enemy_speed
    enemyPath[3][4][4]=0.81*enemy_speed
    enemyPath[3][4][5]=0.95*enemy_speed
    enemyPath[3][4][6]=enemy_speed
    enemyPath[3][4][7]=0.95*enemy_speed
    enemyPath[3][4][8]=0.81*enemy_speed
    enemyPath[3][4][9]=0.59*enemy_speed
    enemyPath[3][4][10]=0.31*enemy_speed
    enemyPath[3][4][11]=0
    enemyPath[3][4][12]=-0.31*enemy_speed
    enemyPath[3][4][13]=-0.59*enemy_speed
    enemyPath[3][4][14]=-0.81*enemy_speed
    enemyPath[3][4][15]=-0.95*enemy_speed
    enemyPath[3][4][16]=-enemy_speed
    enemyPath[3][4][17]=-0.95*enemy_speed
    enemyPath[3][4][18]=-0.81*enemy_speed
    enemyPath[3][4][19]=-0.59*enemy_speed
    enemyPath[3][4][20]=-0.31*enemy_speed
    enemyPath[3][4][21]=0

    ‘round r=10
    enemyPath[4][0][0]=21
    enemyPath[4][1][1]=110
    enemyPath[4][1][2]=120
    enemyPath[4][1][3]=130
    enemyPath[4][1][4]=140
    enemyPath[4][1][5]=150
    enemyPath[4][1][6]=160
    enemyPath[4][1][7]=170
    enemyPath[4][1][8]=180
    enemyPath[4][1][9]=190
    enemyPath[4][1][10]=200
    enemyPath[4][1][11]=210
    enemyPath[4][1][12]=220
    enemyPath[4][1][13]=230
    enemyPath[4][1][14]=240
    enemyPath[4][1][15]=250
    enemyPath[4][1][16]=260
    enemyPath[4][1][17]=270
    enemyPath[4][1][18]=280
    enemyPath[4][1][19]=290
    enemyPath[4][1][20]=300
    enemyPath[4][1][21]=500
    enemyPath[4][2][1]=0
    enemyPath[4][2][2]=18
    enemyPath[4][2][3]=36
    enemyPath[4][2][4]=54
    enemyPath[4][2][5]=72
    enemyPath[4][2][6]=90
    enemyPath[4][2][7]=108
    enemyPath[4][2][8]=126
    enemyPath[4][2][9]=144
    enemyPath[4][2][10]=162
    enemyPath[4][2][11]=180
    enemyPath[4][2][12]=198
    enemyPath[4][2][13]=216
    enemyPath[4][2][14]=234
    enemyPath[4][2][15]=252
    enemyPath[4][2][16]=-90
    enemyPath[4][2][17]=-72
    enemyPath[4][2][18]=-54
    enemyPath[4][2][19]=-36
    enemyPath[4][2][20]=-18
    enemyPath[4][2][21]=0
    enemyPath[4][3][1]=enemy_speed
    enemyPath[4][3][2]=0.95*enemy_speed
    enemyPath[4][3][3]=0.81*enemy_speed
    enemyPath[4][3][4]=0.59*enemy_speed
    enemyPath[4][3][5]=0.31*enemy_speed
    enemyPath[4][3][6]=0
    enemyPath[4][3][7]=-0.31*enemy_speed
    enemyPath[4][3][8]=-0.59*enemy_speed
    enemyPath[4][3][9]=-0.81*enemy_speed
    enemyPath[4][3][10]=-0.95*enemy_speed
    enemyPath[4][3][11]=-enemy_speed
    enemyPath[4][3][12]=-0.95*enemy_speed
    enemyPath[4][3][13]=-0.81*enemy_speed
    enemyPath[4][3][14]=-0.59*enemy_speed
    enemyPath[4][3][15]=-0.31*enemy_speed
    enemyPath[4][3][16]=0
    enemyPath[4][3][17]=0.31*enemy_speed
    enemyPath[4][3][18]=0.59*enemy_speed
    enemyPath[4][3][19]=0.81*enemy_speed
    enemyPath[4][3][20]=0.95*enemy_speed
    enemyPath[4][3][21]=enemy_speed
    enemyPath[4][4][1]=0
    enemyPath[4][4][2]=0.31*enemy_speed
    enemyPath[4][4][3]=0.59*enemy_speed
    enemyPath[4][4][4]=0.81*enemy_speed
    enemyPath[4][4][5]=0.95*enemy_speed
    enemyPath[4][4][6]=enemy_speed
    enemyPath[4][4][7]=0.95*enemy_speed
    enemyPath[4][4][8]=0.81*enemy_speed
    enemyPath[4][4][9]=0.59*enemy_speed
    enemyPath[4][4][10]=0.31*enemy_speed
    enemyPath[4][4][11]=0
    enemyPath[4][4][12]=-0.31*enemy_speed
    enemyPath[4][4][13]=-0.59*enemy_speed
    enemyPath[4][4][14]=-0.81*enemy_speed
    enemyPath[4][4][15]=-0.95*enemy_speed
    enemyPath[4][4][16]=-enemy_speed
    enemyPath[4][4][17]=-0.95*enemy_speed
    enemyPath[4][4][18]=-0.81*enemy_speed
    enemyPath[4][4][19]=-0.59*enemy_speed
    enemyPath[4][4][20]=-0.31*enemy_speed
    enemyPath[4][4][21]=0

    ‘round r=15 + exit down
    enemyPath[5][0][0]=27
    enemyPath[5][1][1]=120
    enemyPath[5][1][2]=125
    enemyPath[5][1][3]=150
    enemyPath[5][1][4]=165
    enemyPath[5][1][5]=180
    enemyPath[5][1][6]=195
    enemyPath[5][1][7]=210
    enemyPath[5][1][8]=225
    enemyPath[5][1][9]=240
    enemyPath[5][1][10]=255
    enemyPath[5][1][11]=270
    enemyPath[5][1][12]=285
    enemyPath[5][1][13]=300
    enemyPath[5][1][14]=315
    enemyPath[5][1][15]=330
    enemyPath[5][1][16]=345
    enemyPath[5][1][17]=360
    enemyPath[5][1][18]=375
    enemyPath[5][1][19]=390
    enemyPath[5][1][20]=405
    enemyPath[5][1][21]=600
    enemyPath[5][1][22]=615
    enemyPath[5][1][23]=630
    enemyPath[5][1][24]=645
    enemyPath[5][1][254]=660
    enemyPath[5][1][26]=675
    enemyPath[5][1][27]=800

    enemyPath[5][2][1]=0
    enemyPath[5][2][2]=18
    enemyPath[5][2][3]=36
    enemyPath[5][2][4]=54
    enemyPath[5][2][5]=72
    enemyPath[5][2][6]=90
    enemyPath[5][2][7]=108
    enemyPath[5][2][8]=126
    enemyPath[5][2][9]=144
    enemyPath[5][2][10]=162
    enemyPath[5][2][11]=180
    enemyPath[5][2][12]=198
    enemyPath[5][2][13]=216
    enemyPath[5][2][14]=234
    enemyPath[5][2][15]=252
    enemyPath[5][2][16]=-90
    enemyPath[5][2][17]=-72
    enemyPath[5][2][18]=-54
    enemyPath[5][2][19]=-36
    enemyPath[5][2][20]=-18
    enemyPath[5][2][21]=0

    enemyPath[5][2][22]=18
    enemyPath[5][2][23]=36
    enemyPath[5][2][24]=54
    enemyPath[5][2][25]=72
    enemyPath[5][2][26]=90
    enemyPath[5][2][27]=90

    enemyPath[5][3][1]=enemy_speed
    enemyPath[5][3][2]=0.95*enemy_speed
    enemyPath[5][3][3]=0.81*enemy_speed
    enemyPath[5][3][4]=0.59*enemy_speed
    enemyPath[5][3][5]=0.31*enemy_speed
    enemyPath[5][3][6]=0
    enemyPath[5][3][7]=-0.31*enemy_speed
    enemyPath[5][3][8]=-0.59*enemy_speed
    enemyPath[5][3][9]=-0.81*enemy_speed
    enemyPath[5][3][10]=-0.95*enemy_speed
    enemyPath[5][3][11]=-enemy_speed
    enemyPath[5][3][12]=-0.95*enemy_speed
    enemyPath[5][3][13]=-0.81*enemy_speed
    enemyPath[5][3][14]=-0.59*enemy_speed
    enemyPath[5][3][15]=-0.31*enemy_speed
    enemyPath[5][3][16]=0
    enemyPath[5][3][17]=0.31*enemy_speed
    enemyPath[5][3][18]=0.59*enemy_speed
    enemyPath[5][3][19]=0.81*enemy_speed
    enemyPath[5][3][20]=0.95*enemy_speed
    enemyPath[5][3][21]=enemy_speed
    enemyPath[5][3][22]=0.95*enemy_speed
    enemyPath[5][3][23]=0.81*enemy_speed
    enemyPath[5][3][24]=0.59*enemy_speed
    enemyPath[5][3][25]=0.31*enemy_speed
    enemyPath[5][3][26]=0
    enemyPath[5][3][27]=0

    enemyPath[5][4][1]=0
    enemyPath[5][4][2]=0.31*enemy_speed
    enemyPath[5][4][3]=0.59*enemy_speed
    enemyPath[5][4][4]=0.81*enemy_speed
    enemyPath[5][4][5]=0.95*enemy_speed
    enemyPath[5][4][6]=enemy_speed
    enemyPath[5][4][7]=0.95*enemy_speed
    enemyPath[5][4][8]=0.81*enemy_speed
    enemyPath[5][4][9]=0.59*enemy_speed
    enemyPath[5][4][10]=0.31*enemy_speed
    enemyPath[5][4][11]=0
    enemyPath[5][4][12]=-0.31*enemy_speed
    enemyPath[5][4][13]=-0.59*enemy_speed
    enemyPath[5][4][14]=-0.81*enemy_speed
    enemyPath[5][4][15]=-0.95*enemy_speed
    enemyPath[5][4][16]=-enemy_speed
    enemyPath[5][4][17]=-0.95*enemy_speed
    enemyPath[5][4][18]=-0.81*enemy_speed
    enemyPath[5][4][19]=-0.59*enemy_speed
    enemyPath[5][4][20]=-0.31*enemy_speed
    enemyPath[5][4][21]=0
    enemyPath[5][4][22]=0.31*enemy_speed
    enemyPath[5][4][23]=0.59*enemy_speed
    enemyPath[5][4][24]=0.81*enemy_speed
    enemyPath[5][4][25]=0.95*enemy_speed
    enemyPath[5][4][26]=enemy_speed
    enemyPath[5][4][27]=enemy_speed

    enemyPath[6][0][0]=3
    enemyPath[6][1][1]=1
    enemyPath[6][1][2]=80
    enemyPath[6][1][3]=200
    enemyPath[6][2][1]=0
    enemyPath[6][2][2]=90
    enemyPath[6][2][3]=-90
    enemyPath[6][3][1]=0
    enemyPath[6][3][2]=0
    enemyPath[6][3][3]=0
    enemyPath[6][4][1]=0
    enemyPath[6][4][2]=enemy_speed
    enemyPath[6][4][3]=-enemy_speed
    EndSub

    Sub create_level1   ‘this define the behavior of the différent squadron along the time play for level 1
    level1[1][1]=20    ‘when timeplay=level1[1][1]
    level1[1][2]= 2     ‘ lauch enemy with Path level1[1][2]
    level1[1][3]= -10   ‘ at x coordinate level1[1][3]
    level1[1][4] = 0      ‘ at y coordinate level1[1][4]
    level1[1][5] = 1      ‘ 1 for create enemy at the left side; 2 for the right side of screen
    level1[1][6] = 4      ‘level[1][6] is the number of enemies
    level1[1][7] = 1      ‘type of enemy

    level1[2][1]= 80
    level1[2][2]= 6
    level1[2][3]= gameWidth/2
    level1[2][4] = -500
    level1[2][5] = 1
    level1[2][6] = 3
    level1[2][7] = 1

    level1[3][1]= 150
    level1[3][2]= 0
    level1[3][3]= -10
    level1[3][4] = 0
    level1[3][5] = 1
    level1[3][6] = 6
    level1[3][7] = 2

    level1[4][1]= 280
    level1[4][2]= 4
    level1[4][3]= -10
    level1[4][4] = 0
    level1[4][5] = 1
    level1[4][6] = 3
    level1[4][7] = 2

    level1[5][1]= 410
    level1[5][2]= 6
    level1[5][3]= gameWidth/3
    level1[5][4] = -50
    level1[5][5] = 1
    level1[5][6] = 3
    level1[5][7] = 1

    level1[6][1]= 430
    level1[6][2]= 6
    level1[6][3]= 2*gameWidth/3
    level1[6][4] = -50
    level1[6][5] = 2
    level1[6][6] = 3
    level1[6][7] = 1

    level1[5][1]= 500
    level1[5][2]= 6
    level1[5][3]= gameWidth/3
    level1[5][4] = -50
    level1[5][5] = 1
    level1[5][6] = 6
    level1[5][7] = 2

    level1[6][1]= 590
    level1[6][2]= 5
    level1[6][3]= 100
    level1[6][4] = -80
    level1[6][5] = 1
    level1[6][6] = 3
    level1[6][7] = 3

    level1[7][1]= 690
    level1[7][2]= 6
    level1[7][3]= gameWidth/3
    level1[7][4] = -50
    level1[7][5] = 2
    level1[7][6] = 3
    level1[7][7] = 2
    For i= 1 To 10
    Level1[7+i][1]=700+50*i
    level1[7+i][2]= 6
    level1[7+i][3]=  math.GetrandomNumber(gameWidth)
    level1[7+i][4] = -50 +i
    level1[7+i][5] = math.GetrandomNumber(2)
    level1[7+i][6] = math.GetrandomNumber(3)
    level1[7+i][7] = math.GetrandomNumber(2)
    EndFor
    level1[18][1]= 1300
    level1[18][2]= 1
    level1[18][3]= gameWidth
    level1[18][4] = -10
    level1[18][5] = 2
    level1[18][6] = 6
    level1[18][7] = 2

    For i= 1 To 10
    Level1[18+i][1]=1330+50*i
    level1[18+i][2]= 4+math.GetrandomNumber(2)
    level1[18+i][3]=  math.GetrandomNumber(50)
    level1[18+i][4] = i
    level1[18+i][5] = 1
    level1[18+i][6] = math.GetrandomNumber(3)
    level1[18+i][7] = math.GetrandomNumber(2)
    EndFor
    For i= 1 To 10
    Level1[28+i][1]=1900+50*i
    level1[28+i][2]= 4+math.GetrandomNumber(2)
    level1[28+i][3]=  -math.GetrandomNumber(50)
    level1[28+i][4] = i
    level1[28+i][5] = 1
    level1[28+i][6] = math.GetrandomNumber(3)
    level1[28+i][7] = math.GetrandomNumber(2)
    EndFor
    For i= 1 To 10
    Level1[38+i][1]=2450+100*i
    level1[38+i][2]= 6
    level1[38+i][3]=  math.GetrandomNumber(gameWidth)
    level1[38+i][4] = -50 +i
    level1[38+i][5] = math.GetrandomNumber(2)
    level1[38+i][6] = math.GetrandomNumber(5)
    level1[38+i][7] = math.GetrandomNumber(2)
    EndFor

    EndSub

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

Sierpenski Triangles – Small Basic Featured Programs (Código)


a18

The Official Blog of Small Basic    http://blogs.msdn.com/b/smallbasic/   Ed Price – MSFT    NaochanON created this program that generates these triangles:

Program Listing: RBB339

  1. ‘ Fractale viewdata()              ‘Input numbers&marks for controls
    init_View()
    Controls.ButtonClicked = OnButtonClicked

    Sub Show_Fractal
    ‘ Base
    Base_Triangle()
    for k=Real_No[4] To 1 Step -1
    GraphicsWindow.PenWidth=1
    GraphicsWindow.PenColor=”white”
    GraphicsWindow.BrushColor= GraphicsWindow.GetRandomColor() ‘ “white”
    PowerK=Math.Power(0.5,k)
    For i=1 To  (Math.Power(2,k)-1)  Step 2          ‘ Y direction

    For j=1 To (Math.Power(2,k)-1-(i-1))   Step 2        ‘ X direction
    BaseY[i][j]=ACY*PowerK +(i-1)*ACY*Powerk
    BaseX[i][j]=ACX*PowerK +(j-1)*ABX*PowerK +(i-1)*ACX*powerk
    gas[i][j]=Shapes.AddTriangle(0,0,PowerK*Lc,0,PowerK*(Lc-MCX),PowerK*YH)
    Shapes.Animate(gas[i][J],SX+BaseX[i][j],SY+AY-BaseY[i][j],1000/k)
    EndFor
    EndFor
    EndFor
    EndSub

    Sub Base_Triangle
    La=Real_No[1]    ‘ Length a
    Lb=Real_No[2]    ‘ Length b
    Lc=Real_No[3]    ‘ Length c
    MCX=(La*La+Lc*Lc-Lb*Lb)/2/Lc           ‘ MCX
    YH=math.SquareRoot(La*La-MCX*MCX)      ‘ Hight
    AX=0             ‘ Point-A X C
    AY=YH            ‘ Point-A Y . . .
    BX=Lc            ‘ Point-B X . . YH .
    BY=YH            ‘ Point-B Y A . . . . . B
    CX=MCX
    CY=0
    ABX=(AX+BX)
    ABY=(AY+BY)
    ACX=(AX+CX)
    ACY=(AY+CY)

    GraphicsWindow.PenColor=”#FF0000″  ‘”Red”
    GraphicsWindow.BrushColor=”#FF0000″  ‘”Red”
    Base=Shapes.AddTriangle(AX,AY,BX,BY,CX,CY)
    SX=50             ‘ shift X
    SY=170            ‘ shift Y
    Shapes.Animate(Base,SX,SY,100)
    Program.Delay(500)
    EndSub

    Sub OnButtonClicked
    GraphicsWindow.BrushColor = “Red”
    name=controls.LastClickedButton     ‘Last button
    nm=controls.GetButtonCaption(name)  ‘ Button’s caption
    Xloc=50+2*BW*(count)    ‘ Angle number / length showing position
    If nm=”Del” Then
    Del_word()
    elseIf nm=”AC” Then
    Reset()
    elseIf nm=”Exe” Then
    Execute()
    else
    Make_word()
    endif
    EndSub

    Sub Fractale
    If Real_No[1]+Real_No[2] <= Real_No[3] Then
    Sound.PlayBellRing()    ‘ Check ( a+ b > C)
    Reset()
    endif
    For i= 1 To 4
    Shapes.Remove(T[i])   ‘ initial triangle and a b c
    EndFor
    Show_Fractal()          ‘ fractale showing
    EndSub

    Sub Sample_Triangle
    GraphicsWindow.PenColor=”Yellow”
    GraphicsWindow.BrushColor=”Yellow”
    AX=0
    AY=400
    BX=600
    BY=400
    CX=450
    CY=0
    MX=50
    MY=150
    T[1]=Shapes.AddTriangle(AX,AY,BX,BY,CX,CY)
    Shapes.SetOpacity(T[1],30)
    Shapes.Animate(T[1],MX,MY,600)
    T[2]=shapes.AddText(” a “)
    Shapes.Animate(T[2],MX+CX/2-50,MY+AY/2,800)
    T[3]=shapes.AddText(” b “)
    Shapes.Animate(T[3],MX+10+CX+(BX-CX)/2,MY+CY+(BY-CY)/2,1000)
    T[4]=shapes.AddText(” c “)
    Shapes.Animate(T[4],MX+BX/2,MY+BY,1200)
    EndSub

    Sub   Button_Set
    GraphicsWindow.BrushColor = “Blue”
    nn=0
    dm=s[1]
    Loop2:
    end_P=Text.GetIndexOf(dm,” “)
    msg=text.GetSubText(dm,1,end_P-1)  ‘ word
    nn=nn+1
    btn[nn][1] =Controls.AddButton(msg, 10+BW*(nn-1), BH+50)
    Controls.SetSize(btn[nn][1] ,BW-2,BH-2)  ‘Set 13 Control buttons
    If nn=WN Then
    Goto end1
    EndIf
    dm=text.GetSubTextToEnd(dm,end_p+1)   ‘gets number value or mark’s name
    Goto loop2
    end1:
    add_num=””
    count=0
    EndSub

    Sub Reset
    GraphicsWindow.Clear()
    GraphicsWindow.Show()
    init_View()
    Button_Set()
    EndSub

    Sub init_View
    WN=13   ‘ 13 words
    BW=70
    BH=45
    GW=BW*WN
    GH=BH*15+20
    GraphicsWindow.Hide()
    GraphicsWindow.top=0
    GraphicsWindow.Width = GW+2*10
    GraphicsWindow.Height = GH
    GraphicsWindow.Title = “Fractale graph”
    GraphicsWindow.Show()
    GraphicsWindow.BackgroundColor = “Teal”
    GraphicsWindow.BrushColor = “White”
    GraphicsWindow.FillRectangle(10+BW*0, 45, BW*3/2, BH-10)
    GraphicsWindow.FillRectangle(10+BW*2, 45, BW*3/2, BH-10)
    GraphicsWindow.FillRectangle(10+BW*4, 45, BW*3/2, BH-10)
    GraphicsWindow.FillRectangle(10+BW*6, 45, BW*3/2, BH-10)
    GraphicsWindow.BrushColor =”Yellow”
    GraphicsWindow.FontSize = 20
    GraphicsWindow.FontName = “Coorie new”
    GraphicsWindow.FontItalic=”True”
    GraphicsWindow.DrawText(15,5,”Input a b c values (300-800 may be better)”)
    GraphicsWindow.DrawText(10+BW*9,5,”Note!: Must be ( a + b > c ) “)
    GraphicsWindow.DrawText(10+BW*6,23,”Steps: Under 7 “)
    GraphicsWindow.DrawText(10+BW*9,40,”AC=All Clear”)
    GraphicsWindow.DrawText(10+BW*9,60,”Exe=Enter Value or Run”)
    Button_Set()
    GraphicsWindow.FontSize = 23
    GraphicsWindow.DrawText(20,45,”a: “)
    GraphicsWindow.DrawText(20+BW*2,45,”b: “)
    GraphicsWindow.DrawText(20+BW*4,45,”c: “)
    GraphicsWindow.DrawText(20+BW*6,45,”S: “)
    Sample_Triangle()   ‘ show sample triangle
    EndSub

    Sub data  ‘ 13 words
    s[1]=”1 2 3 4 5 6 7 8 9 0 Del AC Exe ”
    EndSub

    Sub Del_word
    Shapes.Remove(numbers[count])
    add_num=Text.GetSubText(add_num,1,Text.GetLength(add_num)-1)
    numbers[count] = Shapes.AddText(add_num)   ‘ 1 word delete
    Shapes.Move(numbers[count] , Xloc, 45)
    EndSub

    Sub Execute
    count=count+1
    Real_No[count]=add_num
    add_num=””
    If count=4 then
    Fractale()
    endif
    EndSub

    Sub Make_word
    Shapes.Remove(numbers[count])
    add_num=text.Append(add_num,nm) ‘ Add 1 word
    numbers[count] = Shapes.AddText(add_num)
    Shapes.Move(numbers[count], Xloc, 45)
    EndSub

  2. //

Copyright (c) Microsoft Corporation. All rights reserved.

Viendo más con la programación VBA


a1

Aunque este artículo es corto y araña sólo la superficie de VBA y la programación, es esperar lo suficiente para empezar.
En esta sección se analiza brevemente algunos de los temas más importantes.
Variables
En los ejemplos simples en este artículo manipulado objetos que la aplicación ya se había creado. Es posible que desee crear sus propios objetos para almacenar valores o referencias a otros objetos para uso temporal en la aplicación. Estos se llaman variables.
Para utilizar una variable en VBA, debe decirle a VBA qué tipo de objeto representa la variable mediante la instrucción Dim. A continuación, establezca su valor y lo utilizan para definir otras variables o propiedades.

VB

Copy

Dim MyStringVariable As String

MyStringVariable = “Wow!”

Worksheets(1).Range(“A1”).Value = MyStringVariable

Saltos y bucles
Los programas simples en este artículo ejecutar una línea a la vez, de arriba hacia abajo. El poder real en la programación proviene de las opciones que usted tiene para determinar qué líneas de código a ejecutar, sobre la base de una o varias condiciones que se especifiquen. Puede ampliar esas capacidades aún más cuando se puede repetir la operación varias veces. Por ejemplo, el siguiente código se extiende Macro1

.VB

Copy

Sub Macro1()

If Worksheets(1).Range(“A1”).Value = “Yes!” Then

Dim i As Integer

For i = 2 To 10

Worksheets(1).Range(“A” & i).Value = “OK! ” & i

Next i

Else

MsgBox “Put Yes! in cell A1”

End If

End Sub

Escriba o pegue el código en el Editor de Visual Basic y luego ejecutarlo. Siga las instrucciones en el cuadro de mensaje que aparece y cambia el texto en la celda A1 de Wow! que sí! y ejecutarlo de nuevo para ver el poder de bucle. Este fragmento de código muestra las variables, bifurcaciones y bucles. Lea con cuidado después de ver en acción y tratar de determinar lo que ocurre, ya que cada línea se ejecuta.

http://msdn.microsoft.com/library/ee814735(office.14)#odc_office14_ta_AddingVBAProgrammingToYourOfficeToolkit_WhenAndWhyToUseVBA

Excel Library for Small Basic


excel

Project Description
This library extend Small Basic to allows you to read or write contents of a cell in the Excel file from Small Basic program.

After installed Excel Library for Small Basic, you can use Excel object, and follow functions in Small Basic.

Click “Download” link in this page, and open the .msi installer file that was downloaded.

http://excel4smallbasic.codeplex.com/

Why Learn Small Basic? (en español)


Sin título2

Ed Price – MSFT   Microsoft

Hoy tenemos un invitado especial blogger, Philip Biela! Él está compartiendo con nosotros un extracto de su libro para niños, partir Microsoft Small Basic por Philip Biela y Lou Tylee. Esta sección está disponible como parte del capítulo 1 de “A partir de Microsoft Small Basic”. Usted puede encontrar sus libros y otros materiales en la informática para el sitio web Kids. Gracias a Felipe por compartir. Por favor, disfrute!

==================

 

 

Ed Price – MSFT

Microsoft

 

 

Podríamos muy bien simplemente hacer la pregunta – ¿Por qué aprender un lenguaje de programación? Un lenguaje de programación se utiliza para dar instrucciones a una computadora para realizar tareas específicas. Hay varias razones para hacer esto. En primer lugar, si usted sabe cómo programar, usted tendrá una mejor comprensión de cómo funcionan las computadoras. En segundo lugar, los programas de escritura es un buen ejercicio para sus habilidades de pensamiento – debe ser un pensador muy lógica para escribir programas de ordenador. También debe ser algo así como un perfeccionista – computadoras no son tan inteligentes y requieren, instrucciones perfecta exacta para hacer su trabajo. En tercer lugar, los programadores de computadoras son de la demanda y se puede hacer una buena vida. Y, por último, escribir programas de ordenador es divertido. Es gratificante ver que sus ideas para un determinado programa informático cobran vida en la pantalla del ordenador.
Así que, ¿por qué aprender Small Basic? Una razón importante es que es libre de Microsoft. Otra razón para aprender Small Basic es que es uno de los idiomas más fáciles de aprender. Small Basic es un lenguaje simple. Hay muchos elementos incorporados que hacen su trabajo más simple y el lenguaje en sí es muy simple – sólo 15 palabras reservadas. Sin embargo, sólo porque se trata de un lenguaje sencillo, no significa que carece de capacidades. Verá lo largo de estas notas que se puede construir algunos programas bastante complejos.
Debido a su simplicidad, se puede aprender a escribir pequeños programas básicos muy rápidamente. Sin embargo, sólo porque usted puede escribir su primer programa con rapidez no significa que usted aprenderá todo lo que hay que saber acerca de Small Basic. Este curso sólo introduce Small Basic. Todavía hay mucho que aprender – siempre hay mucho que aprender. Por lo tanto, tenga en cuenta este curso como un primer paso en un viaje para convertirse en un programador competente.
Y, una vez que hayas dominado Small Basic, puede pasar a su hermano mayor más capaz VisualBasic, otro producto de Microsoft utilizado para desarrollar GUI (interfaz gráfica de usuario) de aplicaciones basadas en. Se trata de aplicaciones con menús, barras de herramientas, botones, barras de desplazamiento, y otros controles que dependen del ratón de la computadora para la entrada. Ejemplos de las aplicaciones GUI que puede haber utilizados son los procesadores de texto, programas de hojas de cálculo y juegos de ordenador.

Small Basic Extensions Gallery


a1Ed Price – MSFT

The impossible goal is that this list will eventually contain every quality extension made for Small Basic.

I’m starting with some listed in the Small Basic Forums, but you should also come back later, because this list will evolve over time.

 

D

Data Extension (v1.0.3) – by Oskariok

E

ESL Extension (v.10a) – by Liam McSherry

Excel Library for Small Basic – by JSakamoto

F

Fast 2D Graphics Extension – by FuleSnabel

Fremy’s Extension (v1) – by FremyCompany

I

I/O Extension (v1) – by Noah Buscher and gungan37

IE Library for Small Basic – by JSakamoto

Etc…..

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

 

Small Basic Curriculum


edEd Price – Microsoft MSFT

Learn all about Small Basic by using the curriculum. With the curriculum, you can lean Small Basic with separate lessons – just like you would in a classroom. You can download the curriculum, which includes PowerPoint decks to teach from. As a teacher or as a student learning Small Basic on your own, the curriculum will guide you step by step.

http://blogs.msdn.com/b/smallbasic/archive/2013/04/24/small-basic-curriculum.aspx

TicTacToe v0.4- Copyright Nonki Takahashi (Microsoft Small Basic code)


a15

a16

Program Listing  MRB574

  1. ‘ TicTacToe v0.4

    ‘ RANDOM vs
    ‘ CENTER vs
    ‘ RUNORSTOP vs
    ‘ MONTECARLO vs
    ‘ HUMAN

    ‘ Copyright (c) 2010 NonkiTakahashi

    ‘ constants
    SPACE = 0 ‘ none
    TURN1 = 1 ‘ X
    TURN2 = 2 ‘ O
    OB = 3    ‘ out bound
    GMAX = 10 ‘ max number of games
    iRo = 3  ‘ number of ro (dimension)
    iNR = 0  ‘ number of record

    sVersion = “v0.4”  ‘ program version
    GraphicsWindow.Title = “TicTacToe ” + sVersion
    sFigure[1] = “X”
    sFigure[2] = “O”

    sEntry[1] = “HUMAN”
    sEntry[2] = “RANDOM”
    sEntry[3] = “CENTER”
    sEntry[4] = “RUNORSTOP”
    sEntry[5] = “MONTECARLO”
    iNE = 5  ‘ number of entries

    iTGMax = GMAX
    iE1 = 2
    iE2 = 2
    sPlayer[1] = sEntry[iE1]
    sPlayer[2] = sEntry[iE2]

    lMainMenu:
    GraphicsWindow.Clear()
    InitGame()
    If bStart <> “True” Then
    Program.End()
    EndIf

    GraphicsWindow.BrushColor = “SteelBlue”
    iSeed = 0
    bDebug = “False”

    lReplay:
    iT1 = 0 ‘ times X win
    iT2 = 0 ‘ times O win
    iTD = 0 ‘ times draw
    iTG = 0 ‘ times games
    iTW = 10 ‘ times work out for MONTECARLO

    lNextGame:
    GraphicsWindow.Clear()
    If iTG > 0 Then
    ShowResult()
    EndIf
    iS = 0  ‘ step
    InitBoard() ‘ initialize board
    SaveBoard() ‘ current board <- board
    DrawBoard()

    ‘ game start
    While “True”

    ‘ turn X (Player 1)
    iTurn = TURN1
    EachTurn()
    If sGame <> “continue” Then
    Goto lExit
    EndIf

    ‘ turn O (Player 2)
    iTurn = TURN2
    EachTurn()
    If sGame <> “continue” Then
    Goto lExit
    EndIf

    EndWhile

    lExit:
    GraphicsWindow.BrushColor = “SteelBlue”
    GraphicsWindow.DrawText(10, 10, sGame)
    If sGame = “X win” then
    GraphicsWindow.PenWidth = 2
    GraphicsWindow.PenColor = “SteelBlue”
    GraphicsWindow.DrawLine(iWX0, iWY0, iWX1, iWY1)
    iT1 = iT1 + 1
    ElseIf sGame = “O win” then
    GraphicsWindow.PenWidth = 2
    GraphicsWindow.PenColor = “SteelBlue”
    GraphicsWindow.DrawLine(iWX0, iWY0, iWX1, iWY1)
    iT2 = iT2 + 1
    Else
    iTD = iTD + 1
    EndIf
    iTG = iTG + 1
    If sGame = “X win” then
    Program.Delay(500)
    Else
    Program.Delay(1000)
    EndIf
    If iTG < iTGmax Then
    Goto lNextGame
    EndIf
    GraphicsWindow.BrushColor = “White”
    GraphicsWindow.FillRectangle(400, 20, 150, 150)
    GraphicsWindow.BrushColor = “SteelBlue”
    ShowResult()
    Continue()
    If bRestart Then
    Goto lReplay
    Else
    Goto lMainMenu
    EndIf

    ‘ EachTurn
    ‘ in: integer iTurn – 1 or 2
    ‘ in: string sPlayer[] – selected player
    Sub EachTurn
    GetPutList()  ‘ find next possible puts
    iS = iS + 1
    If sPlayer[iTurn] = “RANDOM” Then
    Random()
    ElseIf sPlayer[iTurn] = “CENTER” Then
    Center()
    ElseIf sPlayer[iTurn] = “RUNORSTOP” Then
    RunOrStop()
    ElseIf sPlayer[iTurn] = “MONTECARLO” Then
    WorkOut() ‘determine a from put list by MONTECARLO method
    ElseIf sPlayer[iTurn] = “HUMAN” Then
    Human()
    EndIf
    Sound.PlayClickAndWait()
    PutFigure()
    Record()    ‘ record game score
    RestoreBoard() ‘ board <- current board
    DrawBoard()
    Judge()
    EndSub

    ‘ Initialize Game
    ‘ work: integer iY1, iY2, iY3, iY4, iY5, idY
    Sub InitGame
    idY = 40
    iY1 = 50
    iY2 = iY1 + idY
    iY3 = iY2 + idY
    iY4 = iY3 + idY
    iY5 = iY4 + idY
    GraphicsWindow.FontSize = 18
    GraphicsWindow.BrushColor = “Black”
    GraphicsWindow.DrawBoundText(10, 10, 400, “TicTacToe ” + sVersion)
    GraphicsWindow.DrawText(10, iY1, “Main Menu”)
    GraphicsWindow.DrawText(10, iY2, “player 1 :”)
    GraphicsWindow.DrawText(10, iY3, “player 2 :”)
    GraphicsWindow.DrawText(10, iY4, “games :”)
    oTB1 = Controls.AddTextBox(120, iY2)
    oTB2 = Controls.AddTextBox(120, iY3)
    oTBG = Controls.AddTextBox(120, iY4)
    oBL1 = Controls.AddButton(“<“, 310, iY2)
    oBR1 = Controls.AddButton(“>”, 345, iY2)
    oBL2 = Controls.AddButton(“<“, 310, iY3)
    oBR2 = Controls.AddButton(“>”, 345, iY3)
    oBLG = Controls.AddButton(“<“, 310, iY4)
    oBRG = Controls.AddButton(“>”, 345, iY4)
    oBStart = Controls.AddButton(“Start”, 10, iY5)
    oBEnd = Controls.AddButton(“End”, 75, iY5)
    sPlayer[1] = sEntry[iE1]
    sPlayer[2] = sEntry[iE2]
    Controls.SetTextBoxText(oTB1, sPlayer[1])
    Controls.SetTextBoxText(oTB2, sPlayer[2])
    Controls.SetTextBoxText(oTBG, iTGMax)
    bStart = “”
    Controls.ButtonClicked = OnButtonClicked
    While bStart = “”
    Program.Delay(500)
    EndWhile
    EndSub

    Sub DrawGrid
    iX0 = 100
    iY0 = 100
    iX1 = 700
    iY1 = 500
    GraphicsWindow.PenColor = “Cyan”
    GraphicsWindow.PenWidth = 1
    For iX = iX0 To iX1 Step iX0
    For iY = iY0 To iY1 Step iY0
    GraphicsWindow.DrawLine(iX, 0, iX, iY1)
    GraphicsWindow.DrawLine(0, iY, iX1, iY)
    EndFor
    EndFor
    EndSub

    ‘ Continue ?
    Sub Continue
    iY1 = 200
    GraphicsWindow.FontSize = 18
    GraphicsWindow.BrushColor = “Black”
    oBC = Controls.AddButton(“Continue”, 400, iY1)
    oBM = Controls.AddButton(“Main”, 500, iY1)
    bRestart = “”
    Controls.ButtonClicked = OnButtonClicked2
    While bRestart = “”
    Program.Delay(500)
    EndWhile
    EndSub

    Sub OnButtonClicked
    oBu = Controls.LastClickedButton
    If oBu = oBStart Then
    bStart = “True”
    ElseIf oBu = oBEnd Then
    bStart = “False”
    ElseIf oBu = oBL1 Then
    iE1 = iE1 – 1
    If iE1 < 1 Then
    iE1 = iNE
    EndIf
    sPlayer[1] = sEntry[iE1]
    Controls.SetTextBoxText(oTB1, sPlayer[1])
    ElseIf oBu = oBR1 Then
    iE1 = iE1 + 1
    If iE1 > iNE Then
    iE1 = 1
    EndIf
    sPlayer[1] = sEntry[iE1]
    Controls.SetTextBoxText(oTB1, sPlayer[1])
    ElseIf oBu = oBL2 Then
    iE2 = iE2 – 1
    If iE2 < 1 Then
    iE2 = iNE
    EndIf
    sPlayer[2] = sEntry[iE2]
    Controls.SetTextBoxText(oTB2, sPlayer[2])
    ElseIf oBu = oBR2 Then
    iE2 = iE2 + 1
    If iE2 > iNE Then
    iE2 = 1
    EndIf
    sPlayer[2] = sEntry[iE2]
    Controls.SetTextBoxText(oTB2, sPlayer[2])
    ElseIf oBu = oBLG Then
    If itGMax > 1 Then
    iTGMax = iTGMax – 1
    Else
    iTGMax = GMAX
    EndIf
    Controls.SetTextBoxText(oTBG, iTGMax)
    ElseIf oBu = oBRG Then
    If iTGMax < GMAX Then
    iTGMax = iTGMax + 1
    Else
    iTGMax = 1
    EndIf
    Controls.SetTextBoxText(oTBG, iTGMax)
    EndIf
    EndSub

    Sub OnButtonClicked2
    oBu = Controls.LastClickedButton
    If oBu = oBC Then
    bRestart = “True”
    ElseIf oBu = oBM Then
    bRestart = “False”
    EndIf
    EndSub

    ‘ Player HUMAN
    ‘ in: integer iPX[], iPY[] – possible puts
    ‘ in: integer iNumPuts – entry count of possible puts
    ‘ work: integer i – index of possible puts
    ‘ work: integer iMX, iMY – mouse position
    ‘ out: integer iX, iY – next put
    Sub Human
    iX = iPX[1]
    iY = iPY[1]
    lCurrentMouse:
    Program.Delay(200)
    iMX = GraphicsWindow.MouseX
    iMY = GraphicsWindow.MouseY
    GetPosition()
    If Mouse.isLeftButtonDown Then
    Goto lCheckPut
    Else
    Goto lCurrentMouse
    EndIf
    lCheckPut:
    For i = 1 To iNumPuts
    If iPX[i] = iX And iPY[i] = iY Then
    Goto lReturnMouse
    EndIf
    EndFor
    Goto lCurrentMouse
    lReturnMouse:
    iX = iPX[i]
    iY = iPY[i]
    EndSub

    ‘ Get position of mouse clicked
    ‘ in: integer iMX, iMY – mouse position
    ‘ out: iX, iY – board position
    Sub GetPosition
    If iMX < 150 Then
    iX = 1
    ElseIf iMX < 250 Then
    iX = 2
    Else
    iX = 3
    EndIf
    If iMY < 150 Then
    iY = 1
    ElseIf iMY < 250 Then
    iY = 2
    Else
    iY = 3
    EndIf
    EndSub

    ‘ Record game score
    ‘ in: integer iX, iY – next put
    ‘ in: integer iS – stage
    ‘ out: iRX[], iRY[] – game score
    Sub Record
    iRX[iS] = iX
    iRY[iS] = iY
    EndSub

    ‘ Show game score to text window for debug
    ‘ in: integer iRX[], iRY[] – game score
    ‘ in: integer iS – put count (stage)
    ‘ work: integer i – index of game score
    Sub ShowRecord
    For i = 1 to iS
    TextWindow.Write(“[” + iRX[i] + “][” + iRY[i] + “],”)
    EndFor
    TextWindow.WriteLine(“”)
    EndSub

    ‘ Show possible puts list to text window for debug
    ‘ in: integer iNumPuts – entry count of possible puts
    ‘ in: integer iPX[], iPY[] – possible puts
    ‘ work: integer i – index of possible puts
    Sub ShowPutList
    For i = 1 To iNumPuts
    TextWindow.Write(“iPX[” + i + “]=” + iPX[i])
    TextWindow.WriteLine(“,iPY[” + i + “]=” + iPY[i])
    EndFor
    EndSub

    ‘ Save possible puts list
    ‘ in: integer iPX[], iPY[] – possible puts
    ‘ in: integer iNumPuts – entry count of possible puts
    ‘ work: integer i
    ‘ out: integer iSX[], iSX[] – saved possible puts
    ‘ out: integer iSNP – saved entry count of possible puts
    Sub SavePutList
    iSNP = iNumPuts
    For i = 1 To iSNP
    iSX[i] = iPX[i]
    iSY[i] = iPY[i]
    EndFor
    EndSub

    ‘ Restore possble puts list
    ‘ in: integer iSX[], iSY[] – saved possible puts
    ‘ in: integer iSNP – saved entry count of possible puts
    ‘ out: integer iPX[], iPY[] – (restored) possible puts
    ‘ out: iNumPuts – (restored) entry count of possible puts
    Sub RestorePutList
    iNumPuts = iSNP
    For i = 1 To iNumPuts
    iPX[i] = iSX[i]
    iPY[i] = iSY[i]
    EndFor
    EndSub

    ‘ Save current board
    ‘ in: integer iBoard[][] – board
    ‘ work: integer iX, iY
    ‘ out: integer iSaved[][] – saved current board
    Sub SaveBoard
    For iY = 1 To iRo
    For iX = 1 To iRo
    iSaved[iX][iY] = iBoard[iX][iY]
    EndFor
    EndFor
    EndSub

    ‘ Restore current board
    ‘ in: integer iRo – 3
    ‘ in: integer iSaved[] – saved current board
    ‘ work: integer iX, iY
    ‘ out: iBoard[] – (restored) board
    Sub RestoreBoard
    For iY = 1 To iRo
    For iX = 1 To iRo
    iBoard[iX][iY] = iSaved[iX][iY]
    EndFor
    EndFor
    EndSub

    ‘ Player MONTECARLO
    ‘ in: integer iS – stage
    ‘ in: integer iSNP – entry count of possible puts
    ‘ work: integer iSS – saved stage
    ‘ work: integer iTT – saved turn
    ‘ work: integer i – index of win counter
    ‘ work: integer iFP – first put
    ‘ work: integer iG – work out game count
    ‘ work: integer iTurn
    ‘ out: integer iX, iY
    Sub WorkOut
    SavePutList()
    iSS = iS ‘ save stage
    iTT = iTurn ‘ save turnFor i = 1 To iSNP ‘ instead of iNumPuts
    iWin[i] = 0 ‘ result clear
    EndFor
    For iG = 1 To iTW * iSNP
    iS = iSS – 1 ‘ temporaly stage
    RestoreBoard() ‘ board <- current board
    iTurn = TURN1
    If Math.Remainder(iS, 2) = 0 Then
    iTurn = TURN2
    Goto lNextO
    EndIf

    lNextX:
    ‘ turn X
    GetPutList()
    iS = iS + 1
    RunOrStop()
    If iS = iSS Then
    iFP = iNP ‘ first put
    EndIf
    iBoard[iX][iY] = TURN1
    Judge()
    If sGame <> “continue” Then
    Goto lEndGame
    EndIf

    lNextO:
    ‘ turn O
    GetPutList()
    iS = iS + 1
    RunOrStop()
    If iS = iSS Then
    iFP = iNP ‘ first put
    EndIf
    iBoard[iX][iY] = TURN2
    Judge()
    If sGame <> “continue” Then
    Goto lEndGame
    EndIf

    Goto lNextX

    lEndGame:
    If sGame = sFigure[iTurn] + ” win” Then
    iWin[iFP] = iWin[iFP] + 3 * (10 – iS)
    ElseIf sGame = “draw” then
    iWin[iFP] = iWin[iFP] + (10 – iS)
    Else
    iWin[iFP] = iWin[iFP] + 2 * (10 – iS)
    EndIf
    EndFor

    iMax = 0
    For i = 1 to iSNP ‘ instead of p
    If iWin[i] >= iMax Then
    iMax = iWin[i]
    iNP = i
    EndIf
    EndFor
    RestorePutList()
    iS = iSS ‘ restore stage
    iTurn = iTT ‘ restore turn
    iX = iPX[iNP]
    iY = iPY[iNP]
    EndSub

    ‘ Player RANDOM
    ‘ in: boolean bDebug – is debug ?
    ‘ in/out: integer iSeed – seed for random number debug version
    ‘ in: integer iNumPuts – number of possible puts
    ‘ work: integer iNP – index of possible puts
    ‘ out: integer iX, iY – next put
    Sub Random
    iNP = Math.GetRandomNumber(iNumPuts)
    If bDebug Then
    iSeed = iSeed + 1
    If iSeed > iNumPuts Then
    iSeed = 1
    EndIf
    iNP = iSeed
    EndIf
    iX = iPX[iNP]
    iY = iPY[iNP]
    EndSub

    ‘ Player CENTER
    ‘ in: integer iBoard[][] – board
    ‘ out: integer iX, iY – next put
    Sub Center
    If iBoard[2][2] = SPACE Then
    iX = 2
    iY = 2
    Else
    Random()
    EndIf
    EndSub

    ‘ Player RUNORSTOP
    ‘ in: integer iNumPuts – entry count of possible puts
    ‘ in: integer iPX[], iPY[] – possible puts
    ‘ work: integer iRun[] – count of run (ex. X_X for X)
    ‘ work: integer iStop[] – count of stop (ex. O_O for X)
    ‘ work: integer i – index of run and stop candidate
    ‘ work: integer iX0, iY0 – a possible put
    ‘ work: integer iMax – max count of run
    ‘ work: integer iX1, iY1, iX2, iY2 – points on a run
    ‘ out: integer iNP – final index of possble puts
    ‘ out: integer iX, iY – next put
    Sub RunOrStop
    ‘ clear run and stop candidate
    For i = 1 To iNumPuts
    iRun[i] = 0
    iStop[i] = 0
    EndFor
    ‘ set next of candidate
    For i = 1 To iNumPuts
    iX0 = iPX[i]
    If iX0 = 1 Then
    iX1 = 2
    iX2 = 3
    ElseIf iX0 = 2 Then
    iX1 = 1
    iX2 = 3
    Else ‘ iX0 = 3
    iX1 = 1
    iX2 = 2
    EndIf
    iY0 = iPY[i]
    If iY0 = 1 Then
    iY1 = 2
    iY2 = 3
    ElseIf iY0 = 2 Then
    iY1 = 1
    iY2 = 3
    Else ‘ iY0 = 3
    iY1 = 1
    iY2 = 2
    EndIf

    If iBoard[iX1][iY0] = iBoard[iX2][iY0] Then
    ‘ horizontal run or stop found
    If iBoard[iX1][iY0] = TURN1 Then
    ‘ X_X
    If Math.Remainder(iS, 2) = 1 Then
    ‘ turn X
    iRun[i] = iRun[i] + 1
    Else
    ‘ turn O
    iStop[i] = iStop[i] + 1
    EndIf
    EndIf
    If iBoard[iX1][iY0] = TURN2 Then
    ‘ O_O
    If Math.Remainder(iS, 2) = 1 Then
    ‘ turn X
    iStop[i] = iStop[i] + 1
    Else
    ‘ turn O
    iRun[i] = iRun[i] + 1
    EndIf
    EndIf
    EndIf
    If iBoard[iX0][iY1] = iBoard[iX0][iY2] Then
    ‘ vartical run or stop found
    If iBoard[iX0][iY1] = TURN1 Then
    ‘ X_X
    If Math.Remainder(iS, 2) = 1 Then
    ‘ turn X
    iRun[i] = iRun[i] + 1
    Else
    ‘ turn O
    iStop[i] = iStop[i] + 1
    EndIf
    EndIf
    If iBoard[iX0][iY1] = TURN2 Then
    ‘ O_O
    If Math.Remainder(iS, 2) = 1 Then
    ‘ turn X
    iStop[i] = iStop[i] + 1
    Else
    ‘ turn O
    iRun[i] = iRun[i] +1
    EndIf
    EndIf
    EndIf
    If iX0 = iY0 And iBoard[iX1][iY1] = iBoard[iX2][iY2] Then
    ‘ down run or stop found
    If iBoard[iX1][iY1] = TURN1 Then
    ‘ X_X
    If Math.Remainder(iS, 2) = 1 Then
    ‘ turn X
    iRun[i] = iRun[i] + 1
    Else
    ‘ turn O
    iStop[i] = iStop[i] + 1
    EndIf
    EndIf
    If iBoard[iX1][iY1] = TURN2 Then
    ‘ O_O
    If Math.Remainder(iS, 2) = 1 Then
    ‘ turn X
    iStop[i] = iStop[i] + 1
    Else
    ‘ turn O
    iRun[i] = iRun[i] + 1
    EndIf
    EndIf
    EndIf
    If iX0 + iY0 = 4 And iBoard[iX1][iY2] = iBoard[iX2][iY1] Then
    ‘ up run or stop found
    If iBoard[iX1][iY2] = TURN1 Then
    ‘ X_X
    If Math.Remainder(iS, 2) = 1 Then
    ‘ turn X
    iRun[i] = iRun[i] + 1
    Else
    ‘ turn O
    iStop[i] = iStop[i] + 1
    EndIf
    EndIf
    If iBoard[iX1][iY2] = TURN2 Then
    ‘ O_O
    If Math.Remainder(iS, 2) = 1 Then
    ‘ turn X
    iStop[i] = iStop[i] + 1
    Else
    ‘ turn O
    iRun[i] = iRun[i] + 1
    EndIf
    EndIf
    EndIf
    EndFor
    iMax = 0
    For i = 1 To iNumPuts
    If iRun[i] > iMax Then
    iMax = iRun[i]
    iNP = i
    EndIf
    EndFor
    If iMax > 0 Then
    Goto lReturnNP
    EndIf
    For i = 1 To iNumPuts
    If iStop[i] > iMax Then
    iMax = iStop[i]
    iNP = i
    EndIf
    EndFor
    If iMax > 0 Then
    Goto lReturnNP
    EndIf
    Random()
    lReturnNP:
    iX = iPX[iNP]
    iY = iPY[iNP]
    EndSub

    ‘ Show result of games
    ‘ in: integer iT1 – times X wins
    ‘ in: integer iT2 – times O wins
    ‘ in: integer iTD – times draw
    ‘ in: integer iTG – games
    ‘ in: string sPlayer[] – players logic names
    Sub ShowResult
    GraphicsWindow.DrawText(400, 20, sFigure[1] + ” win: ” + iT1 + ” (” + Math.Floor(iT1 / iTG * 100) + “%)”)
    GraphicsWindow.DrawText(400, 40, sFigure[2] + ” win: ” + iT2 + ” (” + Math.Floor(iT2 / iTG * 100) + “%)”)
    GraphicsWindow.DrawText(400, 60, “draw : ” + iTD + ” (” + Math.Floor(iTD / iTG * 100) + “%)”)
    GraphicsWindow.DrawText(400, 80, “games: ” + iTG)
    GraphicsWindow.DrawText(400, 120, sFigure[1] + “: ” + sPlayer[1])
    GraphicsWindow.DrawText(400, 140, sFigure[2] + “: ” + sPlayer[2])
    EndSub

    ‘ Check game end
    ‘ in: integer iNumPuts – entry count of possible puts
    ‘ in: integer iS – stage
    ‘ out: string sGame – game result “continue” or “X win” or “O win” or “draw”
    Sub Judge
    sGame = “continue”
    If iNumPuts <= 6 Then
    If Math.Remainder(iS, 2) = 1 Then
    iTurn = TURN1
    Else
    iTurn = TURN2
    EndIF
    CheckRun()
    If iNumPuts = 1 And sGame = “continue” Then
    sGame = “draw”
    EndIf
    EndIf
    EndSub

    ‘ Check Run
    ‘ in: integer iTurn
    ‘ in: integer iBoard[][] – board
    ‘ out: string sGame
    ‘ out: integer iWX0, iWY0, iWX1, iWY1 – line of win
    Sub CheckRun
    If iBoard[1][1] = iTurn And iBoard[2][1] = iTurn And iBoard[3][1] = iTurn Then
    iWX0 =  50
    iWY0 = 100
    iWX1 = 350
    iWY1 = 100
    sGame = sFigure[iTurn] + ” win”
    ElseIf iBoard[1][2] = iTurn And iBoard[2][2] = iTurn And iBoard[3][2] = iTurn Then
    iWX0 =  50
    iWY0 = 200
    iWX1 = 350
    iWY1 = 200
    sGame = sFigure[iTurn] + ” win”
    ElseIf iBoard[1][3] = iTurn And iBoard[2][3] = iTurn And iBoard[3][3] = iTurn Then
    iWX0 =  50
    iWY0 = 300
    iWX1 = 350
    iWY1 = 300
    sGame = sFigure[iTurn] + ” win”
    ElseIf iBoard[1][1] = iTurn And iBoard[1][2] = iTurn And iBoard[1][3] = iTurn Then
    iWX0 = 100
    iWY0 =  50
    iWX1 = 100
    iWY1 = 350
    sGame = sFigure[iTurn] + ” win”
    ElseIf iBoard[2][1] = iTurn And iBoard[2][2] = iTurn And iBoard[2][3] = iTurn Then
    iWX0 = 200
    iWY0 =  50
    iWX1 = 200
    iWY1 = 350
    sGame = sFigure[iTurn] + ” win”
    ElseIf iBoard[3][1] = iTurn And iBoard[3][2] = iTurn And iBoard[3][3] = iTurn Then
    iWX0 = 300
    iWY0 =  50
    iWX1 = 300
    iWY1 = 350
    sGame = sFigure[iTurn] + ” win”
    ElseIf iBoard[1][1] = iTurn And iBoard[2][2] = iTurn And iBoard[3][3] = iTurn Then
    iWX0 =  50
    iWY0 =  50
    iWX1 = 350
    iWY1 = 350
    sGame = sFigure[iTurn] + ” win”
    ElseIf iBoard[1][3] = iTurn And iBoard[2][2] = iTurn And iBoard[3][1] = iTurn Then
    iWX0 = 350
    iWY0 =  50
    iWX1 =  50
    iWY1 = 350
    sGame = sFigure[iTurn] + ” win”
    EndIf
    EndSub

    ‘ Get possible puts list
    ‘ in: integer iBoard[][] – board
    ‘ out: integer iNumPuts – entry count of possible puts
    ‘ out: integer iPX[], iPY[] – possible puts
    ‘ work: integer iNP – instead of x, y for iBoard[][]
    Sub GetPutList
    iNumPuts = 0
    For iNP = 0 To 8
    If iBoard[Math.Remainder(iNP, 3) + 1][Math.Floor(iNP / 3) + 1] = SPACE Then
    iNumPuts = iNumPuts + 1
    iPX[iNumPuts] = Math.Remainder(iNP, 3) + 1
    iPY[iNumPuts] = Math.Floor(iNP / 3) + 1
    EndIf
    EndFor
    EndSub

    ‘ Draw board on graphics window
    ‘ in: integer iRo – 3
    ‘ work: integer iX, iY
    Sub DrawBoard
    GraphicsWindow.PenWidth = 2
    GraphicsWindow.PenColor = “Black”
    GraphicsWindow.DrawLine(50, 150, 350, 150)
    GraphicsWindow.DrawLine(50, 250, 350, 250)
    GraphicsWindow.DrawLine(150, 50, 150, 350)
    GraphicsWindow.DrawLine(250, 50, 250, 350)
    GraphicsWindow.PenWidth = 4
    GraphicsWindow.PenColor = “Gray”
    For iY = 1 To iRo
    For iX = 1 To iRo
    If sFigure[iBoard[iX][iY]] = “O” Then
    GraphicsWindow.DrawEllipse(65 + (iX – 1) * 100, 65 + (iY – 1) * 100, 70, 70)
    ElseIf sFigure[iBoard[iX][iY]] = “X” Then
    GraphicsWindow.DrawLine(65 + (iX – 1) * 100, 65 + (iY – 1) * 100, 135 + (iX – 1) * 100, 135 + (iY – 1) * 100)
    GraphicsWindow.DrawLine(135 + (iX – 1) * 100, 65 + (iY – 1) * 100, 65 + (iX – 1) * 100, 135 + (iY – 1) * 100)
    EndIf
    EndFor
    EndFor
    EndSub

    ‘ Put figure onto board
    ‘ in: integer iSaved[][] – current board
    ‘ in: integer iRo – 3
    ‘ in: integer iX -x coordinate
    ‘ in: integer iY -y coordinate
    ‘ in: integer iTurn – 1 or 2
    ‘ in: string sAlpha[] – alphabet for SGF game score
    Sub PutFigure
    If (iX > 0 And iX <= iRo And iY > 0 And iY <= iRo) Then
    iSaved[iX][iY] = iTurn
    If (iTurn = TURN1) Then
    sLine = “;B[” + sAlpha[iX] + sAlpha[iY] + “]C[” + sFigure[TURN1] + “(” + iX + “,” + iY + “)]”
    OutputLine()
    ElseIf (iTurn = TURN2) Then
    sLine = “;W[” + sAlpha[iX] + sAlpha[iY] + “]C[” + sFigure[TURN2] + “(” + iX + “,” + iY + “)]”
    OutputLine()
    ElseIf (iTurn = SPACE) Then
    sLine = “;E[” + sAlpha[iX] + sAlpha[iY] + “]C[-(” + iX + “,” + iY + “)]”
    OutputLine()
    EndIf
    EndIf
    EndSub

    ‘ OutputLine
    ‘ in: string sLine – output line
    Sub OutputLine
    iNR = iNR + 1
    sRec[iNR] = sLine
    EndSub

    ‘ Get figure from board
    ‘ in: integer iSaved[][] – current board
    ‘ in: integer iX, iY – x, y coordinate
    ‘ out: integer iFigure – TURN1 or TURN2
    Sub GetFigure
    If (iX >= 1 And iX <= iRo And iY >= 1 And iY <= iRo) Then
    iFigure = iSaved[iX][iY]
    Else
    iFigure = OB
    EndIf
    EndSub

    ‘ Initialize board
    ‘ in: integer iRo – 3
    ‘ work: integer iX, iY, i
    ‘ out: integer iBoard – board
    ‘ out: string sAlpha[] – alphabet for SGF game score
    Sub InitBoard
    For iY = 1 To iRo
    For iX = 1 To iRo
    iBoard[iX][iY] = SPACE
    EndFor
    EndFor

    For i = 0 To iRo + 1
    iBoard[i][0] = OB
    iBoard[i][iRo + 1] = OB
    iBoard[0][i] = OB
    iBoard[iRo + 1][i] = OB
    EndFor

    For i = 0 To iRo
    ‘ alphabet for SGF game score
    sAlpha[i] = Text.GetSubText(” abcdefghijklmnopqrs”, i + 1, 1)
    EndFor
    EndSub
  2. //
    1. Final del formulario
  3. Copyright (c) Microsoft Corporation. All rights reserved.

Easy Graf making Controlbox data by NaoChanON (code/ código)


a13

Microsoft Small Basic

Program Listing:  pnz684      http://smallbasic.com/smallbasic.com/program/?pnz684
a14
  1. ‘ Easy Graf making Controlbox data Input version 2011/12/21 by NaoChanON GraphicsWindow.Top=30
    GraphicsWindow.Left=50
    GraphicsWindow.Width=1000
    GraphicsWindow.Height=600
    GraphicsWindow.BackgroundColor=”Lavender”
    GraphicsWindow.Show()
    Controls.ButtonClicked=Onclick

    TextBoX_Input()

    Sub OnClick
    name=””
    name=controls.LastClickedButton     ‘ Last button
    nm=controls.GetButtonCaption(name)  ‘ Button’s caption
    If nm=”Execute” Then
    get_data()
    init()
    Plot_Data()
    Regressionline()
    EndIf
    EndSub

    Sub TextBoX_Input
    GraphicsWindow.BrushColor=”Red”
    GraphicsWindow.FontSize=30
    GraphicsWindow.DrawText(80,5,” Input boxes and push execute “)
    EXEC=Controls.AddButton(“Execute”,230,540)
    Controls.SetSize(EXEC,300,50)
    GraphicsWindow.FontSize=20

    GraphicsWindow.BrushColor=”Navy”
    GraphicsWindow.FontSize=15
    GraphicsWindow.DrawText(30,50,”Graf Width,Height”)  ‘ Width and height
    GraphicsWindow.DrawText(30,70,”EXAM: 800,500″)
    GXYBOX= Controls.AddTextBox(230,50)
    Controls.SetSize(GXYBOX,100,40)
    Controls.SetTextBoxText(GXYBOX,”800,500″)

    GraphicsWindow.DrawText(30,120,”Min-X , Max-X”)    ‘ Min-X and Max-X
    GraphicsWindow.DrawText(30,140,”EXAM: 0,800″)
    MINMAXX= Controls.AddTextBox(230,120)
    Controls.SetSize(MINMAXX,100,40)
    Controls.SetTextBoxText(MINMAXX,”0,800″)

    GraphicsWindow.DrawText(30,190,”Min-Y , Max-Y”)     ‘Min-Y and Max-Y
    GraphicsWindow.DrawText(30,210,”EXAM: 0,500″)
    MINMAXY= Controls.AddTextBox(230,190)
    Controls.SetSize(MINMAXY,100,40)
    Controls.SetTextBoxText(MINMAXY,”0,500″)

    GraphicsWindow.DrawText(30,260,”Dividing X , Y”)   ‘ dividing number
    GraphicsWindow.DrawText(30,280,”EXAM: 4,5″)
    DivBOX= Controls.AddTextBox(230,260)
    Controls.SetSize(DivBOX,100,40)
    Controls.SetTextBoxText(DivBOX,”4,5″)

    GraphicsWindow.DrawText(30,330,”Label X”)         ‘ Label-X name
    GraphicsWindow.DrawText(30,350,”EXAM: Weight”)
    LABELXBOX=Controls.AddTextBox(230,330)
    Controls.SetSize(LABELXBOX,300,40)
    Controls.SetTextBoxText(LABELXBOX,” Label X “)

    GraphicsWindow.DrawText(30,400,”Label Y”)         ‘ Label-Y name
    GraphicsWindow.DrawText(30,420,”EXAM: Height”)
    LABELYBOX=Controls.AddTextBox(230,400)
    Controls.SetSize(LABELYBOX,300,40)
    Controls.SetTextBoxText(LABELYBOX,” Label Y “)

    GraphicsWindow.DrawText(30,470,”Title name”)        ‘ Title name
    GraphicsWindow.DrawText(30,490,”EXAM: Weight vs Height”)
    TTLBOX=Controls.AddTextBox(230,470)
    Controls.SetSize(TTLBOX,300,40)
    Controls.SetTextBoxText(TTLBOX,” Test Graph “)

    GraphicsWindow.DrawText(660,5,”Input X , Y data”)   ‘ X,Y data
    GraphicsWindow.DrawText(660,25,”EXAM: 50 , 100 enter”)
    GraphicsWindow.DrawText(720,45,”80 , 150 enter”)
    MBOX= Controls.AddMultiLineTextBox(700,80)
    Controls.SetSize(MBOX,100,500)
    Controls.SetTextBoxText(MBOX,” 50,100″)
    EndSub

    Sub get_data
    GWH=Controls.GetTextBoxText(GXYBOX)
    GWidth= Text.GetSubText(GWH,1,text.GetIndexOf(GWH,”,”)-1)    ‘ Gwidth
    GHeight=Text.GetSubTextToEnd(GWH,text.GetIndexOf(GWH,”,”)+1)  ‘Ghight

    MMX=Controls.GetTextBoxText(MINMAXX)
    MinX= Text.GetSubText(MMX,1,text.GetIndexOf(MMX,”,”)-1)     ‘ Min-X
    MaxX=Text.GetSubTextToEnd(MMX,text.GetIndexOf(MMX,”,”)+1)   ‘Max-X

    MMY=Controls.GetTextBoxText(MINMAXY)
    MinY= Text.GetSubText(MMY,1,text.GetIndexOf(MMY,”,”)-1)      ‘Min-Y
    MaxY=Text.GetSubTextToEnd(MMY,text.GetIndexOf(MMY,”,”)+1)    ‘Max-Y

    DXY=Controls.GetTextBoxText(DivBOX)
    XDiv= Text.GetSubText(DXY,1,text.GetIndexOf(DXY,”,”)-1)      ‘X-Dividing number
    YDiv=Text.GetSubTextToEnd(DXY,text.GetIndexOf(DXY,”,”)+1)    ‘Y-Dividing number

    LBLX=Controls.GetTextBoxText(LABELXBOX)            ‘ Label-X
    LBLY=Controls.GetTextBoxText(LABELYBOX)            ‘ Label-Y
    TTL=Controls.GetTextBoxText(TTLBOX)                ‘ Title name

    DatXY=Controls.GetTextBoxText(MBOX)               ‘ X-Y data
    Get_XYata()                                       ‘ Pick Up X,Y data from multilinetextbox

    EndSub

    Sub Get_XYata                           ‘ Pick Up X,Y data from multilinetextbox
    DatXY=Controls.GetTextBoxText(MBOX)
    If Text.GetCharacterCode(text.GetSubText(DatXY,Text.GetLength(datXY),1))=10 Then
    DatXY= text.GetSubText(DatXY,1,Text.GetLength(datXY)-2)  ‘ if DatXY -end = Chr$(13)+chr$(10) then delete
    EndIf

    For i=1 To Text.GetLength(DatXY)
    word1=text.GetSubText(datXY,i,1)
    If word1=text.GetCharacter(13) Then     ‘ delete chr$(13)
    word1=””
    ElseIf word1=text.GetCharacter(10) Then ‘ conversion Chr$(10) to “:” =delimiter
    word1=”:”
    EndIf
    midw=text.Append(midw,word1)
    EndFor
    midw=midw+”:”                 ‘ connect all word and add “:” =delimiter

    while midw<>””
    NN=NN+1
    midp1=Text.GetIndexOf(midw,”,”)
    midp2=Text.GetIndexOf(midw,”:”)
    px[NN]=Text.GetSubText(midw,1,midp1-1)              ‘ pick up X-data
    py[NN]=Text.GetSubText(midw,midp1+1,midp2-midp1-1)  ‘ pick up Y-data
    midw=Text.GetSubTextToEnd(midw,midp2+1)
    EndWhile
    EndSub

    Sub init
    GraphicsWindow.Clear()
    GraphicsWindow.top=50
    GraphicsWindow.Left=50
    GraphicsWindow.Width=1000
    GraphicsWindow.Height=650
    GraphicsWindow.Show()
    GraphicsWindow.BackgroundColor=”Lightcyan”
    GraphicsWindow.BrushColor=”Navy”
    GraphicsWindow.PenColor=”Red”

    ‘ Draw Rectangle
    GTop=60
    GLeft=150
    GraphicsWindow.DrawRectangle(Gleft,Gtop,GWidth,GHeight)

    ‘ Title and X,Y-labels
    GraphicsWindow.FontSize=30
    GTitle=Shapes.AddText(TTL)
    Shapes.Animate(GTitle,Gleft+150,Gtop-40,1000)
    LabelY=Shapes.AddText(LBLY)
    Shapes.Animate(LabelY,15,(Gtop+GHeight)/2,1500)
    Shapes.Rotate(LabelY,-90)
    LabelX=Shapes.AddText(LBLX)
    Shapes.Animate(LabelX,(Gleft+Gwidth)/2-20,Gtop+GHeight+40,2000)

    ‘ X—–Axis
    GraphicsWindow.FontSize=20
    GraphicsWindow.BrushColor=”Red”

    For i= 0 To XDiv
    For j=GTop To GTop+Gheight-5 Step 10
    GraphicsWindow.DrawLine(Gleft+i*(Gwidth/Xdiv),J,Gleft+i*(Gwidth/Xdiv),j+5)
    EndFor
    DivX=math.round(minX+i*((MaxX-minX)/Xdiv))
    GraphicsWindow.DrawText(Gleft+i*(Gwidth/Xdiv)-20,GTop+GHeight+10,DivX)
    EndFor

    ‘ Y—Axis
    For i= YDiv To 0 Step -1
    For j=GLeft To GLeft+Gwidth-5 Step 10
    GraphicsWindow.DrawLine(j,GTop+i*(GHeight/Ydiv),j+5,GTop+i*(GHeight/Ydiv))
    EndFor
    DivY=math.Round(MaxY-i*((MaxY-minY)/Ydiv))
    GraphicsWindow.DrawText(Gleft-40,GTop+i*(GHeight/Ydiv)-10,DivY)
    EndFor

    EndSub

    Sub  Plot_Data
    GraphicsWindow.PenColor=”Green”
    GraphicsWindow.PenWidth=3
    For i=1 To NN
    plotx=Gleft + (PX[i]-minX)*Gwidth/(MaxX-MinX)
    ploty=GTop + Gheight- (PY[i]-minY)*Gheight/(MaxY-MinY)
    sc[i]=Shapes.AddEllipse(10,10)
    Shapes.Animate(sc[i],plotx-5,ploty-5,1000)
    EndFor
    EndSub

    Sub Regressionline
    For i=1 To NN
    sumx=sumx+px[i]
    sumy=sumy+py[i]
    sumX2=sumX2+px[i]*px[i]
    sumXY=sumXY+px[i]*py[i]
    sumY2=sumY2+py[i]*py[i]
    EndFor

    slope=(NN*sumXY-sumx*sumy)/(NN*sumx2-sumx*sumx)  ‘ slope a
    slope=math.Round(slope*100)/100                   ‘ round a
    intercept=sumy/NN-slope*sumx/NN                  ‘ intercept b
    intercept=math.Round(intercept*100)/100          ‘ round b

    Reg_line=”y= “+slope+”X + “+intercept          ‘ y= aX+b
    sreg=Shapes.AddText(Reg_line)
    Shapes.Animate(sreg,Gleft+10,80,1500)

    regY1=slope*minx+intercept                ‘ X=MinX Y= intercept
    regY2=maxY*0.8                           ‘ Y=maxY*0.8
    regx2=(regY2-intercept)/slope             ‘ X at Y
    Gregx1=Gleft                                           ‘conversion x1=minX
    GregX2=Gleft + (regx2-minX)*Gwidth/(MaxX-MinX)         ‘ conversion x2
    Gregy1=GTop + Gheight- (regY1-minY)*Gheight/(MaxY-MinY) ‘ conversion y1
    Gregy2=GTop + Gheight- (regY2-minY)*Gheight/(MaxY-MinY) ‘ conversion y2

    slope2=(NN*sumXY-sumx*sumy)/(NN*sumY2-sumY*sumY)  ‘ slope c
    slope2=math.Round(slope2*100)/100                 ‘ round c
    Coefficient=Math.SquareRoot(slope*slope2)         ‘Correlation coefficient
    Coefficient=math.Round(Coefficient*1000)/1000
    scoef= Shapes.AddText(“Coefficient= “+Coefficient)
    Shapes.Animate(scoef,Gleft+10,100,1500)

    GraphicsWindow.PenColor=”Green”
    GraphicsWindow.DrawLine(Gregx1,GregY1,GregX2,GregY2)   ‘ draw regression Line

    EndSub

Soroban – Japanese Abacus (código)


aaaabbbbSoroban – Japanese Abacus – SKH302-3
‘Harry Hardjono
‘August 2012

‘These Unicode Characters draw Card Suits: Spade, Heart, Diamond,Club
‘TestStr=Text.GetCharacter(9824)+Text.GetCharacter(9829)+Text.GetCharacter(9830)+Text.GetCharacter(9827)

‘Special Thanks for Nonki Takahashi for his ideas and encouragements.

InitLoop:
GraphicsWindow.Title=”Small Basic Abacus”
GraphicsWindow.Width = 400
GraphicsWindow.Height=400
GraphicsWindow.FontSize=20
GraphicsWindow.FontName=”Courier”
GraphicsWindow.Clear()
GraphicsWindow.Show()
GraphicsWindow.BrushColor=”white”
GraphicsWindow.FillRectangle(0,0,GraphicsWindow.Width,GraphicsWindow.Height)
GraphicsWindow.BrushColor=”black”

DoBG()
SetBead()
For i=0 To 14
BB[i]=0
SB[i]=0
EndFor
DoBead()
DoDigit()
IBB=BB
ISB=SB

DrawLoop:
BB=IBB
SB=ISB
x= GraphicsWindow.MouseX
y= GraphicsWindow.MouseY

If Mouse.IsLeftButtonDown Then
DoMouse()
DoBead()
DoDigit()
DoClick()
EndIf

Program.Delay(50) ‘Wait 50 miliseconds
Goto DrawLoop

Sub DoBG
GraphicsWindow.BrushColor=”Black” ‘Draw Frame
GraphicsWindow.FillRectangle(0,0,399,212)
GraphicsWindow.BrushColor=”White”
GraphicsWindow.FillRectangle(12,12,375,188)
GraphicsWindow.BrushColor=”Brown”
For i=0 to 14
GraphicsWindow.FillRectangle(23+(i*25),12,3,188)
endfor
GraphicsWindow.BrushColor=”Black” ‘Draw Slate & Rod
GraphicsWindow.FillRectangle(0,62,399,13)

‘Credits
GraphicsWindow.DrawText(20,300,”Four Suit Abacus”)
GraphicsWindow.DrawText(120,325,”by”)
GraphicsWindow.DrawText(150,350,”Harry M. Hardjono”)

‘Draw FourSuits
GraphicsWindow.BrushColor=”White”
GraphicsWindow.FontSize=10 ‘May need changing for different system
GraphicsWindow.DrawText(85,62,Text.GetCharacter(9824))
GraphicsWindow.DrawText(160,62,Text.GetCharacter(9829))
GraphicsWindow.DrawText(235,62,Text.GetCharacter(9830))
GraphicsWindow.DrawText(310,62,Text.GetCharacter(9827))

GraphicsWindow.FontSize=20

EndSub

Sub SetBead
‘BigBead
For i=0 to 14
GraphicsWindow.BrushColor=GraphicsWindow.GetRandomColor()
SSBB[0][i]=Shapes.AddEllipse(25,25)
Shapes.Move(SSBB[0][i],12+(i*25),12)
EndFor

‘SmallBead
For j=0 To 3
For i=0 to 14
GraphicsWindow.BrushColor=GraphicsWindow.GetRandomColor()
SSSB[j][i]=Shapes.AddEllipse(25,25)
Shapes.Move(SSSB[j][i],12+(i*25),75+(j*25))
EndFor
endfor

‘Digits
For i=0 to 14
GraphicsWindow.BrushColor=GraphicsWindow.GetRandomColor()
SSDG[i]=Shapes.AddText(“0”)
Shapes.Move(SSDG[i],17+(i*25),212)
EndFor

EndSub

Sub DoDigit
For i=0 to 14
Shapes.SetText(SSDG[i],(5*BB[i]+SB[i]))
endFor
EndSub

Sub DoBead
For i=0 to 14
Shapes.Move(SSBB[0][i],12+(i*25),12+(BB[i]*25))
EndFor

For i=0 to 14
For j=0 to 3
If (SB[i]<=j) then
Shapes.Move(SSSB[j][i],12+(i*25),75+((j+1)*25))
Else
Shapes.Move(SSSB[j][i],12+(i*25),75+((j)*25))
endif
EndFor
EndFor

EndSub

Sub DoMouse
map_var=”mx1=12;mx2=”+x+”;mx3=387;my1=0;my3=15″ ‘Xcoord mapped to 0-14
map()
cx=Math.Floor(map_var[“my2”])
If (cx>=0 and cx<=14) then
If (y>12 And y<62) Then
map_var=”mx1=12;mx2=”+y+”;mx3=62;my1=2;my3=0″ ‘Ycoord mapped to 1-0
map()
cy=Math.Floor(map_var[“my2”])
If (cy>=0 And cy<=1) Then
BB[cx]=cy
EndIf
EndIf

If (y>75 And y<200) Then
map_var=”mx1=75;mx2=”+y+”;mx3=200;my1=0;my3=5″ ‘Ycoord mapped to 4-0
map()
cy=Math.Floor(map_var[“my2”])
If (cy>=0 And cy<=4) Then
SB[cx]=cy
EndIf
EndIf
EndIf

EndSub

Sub DoClick
if (BB<>IBB Or ISB<>SB) Then
Sound.PlayClick()
EndIf
IBB=BB
ISB=SB
EndSub

‘———————————————-
‘map function
‘———————————————-
Sub map
‘x1-x2-x3 y1-y2-y3
‘(x2-x1)/(x3-x1)=(y2-y1)/(y3-y1)
‘y1+(y3-y1)*(x2-x1)/(x3-x1)=y2
map_var[“my2”]=((map_var[“my3”]-map_var[“my1”])*(map_var[“mx2”]-map_var[“mx1”])/(map_var[“mx3”]-map_var[“mx1”]))+map_var[“my1”]
EndSub

  1. //
    1. Final del formulario
  2. Copyright (c) Microsoft Corporation. All rights reserved.

Eyeballs – by Math Man (código)


aaaabbb

Microsoft Small Basic

                        Program Listing:  SLH926

   
  1. GraphicsWindow.BackgroundColor = “Wheat”
    eyeball_num = 5
    For i = 1 to eyeball_num
    rad[i] = Math.GetRandomNumber(150)+50
    pupilrad[i] = rad[i]/5
    irisrad[i] = pupilrad[i]*1.5
    eyecolor[i] = GraphicsWindow.GetRandomColor()
    GraphicsWindow.BrushColor = “White”
    eyeball[i] = Shapes.AddEllipse(rad[i],rad[i])
    GraphicsWindow.BrushColor = eyecolor[i]
    iris[i] = Shapes.AddEllipse(irisrad[i],irisrad[i])
    GraphicsWindow.BrushColor = “Black”
    pupil[i] = Shapes.AddEllipse(pupilrad[i],pupilrad[i])
    posX[i] = Math.GetRandomNumber(GraphicsWindow.Width-rad[i])
    posY[i] = Math.GetRandomNumber(GraphicsWindow.Height-rad[i])
    Shapes.Move(pupil[i],posX[i]-pupilrad[i]/2,posY[i]-pupilrad[i]/2)
    Shapes.Move(eyeball[i],posX[i]-rad[i]/2,posY[i]-rad[i]/2)
    Shapes.Move(iris[i],posX[i]-irisrad[i]/2,posY[i]-irisrad[i]/2)
    EndFor
    GraphicsWindow.MouseDown = MouseDown
    GraphicsWindow.MouseUp = MouseUp
    While (“True”)
    For g = 1 To eyeball_num
    getAngle()
    distfromcenter[g] = Math.SquareRoot(Math.Abs(dx[g]*dx[g]+dy[g]*dy[g]))
    yOnEyeball[g] = Math.Sin(angle[g])*Math.Min(rad[g]/2-irisrad[g]/2,distfromcenter[g]/3)
    xOnEyeball[g] = Math.Cos(angle[g])*Math.Min(rad[g]/2-irisrad[g]/2,distfromcenter[g]/3)
    Shapes.Move(pupil[g],posX[g]+xOnEyeball[g]-pupilrad[g]/2,posY[g]+yOnEyeball[g]-pupilrad[g]/2)
    Shapes.Move(iris[g],posX[g]+xOnEyeball[g]-irisrad[g]/2,posY[g]+yOnEyeball[g]-irisrad[g]/2)
    EndFor
    Program.Delay(10)
    EndWhile

    Sub getAngle
    dx[g] = GraphicsWindow.MouseX – posX[g]
    dy[g] = GraphicsWindow.MouseY – posY[g]
    If (dx[g] = 0) Then
    angle[g] = Math.Pi/2
    If (dy[g] < 0) Then
    angle[g] = -angle[g]
    EndIf
    Else
    angle[g] = Math.ArcTan(dy[g]/dx[g])
    EndIf
    If (dx[g] < 0) Then
    angle[g] = angle[g]+Math.Pi
    EndIf
    EndSub
    Sub MouseDown
    For r = 1 To eyeball_num
    Shapes.Zoom(iris[r],1.2,1.2)
    Shapes.Zoom(pupil[r],1.2,1.2)
    EndFor
    EndSub
    Sub MouseUp
    For w = 1 To eyeball_num
    Shapes.Zoom(iris[w],1,1)
    Shapes.Zoom(pupil[w],1,1)
    EndFor
    EndSub

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

SNAKEBITE-SB


bivo

// // //

Microsoft Small Basic

Program Listing:  SNKBITE

‘ SNAKEBITE-SB
‘ by Davey~Wavey, v1 Nov. 2009
‘ Written for SmallBasic v0.7

‘ Inspired by the ZX81 game SNAKEBITE.

‘ Eat the snake by chewing off it’s tail. Eat all tail segments to progress to next level.
‘ Watch out though, you may just make it angry!

‘ Use the cursor keys to move around. (You can press any other key to stop moving!)

‘ NOTE: If it crashes a lot, try commenting out the ‘Sound.PlayChimes()’ line. SB doesn’t like sound!

‘ I’ve laid the code out so that all the normal routines used in a game are present. If you’re
‘ learning to write your own game, a similar setup should work well for you. Have fun!

‘ set up the permanent loop (Q key terminates when on intro screen)
While 1=1

‘ initialise game environment
environment()

‘ show intro
introScreen()

While lives > 0
‘ INITIALISE LEVEL

‘ Next line won’t play anything if we have already played the intro screen music!?!?!?!!!
‘ It also seems to cause the prog to crash more often when enabled.
‘Sound.Play (progDir + “\muzak.mid”)

levelConfig()           ‘ level maps can be found at end of program listing below – have fun designing some
paintLevel()
snakeSetup()
playerSetup()

‘ MAIN LOOP
While (snakeSize > 2) And lives > 0

‘ if snake ‘change direction’ delay has expired, try to change snake direction
If snakeMoveDelay = 0 Then
snakeDirection()          ‘ will only change direction at random times

moveSnake()
EndIf

‘ alternative method to check for key press – also delays movement of player
If playerMoveDelay = 0 Then
checkKeys()

movePlayer()

‘ Check for PLAYER COLLISIONS
playerCollisions()
EndIf

‘ ADJUST (or reset) DELAYS
‘ I admit this isn’t the best way to do this.
‘ To get accurate speed, you should be calculating the
‘ frames-per-second and using that to slow various elements down.
If snakeMoveDelay > 0 Then
snakeMoveDelay = snakeMoveDelay-1
Else
snakeMoveDelay = level[thisLevel][“snakeDelay”]
EndIf

If playerMoveDelay > 0 Then
playerMoveDelay = playerMoveDelay-1
Else
playerMoveDelay = playerDelay
EndIf

‘ test snake length increase – NOT CURRENTLY USED
‘If Mouse.IsLeftButtonDown=”True” AND processing=0 Then
‘ addSegment()
‘ElseIf Mouse.IsLeftButtonDown=”False” And processing=1 Then
‘ mUp()
‘EndIf

EndWhile  ‘ main level (or lives) loop

‘ next line is irrellevant as the Sound.Play command above doesn’t work!
‘Sound.Stop (progDir + “\muzak.mid”)

‘ if we still have some lives, then we must have eaten all the snake
If lives > 0 Then

moveSnake()   ‘ update tail position since snake length just decreased

GraphicsWindow.ShowMessage(“YEAH, YOU BEAT THIS SNAKE!!!”, “WHOOPIE!”)

‘ move to next level
thisLevel=thisLevel+1

‘ go back to level 1 if we’ve completed them all
If thisLevel>levels Then
thisLevel=1
EndIf

‘ increase player speed (by decreasing the delay) – player gets a slight advantage for each level cleared 🙂
If playerDelay > 20 Then
playerDelay = playerDelay – 10
EndIf

GraphicsWindow.Clear()
EndIf

EndWhile  ‘ lives > 0

‘ DEAD MEAT!

‘ next line doesn’t work!
‘Sound.Play (progDir + “\gameover.mid”)

GraphicsWindow.ShowMessage(“THAT PUNKY SNAKE BEAT YOU THIS TIME!!! You scored: “+score, “EATEN!!!”)

‘ next line is irrellevant as the Play command above doesn’t work!
‘Sound.Stop (progDir + “\gameover.mid”)

EndWhile

‘ =====================================================================
‘ =====================================================================
‘ ====================== S U B R O U T I N E S ==============================
‘ =====================================================================
‘ =====================================================================

Sub environment
‘ initialise the game environment

‘ progDir = Program.Directory + “\assets” ‘ this is used to locate the graphics and music used in the game
progDir = “http://smallbasic.com/drop/snakebite&#8221;

GraphicsWindow.Title  = “~S~N~A~K~E~B~I~T~E~ v1 for SmallBasic by Davey~Wavey, Nov 2009”
GraphicsWindow.BackgroundColor = “Black”
GraphicsWindow.Width  = 800       ‘ grass sprite is 128 x 128
GraphicsWindow.Height = 600       ‘ 4 x 128 plus status area
GraphicsWindow.Left   = desktop.Width/2-(GraphicsWindow.Width/2)  ‘ 800
GraphicsWindow.Top    = desktop.Height/2-(GraphicsWindow.Height/2)-100   ’50

gwTop     = 18                                                 ‘ set game window top offset
gwBottom  = gwTop+(4*128)
gwLeft    = (GraphicsWindow.Width/2)-(3*128)                  ‘ set game window left offset
gwRight   = gwLeft+(6*128)

‘ initialise game environment
thisLevel       = 1
score           = 0
lives           = 5
playerDelay     = 500   ‘ speed of player movement – lower value = faster player = easier (unless you go too fast!)
snakeMoveDelay  = 0     ‘ this gets set by each level and is the speed of the snake – lower = faster

angrySnake      = -1    ‘ a counter. if >0 it indicates that snake is angry (makes snake faster)
digestionDelay  = 0     ‘ delay to prevent multiple tail pieces being eaten at once.
processing      = 0     ‘ a flag used in sub processes to prevent multiple runs

player          = “”    ‘ blank player array
snake           = “”    ‘ blank snake array

‘Timer.Interval = 2 ‘ set interval to check for key presses
‘Timer.Tick = checkKeys

EndSub

‘ =====================================================================

Sub introScreen
‘ display the game intro screen and wait for Space to be pressed

GraphicsWindow.Clear()

‘ this Play command works, but then prevents any other music playing!?!?!
Sound.Play (progDir + “\intro.mid”)

‘ show intro graphic
img = ImageList.LoadImage(progDir + “\titleScreen_800x600.jpg”)
GraphicsWindow.DrawImage(img, 0,0 )

‘ wait for keypress
lastkey = “”
While lastkey <> “Space”
lastkey = GraphicsWindow.LastKey

If lastkey = “Q” Then
Program.End()
EndIf
EndWhile

Sound.Stop (progDir + “\intro.mid”)
Program.Delay(500)
EndSub

‘ =====================================================================

Sub paintLevel
‘ draw the level objects at the start of each level

‘ create a black rectangle over the whole graphics window so we can create a fade effect after the level has been drawn
GraphicsWindow.BrushColor   = “Black”
bbox                        = Shapes.AddRectangle( 800, 600 )
Shapes.SetOpacity           (bbox, 100)

‘ draw dirt
img = ImageList.LoadImage(progDir + “\status_800x70.png”)
For y = 0 to 600 Step 70
GraphicsWindow.DrawImage (img, 0, y)
EndFor

‘ draw the grass
img = ImageList.LoadImage(progDir + “\grass_128d.png”)
For x = 0 To 5
For y = 0 To 3
GraphicsWindow.DrawImage (img, (x*128)+gwLeft, (y*128)+gwTop)
EndFor
EndFor

‘ draw the flowers
img = ImageList.LoadImage(progDir + “\flower1_32.png”)
Shapes.SetOpacity(img, 20)
For x = 1 To 20
GraphicsWindow.DrawImage (img, ((Math.GetRandomNumber(24)-1)*32)+gwLeft, ((Math.GetRandomNumber(16)-1)*32)+gwTop )
EndFor
img = ImageList.LoadImage(progDir + “\flower2_32.png”)
Shapes.SetOpacity(img, 20)
For x = 1 To 10
GraphicsWindow.DrawImage (img, ((Math.GetRandomNumber(24)-1)*32)+gwLeft, ((Math.GetRandomNumber(16)-1)*32)+gwTop )
EndFor

‘ draw the level blocks
img = ImageList.LoadImage(progDir + “\wall_32.png”)
For my = 1 To 16
For mx = 1 To 24
block = text.GetSubText( level[thisLevel][my], mx, 1 )

‘ position WALLS
If block = “W” Then
GraphicsWindow.DrawImage (img, ((mx-1)*32)+gwLeft, ((my-1)*32)+gwTop) ‘ DrawRectangle( (mx-1)*32, (my-1)*32, 32, 32 )
EndIf

‘ position PLAYER
If block = “P” Then
player[“x”] = ((mx-1)*32+12)+gwLeft    ‘ calculate x,y from 32 x 32 level grid blocks
player[“startX”] = player[“x”]         ‘ remember start position for when player dies
player[“y”] = ((my-1)*32+12)+gwTop
player[“startY”] = player[“y”]
EndIf

‘ position SNAKE
If block = “S” Then
level[thisLevel][“snakeX”] = ((mx-1)*32+16)+gwLeft
level[thisLevel][“snakeY”] = ((my-1)*32+16)+gwTop
EndIf

EndFor
EndFor

‘ draw the border (using the snake body part)
img = ImageList.LoadImage(progDir + “\body_18.png”)
For y = 0 To 600 Step 530
For x=5 to 790 Step 18
‘ draw top and bottom border
GraphicsWindow.DrawImage ( img, x, y)
EndFor
EndFor
For x = 0 To 800 Step 784
For y = 15 to 530 Step 18
‘ draw left and right border
GraphicsWindow.DrawImage ( img, x, y)
EndFor
EndFor

‘ show status bar
status()

‘ fade the screen in
Shapes.Move (bbox, 0, 0)
For lwp = 100 To 0 Step -1
Shapes.SetOpacity(bbox, lwp)
Program.Delay(20)
EndFor

EndSub

‘ =====================================================================

Sub snakeSetup
‘ create the snake array and display snake in starting position

headPart    = ImageList.LoadImage(progDir + “\head_24.png”)
headAngryPart = ImageList.LoadImage(progDir + “\headAngry_24.png”)
headSize    = 22 ’24 ‘ radius of head
headOffset  = 11

bodyPart    = ImageList.LoadImage(progDir + “\body_18.png”)
bodySize    = 18 ’18
bodyOffset  = 9

tailPart    = ImageList.LoadImage(progDir + “\tail_16.png”)
tailSize    = 16 ’32 ’16
tailOffset  = 8

snake = “”
snake[0][“happySnake”] = Shapes.AddImage(headPart)
snake[0][“angrySnake”] = Shapes.AddImage(headAngryPart)
snakeSize = level[thisLevel][“snakeSize”]   ‘ this value will change during game as snake eats/is eaten

‘ remember current pen width
‘pw = GraphicsWindow.PenWidth
‘GraphicsWindow.PenWidth = 0

For snakePart = 1 to snakeSize

‘ create the snake segments
If snakePart = 1 Then
‘GraphicsWindow.BrushColor=”Brown”
snake[snakePart][“sprite”] = snake[0][“happySnake”]   ‘Shapes.AddEllipse(headSize,headSize) ‘ head
‘ Zoom for this shape has been done above

ElseIf snakePart <> snakeSize Then
‘GraphicsWindow.BrushColor=”Chocolate”
snake[snakePart][“sprite”] = Shapes.AddImage(bodyPart)  ‘Shapes.AddEllipse(bodySize,bodySize) ‘ body
Else
‘GraphicsWindow.BrushColor=”SandyBrown”
snake[snakePart][“sprite”] = Shapes.AddImage(tailPart)    ‘Shapes.AddEllipse(tailSize,tailSize) ‘ tail
EndIf

‘ locate snake on screen – probably needs to be part of each level config
snake[snakePart][“x”] = level[thisLevel][“snakeX”]
snake[snakePart][“y”] = level[thisLevel][“snakeY”]

‘ as all segments start at the same x,y we must increment the initial delay for each successive segment
If snakePart > 2 Then
snake[snakePart][“delay”] = ((snakePart-1)*(bodySize-4))+4
Else
snake[2][“delay”] = bodySize ’18
EndIf

EndFor

‘ set initial direction
snake[1][“moves”] = level[thisLevel][“snakeDir”]
snake[1][“delay”] = “0”   ‘ need to initialise delay for snake head – used to determine delay before direction change

‘ reinstate previous pen width
‘GraphicsWindow.PenWidth=pw
EndSub

‘ =====================================================================

Sub playerSetup
‘ create the player and display at start position

‘GraphicsWindow.BrushColor=”Lime”
img = ImageList.LoadImage(progDir + “\player2_24.png”)    ‘ from http://www.freeicons.dk
player[“sprite”] = Shapes.AddImage(img)    ‘Shapes.AddRectangle( 20,20 )
Shapes.Move( player[“sprite”], player[“x”]-11, player[“y”]-11 )     ‘ -11 offset instead of -12 works better!?!?!

playerMoveDelay  = playerDelay                     ‘ initialise player movement speed (delay)

EndSub

‘ =====================================================================

Sub snakeDirection
‘ check if snake is ready for a CHANGE of DIRECTION

‘ using the ‘delay’ element of the snake head (snake[1]) as a counter for the change direction delay
‘ this delay gets decreased in the moveSnake sub
If snake[1][“delay”] = 0  Then

‘ reset change direction delay
snake[1][“delay”] = level[thisLevel][“dirDelay”]

‘ yes, time for a direction change, but only 25% chance of changing
If Math.GetRandomNumber(4) <> 3 Then

‘ not yet – leave the snake going the same way and delay another direction change for a while
snake[1][“delay”] = level[thisLevel][“dirDelay”]

Else
‘ yep, let’s change direction
dir = Math.GetRandomNumber(4)

‘ EDGE BOUNCE – if snake is heading into window edge, force a direction change
‘If (dir = 1 And snake[1][“y”] < 20) Then
‘ dir = 3 ‘ go S
‘EndIf
‘If (dir = 3 And snake[1][“y”] > GraphicsWindow.Height-(20)) Then
‘ dir = 1 ‘ go N
‘EndIf
‘If (dir = 4 And snake[1][“x”] < 20) Then
‘ dir = 2 ‘ go E
‘EndIf
‘If (dir = 2 And snake[1][“x”] > GraphicsWindow.Width-(8+20)) Then
‘ dir = 4 ‘ go W
‘EndIf

‘ point snake head in appropriate direction
snake[1][“moves”] = dir

‘ reset delay until next direction change
snake[1][“delay”] = level[thisLevel][“dirDelay”]

EndIf

‘ ANGRY SNAKE calculation
‘ to slow this effect down, we’re only trying to instigate ‘angry mode’ at each direction change
If (level[thisLevel][“getAngry”] = 1) Then

‘ only try to instigate angry mode in snake is currently happy
If angrySnake < 0 Then
‘GraphicsWindow.Title=”HAPPY SNAKE {:-)”

rn = Math.GetRandomNumber(100)
If (rn = 7) Then
angrySnake = Math.GetRandomNumber(50)+20
level[thisLevel][“snakeDelay”] = level[thisLevel][“snakeDelay”]/2
EndIf

‘ if angrySnake counter has reached zero, reset snake speed back to normal
ElseIf angrySnake = 0 Then
level[thisLevel][“snakeDelay”] = level[thisLevel][“snakeDelay”]*2      ‘ set snake delay back to level setting

EndIf

If angrySnake > -1 Then
angrySnake = angrySnake-1     ‘ decrease angry snake counter
‘GraphicsWindow.Title=”ANGRY SNAKE }:-/”
EndIf

EndIf

EndIf   ‘ change direction delay=0

EndSub

‘ =====================================================================

Sub moveSnake
‘ move snake segments

For snakePart = 1 To snakeSize

‘ find out which direction we’re moving in
dir = text.GetSubText(snake[snakePart][“moves”], 1, 1)

‘ check if head is about to collide with a wall
If snakePart = 1 Then
shapes.Rotate(snake[1][“sprite”], ((dir-1)*90) )    ‘ point snake head in correct direction

snakeCollisions()
EndIf

‘ only move snakepart if it’s delay is zero – or this is the head, which always gets moved
If snakePart = 1 Or snake[snakePart][“delay”] = 0 Then

‘ take direction off moves list for this snake part
If snakePart > 1 Then
snake[snakePart][“moves”] = Text.GetSubTextToEnd(snake[snakePart][“moves”], 2)
EndIf

‘ add this movement onto next snake part’s movement list
If snakePart < snakeSize Then
snake[snakepart+1][“moves”] = text.Append(snake[snakepart+1][“moves”],dir)
EndIf

‘ update x,y co-ordinates of snake part
If dir = 1 Then
snake[snakePart][“y”] = snake[snakePart][“y”]-1      ‘ moving N

ElseIf dir = 2 Then
snake[snakePart][“x”] = snake[snakePart][“x”]+1      ‘ moving E

ElseIf dir = 3 Then
snake[snakePart][“y”] = snake[snakePart][“y”]+1      ‘ moving S

ElseIf dir = 4 Then
snake[snakePart][“x”] = snake[snakePart][“x”]-1      ‘ moving W
EndIf

‘ wrap snake at window edge
If snake[snakePart][“x”] < gwLeft Then
snake[snakePart][“x”] = gwRight
ElseIf snake[snakePart][“x”] > gwRight Then
snake[snakePart][“x”] = gwLeft
ElseIf snake[snakePart][“y”] < gwTop Then
snake[snakePart][“y”] = gwBottom-8
ElseIf snake[snakePart][“y”] > gwBottom-8 Then
snake[snakePart][“y”] = gwTop
EndIf

EndIf

‘ The offsets allow for the various snake segment sizes
If snakePart = 1 Then
offset=headOffset
ElseIf snakePart<>snakeSize Then
offset = bodyOffset
Else
offset = tailOffset
EndIf

‘ DRAW SNAKE PART in new position
shapes.Move(snake[snakePart][“sprite”], snake[snakePart][“x”]-offset, snake[snakePart][“y”]-offset )

‘ DECREASE SNAKE PART DELAY
If snake[snakePart][“delay”] > 0 Then
snake[snakePart][“delay”] = snake[snakePart][“delay”] – 1
EndIf

EndFor

‘ as snake gets shorter, processing speed increases, so we need to add a delay
If snakeSize < 7 Then   ‘level[thisLevel][“snakeSize”] Then
‘For snakePart = snakeSize To level[thisLevel][“snakeSize”]
Program.Delay (0.2*(level[thisLevel][“snakeSize”]-snakeSize))
‘EndFor
EndIf

EndSub

‘ =====================================================================

Sub snakeCollisions
‘ this is a recursive function
‘ it checks for a snake collision with a level object (i.e. a wall) in the current snake direction
‘ if it finds one, it chooses a new direction, then calls itself to check it for a collision
‘ after completing, ‘dir’ will have a direction that does not cause a collision

‘ Up
If dir = 1 Then
sx = math.Floor((snake[1][“x”]-gwLeft)/32)+1
sy = math.Floor(((snake[1][“y”]-gwTop)-(headSize/2))/32)+1

If Text.GetSubText( level[thisLevel][sy], sx, 1) = “W” Then
‘ choose a new direction then check it for collisions by recursing this sub
dir = Math.GetRandomNumber(4)
snakeCollisions()
EndIf

‘ Down
ElseIf dir = 3 Then
sx = math.Floor((snake[1][“x”]-gwLeft)/32)+1
sy = math.Floor(((snake[1][“y”]-gwTop)+(headSize/2))/32)+1

If Text.GetSubText( level[thisLevel][sy], sx, 1) = “W” Then
‘ choose a new direction then check it for collisions by recursing this sub
dir = Math.GetRandomNumber(4)
snakeCollisions()
EndIf

‘ Right
ElseIf dir = 2 Then
sx = math.Floor(((snake[1][“x”]-gwLeft)+(headSize/2))/32)+1
sy = math.Floor((snake[1][“y”]-gwTop)/32)+1

If Text.GetSubText( level[thisLevel][sy], sx, 1) = “W” Then
‘ choose a new direction then check it for collisions by recursing this sub
dir = Math.GetRandomNumber(4)
snakeCollisions()
EndIf

‘ Left
ElseIf dir = 4 Then
sx = math.Floor(((snake[1][“x”]-gwLeft)-(headSize/2))/32)+1
sy = math.Floor((snake[1][“y”]-gwTop)/32)+1

If Text.GetSubText( level[thisLevel][sy], sx, 1) = “W” Then
‘ choose a new direction then check it for collisions by recursing this sub
dir = Math.GetRandomNumber(4)
snakeCollisions()
EndIf
EndIf

‘ set snake in new safe direction
snake[1][“moves”] = dir

EndSub

‘ =====================================================================

Sub checkKeys

‘ indicate if player is to move
keyPress = GraphicsWindow.LastKey

EndSub

‘ =====================================================================

Sub movePlayer
‘ depending on the key pressed, move the player in the required direction
‘ unless we hit the edge of the screen, or a wall

If keyPress <> “” Then    ‘ only process if a key was pressed

move = 0  ‘ initially prevent any movement

‘ CHECK LEFT
If keyPress = “Left” Then
px = math.Floor(((player[“x”]-13)-gwLeft)/32)+1     ‘ subtract 13 from x to allow for half sprite width offset
py = math.Floor(((player[“y”]-gwTop))/32)+1

‘ hit edge of screen?
If player[“x”]-13 > gwLeft Then
move = 1
EndIf

‘ hit a wall?
If Text.GetSubText( level[thisLevel][py], px, 1) = “W” Then
move = 0
EndIf
EndIf

‘ CHECK RIGHT
If keyPress = “Right” Then
px = math.Floor(((player[“x”]+13)-gwLeft)/32)+1
py = math.Floor((player[“y”]-gwTop)/32)+1

‘ hit edge of screen?
If player[“x”]+13 < gwRight Then
move = 1
EndIf

‘ hit a wall?
If Text.GetSubText( level[thisLevel][py], px, 1) = “W” Then
move = 0
EndIf
EndIf

‘ CHECK UP
If keyPress = “Up”  Then
px = math.Floor(((player[“x”])-gwLeft)/32)+1
py = math.Floor(((player[“y”]-13)-gwTop)/32)+1

‘ hit edge of screen?
If player[“y”]-13 > gwTop Then
move = 1
EndIf

‘ hit a wall?
If Text.GetSubText( level[thisLevel][py], px, 1) = “W” Then
move = 0
EndIf
EndIf

‘ CHECK DOWN
If keyPress = “Down” Then
px = math.Floor(((player[“x”])-gwLeft)/32)+1
py = math.Floor(((player[“y”]+13)-gwTop)/32)+1

‘ hit edge of screen?
If player[“y”]+13 < gwBottom Then
move = 1
EndIf

‘ hit a wall?
If Text.GetSubText( level[thisLevel][py], px, 1) = “W” Then
move = 0
EndIf
EndIf

‘ ADJUST PLAYER LOCATION and rotate player to point the correct direction
If keyPress = “Left” Then
player[“x”] = player[“x”] – move
Shapes.Rotate(player[“sprite”], 270)
EndIf
If keyPress = “Right” Then
player[“x”] = player[“x”] + move
Shapes.Rotate(player[“sprite”], 90)
EndIf
If keyPress = “Up”  Then
player[“y”] = player[“y”] – move
Shapes.Rotate(player[“sprite”], 0)
EndIf
If keyPress = “Down”  Then
player[“y”] = player[“y”] + move
Shapes.Rotate(player[“sprite”], 180)
EndIf

‘ MOVE PLAYER SPRITE
Shapes.Move( player[“sprite”], player[“x”]-11, player[“y”]-11 )
keyPress = “”
EndIf
EndSub

‘ =====================================================================

Sub playerCollisions
‘ detect player colliding with various things

‘ detect player/snake tail collision
If (digestionDelay <= 0) Then

‘ have no idea why I have to subtract 4 from the tailOffset calculations here!!
If (math.Abs(player[“x”] – (snake[snakeSize][“x”]-tailOffset)-4) < 10) And (Math.Abs(player[“y”] – (snake[snakeSize][“y”]-tailOffset)-4) < 10) AND snake[snakeSize][“delay”] = 0 Then
digestionDelay = 60         ‘ don’t allow another piece to be eaten for a while

‘ decrease snake length
snakeSize = snakeSize – 1
shapes.Remove(snake[snakeSize][“sprite”])
snake[snakeSize][“sprite”] = snake[snakeSize+1][“sprite”]

‘level[thisLevel][“snakeDelay”] = level[thisLevel][“snakeDelay”] – (2*thisLevel) ‘ make snake faster each level – now set in level settings, therefore redundant here

Sound.PlayChimes()
score = score + 10        ‘ increase player score
status()                ‘ update status area
EndIf
Else
digestionDelay = digestionDelay-1   ‘ just decrease the delay
EndIf

‘ detect player/snake head collision
If (math.Abs(player[“x”] – (snake[1][“x”]-headOffset)) < 16) And (Math.Abs(player[“y”] – (snake[1][“y”]-headOffset)) < 16) Then
playerEaten()
EndIf

EndSub

‘ =====================================================================

Sub playerEaten
‘ when eaten, animate the player sprite for a while

Sound.PlayBellRing()
lives = lives – 1
status()              ‘ update status area

‘ set player back to their start location
player[“x”] = player[“startX”]
player[“y”] = player[“startY”]

‘ if player was eaten at player start location, move player to snake start location to prevent continuous death
If (math.Abs(player[“x”] – (snake[1][“x”]-headOffset)) < 36) And (Math.Abs(player[“y”] – (snake[1][“y”]-headOffset)) < 36) Then
player[“x”] = level[thisLevel][“snakeX”]
player[“y”] = level[thisLevel][“snakeY”]
EndIf

‘ you spin me right round baby, right round, like a record….
For x = 1 to 3
For y = 0 To 360
Shapes.Rotate( player[“sprite”], y )
Shapes.SetOpacity( player[“sprite”], y/2 )
Program.Delay(2)
EndFor
EndFor

If lives > 0 Then
Shapes.Animate( player[“sprite”], player[“x”]-11, player[“y”]-11, 500 )
For lwp = 1 to 1000000
EndFor
EndIf

EndSub

‘ =====================================================================

Sub addSegment
‘ NOT USING THIS AT PRESENT – USEFUL IF FOOD IS ADDED FOR SNAKE TO EAT
‘ this code hasn’t been updated since snake was changed from Ellipse shapes to graphic shapes, so needs some work if used!

processing = 1  ‘ flag that we’re working on it!

‘ increase snake size and delay movement of new tail
snakeSize = snakeSize + 1
snake[snakeSize][“delay”] = snake[snakeSize-1][“delay”]+12

‘ need to remove old tail due to Small Basic’s layering of graphic shapes
Shapes.Remove(snake[snakeSize-1][“sprite”])

‘ add a new body part
GraphicsWindow.BrushColor = “Chocolate”
snake[snakeSize-1][“sprite”] = Shapes.AddEllipse(bodySize, bodySize)
Shapes.Move(snake[snakeSize-1][“sprite”], snake[snakeSize-1][“x”], snake[snakeSize-1][“y”])

‘ add new tail
snake[snakeSize][“x”] = snake[snakeSize-1][“x”]
snake[snakeSize][“y”] = snake[snakeSize-1][“y”]
GraphicsWindow.BrushColor = “SandyBrown”
snake[snakeSize][“sprite”] = Shapes.AddEllipse(tailSize, tailSize)
Shapes.Move(snake[snakeSize][“sprite”], snake[snakeSize][“x”], snake[snakeSize][“y”])
EndSub

Sub mUp
‘ NOT USED AT PRESENT – put here to handle mouse button presses
‘ used in conjunction with AddSegment subroutine above
processing = 0  ‘ cancel the mousedown action – have to do this ‘cos the ‘puter is much faster than our likkle fingers
EndSub

‘ =====================================================================

Sub status
‘ show the various game values in status area

GraphicsWindow.BrushColor    = “White”
GraphicsWindow.PenColor      = “White”
GraphicsWindow.FontSize      = 32

GraphicsWindow.DrawText      ( 20, 550, “Round: Lives: Score:”)
GraphicsWindow.FillRectangle ( 140,555, 80, 32 )
GraphicsWindow.FillRectangle ( 370,555, 80, 32 )
GraphicsWindow.FillRectangle ( 610,555, 160, 32 )

GraphicsWindow.BrushColor    = “Black”
GraphicsWindow.DrawText      ( 170, 550, thisLevel )
GraphicsWindow.DrawText      ( 400, 550, lives )
GraphicsWindow.DrawText      ( 640, 550, score )
EndSub

‘ =====================================================================

Sub levelConfig
‘ configuration settings for each of the levels

‘ to add new levels, simply duplicate the last one below, change it’s level number, make a new layout,
‘ then increase the ‘levels’ value below. To test your new level without playing all the earlier ones, change
‘ the ‘thisLevel’ variable (at the beginning of the program code above).

levels = 5

level[1][“snakeDir”]  = Math.GetRandomNumber(4)  ‘ start snake off in a random direction: 1=N, 2=E, 3=S, 4=W
level[1][“snakeSize”] = 12      ‘ length of snake
level[1][“snakeDelay”]= 700    ‘ speed of snake (higher = slower)
level[1][“dirDelay”]  = 50      ‘ delay (moves) before snake can change direction (lower = more jittery snake)
level[1][“getAngry”]  = 1      ‘ flag indicating if the snake can switch to angry mode (=1) or not (=0)

‘ W = wall segment
‘ S = Snake start location
‘ P = Player start location

level[0][0]=  “………1………2….”    ‘ just a ruler
level[1][1]=  “W W”
level[1][2]=  ” ”
level[1][3]=  ” WWWWWWWWWWWWWW ”
level[1][4]=  ” ”
level[1][5]=  ” ”
level[1][6]=  ” S ”
level[1][7]=  ” ”
level[1][8]=  ” ”
level[1][9]=  ” ”
level[1][10]= ” ”
level[1][11]= ” ”
level[1][12]= ” P ”
level[1][13]= ” ”
level[1][14]= ” WWWWWWWWWWWWWW ”
level[1][15]= ” ”
level[1][16]= “W W”

level[2][“snakeDir”]  = Math.GetRandomNumber(4)  ‘ start snake off in a random direction: 1=N, 2=E, 3=S, 4=W
level[2][“snakeSize”] = 14      ‘ length of snake
level[2][“snakeDelay”]= 1100    ‘ speed of snake (higher = slower)
level[2][“dirDelay”]  = 50      ‘ delay (moves) before snake can change direction (lower = more jittery snake
level[2][“getAngry”]  = 1      ‘ flag indicating if the snake can switch to angry mode (=1) or not (=0)

level[0][0]=  “………1………2….”    ‘ just a ruler
level[2][1]=  ” ”
level[2][2]=  ” WWWWWWWWWWWWWWWW ”
level[2][3]=  ” W W ”
level[2][4]=  ” W WWWWWWWWWWWWW W ”
level[2][5]=  ” W WW WWW WW W ”
level[2][6]=  ” W WWWWWWWWWWWWW W ”
level[2][7]=  ” W P WW S W ”
level[2][8]=  ” WWWWW W WWWWWW ”
level[2][9]=  ” WW W W ”
level[2][10]= ” W WWWWWWW W ”
level[2][11]= ” WWW W WW WW W ”
level[2][12]= ” W WWWW WWWWWWW W ”
level[2][13]= ” W W ”
level[2][14]= ” WWWWWWWWWWWWWWWW ”
level[2][15]= ” ”
level[2][16]= ” ”

level[3][“snakeDir”]  = 1  ‘Math.GetRandomNumber(4) ‘ start snake off in a random direction: 1=N, 2=E, 3=S, 4=W
level[3][“snakeSize”] = 16      ‘ length of snake
level[3][“snakeDelay”]= 600    ‘ speed of snake (higher = slower)
level[3][“dirDelay”]  = 30      ‘ delay (moves) before snake can change direction (lower = more jittery snake
level[3][“getAngry”]  = 1      ‘ flag indicating if the snake can switch to angry mode (=1) or not (=0)

level[0][0]=  “………1………2….”    ‘ just a ruler
level[3][1]=  ” ”
level[3][2]=  ” WWWW WWWW ”
level[3][3]=  ” WW W W WWW ”
level[3][4]=  ” WW W WW ”
level[3][5]=  ” W WWW WWW W ”
level[3][6]=  ” W W W W ”
level[3][7]=  ” WW WWWWW WWWWWW WW ”
level[3][8]=  ” W P W ”
level[3][9]=  ” WW WWWWW WWWWWW WW ”
level[3][10]= ” W WW W W WW W ”
level[3][11]= ” W WWWW WWWWW W ”
level[3][12]= ” WW W W WW ”
level[3][13]= ” WWWWWWW WWWWWWWW ”
level[3][14]= ” WSW ”
level[3][15]= ” W ”
level[3][16]= ” ”

level[4][“snakeDir”]  = 3  ‘Math.GetRandomNumber(4) ‘ start snake off in a random direction: 1=N, 2=E, 3=S, 4=W
level[4][“snakeSize”] = 18      ‘ length of snake
level[4][“snakeDelay”]= 500    ‘ speed of snake (higher = slower)
level[4][“dirDelay”]  = 20      ‘ delay (moves) before snake can change direction (lower = more jittery snake
level[4][“getAngry”]  = 0      ‘ flag indicating if the snake can switch to angry mode (=1) or not (=0)

level[0][0]=  “………1………2….”    ‘ just a ruler
level[4][1]=  ” W ”
level[4][2]=  ” WSW ”
level[4][3]=  ” W W ”
level[4][4]=  ” W W ”
level[4][5]=  ” W W ”
level[4][6]=  ” W WW ”
level[4][7]=  ” W WW ”
level[4][8]=  ” W WW ”
level[4][9]=  ” WW W ”
level[4][10]= ” WW W ”
level[4][11]= ” WW W ”
level[4][12]= ” W W ”
level[4][13]= ” W W ”
level[4][14]= ” W W ”
level[4][15]= ” WPW ”
level[4][16]= ” W ”

level[5][“snakeDir”]  = 3  ‘Math.GetRandomNumber(4) ‘ start snake off in a random direction: 1=N, 2=E, 3=S, 4=W
level[5][“snakeSize”] = 20      ‘ length of snake
level[5][“snakeDelay”]= 300    ‘ speed of snake (higher = slower)
level[5][“dirDelay”]  = 20      ‘ delay (moves) before snake can change direction (lower = more jittery snake
level[5][“getAngry”]  = 0      ‘ flag indicating if the snake can switch to angry mode (=1) or not (=0)

level[0][0]=  “………1………2….”    ‘ just a ruler
level[5][1]=  “WW WW”
level[5][2]=  “W P W”
level[5][3]=  ” WWWWWWWWWWWWWW ”
level[5][4]=  “WWWWWW WWW WW”
level[5][5]=  ” ”
level[5][6]=  ” WWWWWWWWWWWWWWW ”
level[5][7]=  “WW WWW WWWWW”
level[5][8]=  ” ”
level[5][9]=  “WW WWW WWW WW”
level[5][10]= ” WWWWWWWWWWWWWW ”
level[5][11]= ” ”
level[5][12]= “WWWWWW WWW WW”
level[5][13]= ” WWWWWWWWWWWWWW ”
level[5][14]= ” ”
level[5][15]= “W WWWWW WWWWW W”
level[5][16]= “WW S WW”

EndSub

//

Final del formulario

Copyright (c) Microsoft Corporation. All rights reserved.

Small Basic and tablet compatibility


tablet

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)

However, if you’re using a mobile with Windows Phone 7 or 8, you can only test from the web,

http://social.msdn.microsoft.com/Forums/en-US/smallbasic/thread/cfdb6219-ea5b-4722-82b7-729888074993

Small Basic – The Programmer’s Guide


Small Basic – The Programmer’s Guide
Written by Mike James
Article Index
Small Basic – The Programmer’s Guide
Subroutines and Data Structures
Page 1 of 2

If you have been looking for a simple language that makes it possible to teach complete beginners then you might be pleased to meet Small Basic. It is, as its name, suggests a small and simple language but it also has lots of rewards built in to keep the beginner’s interest.

Modern languages are very powerful, but have you ever tried to teach one to a complete beginner? Before you can write a single program there is so much to master. You find yourself having to explain complicated and sophisticated ideas when you would really prefer to concentrate on the more basic ideas of programming.

You don’t need objects, data typing or anything complicated to get in the way of learning the essence of programming. This sort of simplicity was the original intent of BASIC which was so successful at getting people to program that it grew well beyond its initial simplicity. Small Basic is almost a re-creation of this earlier form of Basic.

If you know any form of Basic, be prepared to be surprised at what has been left in and what has been left out. Try to keep in mind that the objective is not to recreate any existing form of Basic – QBasic or the original Visual Basic – but to put together something that is easy for beginners to learn. This said, there are some decisions that you might want to take issue with – but let’s find out about Small Basic first.

Small Basic is easy to download and easy to install – as long you you have Windows XP or later and the .NET 3.5 Framework. Yes Small Basic is a .NET managed language, but don’t imagine for a second that it is a cut down version of Visual Basic – it isn’t.

Hello Small Basic

When you first run Small Basic what you will discover is that part of making it easy to use for beginners is the IDE. This presents a simple editor window where you can type commands and issue a the Run command. There is no distinction between run and debug to confuse the beginner – you write your program code and then run it. As you type the IDE prompts with possible completions of what you type and a side panel provides documentation on the command – Intellisense style.

The first important thing to know about Small Basic is that it allows you to use objects but not to create them.

This is very reasonable because beginners often have difficulty with the creation of objects, especially in class based languages, but they have less difficulty with the idea of using an object with properties and methods. Once the idea of an object has sunk in then they are ready to ask the question of how to extend the language by creating new objects – they are also more than ready to move on to a more sophisticated language.

To see this in action, and to see how simple Small Basic is let’s write Hello World. To do this you do need to know a little about the Small Basic output window – the TextWindow object.

If you start to type T e x t … then you can see the possible choices appear and you eventually get to TextWindow

hello1

Next you can select the method you require – WriteLine – and enter the string to print. The entire program is just the single line:

TextWindow.WriteLine("Hello World")

No curly brackets and no semicolons to be seen.

At the far right of the window a summary of the object and its method are presented to make sure you don’t have to rush of and consult a manual.

Running the program is just as easy – press F5 or click the Run icon.  In this case a command console opens and you see the printed message. There is also an End Program button that appears in the IDE just in case things don’t work out.

Variables

So far so good but what do you need to tell the beginner to make progress in Small Basic?

The first thing they need to master is the idea of a variable and a value. In Small Basic this is stripped down to its bare essentials. There are no data types apart from numbers and strings and these are automatically converted where possible. This means you don’t have to draw the beginners attention to the difference between 1 and “1” until they are ready to notice it.

There is also no need to worry about anything beyond simple value assignment – there are no reference or pointer types. All you can do is store a value in a variable. You don’t even have to declare variables before using them. Using a variable is enough of a sign that you want to create some storage for a value.

So you can just write

myVariable=1 myString="Hello World"

The next simplification might have some programmer worried – all variables are global and they persist for the lifetime of the program. This may be worrying but it means that the beginner doesn’t have to worry about scope, shadowing or lifetimes. It is simple and it works for small programs. Once the beginner has the concept of variable, value and assignment well mastered then they can be introduced to scope and other matters but in some more appropriate language.

Control

The second issue in teaching a programming language is to deal with the flow of control and here I have a problem with Small Basic – it has labels and Goto. It also uses the Goto in many of its examples. The problem is that the Goto isn’t simple and it doesn’t carry over into other languages. Unlike the other simplifications of Small Basic that have to be extended when the beginner moves to a modern and more advanced language the Goto has to excised, removed, forgotten and generally trampled on. Why teach something so early that is unnecessary and that has to be unlearned?

There is one tiny excuse for including Goto and this is to teach the very primitive control structures that are found in the machine code and hence assembly language. Perhaps there is value in teaching how to create a loop and a conditional using a jump or Goto – but not to a complete beginner.

If you are using Small Basic to teach some one new and impressionable make sure to avoid the Goto at all costs.

So apart from the Goto and the label, of which no more will be said, what other control structures are there?

The good news is that the control structures are close to the original Basic forms which means they are also closer to the usual English expression of the same idea than the usual curly bracket equivalents.

The If statement takes the form:

if (condition) Then  statements Else  statements Endif

Where you can leave out the Else part if you want to create a simpler

if (condition) then   statements Endif

Small Basic also supports the usual two of the three structured programming loops – the for and the while.

The for loop takes the easier to use restricted form introduced by Basic:

For index=start To Stop Step increment   statements EndFor

Of course you can leave out the Step part of the instruction to create a simpler For loop that increments the index by one each time. For example:

For i=1 To 10   TextWindow.WriteLine(i) EndFor

This is so much easier to explain to a beginner than the C-style for loop

for(var i=1;i<11;i++){...}

which is much more general than a simple enumeration loop needs to be and reads like an arcane magical expression than something meaningful.

Notice that the For loop doesn’t end with the traditional Next statement but with an arguably more consistent EndFor. You can argue about this for hours. Next has the advantage of being an active instruction in the beginners minds at least in that it says “get the next value of the index and start the loop again” where the “Endfor” is just a terminating punctuation in the general syntax of the language – does it End the For in any active sense? No.

The conditional loop is supported in Small Basic via the While loop:

While(condition)  statements EndWhile

This provides a loop with an exit point at the start and so the loop can be used to create zero or more alterations.

You can program everything you want to using nothing but the For and While loop – in fact you really only need the While loop as it combined with the If statement are provably sufficient for any program. However it would be better if Small Basic also supported an Until loop. An Until loop has its exit point at the end and can be used to create one or more iterations. The distinction between While and Until is a subtle one however and something that can best be left for later. The big problem is that without and Until or without a Break statement the temptation is to use the Goto to create more complex loops – this is not good.

Prev – Next >>
Last Updated ( Wednesday, 12 December 2012 14:10 )

 

Developer Express Ad

RedditBaiduSlashdotStumbleUponDZone

ScaleOut Ad
Telerik Ad
Developer Express Ad
RSS feed of all content
I Programmer - full contents
Copyright © 2013 i-programmer.info. All Rights Reserved.
Joomla! is Free Software released under the GNU/GPL License.
Developer Express Ad

RedditBaiduSlashdotStumbleUponDZone
ScaleOut Ad
Telerik Ad
Developer Express Ad
RSS feed of all content
I Programmer - full contents
Copyright © 2013 i-programmer.info. All Rights Reserved.
Joomla! is Free Software released under the GNU/GPL License.

http://smallbasic.com/


aaaaaaaaaa

 

 

Featured programs

Collision Physics

Demonstrates object collisions using real world physics properties.  Tweak properties like    elasticity, gravity, etc. to see the effects.

Import ID = PMT149 Play

Soko Ban

A Small Basic port of the famous SokoBan puzzle game.  Quite possibly the most visually striking     game built on Small Basic.

Import ID = SOKO Play

Tetris

A faithful port of the famous Tetris game, this is the most popular and the most downloaded program on Small Basic.

Import ID = TETRIS Play

Small Challenge 1 – código Microsoft Small Basic


aabbcc Escriba un programa para calcular la suma de todos los números cuadrados de menos de 1.000. Un número cuadrado es el número de AA que tiene una raíz cuadrada del número entero, tal como 1, 4, 9, 16 etc

Program Listing: MJP126

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

TextWindow.Write(“Enter the value of n : “)

upto = TextWindow.ReadNumber()

TextWindow.WriteLine(” “)

t = Clock.ElapsedMilliseconds

method_first()

time[1] = Clock.ElapsedMilliseconds – t

t = Clock.ElapsedMilliseconds

method_second()

time[2] = Clock.ElapsedMilliseconds – t

t = Clock.ElapsedMilliseconds

method_third()

time[3] = Clock.ElapsedMilliseconds – t

timetaken()

Sub method_first

sum = 0

For n = 1 To upto

sum = sum + Math.Power(n,2)

EndFor

TextWindow.WriteLine(“Sum of first “+upto+” square number “+sum)

TextWindow.WriteLine(“_____________________________________________”)

EndSub

Sub method_second

sum = 0

n = upto

sum = (n*(n+1)*((2*n)+1)/6)

TextWindow.WriteLine(“Sum of first “+upto+” square number “+sum)

TextWindow.WriteLine(“_____________________________________________”)

EndSub

Sub method_third

odd = 1

temp = 0

sum = 0

For n = 1 To upto

temp = temp + odd

sum = sum + temp

odd = odd + 2

EndFor

TextWindow.WriteLine(“Sum of first “+upto+” square number “+sum)

TextWindow.WriteLine(“_____________________________________________”)

EndSub

Sub timetaken

For i = 1 To 3

TextWindow.WriteLine(“Time Taken by method “+i+” = “+time[i])

EndFor

EndSub

escribir un programa que contiene un ciclo For..EndFor (código Small Basic)


a4En 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.

TextWindow.Title = “Ciclos en Small Basic”
For a = 1 to 10
    TextWindow.WriteLine(a)
EndFor
 

Lenguajes de programación – Visual Studio .NET


bbbbbbLa elección de un lenguaje de programación depende de sus conocimientos del lenguaje y del ámbito de la aplicación que está generando. Las aplicaciones de pequeño tamaño se suelen crear utilizando un único lenguaje, y es frecuente implementar aplicaciones grandes utilizando varios lenguajes.

Por ejemplo, si está ampliando una aplicación con servicios Web de XML existentes, podría utilizar un lenguaje de secuencias que no requiera apenas tareas de programación. Para aplicaciones cliente-servidor, utilizaría probablemente el lenguaje del que tiene más conocimientos para toda la aplicación. Para nuevas aplicaciones empresariales, donde un equipo grande de programadores crea componentes y servicios para implementarlos en varios sitios remotos, la mejor opción sería utilizar varios lenguajes dependiendo de los conocimientos de los programadores y de las expectativas de mantenimiento a largo plazo.

Los lenguajes de programación de la plataforma .NET, incluidos Visual Basic .NET, Visual C# y las Extensiones administradas de C++, y otros lenguajes de distintos fabricantes, utilizan los servicios y características de .NET Framework a través de un conjunto común de clases unificadas. Las clases unificadas de .NET proporcionan un método coherente de acceso a la funcionalidad de la plataforma. Si aprende a utilizar la biblioteca de clases, observará que todas las tareas siguen la misma arquitectura uniforme. Ya no necesitará aprender ni administrar distintas arquitecturas API para escribir las aplicaciones.

En la mayoría de las situaciones, puede utilizar de manera eficiente todos los lenguajes de programación de Microsoft. Sin embargo, cada lenguaje de programación tiene sus puntos fuertes, y es recomendable comprender las características únicas para cada uno de ellos. Las secciones siguientes le ayudarán a seleccionar el lenguaje de programación que mejor se ajuste a su aplicación.

Visual Basic .NET

Visual Basic .NET es la nueva generación del lenguaje Visual Basic de Microsoft. Con Visual Basic puede generar aplicaciones .NET, incluyendo servicios Web y aplicaciones Web de ASP.NET, rápida y fácilmente. Las aplicaciones construidas con Visual Basic se generan con los servicios de Common Language Runtime y se benefician de .NET Framework.

Visual Basic tiene una gran cantidad de características nuevas y mejoradas como la herencia, las interfaces y la sobrecarga que la convierten en un lenguaje eficaz de programación orientado a objetos. Otras características nuevas del lenguaje son el subprocesamiento libre y el control de excepciones estructurado. Visual Basic integra .NET Framework y Common Language Runtime completamente, que conjuntamente proporcionan interoperabilidad del lenguaje, recolección de elementos no utilizados, seguridad ampliada y compatibilidad de versiones mejorada. Visual Basic admite herencia única y crea lenguaje intermedio de Microsoft (MSIL) como entrada de compiladores de código nativo.

Visual Basic es, comparativamente, fácil de aprender y utilizar, y se ha convertido en el lenguaje de programación elegido por cientos de programadores durante la pasada década. El conocimiento de Visual Basic se puede aprovechar de distintas maneras, por ejemplo, escribiendo macros en Visual Studio o programando en aplicaciones como Microsoft Excel, Access y Word.

Visual Basic proporciona prototipos de algunos de los tipos de proyectos más comunes, incluyendo:

  • Aplicación para Windows.
  • Biblioteca de clases.
  • Biblioteca de control de Windows.
  • Aplicación Web ASP.NET.
  • Servicio Web ASP.NET.
  • Biblioteca de control Web.
  • Aplicación de consola.
  • Servicio de Windows.

Para obtener más información, vea Lenguaje Visual Basic y Automatizar acciones repetitivas mediante macros.

Visual C# .NET

Visual C# (pronunciado “C sharp”) está diseñado para crear de manera rápida y fácil aplicaciones .NET, incluyendo servicios Web y aplicaciones Web ASP.NET. Las aplicaciones escritas en Visual C# se generan con los servicios de Common Language Runtime y se benefician de .NET Framework.

C# es un lenguaje orientado a objetos simple, elegante y con seguridad en el tratamiento de tipos que acaba de implementar Microsoft para generar una gran variedad de aplicaciones. Cualquiera que esté familiarizado con C y lenguajes similares, encontrará pocos problemas para adaptarse a C#. C# está diseñado para que el programador de C++ haga desarrollos rápidos, sin sacrificar la potencia y el control que constituyen el sello de C y C++. Gracias a esta herencia, C# tiene un alto grado de fidelidad con C y C++, y los programadores familiarizados con estos lenguajes pueden ser rápidamente productivos en C#. C# proporciona mecanismos intrínsecos de código de confianza para obtener un nivel alto de seguridad, la recolección de elementos no utilizados y la seguridad de tipos. C# admite herencia única y crea lenguaje intermedio de Microsoft (MSIL) como entrada de compiladores de código nativo.

C# está completamente integrado con .NET Framework y Common Language Runtime, que conjuntamente proporcionan interoperabilidad del lenguaje, recolección de elementos no utilizados, seguridad ampliada y compatibilidad de versiones mejorada. C# simplifica y moderniza algunos de los aspectos más complejos de C y C++, como los espacios de nombres, las clases, las enumeraciones, la sobrecarga y el control estructurado de excepciones. C# también elimina ciertas características de C y C++ como macros, herencia múltiple y clases base virtuales. Para los programadores de C++ actuales, C# proporciona un lenguaje alternativo de gran potencia y productividad.

Visual C# proporciona prototipos de algunos de los tipos de proyectos más comunes, incluyendo:

  • Aplicación para Windows.
  • Biblioteca de clases.
  • Biblioteca de control de Windows.
  • Aplicación Web ASP.NET.
  • Servicio Web ASP.NET.
  • Biblioteca de control Web.
  • Aplicación de consola.
  • Servicio de Windows.

Para obtener más información, vea Características de Visual C# Standard y Un paseo por el lenguaje C#.

Visual C++ .NET

Visual C++ .NET es la nueva generación del lenguaje Visual C++ de Microsoft. Visual C++ siempre se ha considerado el mejor lenguaje para crear aplicaciones de alto rendimiento para Microsoft Windows y World Wide Web.

Visual C++ proporciona un número importante de bibliotecas que le ayudan a escribir código para las aplicaciones, incluyendo la biblioteca ATL (Active Template Library, un conjunto de clases de C++ basadas en plantillas para objetos COM), Servidor Active Template Library (un conjunto de clases de C++ nativo para crear aplicaciones Web, servicios Web y otras aplicaciones de servidor) y Microsoft Foundation Classes (un conjunto de clases compatibles con aplicaciones escritas para la API de Windows).

Visual C++ proporciona prototipos de algunos de los tipos de proyectos más comunes, incluyendo:

  • Proyecto de biblioteca ATL (Active Template Library).
  • Proyecto de servidor ATL.
  • Servicio Web de servidor ATL.
  • Asistente personalizado para aplicaciones.
  • Archivo DLL para procedimientos almacenados extendidos.
  • Proyecto de archivos MAKE.
  • Servicio Web ASP.NET
  • Biblioteca de clases (.NET)
  • Aplicación de consola (.NET)
  • Biblioteca de controles de Windows (.NET)
  • Aplicación de formularios Windows Forms (.NET)
  • Servicio de Windows (.NET)
  • Control ActiveX de biblioteca      MFC (Microsoft Foundation Classes).
  • Aplicación MFC.
  • Archivo DLL de MFC.
  • Archivo DLL de extensión ISAPI MFC.
  • Proyecto Win32.

Para obtener más información, vea Visual C++ y Visual C++ .NET Standard.

Extensiones administradas de C++

Si está creando una nueva aplicación o componente, puede utilizar sus conocimientos actuales de C++ para escribir código administrado con las extensiones administradas de C++. Cuando utiliza las extensiones administradas, obtiene los beneficios de la compatibilidad y de los servicios que proporciona Common Language Runtime (como la administración de memoria, integración entre lenguajes, seguridad de acceso a código y control automático de la vida de los objetos).

Las extensiones administradas de C++ también permiten integrar aplicaciones existentes en .NET Framework de una manera sencilla. Por ejemplo, es posible que necesite portar código no administrado a .NET. Como ya ha compilado previamente bibliotecas estáticas y vinculadas, archivos DLL y distintas clases de C++ no administradas, sólo necesita compilar el código Win32 existente como una aplicación .NET. Después, si dispone de tiempo, puede rediseñar los componentes para beneficiarse de las características del código administrado.

Para obtener más información, vea Extensiones administradas de la programación en C++.

Transact-SQL

Transact-SQL es el lenguaje nativo para almacenar, modificar y recuperar información de bases de datos relacionales de Microsoft SQL Server. También puede utilizar Transact-SQL para crear bases de datos y cualquiera de los objetos que se almacenan en una base de datos, como tablas, columnas, disparadores, claves, índices, vistas, procedimientos almacenados y funciones. Transact-SQL es totalmente compatible con el editor de Visual Studio y con los diseñadores suministrados con Visual Database Tools.

Nota   Visual Database Tools también se puede conectar a una base de datos Oracle. Cuando se utiliza una base de datos Oracle, Visual Database Tools controla correctamente la sintaxis SQL específica de Oracle. Para obtener información detallada, vea Bases de datos Oracle.

Para obtener más información, vea SQL Server 2000 y Visual Database Tools.

Lenguajes de secuencias

Ya que las aplicaciones para Internet están en el punto de mira tecnológico, se van a seguir desarrollando soluciones para problemas de programación asociados al cálculo distribuido. Los lenguajes de secuencia, en general, no son nuevos, pero algunos de los más útiles acaban de salir al mercado. Con los nuevos lenguajes de secuencia, puede ejecutar las secuencias de comandos fácilmente desde un escritorio local o desde una consola remota para controlar tareas administrativas y eventos de programas.

Windows Scripting Host

Windows Scripting Host (WSH) es un entorno de secuencias independiente del lenguaje para plataformas Windows de 32 bits. Con WSH, Microsoft ofrece los motores de secuencias VBScript, JScript y JScript .NET. Estos lenguajes de secuencias se pueden utilizar en las páginas ASP de un servidor Web, en las páginas HTML que se ejecutan en Internet Explorer y en los motores de secuencias de Windows Scripting Host en Windows 98 y Windows 2000.

WSH puede automatizar tareas administrativas en el servidor utilizando cualquier lenguaje de secuencias. Por ejemplo, un administrador puede escribir código VBScript para crear un directorio virtual nuevo y, después, con WSH ejecutándose en segundo plano, ejecutar el archivo de secuencias desde la línea de comandos para crear el nuevo directorio virtual en el sitio Web. Además, los administradores pueden escribir una única secuencia de comandos para múltiples sitios Web o servidores físicos.

Organizaciones de terceros proporcionan motores de secuencias ActiveX para otros lenguajes como Perl, TCL, REXX y Python.

Para obtener más información, vea Windows Scripting Host.

VBScript

Microsoft Visual Basic Scripting (VBScript) es un subconjunto de Microsoft Visual Basic, y le resultará familiar si ya ha utilizado Visual Basic. Sin embargo, no son idénticos. Como VBScript está diseñado específicamente para trabajar en exploradores de Internet Explorer (IE), no incluye características que se encuentran normalmente fuera del ámbito de las secuencias de comandos, como el acceso e impresión de archivos. No obstante, es muy frecuente utilizar el objeto FileSystem con VBScript para manipular archivos.

VBScript le proporciona secuencias de comandos activas para una gran variedad de entornos, incluyendo secuencias de cliente Web en IE y secuencias de servidor Web en Microsoft Internet Information Services (IIS), Microsoft Internet Security and Acceleration Server (ISA) y Sun Solaris. VBScript es un lenguaje de secuencias orientado a objetos, rápido, portátil e interpretado que procesa código fuente incrustado directamente en páginas HTML. Puede utilizar VBScript para agregar inteligencia e interactividad a páginas WSH, ASP y HTML.

Al igual que JSCript, VBScript se comunica con las aplicaciones principales mediante Windows Scripting. Con Windows Scripting, los exploradores y otras aplicaciones principales no necesitan ningún código de integración especial para cada componente de ejecución de secuencias de comandos. Windows Scripting permite que un host compile secuencias de comandos, obtenga y llame a puntos de entrada y administre el espacio de nombres disponible para el programador.

VBScript es un lenguaje en el que no se necesita declarar los tipos de datos. Esto significa que no es necesario declarar explícitamente los tipos de datos de las variables. De hecho, no se pueden declarar explícitamente los tipos de datos en VBScript. Además, en muchos casos VBScript realiza conversiones de forma automática cuando es necesario. Por ejemplo, si agrega un número a un elemento que contiene texto (una cadena), el número se convierte en texto.

Para obtener más información, vea Guía de usuario de VBScript. VBScript se incluye con IE, IIS e ISA, o puede descargarlo del sitio Web de tecnologías Microsoft Windows Scripting ((http://www.microsoft.com/latam/windows2000/datacenter/default.asp).

JScript

Microsoft JScript se ha diseñado para programar secuencias de comandos en páginas Web. JScript cumple la especificación de lenguaje ECMA 262. JScript es un eficaz lenguaje de secuencias de comandos especialmente orientado a Internet. Al igual que VBScript, JScript es un lenguaje de secuencias orientado a objetos e interpretado, que procesa código fuente incrustado directamente en páginas HTML. JScript se ejecuta tanto en exploradores de Internet Explorer como de Netscape.

Como VBSCript, JScript se comunica con las aplicaciones principales mediante Windows Scripting Host. Con Windows Scripting Host, los exploradores y otras aplicaciones principales no necesitan ningún código de integración especial para cada componente de ejecución de secuencias de comandos. Windows Scripting Host permite que un host compile secuencias de comandos, obtenga y llame a puntos de entrada y administre el espacio de nombres disponible para el programador.

JScript es un lenguaje en el que no se necesita declarar los tipos de datos. Esto significa que no es necesario declarar explícitamente los tipos de datos de las variables. De hecho, no se pueden declarar explícitamente los tipos de datos en JScript. Además, en muchos casos JScript realiza conversiones de forma automática cuando es necesario. Por ejemplo, si agrega un número a un elemento que contiene texto (una cadena), el número se convierte en texto.

Para obtener más información, vea JScript.

JScript .NET

JScript .NET es la siguiente generación de la implementación por parte de Microsoft del lenguaje ECMA 262, desarrollado junto con ECMAScript Edition 4. Está diseñado para ejecutarse en Common Language Runtime con el fin de administrar la ejecución de código y ofrecer servicios que faciliten el proceso de desarrollo. JScript .NET proporciona integración entre lenguajes, control de excepciones entre lenguajes, seguridad ampliada, compatibilidad de versiones e implementaciones, un modelo simplificado para la interacción de componentes y servicios de depuración y de perfiles.

Combinando el conjunto de características que proporciona el lenguaje JScript clásico (completamente compatible) con Common Language Runtime y las mejores características de lenguajes basados en clases, JScript .NET le ofrece la mejor de las opciones. Entre las mejoras de JScript .NET, cabe destacar: código compilado, variables con tipos y sin tipos, clases (con herencia, sobrecarga de funciones, descriptores de acceso de propiedades, etc.), paquetes, compatibilidad entre lenguajes y acceso a .NET Framework.

Para obtener más información, vea Lo nuevo en JScript .NET.

Lenguaje de marcado extensible (XML)

XML proporciona un formato para describir datos estructurados que permite precisar declaraciones de contenido y resultados de búsqueda útiles entre múltiples plataformas. XML define información y datos de acuerdo a una finalidad más que por motivos de presentación, por lo que varias aplicaciones pueden utilizar la información y los datos de distintas formas y conseguir reutilizaciones diversas de la aplicación y extensibilidad. XML es un lenguaje de metamarcado cada vez más importante, cuyo uso es muy útil en Internet.

Tenga en cuenta que los distintos Servidores empresariales de Windows Server 2003 Enterprise Edition admiten XML como formato de intercambio de datos. Por ejemplo, la característica XML SQL de SQL Server 2000 hace posible que las aplicaciones .NET obtengan los resultados de consultas a la base de datos como documentos XML en lugar de como conjuntos de resultados relacionales. Como tecnología importante de la plataforma .NET, XML está creando una nueva generación de servicios basados en Web para clientes y proveedores.

XML no reemplaza a HTML. Aunque ambos son lenguajes de marcado, funcionan de manera complementaria. La potencia de HTML se basa en la presentación de la información, mientras que XML es excelente para describir la información. La potencia de XML radica parcialmente en su habilidad para separar la interfaz de usuario de los datos mostrados, permitiendo así el rendimiento entre plataformas.

En arquitecturas de aplicaciones distribuidas, la mensajería XML permite que los datos se muevan fácilmente a través de servidores de seguridad y entre sistemas heterogéneos utilizando mecanismos de transporte estándar. Para cualquier cosa que requiera la aplicación, como importar, exportar, intercambiar datos, interoperar con otras aplicaciones (como Office 2000 o Exchange 2000), analizar, modificar, tener acceso a datos, almacenar datos, etc., XML es un formato de intercambio de datos muy fácil de utilizar. Visual Studio .NET incluye algunas herramientas excelentes para trabajar con XML y su lenguaje de programación favorito.

Para obtener más información, vea XML en Visual Studio.

Visual J++

Microsoft proporciona Java User Migration Path para Microsoft .NET (JUMP para .NET) como un conjunto de tecnologías y servicios que permite a los programadores mantener, ampliar y migrar proyectos en lenguaje Java en la plataforma Microsoft .NET. Con JUMP para .NET puede aprovechar los conocimientos en Visual J++ y el código fuente existente mientras extiende la aplicación y los componentes en la plataforma .NET. Si está familiarizado con el lenguaje Visual J++, puede utilizarlo para crear nuevas aplicaciones .NET o para migrar fácilmente código existente al nuevo lenguaje C# mediante herramientas de migración automatizadas.

Para obtener más información, vea el sitio Web de Microsoft Visual J++ (http://www.microsoft.com/windows2000/server/default.asp).

Lenguajes alternativos

Microsoft está asociado con muchas organizaciones para incorporar sus lenguajes en la plataforma .NET. Además de los lenguajes proporcionados por Microsoft, existen varios lenguajes alternativos que se admiten en la plataforma .NET, incluyendo:

  • COBOL para Microsoft .NET.
  • Perl para Microsoft .NET.
  • Eiffel para Microsoft .NET.
  • Python para Microsoft .NET.
  • Pascal para Microsoft .NET.
  • Mercury para Microsoft .NET.
  • Mondrian para Microsoft .NET.
  • Oberon para Microsoft .NET.
  • Salford FTN95 (Fortran) para Microsoft .NET.
  • SmallTalk para Microsoft .NET.
  • ML estándar para Microsoft .NET.
  • Dyalog APL para Microsoft .NET.

La flecha sigue el movimiento del mouse (código)


aaaaa

Construído en Small y Basic y graduado a Visual Basic  Microsoft Small Basic  Program Listing SFP468

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

Código Small Basic

Arrow = Shapes.AddImage(“http://cdn4.iconfinder.com/data/icons/markerstyle_icons/PNG/64px/arrow-right.png&#8221;)
Shapes.Move(Arrow,200,200)
While 1 = 1
  Program.Delay(5)
  difx = GraphicsWindow.MouseX – 200
  dify = GraphicsWindow.MouseY – 200
  If difx > 0 Then
    Angle = Math.GetDegrees(Math.ArcTan(dify / difx))
  ElseIf difx < 0 Then
    Angle = Math.GetDegrees(Math.ArcTan(dify / difx)) + 180
  ElseIf difx = 0 And dify > 0 Then
    Angle = 90
    EndIf
    Shapes.Rotate(Arrow,Angle)
    Endwhile

 

Código Visual Basic

Module UntitledModule

    Dim Arrow, difx, dify, Angle As Primitive

    Sub Main()

        GraphicsWindow.BackgroundColor = “Yellow”

        Arrow = Shapes.AddImage(“http://cdn4.iconfinder.com/data/icons/markerstyle_icons/PNG/64px/arrow-right.png&#8221;)

        Shapes.Move(Arrow, 200, 200)

        While 1 = 1

            Program.Delay(5)

            difx = GraphicsWindow.MouseX – 200

            dify = GraphicsWindow.MouseY – 200

            If difx > 0 Then

                Angle = Microsoft.SmallBasic.Library.Math.GetDegrees(Microsoft.SmallBasic.Library.Math.ArcTan(dify / difx))

            ElseIf difx < 0 Then

                Angle = Microsoft.SmallBasic.Library.Math.GetDegrees(Microsoft.SmallBasic.Library.Math.ArcTan(dify / difx)) + 180

            ElseIf (difx = 0) And (dify > 0) Then

                Angle = 90

            End If

            Shapes.Rotate(Arrow, Angle)

        End While

 

    End Sub

End Module

 

 

The Official Blog of Small Basic


ab2

Small Basic

Small Basic Program Gallery  Ed Price – MSFT

The goal is that this list contains a lot of Small Basic programs. We’re looking for interactive programs that are easy to use, fun, and have little to no learning curve.

To browse a larger variety of programs that are listed categorically, see Small Basic Program Gallery – Listed By Category. Categories include Games, Graphical, Math, Physics, Productivity Apps, Sciences (Other), Sound, and Text.

You should also come back later, because this list will evolve over time.

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

6 Lessons to learn Small Basic and graduate to Visual Basic!


 

Lesson 1: Getting Started with Small Basic

Lesson 1.1: Introduction to Small Basic – Estimated time to complete this sub-lesson: 30 minutes

ab1

Lesson 1.2: Statements, Properties, and Operations – Estimated time to complete this sub-lesson: 1 hour

Lesson 1.3: Variables – Estimated time to complete this sub-lesson: 1 hour

Lesson 1.4: Conditions and Loops – Estimated time to complete this sub-lesson: 1 hour

Lesson 1.5: Branching and Subroutines – Estimated time to complete this sub-lesson: 1 hour

Lesson 2: Graphics Window

Lesson 2.1: Introduction to Graphics Window – Estimated time to complete this sub-lesson: 1 hour

ab2

Lesson 2.2: Turtle Graphics – Estimated time to complete this sub-lesson: 1 hour

Lesson 2.3: Exploring Shapes – Estimated time to complete this sub-lesson: 1 hour

Lesson 2.4: Sound, Program, and Text Objects – Estimated time to complete this sub-lesson: 1 hour

Lesson 2.5: Clock, Desktop, and Dictionary Objects – Estimated time to complete this sub-lesson: 1 hour

Lesson 2.6: Flickr, ImageList, and Network Objects – Estimated time to complete this sub-lesson: 1 hour

Lesson 3: Input and Output

Lesson 3.1: File Input and Output – Estimated time to complete this sub-lesson: 1 hour

aa23

Lesson 3.2: Stacks and Arrays – Estimated time to complete this sub-lesson: 1 hour

Lesson 3.3: The Math Object – Estimated time to complete this sub-lesson: 1 hour

Lesson 3.4: Events and Interactivity – Estimated time to complete this sub-lesson: 1 hour

Lesson 3.5: The Controls Object – Estimated time to complete this sub-lesson: 1 hour

Lesson 3.6: Debugging Aids – Estimated time to complete this sub-lesson: 1 hour

Lesson 4: Making Your Game

Lesson 4.1: Playing with Shapes – Estimated time to complete this sub-lesson: 1 hour

Lesson 4.2: Responding to Events – Estimated time to complete this sub-lesson: 1 hour

Lesson 4.3: Collision Detection – Estimated time to complete this sub-lesson: 1 hour

ab4

Lesson 4.4: Advanced Games – Estimated time to complete this sub-lesson: 1 hour

Lesson 5: Share

Lesson 5.1: Sharing Code – Estimated time to complete this sub-lesson: 1 hour

ab5

Lesson 6: Graduation Ceremony

Lesson 6: Graduating to Visual Basic – Estimated time to complete this sub-lesson: 1 hour

ab6

Anybody make it through all 6 lessons? And post a comment if you have a better time estimate for these sub-lessons!

– Tall Basic Ed

small basic, Ed Price, 10C+, tutorials, 3K+, 5K+, 7K+

¿Qué tipo de opciones están disponibles para los profesores que quieran dar a los estudiantes el reto adicional que Small Basic puede ofrecer?


a1

Ed Price & Small Basic – Microsoft

Echa un vistazo a empezar con Small Basic. Tenemos el libre Guía de Inicio y el Currículo Básico Pequeño (que incluye material escrito y las cubiertas de PowerPoint hechas profesionalmente para la enseñanza en el aula, y los libros de bajo costo y los campos de nuestros diversos socios). Esperamos actualizar la página con más estrategias curriculares y opciones a medida que continuamos perseguir la integración de Small Basic en la educación.
Small Basic es único porque introduce el código como un concepto de primera clase, que es lo que finalmente va a tiene que acercarse a la informática. Kodu es algo que siempre puede volver a con el fin de crear fácilmente mundos divertidos y entornos 3D.

El paso más importante es el primer paso. Trate de dedicar un minuto al día para revisar Small Basic. Instálalo y explorar lo que es posible. En poco tiempo, usted estará en el software o juego de la industria de la creación de nuestras próximas generaciones de tecnología.
________________________________________
Nos gustaría dar las gracias a Ed por tomarse el tiempo de su día ocupado para responder a nuestras preguntas! Si usted está buscando algunos desafíos adicionales en sus aventuras de codificación o se siente listo para llevar las cosas al siguiente nivel, por qué no darle una oportunidad Small Basic? O, si eres curioso acerca de las posibilidades, ¿por qué no tomar un momento para jugar Tankinator, la Presa extranjero, ambas hechas en Small Basic?

http://koduwebdnn.cloudapp.net/Home/tabid/55/forumid/4/threadid/1035/scope/posts/Default.aspx

¿Qué tipo de lecciones pueden los estudiantes aprender en Small Basic?


a1Ed Price – MSFT  Microsoft
Usted aprenderá los conceptos básicos de forma rápida y sencilla porque se aprende en el entorno más sencillo. BASIC se inició en 1964 y representa todo uso Código de Instrucciones Simbólicas para principiantes. Fue creado para enseñar el desarrollo de software. Así, le ofrecemos una versión que es aún más sencilla y más adecuada para conseguir que la puesta en funcionamiento, escribiendo su propio código, y la comprensión de conceptos básicos de programación, aún más rápido. Estos conceptos básicos son variables, condiciones y ramificación, Loops, gráficos, formas, subrutinas, matrices, y Eventos y la interactividad.
Siga uno de nuestros tutoriales, y es probable que recoger estos conceptos mucho más rápidamente por su cuenta (y aún más rápido con un mentor ayuda a usted) que lo haría en un salón de clases, donde se puede aprender los conceptos, por primera vez, en un lenguaje más complicado. Usted aprenderá todos los bloques de construcción fundamentales de lenguajes como Visual Basic, C + +, C #, y muchos más.

http://blogs.msdn.com/b/smallbasic/archive/2013/03/29/what-sort-of-lessons-can-students-learn-in-small-basic-kodu-community-spotlight-part-1.aspx?CommentPosted=true#commentmessage

Small Basic – Elementary & Middle Student Testimonials


a1Microsoft

Ed Price MSFT

168,594 Points 25 20 18

Recent Achievements

Forums Replies V Proposed Answerer III Gallery Contributor II

View Profile

Thu, Oct 25 2012 3:02 PM

  • Comments 25

Last Updated: 4/12/13

This blog post is a work in progress. It will grow as we collect testimonials. Please add to it by leaving comments below. Please include the age and grade of the child and then a paragraph that explains how well the student was able to learn Small Basic. It can be a story, an example, or in any form you’d like. We’ll list the youngest students at the top. We’re looking for students age 1-13.

http://blogs.msdn.com/b/smallbasic/archive/2012/10/25/small-basic-elementary-student-testimonials.aspx

Community Spotlight: Ed Price & Small Basic


edGreetings, Kodu Community!

In today’s Community Spotlight, we’d like to introduce you to Microsoft employee Ed Price, an enthusiastic advocate of Small Basic. Once we learned about Small Basic, it was easy to see why it should be considered by many as the next logical step after Kodu on the ladder of learning in computer programming. He volunteered to chat with us recently and tell the community all about it.


Can you tell us a little bit about yourself and how you got involved with Small Basic?
Hello! I’m Ed Price. My connection to Small Basic is more like a small jigsaw puzzle, so I have to start by explaining the puzzle pieces of my background. I work on Customer Programs in the Data Platform Group. I’ve been working in Microsoft’s Server and Tools division (which includes developer software) since 2009, helping further the progress of Microsoft community tools and environments such as TechNet Wiki and MSDN Forums.

When I was helping build self-sustaining communities in the MSDN Forums, I saw first-hand how passionate and vibrant the Small Basic community was. I saw how it was teaching youth, from age 8-13, how to learn programming and become professional-level software developers before they even graduate high school.

See more  in http://koduwebdnn.cloudapp.net/Home/tabid/55/forumid/4/threadid/1035/scope/posts/Default.aspx

Juego de Basket


basket

Microsoft Small Basic   Program Listing: mmq961-1

‘ Challenge of the month August 2012 Free throw basketball by NaochanON MMQ961-1

‘ Throwed ball traced

‘ Click ball , move(slide) ball and release ball within blue circle

GUI()

GraphicsWindow.MouseDown=Onmousedown

GraphicsWindow.MouseMove=Onmousemove

GraphicsWindow.Mouseup=Onmouseup

While “true”

If move=”true” Then

Shoot()            ‘ ball is throwed

Goalcheck()        ‘ if ball goals in or not

Goalin()           ‘ ball goes down throgh goal net

EndIf

Program.Delay(20)

endwhile

sub Goalin

If goal=”true” Then

Vx=0

newx=RX+(RW-BD)/2                 ‘ ball falling position

Vy=Vy/3                           ‘ ball falling speed

Gravity=Gravity*0.8

If (PY+BD/2)<Shapes.GetTop(BBall) and Shapes.GetTop(BBall)<(PY+BD) Then

For i=1 To 11

Shapes.Rotate(line[i],10)      ‘ goal net swings

EndFor

Program.Delay(50)

EndIf

If (PY+BD)<Shapes.GetTop(BBall) then

staynet()                        ‘ Net return initial state

Gravity=7

EndIf

endif

EndSub

Sub staynet

For i=1 To 11

Shapes.Rotate(line[i],0)           ‘ goal net stay

EndFor

EndSub

Sub goalcheck

If goal=”false” and RX<newx And newx<RX+RW-BD and  math.Abs(newY-PY)<BD/2 Then

Shapes.SetText(smsg,” Goal !!!!! “)

Shapes.Animate(smsg,1000,150,1500)

goal=”true”

MM=MM+1                            ‘ count up goals

resultshow()

EndIf

endsub

Sub resultshow

result=” Click , move(slide) and release ball within blue circle. ” +Text.GetCharacter(10)+ ” Throwing = “+NN +” times Goal= “+MM+” times”

Shapes.SetText(sresult,result)

EndSub

Sub Shoot

dn=dn+1

Shapes.ShowShape(gball[dn])           ‘ trace ball

Shapes.Move(gball[dn],newx,newy)

t3=clock.ElapsedMilliseconds

newx=newx-vx*PM

newy=newy-vy +(t3-t2)*(t3-t2)*Gravity/2/1000000

Shapes.Move(BBall,newx,newy)

GraphicsWindow.Title=”Now Ball X= “+math.Floor(newx)+ ” Y= “+math.Floor(newy)+” Vx = “+math.Floor(Vx) + ” Vy = “+math.Floor(Vy)

If (RX-PW<newx and newx<RX+4)   And (PY-PH/2-BD/2<newY And newY<PY) Then ‘ if ball taches the panel

PM=-1

EndIf

If GH-BD-20<newy Then

move=”false”

newx=0

newy=0

Shapes.Animate(BBall,x0,y0,4000)   ‘ ball backs initial position

Program.Delay(4000)

Shapes.Move(smsg,-100,-50)         ‘ hide goal message

GraphicsWindow.Title=”Now Ball is “+X0+ ” : “+Y0

For i=1 To dn

Shapes.HideShape(gball[i])

EndFor

dn=0

EndIf

EndSub

Sub onmousedown

gx= GraphicsWindow.MouseX

gy= GraphicsWindow.MouseY

If math.Abs(gx-x0)<50 And math.Abs(gy-y0)<50 Then

NN=NN+1

PM=1

catch=”true”

goal=”false”

Gravity=9.8

t1=clock.ElapsedMilliseconds        ‘ ball caught time

resultshow()                        ‘ result

staynet()                           ‘ Net return initial state

EndIf

endsub

Sub onmousemove

If catch=”true” Then

gx1= GraphicsWindow.MouseX

gy1= GraphicsWindow.MouseY

Shapes.Move(BBall,gx1,gy1)

r=Math.SquareRoot((gx1-x0)*(gx1-x0)+ (gy1-y0)*(gy1-y0))  ‘ distance from initial position

If r>410 Then

onmouseup()                       ‘ forced throwing

endif

EndIf

endsub

Sub onmouseup

If catch=”true” Then

gx2= GraphicsWindow.MouseX

gy2= GraphicsWindow.MouseY

t2=clock.ElapsedMilliseconds        ‘ Ball release time

catch=”false”

Vx=(gx-gx2)/(t2-t1)*10              ‘ Ball speed X

Vy=(gy-gy2)/(t2-t1)*10              ‘ Ball speed Y

newx=shapes.GetLeft(BBall)

newy=shapes.Gettop(BBall)

Move=”true”

EndIf

endsub

Sub GUI

GraphicsWindow.Show()

GraphicsWindow.Hide()

GraphicsWindow.Top=20

GraphicsWindow.Left=20

‘—————- initial value ———————-

GW=1200

GH=650

GraphicsWindow.BackgroundColor=”Darkgreen”

GraphicsWindow.Width=GW

GraphicsWindow.Height=GH

GraphicsWindow.BrushColor=”Lightcyan”

GraphicsWindow.PenColor=”Navy”

GraphicsWindow.PenWidth=3

circle= Shapes.AddEllipse(800,800)   ‘ throwing circle

Shapes.Move(circle,GW-400,GH-400)

‘—————- basketball ———————-

BD=50

GraphicsWindow.BrushColor=”lightgray”

GraphicsWindow.penColor=”gray”

For i=1 To 300

gball[i]=Shapes.AddEllipse(BD,BD)  ‘ trace ball

Shapes.Move(gball[i],1200,900)

Shapes.HideShape(gball[i])

endfor

GraphicsWindow.BrushColor=”Brown”

GraphicsWindow.PenColor=”Coral”

X0=GW-BD

Y0=GH-BD

BBall= Shapes.AddEllipse(BD,BD)

Shapes.Move(BBall,X0,Y0)

‘—————- Message ———————-

GraphicsWindow.BrushColor=”Yellow”

GraphicsWindow.FontSize=25

GraphicsWindow.FontItalic=”True”

smsg=shapes.AddText(” “)

Shapes.Move(smsg,-100,-50)

result=” Click , move(slide) and release ball within blue circle. ” +Text.GetCharacter(10)+ ” Throwing = “+NN +” times Goal= “+MM+” times”

sresult=shapes.AddText(result)

Shapes.Move(sresult,200,10)

‘—————- Goal Net ———————-

GraphicsWindow.BrushColor=”Yellow”

PW=20                                  ‘ Panel Width

PH=200                                 ‘ Panel Height

PY=200                                 ‘ Panel position Y

RX=90                                  ‘ Ring position X

RW=110                                 ‘ Ring width

panel=shapes.AddRectangle(PW,PH)

GraphicsWindow.BrushColor=”Darkgreen”

Ring=shapes.AddRectangle(RW,10)

GraphicsWindow.PenColor=”lightcyan”

For i=1 To 11

line[i]=Shapes.AddLine(0+10*i,0,30+5*i,100)    ‘ Net

EndFor

setgoal()

GraphicsWindow.Show()

‘————————————–

catch=”false”

NN=0

MM=0

EndSub

Sub setgoal

Shapes.Move(panel,RX-PW,PY-PH/2)

Shapes.Move(ring,RX,PY)

For i=1 To 11

Shapes.Move(line[i],RX,PY)

EndFor

Endsub

Small Basic: Resolver ecuaciones cuadráticas (código)


aa23

De la biblioteca Program Listing:   http://smallbasic.com/program/?CXK936

Código:

TextWindow.Title=”Quadratic Equation Solver© – Brought to you by Sam Christy”
TextWindow.ForegroundColor=”Green”
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

El mouse y Small Basic (código)


a1

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

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

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

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

‘ Prueba con el mouse

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

GraphicsWindow.Title = “Prueba con el ratón”

GraphicsWindow.BackgroundColor = “White”

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

isMovingBox = “False”

size = 42

sep = size / 2

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

x = GraphicsWindow.Width / 2 – sep

y = GraphicsWindow.Height / 2 – sep

GraphicsWindow.PenColor = “Black”

GraphicsWindow.BrushColor = “SteelBlue”

square = Shapes.AddRectangle(42, 42)

Shapes.Move(square, x, y)

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

GraphicsWindow.KeyDown = OnKeyDown

GraphicsWindow.MouseMove = OnMouseMove

GraphicsWindow.MouseDown = OnMouseDown

GraphicsWindow.MouseUp = OnMouseUp

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

Sub OnKeyDown

If GraphicsWindow.LastKey = “S” Then

Mouse.ShowCursor()

ElseIf GraphicsWindow.LastKey = “H” Then

Mouse.HideCursor()

ElseIf GraphicsWindow.LastKey = “Up” Then

Mouse.MouseY = Mouse.MouseY – 10

ElseIf GraphicsWindow.LastKey =
“Down” Then

Mouse.MouseY = Mouse.MouseY + 10

ElseIf GraphicsWindow.LastKey = “Left” Then

Mouse.MouseX = Mouse.MouseX – 10

ElseIf GraphicsWindow.LastKey = “Right” Then

Mouse.MouseX = Mouse.MouseX + 10

EndIf

EndSub

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

Sub OnMouseMove

If isMovingBox Then

x = GraphicsWindow.MouseX – distx

y = GraphicsWindow.MouseY – disty

Shapes.Move(square, x, y)

EndIf

EndSub

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

Sub OnMouseDown

If Mouse.IsLeftButtonDown Then

ActivateMove()

ElseIf Mouse.IsRightButtonDown Then

endl = Text.GetCharacter(13)

endl = endl + Text.GetCharacter(10)

aux = “Global mouse coords”+endl

aux = aux+”X = “+Mouse.MouseX+endl

aux = aux+”Y = “+Mouse.MouseY+endl

aux = aux+”Local mouse coords” + endl

aux = aux+”X = “+GraphicsWindow.MouseX+endl

aux = aux+”Y = “+GraphicsWindow.MouseY

GraphicsWindow.ShowMessage(aux, “Mouse Info”)

EndIf

EndSub

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

Sub ActivateMove

x1 = Shapes.GetLeft(square)

y1 = Shapes.GetTop(square)

x2 = x1 + size

y2 = y1 + size

mx = GraphicsWindow.MouseX

my = GraphicsWindow.MouseY

If x1<=mx And mx<=x2 And y1<=my And my<=y2 Then

distx = mx – x1

disty = my – y1

isMovingBox = “True”

EndIf

EndSub

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

Sub OnMouseUp

isMovingBox = “False”

EndSub

http://mssbesp.wordpress.com/2009/05/11/el-raton-y-small-basic/

Comparación de VBA y VSTO


a1

Microsoft Visual Basic for Aplicaciones (VBA) utiliza código no administrado que está perfectamente integrado con las aplicaciones de Office. Los proyectos de Microsoft Office creados con Visual Studio 2010 le permiten aprovechar las herramientas de diseño de Visual Studio y .NET Framework.

La tabla siguiente proporciona una comparación básica entre las soluciones VBA y soluciones de Office en Visual Studio.

Soluciones VBA

Soluciones Office con Visual Studio (VSTO)

Usa código que está conectado y se almacenan con un documento concreto.

Usa código que se almacena por separado desde el documento (para las personalizaciones a nivel de documento) o en un ensamblado que carga la aplicación (para complementos a nivel de aplicación).

Funciona con los modelos de objetos de Office y las API de VBA.

Proporciona acceso a modelos de objetos de Office y las API de .NET Framework.

Diseñado para la grabación de macros y una experiencia simplificada para el desarrollador.

Diseñado para que la seguridad, facilitar el mantenimiento de código y la capacidad para utilizar el completo entorno de desarrollo integrado (IDE) de Visual Studio.

Funciona bien para soluciones que se benefician de una integración muy estrecha con aplicaciones de Office (IDE, menús, botones de barra de herramientas etc.).

Funciona bien para soluciones que se benefician de todos los recursos de Visual Studio y .NET Framework.

Tiene limitaciones para la empresa, especialmente en las áreas de seguridad e implementación.

Diseñado para su uso en la empresa.

http://msdn.microsoft.com/es-ar/office/ff458124#Comparisonchart

 

Guía básica de desarrollo de Excel


a1

Los desarrolladores de soluciones de Excel pueden tener acceso a la potencia de Excel directamente desde sus aplicaciones. Use la Guía para desarrolladores de Excel para encontrar referencias, ejemplos de código, artículos, capítulos del libro y vídeos de procedimientos para desarrollar soluciones de Excel. Le agradecemos sus comentarios o preguntas sobre este contenido. Puede enviar los comentarios sobre la Guía para desarrolladores de Excel a docthis@microsoft.com.

Visual   Basic para Aplicaciones (VBA) Código   administrado (Visual Studio, VSTO) XLL y   HPC Interfaz   de usuario de Fluent Excel   Services OpenXML

http://msdn.microsoft.com/es-ar/office/ff458124

Funciones matemáticas en Small Basic


a1

http://mssbesp.wordpress.com/2009/05/04/las-matematicas-y-small-basic/

Como hemos podido ver en la introducción, Small Basic apenas tiene demasiados operadores y aunque posiblemente con los cuatro básicos podríamos hacer cualquier operación, eso no quita que sea más cómodo que tengamos a nuestro alcance algunas operaciones básicas para ahorrarnos el tedioso trabajo de reinventar la rueda. Por ello tenemos a nuestro alcance la librería Math, que recoge una serie de operaciones para poder realizar cálculos ya un poco más complejos que sumar o multiplicar números. Aquí está la lista de atributos y operaciones soportadas en la librería:

  • Pi: Devuelve el valor      numérico de Pi (3,141592653589793 aproximadamente).
  • GetRandomNumber(númeroMáximo): Devuelve      un número aleatorio entre 1 y el número que le hemos pasado.
  • Max(número1, número2):      Devuelve el mayor valor de entre dos números.
  • Min(número1, número2):      Devuelve el menor valor de entre dos números.
  • Abs(número): Devuelve el      valor absoluto de un número.
  • Round(número): Devuelve el      número que le hemos dado convertido en un entero redondeado. Las reglas      para el redondeo son que si el número está en el intervalo x + [0.0,      0.5) devolverá el entero menor o igual al que le hemos dado, si está      en x + (0.5, 1.0) devolverá el entero mayor, y por último si nos      encontramos en x + 0.5 devolverá el entero par más cercano al      número dado.
  • Ceiling(número): Devuelve el      entero inmediatamente mayor o igual que el número que le hemos dado.
  • Floor(número): Devuelve el      entero inmediatamente menor o igual que el número que le hemos dado.
  • Log(número): Devuelve el      logaritmo en base 10 de un número.
  • NaturalLog(número): Devuelve el      logaritmo neperiano (o también llamado logaritmo natural) de un número.
  • Power(base, exponente): Eleva      un número base a un número exponente.
  • SquareRoot(número): Devuelve la      raíz cuadrada de un número.
  • Remainder(dividendo, divisor):      Devuelve el resto o módulo de una división.
  • GetDegrees(ánguloEnRadianes):      Devuelve un ángulo en radianes convertido a grados.
  • GetRadians(ánguloEnGrados):      Devuelve un ángulo en grados convertido a radianes.
  • Cos(ánguloEnRadianes):      Devuelve el coseno de un ángulo en radianes.
  • Sin(ánguloEnRadianes):      Devuelve el seno de un ángulo en radianes.
  • Tan(ánguloEnRadianes):      Devuelve la tangente de un ángulo en radianes.

Accesibilidad de las macros (VBA)


a1

(Introducción a VBA en Excel 2010)

También puede tener acceso al cuadro de diálogo Macros desde la ficha Ver, pero si usa una macro con frecuencia, le resultará más cómodo tener acceso a ella mediante un método abreviado de teclado o un botón de la Barra de herramientas de acceso rápido.

Para crear un botón para la macro Hello en la Barra de herramientas de acceso rápido, use el siguiente procedimiento.

El siguiente procedimiento describe cómo crear un botón para una macro en la Barra de herramientas de acceso rápido:

Para crear un botón para una macro en la Barra de herramientas de acceso rápido

  1. Haga clic en la pestaña Archivo.
  2. Haga clic en Opciones para abrir el cuadro de diálogo Opciones de Excel y, a continuación, haga clic en Barra de herramientas de acceso rápido.
  3. En la lista que se encuentra en Comandos disponibles en:, elija Macros. Busque en la lista el texto que es similar a Book1!Hello y selecciónelo.
  4. Haga clic en el botón Agregar >> para agregar la macro a la lista en el lado derecho y, a continuación, haga clic en el botón Modificar…, a fin de seleccionar una imagen del botón para asociar a la macro.
  5. Haga clic en Aceptar. El nuevo botón deberá mostrarse en la Barra de herramientas de acceso rápido, encima de la ficha Archivo.

Ahora puede ejecutar rápidamente la macro en cualquier momento sin tener que usar la ficha Programador: inténtelo.

http://msdn.microsoft.com/library/ee814737.aspx#odc_Office14_ta_GettingStartedWithVBAInExcel2010

Microsoft Kodu – Para crear juegos sin conocimientos de programación


a1

Muchos usuarios habréis pensado que la creación de juegos siempre ha estado hecho de la mano de expertos programadores y diseñadores y realmente estáis en lo cierto, pero he de deciros que esto puede estar cambiando.

Hace poco más de un año, Microsoft lanzo una tecnología llamada Kodu, sencillamente podemos decir que es una plataforma en la que cualquier persona, tenga conocimientos o no de programación y diseño, pueda crear y gestionar su propio juego, eso sí, con recursos limitados, pero que finalmente es un juego hecho y derecho.

Esta tecnología es bastante sencilla de utilizar, tenemos que ir insertando objetos, enemigos, obstáculos, arboles, animales, entre otros objetos para ir perfilando nuestro mundo, tambien podremos configurar los controles y ajustes del escenario (hay varios disponibles).

Si deseamos empezar a utilizar la aplicación, debemos tener en cuenta que necesitamos dos programas instalados previamente antes de ejecutar el instalador de Kodu, estos son Microsoft Net Framework y XNA Framework Redistributable.

a2

Una vez tengamos todo configurado e instalado, podemos seguir los pasos de estos dos tutoriales [ Tutorial parte 1 | Parte 2 (En inglés) | Microsoft Kodu videotutorial ] para empezar a crear nuestro juego.

a3

Una vez terminéis la creación, podéis dejarnos en los comentarios vuestra experiencia para ayudar a otros usuarios.

Descarga | XNA FrameWork Redistributable [Microsoft Download Center]
Descarga | Microsoft .NET Framework +3.5 [Microsoft Download Center]
Enlace | Microsoft Official Site Kodu

http://wwwhatsnew.com/2011/03/21/microsoft-kodu-para-crear-juegos-sin-conocimientos-de-programacion/

Editor de Visual Basic


 

(Introducción a VBA en Excel 2010)

El siguiente procedimiento muestra cómo crear un nuevo libro en blanco donde se almacenarán las macros. A continuación, podrá guardar el libro con el formato .xlsm.

Para crear un nuevo libro en blanco

  1. Haga clic en el botón Macros, de la ficha Programador.
  2. En el cuadro de diálogo Macro que aparece, escriba Hello en Nombre de macro.
  3. Haga clic en el botón Crear para abrir el Editor de Visual Basic que incluirá los esquemas de una nueva macro ya escritos.

VBA es un lenguaje de programación completo y, en consecuencia, tiene un entorno de programación completo. En este artículo solo se estudian las herramientas que se usan para empezar a trabajar en programación sin incluir la mayoría de las herramientas del Editor de Visual Basic. Realizada esta salvedad, cierre la ventana Propiedades en el lado izquierdo del Editor de Visual Basic e ignore las dos listas desplegables que aparecen sobre el código.

 aabb

El Editor de Visual Basic contiene el siguiente código.

VB

Copiar

Sub Hello()

End Sub

Sub se refiere a Subrutinaque, por el momento, se puede definir como “macro”. Al ejecutar la macro Hello se ejecuta cualquier código que se encuentre entre Sub Hello() y End Sub.

Ahora, edite la macro para que tenga un aspecto similar al siguiente código.

VB

Copiar

Sub Hello()

MsgBox (“Hello, world!”)

End Sub

Vuelva a la ficha Programador en Excel y haga clic de nuevo en el botón Macros.

Seleccione la macro Hello en la lista que aparece y, a continuación, haga clic en Ejecutar para mostrar un cuadro de mensaje pequeño que contiene el texto “Hello, world!”.

Acaba de crear e implementar correctamente código de VBA personalizado en Excel. Haga clic en Aceptar en el cuadro de mensaje para cerrarlo y terminar de ejecutar la macro.

Si no aparece el cuadro de mensaje, compruebe la configuración de seguridad de la macro y reinicie Excel.

http://msdn.microsoft.com/library/ee814737.aspx#odc_Office14_ta_GettingStartedWithVBAInExcel2010_WhyUseVBAInExcel2010

Programación de VBA 101


(Introducción a VBA en Excel 2010)

Uso de código para hacer que las aplicaciones realicen las tareas

Quizá crea que escribir código es algo misterioso o complicado, pero sus principios básicos usan la lógica diaria y son bastante accesibles. Las aplicaciones de Office 2010 están creadas de tal modo que exponen lo que se denomina objetos. Estos objetos reciben instrucciones. Para interactuar con las aplicaciones, se envían instrucciones a varios objetos de la aplicación. Los objetos, si bien son variados y flexibles, tienen sus límites. Solo pueden hacer aquello para lo que fueron diseñados y solo harán lo que se les indique que hagan.

Objetos

Los objetos de programación se relacionan entre sí sistemáticamente en una jerarquía denominada modelo de objetos de la aplicación. El modelo de objetos básicamente refleja lo que se ve en la interfaz de usuario. Por ejemplo, el modelo de objetos de Excel contiene los objetos Application, Workbook, Sheet y Chart, entre muchos otros. El modelo de objetos constituye el mapa conceptual de la aplicación y sus funcionalidades.

Propiedades y métodos

Es posible manipular objetos al establecer sus Propiedades y llamar a sus métodos. Si se establece una propiedad, se producen algunos cambios en la calidad del objeto. Si se llama a un método, se logra que el objeto realice una determinada acción. Por ejemplo, el objeto Workbook tiene un método Close que cierra el libro y una propiedad ActiveSheet que representa la hoja activa del libro.

Colecciones

Varios objetos vienen en las versiones singular y plural; por ejemplo, libro y libros, hoja de cálculo y hojas de cálculo. Las versiones en plural se denominan colecciones. Los objetos de una colección se usan para realizar una acción en varios elementos de esa colección. Más adelante, en este artículo, se explicará cómo usar la colección Worksheets para cambiar el nombre de cada hoja de cálculo de un libro.

Macros y el Editor de Visual Basic

Ahora que ya conoce en parte cómo Microsoft Excel 2010 expone su modelo de objetos, puede intentar llamar a los métodos de un objeto y establecer las propiedades del objeto. Para hacerlo, debe escribir el código en un lugar y de una manera que Office pueda comprender; generalmente, mediante el uso del Editor de Visual Basic. Aunque se instala de forma predeterminada, muchos usuarios ni siquiera saben que está disponible hasta que no se habilita en la cinta de opciones.

Ficha Programador

Todas las aplicaciones de Office 2010 usan la cinta de opciones. La ficha Programador es una de las fichas incluidas en la cinta de opciones, donde se puede tener acceso al Editor de Visual Basic y a otras herramientas de programador. Debido a que Office 2010 no muestra la ficha Programador de manera predeterminada, debe habilitarla mediante el siguiente procedimiento:

Para habilitar la ficha Programador

  1. En la ficha Archivo, elija Opciones para abrir el cuadro de diálogo Opciones de Excel.
  2. Haga clic en Personalizar cinta de opciones en el lado izquierdo del cuadro de diálogo.
  3. En Comandos disponibles en:, en el lado izquierdo del cuadro de diálogo, seleccione Comandos más utilizados.
  4. En Personalice esta cinta de opciones, en el lado derecho del cuadro de diálogo, seleccione Fichas principales y, a continuación, active la casilla de verificación Programador.
  5. Haga clic en Aceptar.

Después de que Excel muestre la ficha Programador, observe la ubicación de los botones Visual Basic, Macros y Seguridad de macros en la ficha.

aabb

Problemas de seguridad

Haga clic en el botón de Seguridad de macros para especificar qué macros pueden ejecutarse y en qué condiciones. Aunque el código de macros de sistemas no confiables puede dañar gravemente el equipo, las condiciones de seguridad que impiden ejecutar macros útiles pueden disminuir en gran medida la productividad. La seguridad de macros es un tema complejo que se debe estudiar y comprender, si se trabaja con macros de Excel.

Para el propósito de este artículo, tenga en cuenta que si la barra Advertencia de seguridad: las macros se han deshabilitado aparece entre la cinta de opciones y el libro, cuando abre un libro que contiene una macro, puede hacer clic en el botón Habilitar contenido para habilitar las macros.

Además, como medida de seguridad, no puede guardar una macro en el formato de archivo predeterminado de Excel (.xlsx); debe guardar la macro en un archivo con extensión especial (.xlsm).

http://msdn.microsoft.com/library/ee814737.aspx#odc_Office14_ta_GettingStartedWithVBAInExcel2010_VBAProgramming101

El bucle while (código) – Small Basic y Visual Basic


a1

El bucle while (mientras) es otro método de repetición que se usa cuando la cantidad de repeticiones no se conoce por adelantado. Mientras el bucle For se ejecuta una cantidad predefinida de veces, el bucle while se ejecuta mientras una condición dada es cierta

En este ejemplo el programa trazará una línea del ancho y color (“Red”) indicado, en un fondo de escritorio (“Yellow”) también especificado. Mientras la variable definida es mayor que 1 se repetirá el trazado

Small Basic 

numero = 1000

etiquetaInicio:

TextWindow.WriteLine(numero)

GraphicsWindow.Show()

GraphicsWindow.BackgroundColor= “Yellow”

GraphicsWindow.PenWidth= 10

GraphicsWindow.PenColor = “Red”

GraphicsWindow.DrawLine(10, 300, numero, 10)

numero= numero/2

 

While (numero>1)

  Goto etiquetaInicio

  EndWhile

 Visual Basic 

Module whileModule

    Dim numero As Primitive

    Sub Main()

        numero = 1000

etiquetaInicio:

        TextWindow.WriteLine(numero)

        GraphicsWindow.Show()

        GraphicsWindow.BackgroundColor = “Yellow”

        GraphicsWindow.PenWidth = 10

        GraphicsWindow.PenColor = “Red”

        GraphicsWindow.DrawLine(10, 300, numero, 10)

        numero = numero / 2

 

        While numero > 1

            Goto etiquetaInicio

        End While

    End Sub

End Module

Calcular números primos con Visual Basic (Código)


a1

Se utiliza la subrutina ComprobarPrimo, que toma el valor de i y calcula si i es o no un número primo

Module UntitledModule

Dim i, esPrimo, j As Primitive

Sub Main()

For i = 2 To 100

esPrimo = “Cierto”

ComprobarPrimo()

If esPrimo = CType(“Cierto”, Primitive) Then

TextWindow.WriteLine(i)

End If

Next

End Sub

Sub ComprobarPrimo()

For j = 2 To Microsoft.SmallBasic.Library.Math.SquareRoot(i)

If Microsoft.SmallBasic.Library.Math.Remainder(i, j) = 0 Then

esPrimo = “Falso”

Goto FinLoop

End If

Next

FinLoop:

End Sub

End Module

Calcular números primos con Small Basic (Codigo)


a1Se utiliza la subrutina ComprobarPrimo, que toma el valor de i y calcula si i es o no un número primo

  1. For i= 2 To 100
  2.   esPrimo = “Cierto”
  3.   ComprobarPrimo()
  4.   If (esPrimo = “Cierto”) Then
  5.     TextWindow.WriteLine(i)
  6.   EndIf
  7. EndFor
  8. Sub ComprobarPrimo
  9.   For j= 2 To Math.SquareRoot(i)
  10.     If (Math.Remainder(i, j) = 0) Then
  11.       esPrimo = “Falso”
  12.       Goto FinLoop
  13.     EndIf
  14.   EndFor
  15.   FinLoop:
  16.   EndSub

Visual Basic 2010 Express: cálculo de seno y coseno (código)


a1

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.

UntitledModule

Dim número, EnRadianes AsPrimitive

Sub Main()

TextWindow.Title = “El objeto Math”

TextWindow.Write(“Escriba el ángulo en grados y obtenga el seno del ángulo: “)

número =

TextWindow.Read()

EnRadianes = Microsoft.SmallBasic.Library.

Math.GetRadians(número)

TextWindow.WriteLine(“El seno del ángulo es “ + Microsoft.SmallBasic.Library.Math.Sin(EnRadianes))

TextWindow.WriteLine(“El arcoseno del ángulo es “ + Microsoft.SmallBasic.Library.Math.ArcSin(EnRadianes))

TextWindow.WriteLine(“El ángulo en grados es “ + EnRadianes)

TextWindow.Write(“Escriba el ángulo en grados y obtenga el coseno del ángulo: “)

número =

TextWindow.Read()

EnRadianes = Microsoft.SmallBasic.Library.

Math.GetRadians(número)

TextWindow.WriteLine(“El coseno del ángulo es “ + Microsoft.SmallBasic.Library.Math.Cos(EnRadianes))

EndSub

End

Module

 

Small Basic: cálculo de seno y coseno (código)


a1

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.

  1. TextWindow.Title = “El objeto Math”
  2. TextWindow.Write(“Escriba el ángulo en grados y obtenga el seno del ángulo: “)
  3. número = TextWindow.Read()
  4. EnRadianes = Math.GetRadians(número)
  5. TextWindow.WriteLine(“El seno del ángulo es ” + Math.Sin(EnRadianes))
  6. TextWindow.WriteLine(“El arcoseno del ángulo es ” + Math.ArcSin(EnRadianes))
  7. TextWindow.WriteLine(“El ángulo en grados es ” + EnRadianes)
  8. TextWindow.Write(“Escriba el ángulo en grados y obtenga el coseno del ángulo: “)
  9. número = TextWindow.Read()
  10. EnRadianes = Math.GetRadians(número)
  11. TextWindow.WriteLine(“El coseno del ángulo es ” + Math.Cos(EnRadianes))
  12.  

Pilas y matrices (Código)


a2

 

Una matriz puede ser multidimensional, pero una pila sólo tiene una dimensión. Puede acceder directamente a cualquier elemento de una matriz, pero sólo puede acceder al elemento superior de la pila. Es decir, si desea acceder al último elemento de la pila, tiene que pasar por todos los elementos desde el principio.

Una matriz es un tipo de variable que puede almacenar varios valores a la vez. Si desea almacenar los nombres de cinco usuarios, en vez de crear 5 variables, puede usar sólo una variable para almacenar los cinco nombres.

Se usa el método de indexación para almacenar múltiples valores en una matriz. Por ejemplo, puede crear una matriz llamada nombre como sigue: nombre[1], nombre[2], nombre[3], nombre[4] y nombre[5]. Aquí, 1, 2, 3, 4, y 5 son los índices para la matriz nombre.

Puede que nombre[1], nombre[2]… le parezcan diferentes variables, ¡pero todas ellas son una sola variable!

Ejemplo:

Empleado[“Nombre”] = “Juan “
Empleado[“Ciudad”] = ” Nueva York “
Empleado[“e-mail”] = ” juan@ejemplo.com
Empleado[“Móvil”] = ” 06482624 “
ListaEmp = Array.GetAllIndices(Empleado)
TextWindow.WriteLine(ListaEmp)
For i = 1 To Array.GetItemCount(Empleado)
TextWindow.WriteLine(ListaEmp[i] + “:” +Empleado[ListaEmp[i]])
EndFor

VBA Excel: Un ejemplo del mundo real


a1

Supongamos que usted tiene un libro que contiene las listas de un gran número de hojas de trabajo y que desea cambiar el nombre de cada hoja de trabajo para que coincida con el encabezado de la lista en esa hoja de cálculo. No todas las hoja de cálculo tiene una lista en él, pero si lo hace, el título es en la celda B1, y si no lo hace, la celda B1 está en blanco. Los nombres de las hojas de trabajo sin listas deben ser dejados solos.
Por lo general, esto puede ser una tarea compleja que implica examinar cada hoja de cálculo para ver si tiene una lista, copiando el nombre, si lo hace, al hacer clic en la ficha hoja de cálculo y luego pegar en el nuevo nombre. En lugar de realizar todos estos pasos manualmente, utilice Excel VBA para cambiar el nombre de las hojas de forma automática.

Aprender acerca de los objetos

Para resolver un problema de programación VBA, primero debe averiguar qué objetos debe el código manipular. Para investigar esa información, una herramienta fundamental es el objeto de Excel Modelo de Referencia, que forma parte de la Referencia del programador de Excel 2007 en Microsoft Developer Network (MSDN).
Estos materiales de referencia se actualizará para Excel 2010, cuando se hizo público, pero el Excel 2007 Referencia del programador es adecuado para la mayoría de los propósitos de Excel 2010.
El primer paso es encontrar la manera de manipular los objetos particulares que tiene que trabajar para cumplir su tarea, por ejemplo, hojas de cálculo, los nombres de hoja de cálculo, celdas y contenido de celdas. En Excel, hay por lo menos dos maneras de abordar el problema:
• Ir directamente a la referencia del modelo de objetos.
• Anote algunas de las acciones que desee automatizar, ver cómo el código grabado manipula los objetos, y luego ir a la referencia del modelo de objetos para obtener más información.
Las opiniones varían sobre qué método es preferible, pero por ahora, trate de usar la grabadora de macros en primer lugar.

Utilización de la grabadora de macros

A veces una simple macro grabada es todo lo que necesita, en estos casos, no tienen ni siquiera para mirar el código. Más a menudo, la grabación por sí sola no es suficiente. En cambio, es un punto de partida en el proceso siguiente.
Para utilizar la grabadora de macros como punto de partida para su solución
1. Registrar las acciones que desea codificar.
2. Revise el código y encontrar las líneas que llevan a cabo esas acciones.
3. Elimine el resto del código.
4. Modificar el código grabado.
5. Añadir variables, estructuras de control y otros códigos que la grabadora de macros no puede grabar.
Comience su investigación mediante la grabación de una macro que cambia el nombre de una hoja de trabajo para el nuevo nombre. A continuación, puede utilizar la macro grabada para desarrollar su propia macro que cambia el nombre de varias hojas de cálculo basado en su contenido.

Para grabar una macro que cambia el nombre de una hoja de cálculo

1. Haga clic en Grabar macro en la ficha Programador.
2. Nombra los RenameWorksheets macro, cambie el nombre de la Hoja1 por el nuevo nombre y haga clic en Detener grabación.
3. Ir a la ficha Programador o Vista, haga clic en el botón Macros y seleccione Editar para abrir el Editor de Visual Basic.
El código en el Editor de Visual Basic debe ser similar a lo siguiente.

VB
Copiar
Sub RenameWorksheets ()

‘RenameWorksheets Macro


Sheets (“Sheet1”). Seleccione
Nombre Sheets (“Sheet1”). = “Nuevo nombre”
End Sub

Las primeras cuatro líneas después de la línea Sub son comentarios. Cualquier línea que comienza con un apóstrofe es un comentario y no tiene ningún efecto en lo que la macro. Los usos principales de los comentarios son los siguientes:
• Para hacer que el código sea más fácil de entender, no sólo para usted, sino para cualquier otra persona que podría tener que modificar el código más tarde.
• Para desactivar temporalmente una línea de código (llamada comentando hacia fuera).
Los cuatro comentarios en esta macro grabada servir ni fin, por lo que los elimine.
La línea siguiente se utiliza el método Select para seleccionar el miembro Sheet1 del objeto de la colección Sheets. En el código VBA, generalmente no es necesario seleccionar objetos antes de manipularlos, a pesar de que eso es lo que la grabadora de macros hace. En otras palabras, esta línea de código es redundante, por lo que puede eliminarla también.
La última línea de la macro grabada modifica el Nombre de la propiedad del miembro Sheet1 de la colección Sheets. Esta es la línea a seguir.
Después de realizar los cambios, el código grabado debería parecerse a la siguiente.
VB
Copiar
Sub RenameWorksheets ()
Nombre Sheets (“Sheet1”). = “Nuevo Nombre”
End SubCambie manualmente la hoja llamada Nuevo Nombre nuevo a la Hoja1, a continuación, ejecutar la macro. El nombre debe cambiar de nuevo a Nuevo Nombre

http://msdn.microsoft.com/library/ee814737.aspx#odc_Office14_ta_GettingStartedWithVBAInExcel2010_ARealWorldExample

Módulo Visual Basic graduado de Small Basic


a1

Visual Basic

Module UntitledModule

Sub Main()

GraphicsWindow.Width = 200

GraphicsWindow.Height = 200

GraphicsWindow.BackgroundColor = “Yellow”

GraphicsWindow.PenWidth = 10

GraphicsWindow.PenColor = “Green”

GraphicsWindow.DrawLine(10, 10, 100, 100)

GraphicsWindow.PenColor = “Blue”

GraphicsWindow.DrawLine(10, 100, 100, 10)

End Sub

End Module

Small Basic

GraphicsWindow.Width = 200

GraphicsWindow.Height = 200

GraphicsWindow.BackgroundColor = “Yellow”

GraphicsWindow.PenWidth = 10

GraphicsWindow.PenColor = “Green”

GraphicsWindow.DrawLine(10, 10,100, 100)

GraphicsWindow.PenColor = “Blue”

GraphicsWindow.DrawLine(10, 100, 100, 10)

Módulo Visual Basic 2010 Express: elipses (código)


a1

Vamos a comparar el mismo programa codificado en Visual Basic y en Small Basic

el código de Visual Basic es:

Module UntitledModule

    Sub Main()

        GraphicsWindow.Width = 400

        GraphicsWindow.Height = 300

        GraphicsWindow.BackgroundColor = “Yellow”

 

        GraphicsWindow.PenColor = “Red”

        GraphicsWindow.DrawEllipse(20, 20, 300, 60)

 

        GraphicsWindow.BrushColor = “Green”

        GraphicsWindow.FillEllipse(60, 100, 300, 60)

    End Sub

End Module

y su equivalente en Small Basic

GraphicsWindow.Width = 400

GraphicsWindow.Height = 300

GraphicsWindow.BackgroundColor = “Yellow”

 

GraphicsWindow.PenColor = “Red”

GraphicsWindow.DrawEllipse(20, 20, 300, 60)

¿Por qué usar VBA en Excel 2010?


a1

 

 

Microsoft Excel 2010 es una herramienta muy poderosa que puede utilizar para manipular, analizar y presentar datos. A veces sin embargo, a pesar del amplio conjunto de características de la interfaz de usuario estándar de Excel (IU), es posible que desee encontrar un camino más fácil para realizar una tarea trivial, repetitivo, o para realizar alguna tarea que la interfaz de usuario no parece abordar. Afortunadamente, las aplicaciones de Office como Excel tiene Visual Basic para Aplicaciones (VBA), un lenguaje de programación que le ofrece la posibilidad de ampliar dichas aplicaciones. VBA funciona mediante la ejecución de macros, paso a paso los procedimientos escritos en Visual Basic. Aprender a programar puede parecer intimidante, pero con un poco de paciencia y algunos ejemplos, tales como los descritos en este artículo, muchos usuarios encuentran que el aprendizaje de incluso una pequeña cantidad de código VBA que hace que su trabajo sea más fácil y les da la capacidad de hacer cosas en la oficina que no creo que fuera posible. Una vez que hayas aprendido algo de VBA, se vuelve mucho más fácil de aprender mucho más, por lo que las posibilidades son ilimitadas. Con mucho, la razón más común el uso de VBA en Excel es automatizar tareas repetitivas. Por ejemplo, suponga que tiene una docena de libros, cada uno de los cuales tiene unas pocas docenas de hojas de trabajo, y cada una de esas necesidades a tener algunos cambios a la misma. Los cambios podrían ser tan simple como aplicar un nuevo formato a un rango fijo de células o tan complejo como mirar a algunas de las características estadísticas de los datos en cada hoja, elegir el mejor tipo de gráfico para mostrar datos con esas características, a continuación, crear y dar formato el gráfico en consecuencia. De cualquier manera, probablemente preferirían no tener que realizar estas tareas de forma manual, por lo menos no más que un par de veces. En cambio, puede automatizar las tareas mediante el uso de VBA para escribir las instrucciones explícitas de Excel a seguir. VBA no es sólo para las tareas repetitivas sin embargo. También puede utilizar VBA para crear nuevas capacidades en Excel (por ejemplo, usted podría desarrollar nuevos algoritmos para el análisis de los datos, a continuación, utilizar las capacidades de creación de gráficos en Excel para mostrar los resultados), y para llevar a cabo las tareas que se integran con las aplicaciones de Office Excel esas otras como Microsoft Access 2010. De hecho, de todas las aplicaciones de Office, Excel es la más utilizada como algo que se asemeja a una plataforma de desarrollo general. Además de todas las tareas obvias que implican las listas y los contables, los desarrolladores utilizan Excel en una serie de tareas de visualización de datos para creación de prototipos de software. A pesar de todas las buenas razones para utilizar VBA en Excel 2010, es importante recordar que la mejor solución a un problema que no puede implicar VBA en absoluto. Excel tiene una amplia gama de características aún sin VBA, por lo que incluso un usuario avanzado es poco probable que esté familiarizado con todos ellos. Antes de decidirse por una solución de VBA, buscar los recursos de Ayuda y en línea a fondo para asegurarse de que no hay una manera más sencilla.

http://msdn.microsoft.com/library/ee814737.aspx#odc_Office14_ta_GettingStartedWithVBAInExcel2010_WhyUseVBAInExcel2010

 

 

101 ejemplos de VBA para Office 2010


a1

Microsoft Office 2010 le proporciona las herramientas necesarias para crear aplicaciones de gran alcance. Estos Visual Basic para Aplicaciones (VBA) ejemplos de código puede ayudarle a crear sus propias aplicaciones que realizan funciones específicas o como punto de partida para crear soluciones más complejas.
Cada ejemplo se compone de aproximadamente 5 a 50 líneas de código que demuestran una clara característica o conjunto de características en VBA. Cada ejemplo incluye comentarios que describen la muestra y el código de configuración para que pueda ejecutar el código con los resultados esperados o los comentarios se explica cómo configurar el entorno de modo que el código de ejemplo se ejecuta.
Descarga todas las muestras en un único archivo zip, o haga clic en cada título para descargar el código VBA para ese fragmento específico

http://msdn.microsoft.com/en-US/office/hh360994

Microsoft Small Basic Descargar gratis


a1

Aprende a programar con el lenguaje más sencillo

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.

El entorno de desarrollo de Microsoft Small Basic consta de una sola ventana con transparencias y grandes botones. Al escribir código, aparecen sugerencias para funciones y variables declaradas.

En lugar de usar un fichero de ayuda, Microsoft Small Basic muestra descripciones de cada función en el cuadro de autocompletado y en el panel lateral. Al ejecutar el código, los errores aparecen en un panel inferior.

Microsoft Small Basic presenta ideas interesantes de cara a la enseñanza de la programación, pero el uso de un lenguaje tan limitado puede ser una desventaja.

Microsoft Small Basic soporta los siguientes formatos

SB

Pros

  • Coloreado      de sintaxis y autocompletado
  • Ejecución      rápida de los programas
  • Panel      lateral con explicaciones breves
  • Entorno      agradable, ideal para la escuela
  • Traducido      a muchos idiomas

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

El juego del corredor (código)


a1

Un juego simple e instructivo construido en Small Basic

QJQ087  program listing

GraphicsWindow.BackgroundColor = “SteelBlue”

For i = 1 To 6

CorredorGif = ImageList.LoadImage(“http://ingenieriasimple.com/smallbasic/Corredor0&#8221; + i + “.png”)

CorredorSh[i][1] = Shapes.AddImage(CorredorGif)

Shapes.Zoom(CorredorSh[i][1],0.5,0.5)

Shapes.HideShape(CorredorSh[i][1])

CorredorGif = ImageList.LoadImage(“http://ingenieriasimple.com/smallbasic/Corredor0&#8221; + i + “r.png”)

CorredorSh[i][-1] = Shapes.AddImage(CorredorGif)

Shapes.Zoom(CorredorSh[i][-1],0.5,0.5)

Shapes.HideShape(CorredorSh[i][-1])

EndFor

Shapes.ShowShape(CorredorSh[1][1])

Corredor = 1

CorredorDir = 1

Terron = ImageList.LoadImage(“http://ingenieriasimple.com/smallbasic/TerronG.png&#8221;)

Timer.Interval = 160

Timer.Tick = CaeCorredor

GraphicsWindow.KeyDown = CambiaDireccionCorredor

For i = 1 To 4

Tierra[i] = Shapes.AddImage(Terron)

Shapes.HideShape(Tierra[i])

Shapes.Move(Tierra[i],Math.GetRandomNumber(GraphicsWindow.Width),GraphicsWindow.Height*(0.25*i))

Shapes.ShowShape(Tierra[i])

EndFor

Sub CaeCorredor

DeltaXCo = 15

DeltaYCo = 3

DeltaYTrra = 10

CurXCo = Shapes.GetLeft(CorredorSh[Corredor][1])

CurYCo = Shapes.GetTop(CorredorSh[Corredor][1])

For i = 1 To 4

CurXTrra = Shapes.GetLeft(Tierra[i])

CurYTrra = Shapes.GetTop(Tierra[i])

‘GraphicsWindow.DrawEllipse(CurXTrra+7,CurYTrra,52,5)

‘GraphicsWindow.DrawEllipse(CurXCo+25,CurYCo+90,35,5)

If Math.Abs(CurXTrra – CurXCo – 18) < 52 And Math.Abs(CurYTrra – CurYCo – 90) < 15 Then

DeltaYCo = – DeltaYTrra

EndIf

If CurYTrra <= -50 Then

Shapes.Move(Tierra[i],Math.GetRandomNumber(GraphicsWindow.Width),GraphicsWindow.Height)

EndIf

EndFor

Shapes.HideShape(CorredorSh[Corredor][1])

Shapes.HideShape(CorredorSh[Corredor][-1])

Corredor = Math.Remainder(Corredor,6) + 1

Shapes.ShowShape(CorredorSh[Corredor][CorredorDir])

For i = 1 To 6

If i = Corredor Then

Shapes.Animate(CorredorSh[i][1],CurXCo + DeltaXCo*CorredorDir,CurYCo + DeltaYCo,150)

Shapes.Animate(CorredorSh[i][-1],CurXCo + DeltaXCo*CorredorDir,CurYCo + DeltaYCo,150)

Else

Shapes.Move(CorredorSh[i][1],CurXCo + DeltaXCo*CorredorDir,CurYCo + DeltaYCo)

Shapes.Move(CorredorSh[i][-1],CurXCo + DeltaXCo*CorredorDir,CurYCo + DeltaYCo)

EndIf

EndFor

For i = 1 To 4

CurXTrra = Shapes.GetLeft(Tierra[i])

CurYTrra = Shapes.GetTop(Tierra[i])

Shapes.Animate(Tierra[i],CurXTrra,CurYTrra-DeltaYTrra,150)

EndFor

EndSub

Sub CambiaDireccionCorredor

If GraphicsWindow.LastKey = “Left” Then

CorredorDir = -1

ElseIf GraphicsWindow.LastKey = “Right” Then

CorredorDir = 1

EndIf

EndSub

Small Basic Curriculum


a1

Learn all about Small Basic by using the curriculum. With the curriculum, you can lean Small Basic with separate lessons – just like you would in a classroom. As a teacher or as a student learning Small Basic on your own, the curriculum format might be useful to you.

Use the curriculum online     
Download the curriculum     
Find international curriculum     

http://social.technet.microsoft.com/wiki/contents/articles/16299.small-basic-curriculum.aspx

 

XML y Access


a1

Es posible que parte del contenido de este tema no pueda aplicarse a algunos lenguajes.

El Lenguaje de marcado extensible (Lenguaje de marcas extensible (XML): forma condensada del Lenguaje de marcado generalizado estándar (SGML) que permite a los desarrolladores crear etiquetas personalizadas que ofrecen flexibilidad para organizar y presentar información.) (XML, Extensible Markup Language) es el lenguaje estándar para describir y enviar datos a través del Web (World Wide Web (WWW): rama multimedia de Internet que presenta no sólo texto, sino también gráficos, sonido y vídeo. En el Web, los usuarios pueden saltar fácilmente de un elemento a otro, de una página a otra o de un sitio a otro utilizando hipervínculos.), del mismo modo que el Lenguaje de marcado de hipertexto (HTML: lenguaje de marcado estándar utilizado para los documentos del World Wide Web. HTML utiliza etiquetas para indicar cómo deben mostrar los exploradores Web los elementos de página, como texto y gráficos, y cómo deben responder a las acciones del usuario.) (HTML, Hypertext Markup Language) es el lenguaje estándar para crear y mostrar páginas Web. Microsoft Access proporciona medios para importar y exportar datos XML, así como para transformarlos a y desde otros formatos mediante archivos relacionados con XML.

Formato XML

Siempre ha sido complicado mover información en Internet y entre aplicaciones de software debido a los diferentes formatos y estructuras con derecho de propiedad. Aunque HTML esté bien equipado para proporcionar información de texto e imagen para exploradores Web, su capacidad está limitada por la definición de datos y estructuras de datos. El HTML describe el aspecto que debería tener una página Web, mientras que el XML define los datos y describe cómo deberían estar estructurados. El XML es un formato de intercambio de datos, ya que permite intercambiar datos entre sistemas o aplicaciones diferentes. El XML separa los datos de la presentación para que los éstos mismos puedan ser presentados de varias formas al usar archivos de presentación distintos.

El XML es un protocolo basado en estándares regulado por el World Wide Web Consortium (World Wide Web Consortium (W3C): consorcio de instituciones educativas y comerciales que supervisa la investigación y promociona estándares en todas las áreas relacionadas con World Wide Web.) (W3C). El protocolo XML es un conjunto de reglas, instrucciones y convenciones para diseñar formatos y estructuras de datos, de modo que se creen archivos que puedan ser generados y leídos con facilidad por diferentes equipos y aplicaciones. Además, las estructuras definidas por el XML no son ambiguas, es decir, que son auto descriptivas y tienen una plataforma independiente. Al igual que el HTML, el XML utiliza etiquetas y atributos, pero mientras el HTML especifica qué quiere decir cada etiqueta y atributo (y por lo tanto cómo se mostrarán los datos entre ellos en un explorador), el XML utiliza las etiquetas únicamente para delimitar datos y deja la interpretación total de los mismos a la aplicación que los lee. Para obtener más información acerca del XML, visite el sitio MSDN de Microsoft (sólo disponible en inglés) en el Web.

Importar datos XML

Access permite utilizar datos de varias fuentes externas. El uso de  XML permite transformar los datos desde casi cualquier aplicación externa para su uso en Access de manera más sencilla. Permite:

  • Importar datos XML a Jet (motor de base de datos Microsoft Jet: parte del sistema de base de datos de Access que recupera y almacena datos en las bases de datos de usuario y del sistema. Se puede decir que es un administrador de datos sobre el que se construyen sistemas de bases de datos, como Access.), a Microsoft SQL Server (base de datos de Microsoft SQL Server: una base de datos de Microsoft SQL Server consta de tablas, vistas, índices, procedimientos almacenados, funciones y desencadenadores.), o a una base de datos Microsoft SQL Server 2000 Desktop Engine (denominada anteriormente MSDE).
  • Importar datos de un esquema XML a Jet, SQL Server o a una base de datos Microsoft SQL Server 2000 Desktop Engine.
  • Utilizar un archivo XSLT (Extensible Stylesheet Language Transformation) para transformar los datos en un formato XML compatible con Access.

Nota  Para poder importar archivos XML a SQL Server o a una base de datos Microsoft SQL Server 2000 Desktop Engine, a través de un proyecto de Access (ADP), es necesario que Microsoft SQL Server 2000 Desktop Engine esté instalado en el equipo local.

Es posible utilizar el comando Importar (señale Obtener datos externos en el menú Archivo) para importar archivos de datos XML a Access. Este comando muestra el cuadro de diálogo Importar, en el que se puede seleccionar un documento o un esquema XML que describa la estructura de los datos. Sólo se puede importar a Access un documento cada vez. Los datos deben estar en un formato reconocido por Access, ya sea en un formato nativo o mediante la utilización de un esquema. Tenga en cuenta que al importar datos XML no es posible elegir un subconjunto del documento XML. Es necesario importar el archivo completo.

Los datos XML de cualquier tipo pueden transformarse en un formato compatible con Access, para ello seleccione un tipo de transformación en el cuadro de diálogo Importar XML. También es posible especificar si se desea sobrescribir cualquier tabla existente o anexar a datos existentes.

Qué son esquemas XML

Los esquemas XML se utilizan para describir la estructura de los datos en un formato común que tanto clientes, como otros exploradores Web o cualquier programa de software habilitado para XML puedan reconocer. De forma específica, los esquemas definen las reglas de un documento de datos XML, entre los que se incluyen nombres de elementos y tipos de datos, qué elementos pueden aparecer en combinación y qué atributos están disponibles para cada elemento. Los esquemas proporcionan un modelo para un documento de datos XML que define la organización de etiquetas y texto en los documentos a los que se refiere el esquema. Access es compatible con el estándar de esquema XML (XSD). El XSD es un estándar aprobado por el consorcio W3C (World Wide Web Consortium (W3C): consorcio de instituciones educativas y comerciales que supervisa la investigación y promociona estándares en todas las áreas relacionadas con World Wide Web.) diseñado como una infraestructura básica para describir el tipo y estructura de los documentos XML.

La utilización de un esquema permite asegurar que cualquier documento XML utilizado para importar datos a Access o para exportar desde Access a otro formato contiene datos específicos y se ajusta a una estructura definida. Puede facilitar el esquema a otros negocios y aplicaciones para que sepan cómo estructurar la información que les van a proporcionar, y a cambio, proporcionarle su esquema.

Mostrar datos XML

La sintaxis XML (las etiquetas y su organización en un documento) define y describe los datos de un documento XML pero no indica cómo se han de mostrar éstos. En aplicaciones anteriores se utilizaban y en algunos usos actuales se siguen utilizando hojas de estilos en cascada (CSS, Cascading Style Sheets) para indicar al explorador cómo mostrar los datos XML. Sin embargo, las CSS no siempre son una buena elección, ya que están escritas en un lenguaje especializado, lo que significa que el programador tiene que utilizar otro lenguaje para escribir, modificar o entender la estructura de la hoja de estilos. Los archivos CSS sólo permiten especificar el formato de cada elemento XML sin demasiado control sobre el resultado.

Por otra parte, la hoja de estilos XSL (Extensible Stylesheet Language) es mucho más flexible que un archivo CSS. Permite seleccionar con precisión los datos que se mostrarán, especificar el orden o la colocación de éstos y modificar o añadir información. Además, está escrita en un estilo similar a un documento XML, ya que utiliza una combinación de etiquetas parecidas a XML y HTML para crear una plantilla para un estilo de resultado concreto. Para obtener más información acerca de las hojas de estilos XSL, visite el sitio MSDN de Microsoft (sólo disponible en inglés) en el Web.

Observe que no es necesario vincular un archivo CSS o una hoja de estilos XSL a un documento XML para que Microsoft Internet Explorer 5.01 con Service Pack 2 (SP2), o posterior, muestre el documento. Internet Explorer tiene una hoja de estilos predeterminada integrada que muestra el código fuente XML como un árbol contraíble/expansible.

Puede utilizar hojas de estilos para asegurarse de que todas las páginas Web basadas en XML de la intranet o sitio Web son coherentes y presentan una apariencia uniforme sin tener que agregar HTML a cada página.

Extensible Stylesheet Language Transformation (XSLT)

XSLT es una especificación recomendada por el World Wide Web Consortium (World Wide Web Consortium (W3C): consorcio de instituciones educativas y comerciales que supervisa la investigación y promociona estándares en todas las áreas relacionadas con World Wide Web.) (W3C), compatible con Access. El XSLT es un lenguaje basado en XML que permite que un documento XML sea asignado a, o transformado en, otro documento XML. Esto proporciona un medio de transformar la información de la presentación de un documento XML de un formato fuente a un formato destino y así sucesivamente. Normalmente el programador crea un archivo de transformación XSL que al aplicarse a un documento XML durante la exportación interpreta o transforma los datos XML en un formato de presentación que puede ser reconocido por otra aplicación, como el Protocolo de anuncio de servicios (SAP) o por un formato de pedido personalizado.

El XSLT tiene muchas de las construcciones (estructuras y comandos) que se encuentran en otros lenguajes de programación, lo que permite al programador utilizar variables, bucles, iteraciones e instrucciones condicionales. De esta forma el programador puede tener un control considerable sobre el resultado de los datos XML. Para obtener más información acerca de los archivos XSLT, visite el sitio MSDN de Microsoft (sólo disponible en inglés) en el Web.

Exportar a archivos XML

Exportar datos y objetos de bases de datos a un archivo XML es un modo práctico de mover y almacenar información en un formato que puede ser utilizado sin problemas en todo el Web. En Access es posible exportar los datos, los esquemas (estructuras de datos), o ambos, a archivos XML. Permite:

  • Exportar datos de un archivo XML y, de forma opcional, utilizar XSLT para transformar los datos a otro formato.
  • Exportar los esquemas de datos mediante un esquema estándar XML (XSD).
  • Exportar los datos subyacentes de los formularios y los informes a un archivo XML.

También es posible transformar los datos a otro formato de presentación mediante un archivo XSL durante el proceso de exportación. Puede exportar tablas, consultas y los datos subyacentes de los formularios e informes desde una base de datos de Microsoft Access (base de datos: colección de datos relacionados con un fin o tema concreto. Dentro de una base de datos, la información sobre una entidad en particular, como un empleado o un pedido, se categoriza en tablas, registros y campos.) (.mdb), así como tablas, consulta, procedimientos almacenados, funciones y los datos subyacentes de los formularios e informes de un proyecto de Microsoft Access (proyecto de Microsoft Access: archivo de Access que se conecta con una base de datos de Microsoft SQL Server y se utiliza para crear aplicaciones cliente-servidor. Un archivo de proyecto no contiene datos ni objetos basados en definiciones de datos, como, por ejemplo, tablas o vistas.) (.adp).

http://www.monografias.com/trabajos34/microsoft-access/microsoft-access.shtml#archiv

Módulo divertido en Visual Basic 2010 Express


a1

Para crear este juego, utilize GraphicsWindows para crear la interfaz de usuario. Utilize el objeto Controls para agregar un botón y un cuadro de texto y establecer el tamaño de los botones. Utilize el objeto Shapes para agregar diferentes formas. También utilize el objeto Shapes para mostrar, mover, y ocultar formas. Use el objeto Turtle para establecer su ángulo, velocidad y posición. Utilize varias condiciones para diferentes acciones.

Importado  de MS Small Basic

Module UntitledModule

    Dim anVent, alVent, botónPresionado, x, cuadroTextoLados, botónDibujar, botónBorrar, lados, color, i, colorPaleta, largo, ángulo, j, y, índicePaleta As Primitive

    Sub Main()

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

 

        GraphicsWindow.Hide()

        anVent = 600

        alVent = 450

 

        GraphicsWindow.CanResize = “Falso”

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

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

        GraphicsWindow.Title = “Dibujar gráficos con la tortuga”

        GraphicsWindow.Width = anVent

        GraphicsWindow.Height = alVent

        GraphicsWindow.Show()

 

        CrearInterfaz()

 

        AddHandler Controls.ButtonClicked, AddressOf ClicBotón

        AddHandler GraphicsWindow.MouseDown, AddressOf ClicMouse

 

 

 

 

 

    End Sub

    Sub CrearInterfaz()

        GraphicsWindow.BrushColor = “Black”

        GraphicsWindow.DrawText(70, 25, “Introduzca los lados: “)

 

        cuadroTextoLados = Controls.AddTextBox(200, 20)

        Controls.SetSize(cuadroTextoLados, 50, 30)

 

        botónDibujar = Controls.AddButton(“Dibujar imagen”, 270, 20)

        Controls.SetSize(botónDibujar, 110, 30)

 

        botónBorrar = Controls.AddButton(“Borrar”, 390, 20)

        Controls.SetSize(botónBorrar, 100, 30)

 

        GraphicsWindow.PenColor = “Black”

        GraphicsWindow.DrawRectangle(55, 55, 490, 380)

 

        DibujarPaleta()

    End Sub

    Sub ClicBotón()

        botónPresionado = Controls.LastClickedButton

        If botónPresionado = botónDibujar Then

            lados = Controls.GetTextBoxText(cuadroTextoLados)

            If (lados < 3) or (lados > 35) Then

                Controls.SetTextBoxText(cuadroTextoLados, “”)

            Else

                DrawShape()

            End If

        ElseIf botónPresionado = botónBorrar Then

            Controls.SetTextBoxText(cuadroTextoLados, “”)

            GraphicsWindow.BrushColor = “White”

            GraphicsWindow.FillRectangle(55, 55, 490, 380)

            GraphicsWindow.PenColor = “Black”

            GraphicsWindow.DrawRectangle(55, 55, 490, 380)

        End If

    End Sub

    Sub DibujarPaleta()

        color(1) = “Red”

        color(2) = “DeepPink”

        color(3) = “Magenta”

        color(4) = “BlueViolet”

        color(5) = “MediumSlateBlue”

        color(6) = “LimeGreen”

        color(7) = “DeepSkyBlue”

        color(8) = “Blue”

        color(9) = “DarkGreen”

 

        color(10) = “Aqua”

        color(11) = “Green”

        color(12) = “SpringGreen”

        color(13) = “Yellow”

        color(14) = “YellowGreen”

        color(15) = “SteelBlue”

        color(16) = “DarkSlateBlue”

        color(17) = “Black”

        color(18) = “Orange”

 

        GraphicsWindow.PenColor = “Black”

        For i = 1 To 9

            GraphicsWindow.Brushcolor = color(i)

            colorPaleta = Shapes.AddRectangle(40, 40)

            Shapes.Move(colorPaleta, 4, (i * 44) + 6)

        Next

 

        For i = 1 To 9

            GraphicsWindow.Brushcolor = color(i + 9)

            colorPaleta = Shapes.AddRectangle(40, 40)

            Shapes.Move(colorPaleta, 554, (i * 44) + 6)

        Next

    End Sub

    Sub DrawShape()

        GraphicsWindow.DrawRectangle(55, 55, 490, 380)

        Turtle.Show()

        Program.Delay(500)

 

        largo = 500 / lados

        ángulo = 360 / lados

 

        Turtle.Speed = 10

        Turtle.X = 300

        Turtle.Y = 240

 

        For j = 1 To 10

            For i = 1 To lados

                Turtle.Move(largo)

                Turtle.Turn(ángulo)

            Next

            Turtle.Turn(36)

        Next

    End Sub

    Sub ClicMouse()

        x = GraphicsWindow.MouseX

        y = GraphicsWindow.MouseY

 

        If (y > 50) And (y < 446) Then

            If Microsoft.SmallBasic.Library.Math.Remainder(y – 6, 44) <= 40 Then

                índicePaleta = Microsoft.SmallBasic.Library.Math.Floor((y – 6) / 44)

 

                If (x > 4) And (x < 44) Then

                    ‘ Paleta izquierda

                    GraphicsWindow.PenColor = color(índicePaleta)

                    Controls.SetTextBoxText(cuadroTextoLados, “”)

                ElseIf (x > 554) And (x < 594) Then

                    ‘ Paleta derecha

                    GraphicsWindow.PenColor = color(índicePaleta + 9)

                    Controls.SetTextBoxText(cuadroTextoLados, “”)

                End If

 

                GraphicsWindow.DrawRectangle(55, 55, 490, 380)

            End If

        End If

    End Sub

End Module

 

The Developer’s Reference Guide to Small Basic


a1

1. Introducing Small Basic

2. Overview of Small Basic Programming

3. Program Object

4. TextWindow Object

5. GraphicsWindow Object

EAA, Ed Price, en-US, Small Basic, Small Basic E-Books, The Developer’s Reference Guide to Small Basic

[Edit tags]

//

http://social.technet.microsoft.com/wiki/contents/articles/16767.the-developers-reference-guide-to-small-basic.aspx

Código Small Basic


a1

Estas son las instrucciones Small Basic que al aplicarse la función “Graduar” devuelve el módulo Visual Basic posteado en:

https://empiezoinformatica.wordpress.com/2013/04/13/visual-basic-module-graduado-desde-small-basic/

También vea:   http://mssbesp.wordpress.com/2009/04/28/aplicaciones-en-modo-consola-con-small-basic/

  1. ‘ Prueba con operaciones matemáticas
  2. ‘—————————————————-
  3. TextWindow.Title = “Prueba con operaciones matemáticas”
  1. endl = Text.GetCharacter(13)        ‘\n
  2. endl = endl + Text.GetCharacter(10) ‘\r
  3. ‘—————————————————-
  4. aux = “Abs(8)       = ” + Math.Abs(8)
  5. TextWindow.WriteLine(aux)
  1. aux = “Abs(-8)      = ” + Math.Abs(-8)
  2. TextWindow.WriteLine(aux)
  3. TextWindow.Write(endl)
  4. ‘—————————————————-
  5. aux = “Round(4.4)   = ” + Math.Round(4.4)
  6. TextWindow.WriteLine(aux)
  1. aux = “Round(4.6)   = ” + Math.Round(4.6)
  2. TextWindow.WriteLine(aux)
  1. aux = “Round(4.5)   = ” + Math.Round(4.5)
  2. TextWindow.WriteLine(aux)
  1. aux = “Round(5.5)   = ” + Math.Round(5.5)
  2. TextWindow.WriteLine(aux)
  1. aux = “Ceiling(3.5) = ” + Math.Ceiling(3.5)
  2. TextWindow.WriteLine(aux)
  1. aux = “Floor(3.5)   = ” + Math.Floor(3.5)
  2. TextWindow.WriteLine(aux)
  3. TextWindow.Write(endl)
  4. ‘—————————————————-
  5. e = 2.7182818284590452354
  6. aux = “e            = ” + e
  7. TextWindow.WriteLine(aux)
  1. aux = “Ln(e)        = ” + Math.NaturalLog(e)
  2. TextWindow.WriteLine(aux)
  1. aux = “Log(10)      = ” + Math.Log(10.0)
  2. TextWindow.WriteLine(aux)
  3. TextWindow.Write(endl)
  4. ‘—————————————————-
  5. aux = ” 7 ^ 11      = ” + Math.Power(7, 11)
  6. TextWindow.WriteLine(aux)
  1. aux = “23 ^ (1/2)   = ” + Math.SquareRoot(23)
  2. TextWindow.WriteLine(aux)
  3. TextWindow.Write(endl)
  1. TextWindow.Pause()
  2. TextWindow.Clear()
  3. ‘—————————————————-
  4. pi = Math.Pi
  5. aux = “Pi = ” + pi
  6. TextWindow.WriteLine(aux)
  7. TextWindow.Write(endl)
  8. ‘—————————————————-
  9. rad = 0
  10. aux = “0        radianes = ” + Math.GetDegrees(rad)
  11. TextWindow.WriteLine(aux)
  1. rad = pi / 2
  2. aux = “Pi / 2   radianes = ” + Math.GetDegrees(rad)
  3. TextWindow.WriteLine(aux)
  1. rad = pi
  2. aux = “Pi       radianes = ” + Math.GetDegrees(rad)
  3. TextWindow.WriteLine(aux)
  1. rad = pi * 3 / 2
  2. aux = “3 Pi / 2 radianes = ” + Math.GetDegrees(rad)
  3. TextWindow.WriteLine(aux)
  1. rad = pi * 2
  2. aux = “2 Pi     radianes = ” + Math.GetDegrees(rad)
  3. TextWindow.WriteLine(aux)
  4. TextWindow.Write(endl)
  5. ‘—————————————————-
  6. aux = ”  0 º = ” + Math.GetRadians(0)
  7. TextWindow.WriteLine(aux)
  1. aux = ” 90 º = ” + Math.GetRadians(90)
  2. TextWindow.WriteLine(aux)
  1. aux = “180 º = ” + Math.GetRadians(180)
  2. TextWindow.WriteLine(aux)
  1. aux = “270 º = ” + Math.GetRadians(270)
  2. TextWindow.WriteLine(aux)
  1. aux = “360 º = ” + Math.GetRadians(360)
  2. TextWindow.WriteLine(aux)
  3. TextWindow.Write(endl)
  1. TextWindow.Pause()
  2. TextWindow.Clear()
  3. ‘—————————————————-
  4. For i = 0 To 360 Step 18
  5. rad = Math.GetRadians(i)
  6. If i < 10 Then
  7. aux = “Cos(” + i + “)   = “
  8. ElseIf i < 100 Then
  9. aux = “Cos(” + i + “)  = “
  10. Else
  11. aux = “Cos(” + i + “) = “
  12. EndIf
  13. aux = aux + Math.Cos(rad)
  14. TextWindow.WriteLine(aux)
  15. EndFor
  16. TextWindow.Write(endl)
  1. TextWindow.Pause()
  2. TextWindow.Clear()
  1. For i = 0 To 360 Step 18
  2. rad = Math.GetRadians(i)
  3. If i < 10 Then
  4. aux = “Sin(” + i + “)   = “
  5. ElseIf i < 100 Then
  6. aux = “Sin(” + i + “)  = “
  7. Else
  8. aux = “Sin(” + i + “) = “
  9. EndIf
  10. aux = aux + Math.Sin(rad)
  11. TextWindow.WriteLine(aux)
  12. EndFor
  13. TextWindow.Write(endl)
  1. TextWindow.Pause()
  2. TextWindow.Clear()
  1. For i = 0 To 360 Step 18
  2. If i <> 90 And i <> 270 Then
  3. rad = Math.GetRadians(i)
  4. If i < 10 Then
  5. aux = “Tan(” + i + “)   = “
  6. ElseIf i < 100 Then
  7. aux = “Tan(” + i + “)  = “
  8. Else
  9. aux = “Tan(” + i + “) = “
  10. EndIf
  11. aux = aux + Math.Tan(rad)
  12. Else
  13. If i = 90 Then
  14. aux = “Tan(90)  = Infinito”
  15. Else
  16. aux = “Tan(270) = -Infinito”
  17. EndIf
  18. EndIf
  19. TextWindow.WriteLine(aux)
  20. EndFor
  21. TextWindow.Write(endl)
  1. TextWindow.Pause()
  2. TextWindow.Clear()
  3. ‘—————————————————-
  4. aux = “37 % 42 = ” + Math.Remainder(37, 42)
  5. TextWindow.WriteLine(aux)
  6. TextWindow.Write(endl)
  7. ‘—————————————————-
  8. aux = “Max(9, 8) = ” + Math.Max(9, 8)
  9. TextWindow.WriteLine(aux)
  1. aux = “Max(4, 6) = ” + Math.Max(4, 6)
  2. TextWindow.WriteLine(aux)
  3. TextWindow.Write(endl)
  1. aux = “Min(9, 8) = ” + Math.Min(9, 8)
  2. TextWindow.WriteLine(aux)
  1. aux = “Min(4, 6) = ” + Math.Min(4, 6)
  2. TextWindow.WriteLine(aux)
  3. TextWindow.Write(endl)
  4. ‘—————————————————-
  5. For i = 1 To 10
  6. aux = “Random()  = ” + Math.GetRandomNumber(10)
  7. TextWindow.WriteLine(aux)
  8. EndFor
  9. TextWindow.Write(endl)

Visual Basic Module graduado desde Small Basic


a1

Este ejercicio es una prueba de operaciones matemáticas, codificado en Small Basic y convertido a VB.NET con la función “graduar”

matModule

Dim endl, aux, e, pi, rad, i AsPrimitive

Sub Main()

‘ Prueba con operaciones matemáticas

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

TextWindow.Title = “Prueba con operaciones matemáticas”

endl =

Text.GetCharacter(13) ‘\n

endl = endl +

Text.GetCharacter(10) ‘\r

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

aux =

“Abs(8)       = “ + Microsoft.SmallBasic.Library.Math.Abs(8)

TextWindow.WriteLine(aux)

aux =

“Abs(-8)      = “ + Microsoft.SmallBasic.Library.Math.Abs(-8)

TextWindow.WriteLine(aux)

TextWindow.Write(endl)

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

aux =

“Round(4.4)   = “ + Microsoft.SmallBasic.Library.Math.Round(4.4)

TextWindow.WriteLine(aux)

aux =

“Round(4.6)   = “ + Microsoft.SmallBasic.Library.Math.Round(4.6)

TextWindow.WriteLine(aux)

aux =

“Round(4.5)   = “ + Microsoft.SmallBasic.Library.Math.Round(4.5)

TextWindow.WriteLine(aux)

aux =

“Round(5.5)   = “ + Microsoft.SmallBasic.Library.Math.Round(5.5)

TextWindow.WriteLine(aux)

aux =

“Ceiling(3.5) = “ + Microsoft.SmallBasic.Library.Math.Ceiling(3.5)

TextWindow.WriteLine(aux)

aux =

“Floor(3.5)   = “ + Microsoft.SmallBasic.Library.Math.Floor(3.5)

TextWindow.WriteLine(aux)

TextWindow.Write(endl)

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

e = 2.7182818284590452354

aux =

“e            = “ + e

TextWindow.WriteLine(aux)

aux =

“Ln(e)        = “ + Microsoft.SmallBasic.Library.Math.NaturalLog(e)

TextWindow.WriteLine(aux)

aux =

“Log(10)      = “ + Microsoft.SmallBasic.Library.Math.Log(10.0)

TextWindow.WriteLine(aux)

TextWindow.Write(endl)

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

aux =

” 7 ^ 11      = “ + Microsoft.SmallBasic.Library.Math.Power(7, 11)

TextWindow.WriteLine(aux)

aux =

“23 ^ (1/2)   = “ + Microsoft.SmallBasic.Library.Math.SquareRoot(23)

TextWindow.WriteLine(aux)

TextWindow.Write(endl)

TextWindow.Pause()

TextWindow.Clear()

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

pi = Microsoft.SmallBasic.Library.

Math.Pi

aux =

“Pi = “ + pi

TextWindow.WriteLine(aux)

TextWindow.Write(endl)

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

rad = 0

aux =

“0        radianes = “ + Microsoft.SmallBasic.Library.Math.GetDegrees(rad)

TextWindow.WriteLine(aux)

rad = pi / 2

aux =

“Pi / 2   radianes = “ + Microsoft.SmallBasic.Library.Math.GetDegrees(rad)

TextWindow.WriteLine(aux)

rad = pi

aux =

“Pi       radianes = “ + Microsoft.SmallBasic.Library.Math.GetDegrees(rad)

TextWindow.WriteLine(aux)

rad = pi * 3 / 2

aux =

“3 Pi / 2 radianes = “ + Microsoft.SmallBasic.Library.Math.GetDegrees(rad)

TextWindow.WriteLine(aux)

rad = pi * 2

aux =

“2 Pi     radianes = “ + Microsoft.SmallBasic.Library.Math.GetDegrees(rad)

TextWindow.WriteLine(aux)

TextWindow.Write(endl)

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

aux =

”  0 º = “ + Microsoft.SmallBasic.Library.Math.GetRadians(0)

TextWindow.WriteLine(aux)

aux =

” 90 º = “ + Microsoft.SmallBasic.Library.Math.GetRadians(90)

TextWindow.WriteLine(aux)

aux =

“180 º = “ + Microsoft.SmallBasic.Library.Math.GetRadians(180)

TextWindow.WriteLine(aux)

aux =

“270 º = “ + Microsoft.SmallBasic.Library.Math.GetRadians(270)

TextWindow.WriteLine(aux)

aux =

“360 º = “ + Microsoft.SmallBasic.Library.Math.GetRadians(360)

TextWindow.WriteLine(aux)

TextWindow.Write(endl)

TextWindow.Pause()

TextWindow.Clear()

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

For i = 0 To 360 Step 18

rad = Microsoft.SmallBasic.Library.

Math.GetRadians(i)

If i < 10 Then

aux =

“Cos(“ + i + “)   = “

ElseIf i < 100 Then

aux =

“Cos(“ + i + “)  = “

Else

aux =

“Cos(“ + i + “) = “

EndIf

aux = aux + Microsoft.SmallBasic.Library.

Math.Cos(rad)

TextWindow.WriteLine(aux)

Next

TextWindow.Write(endl)

TextWindow.Pause()

TextWindow.Clear()

For i = 0 To 360 Step 18

rad = Microsoft.SmallBasic.Library.

Math.GetRadians(i)

If i < 10 Then

aux =

“Sin(“ + i + “)   = “

ElseIf i < 100 Then

aux =

“Sin(“ + i + “)  = “

Else

aux =

“Sin(“ + i + “) = “

EndIf

aux = aux + Microsoft.SmallBasic.Library.

Math.Sin(rad)

TextWindow.WriteLine(aux)

Next

TextWindow.Write(endl)

TextWindow.Pause()

TextWindow.Clear()

For i = 0 To 360 Step 18

If (i <> 90) And (i <> 270) Then

rad = Microsoft.SmallBasic.Library.

Math.GetRadians(i)

If i < 10 Then

aux =

“Tan(“ + i + “)   = “

ElseIf i < 100 Then

aux =

“Tan(“ + i + “)  = “

Else

aux =

“Tan(“ + i + “) = “

EndIf

aux = aux + Microsoft.SmallBasic.Library.

Math.Tan(rad)

Else

If i = 90 Then

aux =

“Tan(90)  = Infinito”

Else

aux =

“Tan(270) = -Infinito”

EndIf

EndIf

TextWindow.WriteLine(aux)

Next

TextWindow.Write(endl)

TextWindow.Pause()

TextWindow.Clear()

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

aux =

“37 % 42 = “ + Microsoft.SmallBasic.Library.Math.Remainder(37, 42)

TextWindow.WriteLine(aux)

TextWindow.Write(endl)

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

aux =

“Max(9, 8) = “ + Microsoft.SmallBasic.Library.Math.Max(9, 8)

TextWindow.WriteLine(aux)

aux =

“Max(4, 6) = “ + Microsoft.SmallBasic.Library.Math.Max(4, 6)

TextWindow.WriteLine(aux)

TextWindow.Write(endl)

aux =

“Min(9, 8) = “ + Microsoft.SmallBasic.Library.Math.Min(9, 8)

TextWindow.WriteLine(aux)

aux =

“Min(4, 6) = “ + Microsoft.SmallBasic.Library.Math.Min(4, 6)

TextWindow.WriteLine(aux)

TextWindow.Write(endl)

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

For i = 1 To 10

aux =

“Random()  = “ + Microsoft.SmallBasic.Library.Math.GetRandomNumber(10)

TextWindow.WriteLine(aux)

Next

TextWindow.Write(endl)

EndSub

End

Module

Visual Basic / Small Basic


vbasic2

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

What are the limitations of Small Basic?

We wanted to keep Small Basic as small and intuitive as possible. We felt that it’s okay to limit Small Basic from being the language of choice for solving every conceivable problem. For example, while it’s theoretically possible to write a Small Basic compiler using Small Basic, it’s probably not a good idea.

What is the evolution strategy for the language?

One of the most important visions of this project is to focus on the beginner persona. This is very imporatant for us and we’ve so far successfully avoided the temptation to add any any feature that doesn’t cater to this persona. We’ll continue to be guided by this vision. So, don’t expect Small Basic to start supporting Generics any time soon. 🙂


What is the future of Small Basic?

The future of Small Basic depends on you. If the idea and the project are received well, we’ll continue to invest in developing newer versions and supporting the most requested features.

http://smallbasic.com/faq.aspx

Visual Basic y Small Basic


vbasic2

¿Cómo es de diferente con Visual Basic.Net?
Small Basic es pequeño – mucho menor que VB y soporta solo un subconjunto de lo que VB.Net apoya. Además, usted puede escribir un compilador usando VB.Net
¿Cuáles son las limitaciones de Small Basic?
Queríamos mantener Small Basic lo más pequeño y lo más intuitivo posible. Nos sentimos que está bien para limitar Small Basic de ser el lenguaje de su elección para resolver todo tipo de problemas. Por ejemplo, si bien es teóricamente posible escribir un compilador Small Basic utilizando Small Basic, probablemente no sea una buena idea.
¿Cuál es la estrategia de evolución del lenguaje?
Una de las visiones más importantes de este proyecto es centrarse en la persona principiante. Esto es muy importante  para nosotros y hemos conseguido hasta el momento evitar la tentación de agregar cualquier característica alguna que no responda a esta persona. Vamos a seguir guiándonos  por esta visión. Por lo tanto, no espere Small Basic a empezar a apoyar a los genéricos en el corto plazo. 🙂
________________________________________
¿Cuál es el futuro de Small Basic?
El futuro de Small Basic depende de usted. Si la idea y el proyecto se reciben bien, vamos a seguir invirtiendo en el desarrollo de nuevas versiones y apoyar a las características más solicitadas.
http://smallbasic.com/faq.aspx

Archivos de base de datos de Access


a12

Por medio de Microsoft Access, puede administrar toda la información desde un único archivo de base de datos. Dentro del archivo, puede utilizar:

  • Tablas para almacenar los datos.
  • Consultas para buscar y recuperar únicamente los datos que necesita.
  • Formularios para ver, agregar y actualizar los datos de las tablas.
  • Informes para analizar o imprimir los datos con un diseño específico.
  • Páginas de acceso a datos para ver, actualizar o analizar los datos de la base de datos desde Internet o desde una intranet.

Almacenar los datos una vez en una tabla y verlos desde varios lugares.

Cuando se actualizan los datos, se actualizan en todos los lugares donde aparecen.

Mostrar los datos en una consulta

Mostrar los datos en un formulario

Mostrar los datos en un informe

Mostrar los datos en una página de acceso a datos

Tablas y relaciones

Para almacenar los datos, cree una tabla para cada tipo de información de la que hace el seguimiento. Para reunir los datos de varias tablas en una consulta, formulario, informe o página de acceso a datos, defina relaciones entre las tablas.

La información de clientes que antes se guardaba en una lista de correo ahora reside en la tabla Clientes.

La información de pedidos que antes se guardaba en una hoja de cálculo ahora reside en la tabla Pedidos.

Un Id. exclusivo, como un Id. de cliente, permite distinguir los registros de una tabla. Si se agrega el campo de Id. exclusivo de una tabla a otra tabla y después se define una relación, Microsoft Access puede cotejar los registros relacionados de ambas tablas de manera que se puedan combinar en un formulario, un informe o una consulta.

Consultas

Para buscar y recuperar tan sólo los datos que cumplen las condiciones especificadas, incluyendo datos de varias tablas, cree una consulta. Una consulta puede también actualizar o eliminar varios registros al mismo tiempo, y realizar cálculos predefinidos o personalizados en los datos.

Esta consulta tiene acceso a tablas distintas para recuperar la información de Id. de pedido, fecha de entrega, nombre de la organización y ciudad para los clientes de Londres cuyos pedidos se entregaron en el mes de abril.

Formularios

Para ver, escribir y cambiar datos de manera sencilla directamente en una tabla, cree un formulario. Al abrir un formulario, Microsoft Access recupera los datos de una o más tablas, y los muestra en la pantalla con el diseño elegido en el Asistente para formularios, o con un diseño que haya creado en la vista Diseño (vista Diseño: ventana que muestra el diseño de estos objetos de base de datos: tablas, consultas, formularios, informes, macros y páginas de acceso a datos. En la vista Diseño, puede crear objetos de base de datos nuevos y modificar el diseño de otros existentes.).

Una tabla muestra muchos registros al mismo tiempo, pero puede que sea necesario desplazarse para ver todos los datos de un solo registro. Por otra parte, cuando se visualiza una tabla, no se pueden actualizar los datos de más de una tabla al mismo tiempo.

Un formulario sitúa el enfoque en un registro cada vez, pero puede mostrar los campos de más de una tabla. También puede mostrar imágenes y otros objetos.

Un formulario puede incluir un botón que imprima o abra otros objetos, o puede realizar otras tareas automáticamente.

Informes

Para analizar los datos o presentarlos de cierta manera al imprimirlos, cree un informe. Por ejemplo, puede imprimir un informe que agrupe datos y calcule totales, y otro informe de datos diferentes con formato para imprimir etiquetas postales.

  • Utilice un informe para crear etiquetas postales.
  • Utilice un informe para mostrar totales en un gráfico.
  • Utilice un informe para calcular tota

http://www.monografias.com/trabajos34/microsoft-access/microsoft-access.shtml#archiv

EXCEL: TRABAJAR CON VARIOS LIBROS


a11

 

Un único libro de hojas de cálculo de Excel, puede contener millones de bytes de datos. Sin embargo, en algunos casos resulta más conveniente abrir un nuevo libro para situar en él nuevos datos que desplazarse a otra hoja de cálculo dentro del mismo archivo.

También puede ser necesario repartir el contenido de un libro en dos o más libros para facilitar su manipulación, tanto a efectos de almacenamiento como de uso.

No obstante, cuando se almacena información en archivos distintos, puede ser necesario utilizar en uno de ellos los datos contenidos en el otro. Excel facilita la selección de datos de un libro distinto del libro activo, así como las operaciones de copia y traslado de datos entre archivos. También pueden crearse enlaces entre libros mediante fórmulas, los cuales siguen funcionando, aún cuando uno de los libros no esté abierto.

Puedes utilizar la opción Organizar… en el menú Ventana para distribuir los distintos libros abiertos según indiques, disponiéndolos unos sobre otros o adaptándolos de forma que todos queden visibles.

  • ABRIR VARIOS LIBROS

Cuando se inicia una sesión de trabajo de Excel, aparece en pantalla un nuevo libro vacío y, en la barra de título muestra su nombre que por defecto es Librol.

Si lo necesitas, podrás abrir otro libro en otra ventana. Cuando tienes varios libros abiertos, el libro que contiene el indicador de celda es el libro activo, pues sólo puedes trabajar sobre un libro en cada momento auque tengas varios abiertos a la vez.

Para abrir otro libro, sin cerrar el actual, sigue los pasos indicados en el punto ¡Error! No se encuentra el origen de la referencia. (para abrir un archivo existente utiliza Archivo – Abrir…, y para empezar un archivo nuevo elige Archivo – Nuevo).

Si quieres colocar las ventanas de forma que cada una de ellas permanezca visible, elige Ventana-Organizar…. y selecciona la disposición que te resulte más cómoda.

http://html.rincondelvago.com/microsoft-excel.HTML

Entorno + instrucciones en Small Basic


a10

En la imagen vemos las instrucciones escritas en el EDITOR

Por acción de InteliSense, al tipear “b”  despliega Backgroundcolor

Al dar clic en la flecha azul (arriba), se ejecuta el programa.

A la izquierda con un clic importamos de o exportamos a la Web

A la derecha con un clic convertimos el programa de Small Basic a Visual Basic

Los iconos restantes son absolutamente intuitivos

Descarga de un programa Small Basic


a1

 

Para acceder a cualquier programa publicado en Small Basic, haga clic en Importar de la barra de herramientas. El programa puede ser el que ud haya subido, un conocido o puede elegir el programa a descargar seleccionándolo de la galería:

http://blogs.msdn.com/b/smallbasic/archive/2013/02/17/small-basic-program-gallery-listed-by-category.aspx

Debe especificar el identificador de programa único en la caja de texto y hacer clic en Aceptar.

En cambio para publicar su programa  haga  clic en el botón Publicar ¡su programa se publica al momento!

Small Basic genera y muestra un identificador único para su programa. Use dicho identificador para compartir su programa con otros.

También puede asignar un título a su programa, junto con una descripción breve y definir la categoría de su programa.

Páginas Web orientadas a datos


a1

  • Para crear un sitio Web del sistema de archivos
  • Abra Visual Web Developer.
  • En el menú Archivo, haga clic en Nuevo Sitio Web.
  • Aparece el cuadro de diálogo Nuevo sitio Web.
  • En Plantillas instaladas de Visual Studio, haga clic en Sitio Web de ASP.NET.
  • En el cuadro Ubicación situado en el extremo derecho, escriba el nombre de la carpeta en la que desea conservar las páginas del sitio Web.
  • Por ejemplo, escriba el nombre de carpeta C:\WebSites.
  • En la lista Lenguaje, haga clic en el lenguaje de programación con el que prefiera trabajar.
  • Haga clic en Aceptar.
  • Visual Web Developer crea la carpeta y una nueva página denominada Default.aspx.

http://msdn.microsoft.com/es-es/library/bdhhebch(v=vs.80).aspx

Compartir sus programas de Small Basic subiendo el código a Internet.


a1

Una vez que ha creado un programa, puede compartir el código haciendo clic en el botón Publicar. Puede especificar información detallada tal como nombre, descripción y categoría del programa. Ahora su programa está disponible en línea. Para compartirlo con sus amigos debe darles el número de identificación único asignado a su programa.

Small Basic genera y muestra un identificador único para su programa. Use dicho identificador para compartir su programa con otros.

También puede asignar un título a su programa, junto con una descripción breve y definir la categoría de su programa.

¿¿..CÓMO ENSEÑAR A PROGRAMAR..??


a1

 EL PRESENTE BLOG ESTA DISEÑADO COMO UNA AYUDA AL DOCENTE Y A LOS ALUMNOS. ESPERAMOS CONTAR CON SUS COMENTARIOS DE ESTA MANERA PODER MEJORAR Y ACTUALIZAR ESTA PÁGINA…

 

Conceptos básicos de programación

Es un proceso para convertir especificaciones generales de un sistema en instrucciones utilizables por la máquina, que produzcan los resultados deseados. Se le conoce también como desarrollo de software.

PROGRAMA:

DATOS:

Son las características propias de cualquier entidad. Por ejemplo: los datos de una persona como su edad, fecha de nacimiento, domicilio, número de teléfono, etc.

INFORMACIÓN:
 

Es el conocimiento relevante producido como resultado del procesamiento de datos y adquirido por la gente para realzar el entendimiento y cumplir ciertos propósitos.

1.      Especificación del programa

Se conoce también como definición del problema o análisis del programa. En este paso se determinan la información inicial para la elaboración del programa. Es donde se determina qué es lo que debe resolverse con el computador, de qué presupuestos se debe partir… en definitiva, el planteamiento del problema.

Se requieren cinco tareas:

2. Diseño del programa

Es diseñar cualquier sistema nuevo o las aplicaciones que se requieren para satisfacer las necesidades. Esta actividad se debe dividir en:

– Operaciones de entrada/salida

– Cálculos

– Lógica/ comparación

– Almacenamiento/ consulta

En este paso se genera una solución con técnicas de programación como diseño descendente de programas, pseudocódigos, flujogramas y estructuras lógicas.

3. Codificación del programa

Es la generación real del programa con un lenguaje de programación. En esta etapa se hace uso de la lógica que desarrolló en el paso del diseño del programa para efectivamente generar un programa. Se debe seleccionar el lenguaje apropiado para resolver el problema.

4. Prueba y depuración del programa

Depurar es correr el programa en una computadora y corregir las partes que no funcionan. En esta fase se comprueba el funcionamiento de cada programa y esto se hace con datos reales o ficticios. Cuando los programas están depurados, se prueban. Cuando los programas se depuran, se pueden encontrar los siguientes errores:

a) Errores de sintaxis o de compilación

Es una violación de las reglas del lenguaje de programación. Son más fáciles de corregir, ya que son detectados por el compilador (posible error de escritura), el cual dará información sobre el lugar donde está y la naturaleza de cada uno de ellos mediante un mensaje de error.

b) Errores de Ejecución

Se deben generalmente a operaciones no permitidas como dividir por cero, leer un dato no numérico en una variable numérica, exceder un rango de valores permitidos, etc. Se detectan porque se produce una parada anormal del programa durante su ejecución.

c) Errores de Lógica

Corresponden a la obtención de resultados que no son correctos y la única manera de detectarlos es realizando suficientes pruebas del programa. Son los más difíciles de corregir, no sólo por la dificultad de detectarlos, sino porque se deben a la propia concepción y diseño del programa.

d) Errores de Especificación

Es el peor tipo de error y el más difícil de corregir. Se deben a mal diseño del programa posiblemente por mala comunicación usuario programador y se detectan cuando ya se ha concluido el diseño e instalación del programa, lo cual puede implicar repetir gran parte del trabajo realizado.

Prueba:
 
Consiste en verificar la funcionalidad del programa a través de varios métodos para detectar errores posibles.

Métodos de Prueba:

Chequeo de escritorio

Prueba manual de datos de muestra

Intento de traducción

Prueba de datos de muestra en la computadora

Prueba por un grupo selecto de usuarios potenciales.

5. Documentación del programa

Consiste en describir por escrito a nivel técnico los procedimientos relacionados con el programa y su modo de uso. También se debe documentar el programa para que sea más entendible.

¿Para quiénes son la documentación?

– Usuarios (Digitadores)

– Operadores

– Programadores

– Analistas de sistemas

Documentos que se elaboran:

Manual de Usuario y Manual del Analista.

A los usuarios se les elabora un manual de referencia para que aprendan a utilizar el programa. Esto se hace a través de capacitaciones y revisión de la documentación del manual de usuario. El manual del usuario no está escrito a nivel técnico sino al de los distintos usuarios previstos y explica en detalle cómo usar el programa: descripción de las tareas que realiza el programa, instrucciones necesarias para su instalación puesta en marcha y funcionamiento, recomendaciones de uso, menús de opciones, método de entrada y salida de datos, mensajes de error, recuperación de errores, etc.

A los operadores por si se presentan mensajes de error, sepan cómo responder a ellos. Además que se encargan de darle soporte técnico al programa.

A los programadores a través del manual del analista para que recuerden aspectos de la elaboración del programa o en caso que otras personas puedan actualizarlo o modificarlo (darle mantenimiento) y no son necesariamente las personas que lo diseñaron. Es por ello, que la documentación debe contener algoritmos y flujogramas de los diferentes módulos que lo constituyen y las relaciones que se establecen entre ellos; listados del programa, corridas, descripción de variables que se emplean en cada módulo, cuáles son comunes a diferentes módulos y cuáles locales; descripción de los ficheros de cada módulo y todo lo que sea de importancia para un programador.

A los analistas de sistemas que son las personas que deberán proporcionar toda la información al programador. Estos se encargan de hacer una investigación previa de cómo realizar el programa y documentar con las herramientas necesarias para que el programador pueda desarrollar el sistema en algún lenguaje de programación adecuado.

6. Mantenimiento del programa

Es el paso final del desarrollo del software. Alrededor del 75% del costo total del ciclo de vida de un programa se destina al mantenimiento. El propósito del mantenimiento es garantizar que los programas en uso estén libres de errores de operación y sean eficientes y efectivos.

La lógica como aspecto fundamental de la programación

Es la capacidad de pensar racionalmente acerca de soluciones alternativas y los resultados de aplicarlas, y por lo tanto, de hacer elecciones inteligentes.

Definiciones de Lógica:

– Es el estudio crítico del razonamiento y tiene un valor teórico y práctico.

– Es el estudio de los métodos y principios usados al distinguir entre los argumentos correctos (buenos) y los argumentos incorrectos (malos).

– En un sentido amplio, es el estudio del correcto razonamiento.

En lógica, desarrolló para establecer un razonamiento encadenado que, si se respetaban, no producirían nunca falsas conclusiones si la reflexión partía de premisas verdaderas (reglas de validez).

¿Qué es Lógica?

Lógica Deductiva

Es la que se encarga de determinar la validez o invalidez de los argumentos. Permite proporcionar la simbología que nos servirá para facilitar el desarrollo de la capacidad de análisis de problemas, para obtener una solución posible.

Argumentos.
Cuando el razonamiento se expresa con palabras, recibe el nombre de “argumento”. Un argumento es un grupo cualquiera de proposiciones o enunciados que forman premisas y conclusiones. Este puede constar de varias premisas pero de una sola conclusión.

Premisas y Conclusión

Las premisas de un argumento son proposiciones afirmadas como fundamento o razones para aceptar una conclusión. La conclusión es la proposición afirmada que se basa en las otras proposiciones o premisas. Una proposición puede ser premisa en un argumento y conclusión en otro.

 

PRESIONE AQUI: ….BREVE SÍNTESIS.. 

Enviar por correo electrónicoEscribe un blogCompartir con TwitterCompartir con Facebook

Página principal

Suscribirse a: Entradas (Atom)

// VISITANTES

Páginas

http://estrategiasmetodologicasinformaticas.blogspot.com.ar/p/conclusiones.HTML

Aprender a programar


a1

Apender através de este curso los conceptos básicos de la lógica computacional, algoritmos, diagramas de flujo y su codificación realizado en el lenguaje de programación, el cual dará la pauta para establecer los fundamentos de programación.

Comprender y aplicar  los conceptos generales de la programación y lenguajes de programación, de lógica y cómo utilizarlo para deducir las tablas de verdad, además de otra serie de conceptos esenciales para ser un buen programador.

http://www.emagister.com/curso-aprende-programar

The Official Blog of Small Basic


a1

Small Basic Links

Small Basic Program Gallery (listed by Category)

Small Basic Extension Gallery

Small Basic Forum

Small Basic on TechNet Wiki

Small Basic Site

Options

http://blogs.msdn.com/b/smallbasic/archive/2013/04/10/small-basic-e-books.aspx

Código Small Basic convertido automáticamente (Graduar) en Visual Basic 2010


a1

Small Basic

GraphicsWindow.Title = “Explorando las formas”

Forma1 =Shapes.AddRectangle(100, 100)

Fpelota = Shapes.AddEllipse(100, 100)

Shapes.Move(Fpelota, 0, 340)

x = 450

GraphicsWindow.DrawRectangle(550, 0, 80, 450)

GraphicsWindow.BrushColor = “Purple”

GraphicsWindow.FillRectangle(550, 0, 80, 450)

Shapes.Animate(Fpelota, x, 40, 450)

Program.Delay(500)

If (Shapes.GetLeft(Fpelota) = x) Then

Shapes.Animate(Fpelota, 0, 340, 500)

EndIf

 Visual Basic 

Module animateModule

Dim Forma1, Fpelota, x As Primitive

Sub Main()

GraphicsWindow.Title = “Explorando las formas”

Forma1 = Shapes.AddRectangle(100, 100)

Fpelota = Shapes.AddEllipse(100, 100)

Shapes.Move(Fpelota, 0, 340)

x = 450

GraphicsWindow.DrawRectangle(550, 0, 80, 450)

GraphicsWindow.BrushColor = “Purple”

GraphicsWindow.FillRectangle(550, 0, 80, 450)

Shapes.Animate(Fpelota, x, 40, 450)

Program.Delay(500)

If Shapes.GetLeft(Fpelota) = x Then

Shapes.Animate(Fpelota, 0, 340, 500)

End If

End Sub

End Module

Informática elemental…


Está dirigido a alumnos de Colegios Secundarios, Estudiantes Universitarios, y profesionales (contadores, ingenieros) que necesiten usar las Tecnologías de la Información y las Comunicaciones, sin ser especialistas. Usuarios finales

En la parte superior hay un menú (índice) que al cliquear lo lleva al tema seleccionado.

Los posts están hechos de manera que incluyen un ejercicio para archivar en la carpeta de cada usuario y un pregunta teórica que se debe ingresar como comentario.

Las entradas (Posts) están lo suficientemente explicadas y detalladas, para que el usuario pueda resolverlas por sí mismo, sin consultar más que a un buscador de la Web.

Las entradas (Posts) aparecen en el orden de las más recientes (primeras) a las más antiguas. Seleccione la categoría (Excel p. ej) y aparecerá desde la última hacia la primera, en ese orden.

El tema lo puede seleccionar desde el MENÚ (arriba) o desde CATEGORÍAS (abajo).

También en ARCHIVOS podrá seleccionar la fecha (mes/ año) de las entradas o Posts

Gracias por sus comentarios.

Programa escrito en Small Basic y exportado automáticamente a Visual Basic (código)


a1

Código Small Basic

TextWindow.Write(“Introduzca el primer número: “)

num1= TextWindow.ReadNumber()

TextWindow.Write(“Introduzca el 2o número: “)

num2 = TextWindow.ReadNumber() 

FindMax()

TextWindow.WriteLine(“El mayor de los dos números es: ” + max) 

Sub FindMax

  If (num1 > num2) Then

    max = num1

  Else

    max = num2

  EndIf

EndSub

Código Visual Basic exportado desde Small Basic con la función Graduate

Module maxModule

    Dim num1, num2, max As Primitive

    Sub Main()

        TextWindow.Write(“Introduzca el primer numero: “)

        num1 = TextWindow.ReadNumber()

        TextWindow.Write(“Introduzca el 2o numero: “)

        num2 = TextWindow.ReadNumber() 

        FindMax()

        TextWindow.WriteLine(“El mayor de dos numeros es: ” + max) 

    End Sub

    Sub FindMax()

        If num1 > num2 Then

            max = num1

        Else

            max = num2

        End If

    End Sub

End Module

Excel Library for Small Basic – SOFTPEDIA


a1

 

Amplía las funciones de Small Basic usando esta biblioteca práctica.  Esta biblioteca amplía Small Basic para permitirte leer o escribir el contenido de una celda en el archivo de Excel desde el programa Small Basic.

Inicio rápido:
Después de instalar Excel Library for Small Basic podrás utilizar el objeto de Excel y seguir las funciones en Small Basic:
Excel.ReadCell (filePath, sheetName, rowIndex, columnIndex)
Lee el contenido de la celda especificada.

Excel.WriteCell (filePath, sheetName, rowIndex, columnIndex, newValue)
Escribe el contenido de la celda especificada.

Excel.CloseAll()
Cierra todos los archivos de Excel que se hayan abierto.

Requisitos:

http://www.softpedia.es/programa-Excel-Library-for-Small-Basic-181420.html
· Small Basic v.0.9x o versiones superiores
· NET Framework 3.5 Client Profile
· Microsoft Excel 2010 (x86)

Extendiendo Small Basic en C# (¡Excelente blog !)


a1

http://mssbesp.wordpress.com/2009/05/19/extendiendo-small-basic-en-c/

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

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

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

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

12

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

using Microsoft.SmallBasic.Library;namespace MisExtensiones   {

[SmallBasicType]

public static class MiExtension {

// Para definir   variables:

public static Primitive   Propiedad=new Primitive();

//   Para definir métodos:

public static void Metodo1()   {

//   Código del método…

}

public static void Metodo2(Primitive param) {

// Código del método…

}

public static Primitive   Metodo3() {

//   Código del método…

}

public static Primitive   Metodo4(Primitive param) {

//   Código del método…

}

//   Para definir manejadores de eventos:

public static event SmallBasicCallback Evento=null;

}

}

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

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

Small Basic: subrutinas en programas básicos (código)


a1

En este programa, se usa la instrucción Dividir( ) para ejecutar (o llamar) a la subrutina Dividir desde cualquier parte dentro del programa.

Cuando da la instrucción al ordenador para ejecutar una subrutina, está usando una declaración que contiene el nombre de la subrutina, seguida de un conjunto de apertura y cierre de paréntesis. Al usar este tipo de declaraciones, está llamando a la subrutina.

  1. TextWindow.Title = “Subrutinas en Small Basic”
  2. While i < 5
  3.   TextWindow.WriteLine(“Escriba el dividendo: “)
  4.   Dividendo = TextWindow.Read()
  5.   TextWindow.WriteLine(“Escriba el divisor: “)
  6.   Divisor = TextWindow.Read()
  7.   Dividir()
  8.   TextWindow.WriteLine(“El resultado es: ” + Respuesta)
  9.   i = i + 1
  10. EndWhile
  11. Sub Dividir
  12.   Respuesta = Dividendo / Divisor
  13. EndSub

Kodu Enseña más de Programación


a2
• Kodu es una herramienta para la creación de riqueza narrativa y la narración
• Kodu demuestra que la programación es un medio creativo
• Kodu ayuda a niños con pensamiento crítico, rompiendo una meta compleja en pasos manejables, e iterar sobre el proceso de diseño – un enfoque aplicable a todas las materias académicas, los negocios y las relaciones personales
• Kodu introduce la lógica y la resolución de problemas de programación
• Kodu introduce condiciones y secuencias, que enseña la causa y el efecto
• Los estudiantes aprenden sobre la cooperación, la lógica y la creatividad, además de la programación

http://www.kodugamelab.com/About

¿ Qué es Kodu?


a1
Kodu permite a los niños crear juegos en el PC y Xbox a través de un lenguaje de programación visual simple. Kodu puede ser utilizada para enseñar creatividad, resolución de problemas, narración de cuentos, así como de programación. Cualquiera puede usar Kodu para hacer un juego, los niños pequeños y los adultos sin conocimientos de diseño o programación.

Únete a nuestra comunidad y descubrir los juegos creados por otros y compartir sus juegos a KoduGameLab.com.

http://www.kodugamelab.com/About

¡ Enseñar Código en la escuela – antes de que sea demasiado tarde !


alumnos

¿ Se programa un tema que se debe enseñar en las escuelas? ¿O debemos dejar que los niños lo descubran por sí mismos? La evidencia reciente sugiere que en Vietnam la mitad de los estudiantes de grado 11años  podrían pasar el proceso de la entrevista Google! Esto no es lo suficientemente bueno – estudiantes de  grado 11 de todas partes deben ser capaces de pasar la entrevista de Google.
Todos los estudiantes en todas las escuelas deben tener la oportunidad de aprender a código

http://www.i-programmer.info/professional-programmer/i-programmer/5673-teach-code-in-school-before-its-too-late.html

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


a1

 

 

Con un nuevo y revolucionario IntelliSense ®, Small Basic hace que escribir código sea  muy sencillo.
Mirosoft Small Basic pone la “diversión” de nuevo en la programación de computadoras. Con un entorno favorable al desarrollo que es muy fácil de dominar, facilita tanto para niños y adultos en el mundo de la programación.

Simple: Small Basic combina un ambiente agradable, con un lenguaje muy sencillo y un conjunto rico y atractivo de las bibliotecas para hacer sus programas y  juegos. En cuestión de unas pocas líneas de código, usted estará bien en su manera de crear su propio juego!

http://smallbasic.com/about.aspx