Tutorial Basic256 PDF

Capítulo 1: Conociendo BASIC-256 – Diga Hola
Entonces, ¿Usted Desea

Aprender a Programar?
Segunda Edición
James M. Reneau, Ph.D.

Associate Professor
Shawnee State University
Portsmouth Ohio USA
Traducción al castellano por Oswy (Mayo 2014)
http://www.basicbook.org
James M. Reneau
P.O. Box 278
Russell, Kentucky 41169-2078 USA
Para BASIC-256 Version 1.0.0.6 o posterior
© 2014James M. Reneau (CC BY-NC-SA 3.0 US) Traducción al castellano por Oswy (Mayo 2014)
Página 1 of 258
Página 2 of 258
So You Want to Learn to Program?
James M. Reneau, Ph.D. - [email protected]
Copyright C) 2010, 2014

James Martel Reneau, Ph.D.
P.O. Box 278 – Russell KY 41169-0278 USA
Create Space Print ISBN: 978-1494859398

Revision Date: 20140101a
The work released under Creative Commons Attribution-Noncommercial-

Share Alike 3.0 United States License. See http://creativecommons.org for
more information.
Bajo esta licencia usted es libre de: NOTIMPLEMENTED

 De Compartir — copiar, distribuir y transmitir el trabajo
Bajo las siguientes condiciones:

 Attribución – Usted debe atribuir el trabajo o cualquier fragmento del trabajo a
los autores (pero de modo tal que, de ninguna manera, se sugiera que ellos
avalan a usted o o al uso que usted haga del trabajo)
 No-comercial – Usted no puede usar este trabajo con fines comerciales.
 Compartir – Si Usted altera, transforma, o construye sobre este trabajo, debe
distribuir el trabajo resultante bajo la misma o similar licencia que éste.
Traducción al castellano de la versión original en inglés por Osvaldo Lovotti

[email protected]
Página 3 of 258
TABLA DE CONTENIDOS
Prefacio.....................................................................................................................14
Capítulo 1: Conociendo BASIC-256 – Diga Hola..................................................15

La ventana de BASIC-256...............................................................................................15
Su primer programa – La declaración “say” (“decir”)........................................................17
BASIC-256 es realmente bueno con números – Aritmética Simple..................................18
Otro uso para el signo + (Concatenación).......................................................................20
Área de Salida de Texto – El comando “print” (imprimir)..................................................21
Que es un “Error de Sintaxis”? (“Syntax error")...............................................................21
Ejercicios:........................................................................................................................ 22
Capítulo 2: Dibujando Formas Básicas.................................................................23

Dibujando Rectángulos y Círculos...................................................................................23
Guardando su Programa y Cargándolo Nuevamente......................................................28
Dibujando con Líneas......................................................................................................28
Definiendo el Ancho de Línea y Dibujando el Contorno de una Figura............................30
Definiendo Puntos Individuales en Pantalla.....................................................................31
Ejercicios:........................................................................................................................ 35
Capítulo 3: Sonido y Música...................................................................................37

Las Bases del Sonido – Cosas que necesita saber sobre el sonido................................37
Variables Numéricas........................................................................................................40
Abreviaciones en la Asignación de Variables...................................................................42
Ejercicios:........................................................................................................................ 44
Capítulo 4: Pensando como un Programador......................................................46

Pseudocódigo.................................................................................................................. 46
Diagramas de Flujo..........................................................................................................49
Ejercicios:........................................................................................................................ 52
Capítulo 5: Su Programa Busca Consejo.............................................................53

Otro Tipo de Variable – La variable String........................................................................53
Input – Obteniendo Texto o Números del Usuario............................................................54
Ejercicios:........................................................................................................................ 58
Capítulo 6: Decisiones, Decisiones, Decisiones..................................................59

Verdadero y Falso (True y False).....................................................................................59
Operadores de Comparación...........................................................................................59
Tomando decisiones simples - El operador If (Si…).........................................................60
Página 4 of 258
Números Aleatorios (Random Numbers).........................................................................62

Operadores Lógicos.........................................................................................................62
Tomando decisiones con Resultados Complejos - If/End If..............................................64
Decidiendo en ambos sentidos - If/Else/End If.................................................................65
Decisiones Anidadas........................................................................................................65
Capítulo 7: Loops (bucles) y Conteo; Hágalo de Nuevo y de Nuevo.................69

El Loop FOR.................................................................................................................... 69
Haga Algo Hasta que le Diga que se Detenga.................................................................71
Haga Algo mientras le diga que lo Haga..........................................................................72
Continuando y Saliendo de Loops...................................................................................73
Gráficos Acelerados.........................................................................................................74
Ejercicios:........................................................................................................................ 77
Capítulo 8: Gráficos Personalizados - Creando sus Propias Formas...............79

Texto de Fantasía para Salida Gráfica.............................................................................79
Cambiando el Tamaño del Area de Salida Gráfica...........................................................80
Creando un Polígono a Medida.......................................................................................81
Estampando un Polígono.................................................................................................83
Dieciséis Millones de Colores Diferentes.........................................................................85
Ejercicios:........................................................................................................................ 91
Capítulo 9: Funciones y Subrutinas – Reusando Código...................................93

Funciones........................................................................................................................ 93
Subrutinas........................................................................................................................ 96
Usando el Mismo Código en Múltiples Programas.........................................................100
Rótulos (Labels), Goto y Gosub.....................................................................................102
Ejercicios:...................................................................................................................... 106
Capítulo 10: Control del Mouse - Moviendo Cosas...........................................108

Modo Seguimiento......................................................................................................... 108
Modo Click..................................................................................................................... 109
Ejercicios:....................................................................................................................... 115
Capítulo 11: Control del Teclado – Usando el Teclado para hacer Cosas.......117
Obteniendo la última tecla presionada...........................................................................117
Ejercicios:...................................................................................................................... 123
Capítulo 12: Imágenes, WAVs y Sprites..............................................................125

Guardando Imágenes a un Archivo................................................................................125
Recuperando Imágenes desde un Archivo....................................................................126
Reproduciendo Sonidos desde un archivo WAV............................................................127
Moviendo Imágenes - Sprites........................................................................................128
Ejercicios:...................................................................................................................... 136
Capítulo 13: Imprimiendo......................................................................................138

Encendiendo y Apagando la Impresora.........................................................................138
Página 5 of 258
Ejercicios:...................................................................................................................... 143
Capítulo 14: Arrays - Colecciones de Información............................................144

Arrays Numéricos Uni-Dimensionales............................................................................144
Arrays de Strings...........................................................................................................148
Asignando Arrays........................................................................................................... 149
Sonidos y Arrays............................................................................................................149
Gráficos y Arrays...........................................................................................................150
Avanzado: Arrays Bi-Dimensionales..............................................................................152
Realmente Avanzado - Tamaño de Arrays y Pasando Arrays a Subrutinas y Funciones
....................................................................................................................................... 154
Realmente Muy Avanzado – Re-dimensionando Arrays................................................155
Ejercicios:...................................................................................................................... 159
Capítulo 15: Matemáticas – Más diversión con Números.................................161

Operadores Nuevos.......................................................................................................161
Operador Módulo........................................................................................................... 161
Operador División Entera...............................................................................................163
Operator Potencia.......................................................................................................... 163
Nuevas Funciones Enteras............................................................................................164
Nuevas Funciones de Punto Flotante............................................................................166
Avanzado: Funciones Trigonométricas..........................................................................167
Ejercicios:...................................................................................................................... 172
Capítulo 16: Trabajando con Strings...................................................................173

Las Funciones String.....................................................................................................173
La Función String()........................................................................................................173
La función Length()........................................................................................................174
Funciones Left(), Right() y Mid()....................................................................................174
Las funciones Upper() y Lower()....................................................................................175
La función Instr()............................................................................................................176
Ejercicios:...................................................................................................................... 178
Capítulo 17: Files – Guardando Información para Después.............................180

Leyendo Líneas desde un Archivo.................................................................................180
Escribiendo Líneas a un Archivo....................................................................................182
La Función Read() y la Sentencia Write.........................................................................184
Ejercicios:...................................................................................................................... 187
Capítulo 18: Pilas, Colas, Listas y Ordenamiento..............................................189

Stack.............................................................................................................................. 189
Queue............................................................................................................................ 191
Linked List...................................................................................................................... 193
Ordenamiento Lento e Ineficiente – Ordenamiento Burbuja..........................................199
Un Ordenamiento Mejor – Ordenamiento por Inserción.................................................202
Ejercicios:...................................................................................................................... 205
Página 6 of 258
Capítulo 19: Atrapando Errores en Tiempo de Ejecución.................................206

Pruebe (try) una declaración y Atrape (catch) un Error..................................................206
Encontrando cuál Error..................................................................................................207
Errores de Conversión de Tipo......................................................................................208
Creando una Subrutina para Atrapar Errores.................................................................209
Desactivando la Rutina para Atrapar Errores.................................................................210
Ejercicios:...................................................................................................................... 212
Capítulo 20: Programación de Bases de Datos..................................................213

Qué es una Base de Datos (BD)....................................................................................213
El Lenguaje SQL............................................................................................................213
Creando e Ingresando Datos a la Base de Datos..........................................................213
Recuperando Información desde una BD......................................................................217
Ejercicios:...................................................................................................................... 224
Capítulo 21: Conectándose a la Red...................................................................225

Conección Socket..........................................................................................................225
Un Server y un Cliente Simples:....................................................................................226
Chat en la Red............................................................................................................... 227
Apéndice A: Instalando BASIC-256 en su PC Windows©.................................235

1 – Descargando el programa:.......................................................................................235
2 - Instalando.................................................................................................................236
3 – Iniciando BASIC-256................................................................................................239
Apéndice B: Nombres y Números de Color........................................................240
Apéndice C: Tonos Musicales..............................................................................241
Apéndice D: Valores de Teclas.............................................................................242
Apéndice E: Valores de Caracteres Unicode Latín (Inglés)..............................243
Apéndice F: Palabras Reservadas.......................................................................244
Apéndice G: Errores y Advertencias...................................................................248
Apéndice H: Glosario............................................................................................251
Página 7 of 258
INDICE DE PROGRAMAS
Programa 1: Diga “Hola”.........................................................................................19
Programa 2: Diga un Número.................................................................................20
Programa 3: Diga la Respuesta..............................................................................22
Programa 4: Diga otra respuesta...........................................................................22
Programa 5: Diga hola a Juan................................................................................22
Programa 6: Diga Dos Monedas Más....................................................................22
Programa 7: Imprima Hola Mundo.........................................................................23
Programa 8: Varios print en una sola línea...........................................................23
Programa 9: Manchas Grises.................................................................................25
Programa 10: Cara con Rectángulos.....................................................................29
Programa 11: Cara sonriente con círculos...........................................................30
Programa 12: Dibuje un Triángulo.........................................................................31
Programa 13: Dibuje un Cubo................................................................................32
Programa 14: Penwidth y Contorno......................................................................33
Programa 15: Use Plot para dibujar puntos.........................................................34
Programa 16: Programa Grande – Cara que Habla..............................................36
Programa 17: Reproducir tres notas individuales...............................................39
Programa 18: Lista de Sonidos..............................................................................40
Programa 19: Carga!...............................................................................................42
Programa 20: Variables Numéricas simples.........................................................43
Programa 21: Asignación de una variable............................................................43
Programa 22: Re-asignación de una Variable......................................................44
Programa 23: Reproducir Charge! usando Variables..........................................44
Página 8 of 258
Programa 24 : Programa Grande – Fuga en G Menor.........................................45
Programa 25: Bus Escolar......................................................................................49
Programa 26: Me gusta Ana...................................................................................55
Programa 27: Me Gusta (preguntando el nombre)...............................................56
Programa 28: Math-wiz............................................................................................57
Programa 29: Nombre y Edad................................................................................57
Programa 30: Programa Grande – Generador de Historias Tontas...................58
Programa 31: Compare dos Edades......................................................................62
Programa 32: Tirando una Moneda.......................................................................64
Programa 33: Tirando dados..................................................................................66
Programa 34: Tirando una Moneda con else........................................................67
Programa 35: Programa Grande – Tire un dado y dibújelo................................69
Programa 36: Declaración for................................................................................71
Programa 37: for – Con incremento 2...................................................................71
Programa 38: Patrón Moiré.....................................................................................72
Programa 39: Sentencia for – Cuenta hacia atrás...............................................73
Programa 40: Ingrese un nro. Entre 1 y 10...........................................................74
Programa 41: Loop para siempre..........................................................................74
Programa 42: While contando hasta 10................................................................75
Programa 43: Maquina de sumar - Usando Exit While........................................75
Programa 44: Caleidoscopio..................................................................................76
Programa 45: Programa Grande – Pelota rebotando..........................................78
Programa 46: Hola en el área de salida gráfica....................................................81
Programa 47: Redefiniendo el tamaño del área de salida gráfica......................83
Programa 48: Flecha Roja Grande.........................................................................84
Programa 49: Llenando la pantalla con triángulos..............................................85
Programa 50: Cien triángulos al azar....................................................................87
Página 9 of 258
Programa 51: 512 colores de los 16 millones.......................................................88
Programa 52: 100 Triángulos al azar de colores al azar......................................89
Programa 53: Círculos transparentes...................................................................90
Programa 54: 100 Triángulos al azar con colores transparentes al azar...........90
Programa 55 Programa Grande: Una Flor para Tí................................................92
Programa 56: Función Mínimo...............................................................................96
Programa 57: Juego de Dados...............................................................................97
Programa 58: Función String Simple....................................................................98
Programa 59: Subrutina Reloj..............................................................................100
Programa 60: Subrutina Reloj Mejorado.............................................................102
Programa 61: Tirador de Dados – Con Funciones included.............................103
Programa 62: Tirador de Dados – Función die...................................................103
Programa 63: Tirador de Dados – Función inputnumber..................................103
Programa 64: Máquina de Sumar – Usando la función inputnumber..............104
Programa 65: Goto con Label..............................................................................105
Programa 66: Gosub.............................................................................................105
Programa 67: Programa Grande – Tirar dos dados gráficamente...................107
Programa 68: Siguiendo el Mouse.......................................................................110
Programa 69: Mouse Modo Click.........................................................................112
Programa 70: Programa Grande – Selector de Color........................................116
Programa 71: Leer el Teclado...............................................................................119
Programa 72: Prueba de Velocidad con el Teclado...........................................120
Programa 73: Mover la Pelotal.............................................................................122
Programa 74: Programa Grande - Juego de Lluvia de Letras..........................124
Programa 75: Guardar una Imagen......................................................................127
Programa 76: Imgload un Gráfico........................................................................128
Programa 77: Imgload un Gráfico con Cambio de Escala y Rotación.............129
Página 10 of 258
Programa 78: Tirando Números con Música de fondo......................................130
Programa 79: Rebote una Pelota con Sprite y Efectos Sonoros.....................131
Programa 80: Dos Sprites con Colisión..............................................................133
Programa 81: Creando el Sprite de un Polígono................................................134
Programa 82: Juego de Frontón con Sprites.....................................................136
Programa 83 : Imprimiendo una Página con Texto............................................140
Programa 84: Imprimiendo una Página con Gráficos.......................................142
Programa 85: Tabla de Multiplicar.......................................................................144
Programa 86: Array Numérico Uni-dimensional................................................146
Programa 87: Varias Pelotas Rebotando............................................................148
Programa 88: Varias Pelotas Rebotando Usando Sprites.................................149
Programa 89: Lista de Mis Amigos......................................................................150
Programa 90: Asignando un Array con una Lista..............................................151
Programa 91: Sonido Espacial.............................................................................152
Programa 92: Stamp con Sombra........................................................................152
Programa 93: Crear Polígonos Pegados al Azar................................................153
Programa 94: Calculadora de Notas....................................................................155
Programa 95: Tamaño de Array............................................................................156
Programa 96: Re-Dimensionando un Array........................................................157
Programa 97: Big Program – Lluvia de Basura Espacial..................................160
Programa 98: El Operador Módulo......................................................................163
Programa 99: Moviendo la Pelota - Uso de Módulo para mantenerla en pantalla

.................................................................................................................................165
Programa 100: Verifique su división Larga.........................................................165
Programa 101: Las Potencias de Dos.................................................................165
Programa 102: Diferencia entre Int, Ceiling y Floor...........................................168
Programa 103: Programa Grande – Reloj con Manecillas................................173
Programa 104: La función String.........................................................................175
Página 11 of 258
Programa 105: La función Length.......................................................................176
Programa 106: Las funciones Left, Right y Mid.................................................176
Programa 107: Las funciones Upper y Lower....................................................177
Programa 108: La función Instr().........................................................................178
Programa 109: Big Program - Radix Conversion...............................................179
Programa 110: Leer Líneas desde un Archivo...................................................182
Programa 111: Limpie el archivo y escriba líneas.............................................184
Programa 112: Agregue Líneas al Final de un Archivo.....................................186
Programa 113: Programa Grande – Lista Telefónica.........................................188
Programa 114: Stack.............................................................................................192
Programa 115: Queue............................................................................................195
Programa 116: Linked List....................................................................................200
Programa 117: Ordenamiento Burbuja................................................................203
Programa 118: Ordenamiento por Inserción......................................................206
Programa 119: División simple que puede dar Error en Tiempo de Ejecución.
.................................................................................................................................208
Programa 120: Simple Programa que divide y Atrapa error.............................209
Programa 121: Try/Catch – Con Mensajes..........................................................210
Programa 122: Error de Conversión de Tipo......................................................211
Programa 123: Captura de Error Simple con Subrutina....................................212
Programa 124: Deshabilitando la Captura de Errores.......................................213
Programa 125: Crear una DB................................................................................216
Programa 126: Inserta Filas en una BD...............................................................218
Programa 127: Actualizar una Fila en una BD....................................................219
Programa 128: Seleccionando conjuntos de datos de una BD........................220
Programa 129: BD para Mantener una Lista dr Númerous Telefónicos..........225
Programa 130: Server de Red Simple.................................................................228
Programa 131: Cliente de Red Simple.................................................................228
Página 12 of 258
Programa 132: Chat por Red................................................................................230
Programa 133: Batalla de Tanques en Red.........................................................235
Página 13 of 258
INDICE DE ILUSTRACIONES
Ilustración 1: La Ventana de BASIC-256..........................................................................15

Ilustración 2: BASIC-256 – Caja de Diálogo “New”........................................................17
Ilustración 3: Nombres de Colores..................................................................................23
Ilustración 4: El Sistema de Coordenadas Cartesiano del área de salida gráfica........24
Ilustración 5: Opción de líneas de grilla en menú View..............................................24
Ilustración 6: Líneas de grilla en área de salida gráfica.................................................24
Ilustración 7: Rectángulo..................................................................................................25
Ilustración 8: Círculo.........................................................................................................25
Ilustración 9: Ondas Sonoras...........................................................................................35
Ilustración 10: Notas Musicales.......................................................................................36
Ilustración 11: Carga!........................................................................................................37
Ilustración 12: Primeros cuatro compases de Pequeña Fuga en G Menor..................41
Ilustración 13: Bus escolar...............................................................................................44
Ilustración 14: Desayuno – Diagrama de Flujo...............................................................47
Ilustración 15: Máquina expendedora de bebidas – Diagrama de Flujo.......................48
Ilustración 16: Compare dos Edades – Diagrama de Flujo............................................58
Ilustración 17: Tipos de letra (fonts) comunes en Windows..........................................77
Ilustración 18: Flecha Roja Grande..................................................................................79
Ilustración 19: Triángulo Equilátero................................................................................80
Ilustración 20: Grados y Radianes...................................................................................81
Ilustración 21: Programa Grande: Una Flor para Ud. – Stamp de un pétalo................86
Ilustración 22: Diagrama de Bloques de una Función...................................................90
Ilustración 23: Preferencias – Pestaña de Impresión (Printing Tab)...........................133
Ilustración 24: Triangulo Recto......................................................................................158
Ilustración 25: La función sin()......................................................................................158
Ilustración 26: La función cos().....................................................................................159
Ilustración 27: La función tan()......................................................................................159
Ilustración 28: La función asin()....................................................................................160
Ilustración 29: La función acos()....................................................................................160
Ilustración 30: La función atan()....................................................................................160
Ilustración 31: Qué es un Stack.....................................................................................180
Página 14 of 258
Ilustración 32: Que es un “Queue”................................................................................182

Ilustración 33: Linked List (Lista Encadenada).............................................................184
Ilustración 34: Borrando un ítem (o nodo) de una Linked List....................................184
Ilustración 35: Insertando un nuevo ítem (o nodo) en una Linked List......................185
Ilustración 36: Ordenamiento Burbuja – Diagrama de Flujo........................................189
Ilustración 37: Ordenamiento por Inserción – Paso-a-Paso........................................191
Ilustración 38: Preferences – Conversión de Tipo: Ignore/Advierta/Error..................198
Ilustración 39: Diagrama de Relaciones entre Entidades de la BD.............................202
Ilustración 40: Comunicación por Zócalo (Socket Communication)...........................213
Ilustración 41: BASIC-256 en Sourceforge....................................................................223
Ilustración 42: Guardando el Archivo de Instalación...................................................223
Ilustración 43: Instalador descargado...........................................................................224
Ilustración 44: Advertencia de Apertura de Archivo.....................................................224
Ilustración 45: Advertencia de seguridad sobre apertura de archivo.........................224
Ilustración 46: Instalador – Ventana de Bienvenida.....................................................225
Ilustración 47: Instalador – Ventana de Licencia GPL..................................................225
Ilustración 48: Instalador – Qué Instalar.......................................................................226
Ilustración 49: Instalador – Donde Instalar...................................................................226
Ilustración 50: Instalación Completa.............................................................................226
Ilustración 51: Botón Start XP........................................................................................227
Ilustración 52: Menú BASIC-256 en All Programs........................................................227
Página 15 of 258
Agradecimientos
Un gran muchas gracias para toda la gente que ha trabajado en el

proyecto BASIC-256 en Sourceforge. Muy especialmente, a Ian Larsen
(aka: DrBlast) por crear el lenguaje de programación BASIC-256 y su
original visión.
Siento también la necesidad de agradecer a los chicos programadores del

Summer 2000 de la Escuela de Nivel Medio Russell y a Julia Moore.
También un saludo a mi gente, Sergey Lupin y Joel Kahn.
Dedicatoria:
A mi esposa Nancy y mi hija Anna.
Créditos:
Algo de arte de dominio público de http://www.openclipart.com.
Página 16 of 258
Prefacio
La primera edición de este libro fue creada como una introducción a la

programación en lenguaje BASIC para estudiantes del ciclo medio y superior que
deseaban crear código por sus propios medios. En el ultimo par de años el texto ha
evolucionado para ser usado es educación secundaria y post-secundaria.
Esta segunda edición mantiene la mayoría del material de la primera e incluye la
actualización de BASIC-256 para incluir Subrutinas, Funciones y un mejor manejo
de errores. Además de actualizar el lenguaje y mejorar el texto y los programas, se
agregaron ejercicios al final de cada capítulo para reforzar los conceptos discutidos
y enfrentar a nuevos retos al lector o estudiante.
Los capítulos del libro pueden ser estructurados para ser usados en una variedad
de modos:
1. Una introducción a la programación de 9 o 19 semanas.
 capítulos 1, 2, 3, 4 , 5, 6, 7, 8, y 9 para el primer ciclo de 9 semanas
*
 capítulos 10, 11, 12, 13*, 14, 15, 16, 17 and 19* para el segundo ciclo de 9
semanas
2. una breve introducción a los conceptos de programación
 capítulos 1, 3**, 4* , 5, 6, 7, 9, and 14
3. una introducción a estructura de datos para no-programadores.
 capítulos 1, 3**, 4* , 5, 6, 7, 9, 14, 15*, 16*, 17 and 18
4. un breve proyecto de programación para un curso de sistemas de bases de
datos
 capítulos 1, 3**, 4* , 5, 6, 7, 9, 14, 15*, 16*, 19 and 20
5. un breve proyecto de programación para un curso sobre redes
 capítulos 1, 3**, 4* , 5, 6, 7, 9, 14, 15*, 16*, 19 and 21
La característica más importante de este libro es la versatilidad que ofrece para

mezclar y re-mezclar el material para ajustarse a sus necesidades específicas.
Les deseo solo y nada más que éxitos.
-Jim.
* Capítulo Opcional
** Sólo sección de Variables
Numéricas.
Página 17 of 258
Capítulo 1: Conociendo BASIC-256 –

Diga Hola
Este capítulo introduce el ambiente de BASIC-256 mediante el uso de los comandos print
y say. Ud. verá la diferencia entre los comandos que envía a la computadora, cadenas de
texto y números que serán usados por el programa.
También exploraremos la matemática básica para mostrar cuán talentosa es nuestra
computadora. Por último, aprenderá lo que es un “error de sintaxis” y cómo corregirlos.
La ventana de BASIC-256
La ventana de BASIC-256 está dividida en cinco secciones: La Barra de Menú (Menu Bar),
la Barra de Herramientas, (Tool Bar) El Area de Programa (Program Area), el Area de
Salida de Texto (Text Output Area) y el Area de Salida Gráfica (Graphics Output Area) (Ver
Ilustración 1: La Ventana de BASIC-256 a continuación).
Ilustración 1: La Ventana de BASIC-256
Barra de Menú:
La Barra de Menú contiene varios y diferentes menús desplegables. Estos menús incluyen:
"FILE" (Archivos), "EDIT" (Edición), "VIEW" (Ver), "RUN" (Correr, Ejecutar), y "ABOUT"
(Acerca de…).
El menú FILE el permite guardar y recargar programas guardados, imprimir y salir de
BASIC-256.
El menú EDIT nos permite cortar, copiar y pegar texto e imágenes desde el programa y las
áreas de salida texto y gráfica.
El menú VIEW nos permite elegir el mostrar u ocultar varias partes de la ventana de
BASIC-256.
Página 18 of 258
El menú RUN nos permite ejecutar y depurar (debug) nuestros programas (NdT: Depurar
un programa es correrlo en un modo especial que nos permite ejecutarlo línea por línea y
así, por ejemplo, buscar y encontrar errores)
El menú ABOUT muestra una ventana de diálogo con información acerca de BASIC-256 y
la versión que está usando.
Barra de Herramientas:
Las opciones de menú más usadas están también disponibles en la Barra de Herramientas.
New (Nuevo) Comenzar un nuevo programa
Open (Abrir) Abrir un programa previamente guardado.
Save (Guardar) Guarde el programa corriente al HD o a un USB Pendrive
Run (Correr) Ejecute el programa corriente
Debug (Depurar) Dejar de ejecutar el programa una línea por vez.
Step (Paso) Cuando se está depurando (debug): Ir a la próxima línea
Stop (Parar) Parar la ejecución del programa
Undo (Deshacer) Deshacer el último cambio al programa
Redo (Rehacer) Rehacer el último cambio que fue deshecho
Cut (Cortar) Mover el texto marcado al portapapeles
Copy (Copiar) Copiar el texto marcado al cortapapeles
Insertar el texto desde el portapapeles al programa en la

Paste (Pegar) posición corriente del cursor.
Área de Programa:
Los programas consisten en instrucciones para decirle a la computadora exactamente QUE
hacer y COMO hacerlo. Ud. escribirá sus programas, los modificará y corregirá, y cargará y
guardará los mismos en esta área de la pantalla.
Área de Salida Texto:
En esta área se mostrará la salida de su programa. Esta puede incluir números y palabras.
Si el programa necesita hacerle una pregunta, la misma (y lo que Ud. responda) será
mostrado aquí.
Área de Salida Gráfica:
BASIC-256 es un lenguaje de programación gráfico (como pronto verá). Formas, figuras y
gráficos que Ud. creará con sus programas serán mostrados aquí.
Página 19 of 258
Su primer programa – La declaración “say” (“decir”)

Vamos a escribir nuestro primer programa real. Veremos cómo BASIC-256 nos dice “Hola”.
En el Área de Programa, escriba el siguiente programa de una sola línea (BASIC-256 le
mostrará automáticamente el número de línea, Ud. NO debe tipearla)
1 say "Hola!"
Programa 1: Diga “Hola”
Una vez que haya escrito el programa, use el mouse y haga clic en “Run” (que significa
ejecutar, correr el programa) ubicado en la Barra de Herramientas (Tools Bar).
¿Escuchó a BASIC-256 decirle hola por los altavoces de la computadora?
say
La expresión say es usada para hacer que BASIC-256 lea una
expresión en voz alta usando los parlantes de la computadora.
"letras, números 9988 y símbolos &%"

'otra string con "comillas" adentro.'
BASIC-256 trata a las letras, números y símbolos que están entre
comillas simples (‘) como un bloque. Este bloque es lo que se conoce
como un string (cadena de caracteres).
Un string puede comenzar ya sea con comilla simple (‘) o doble (“), y
termina con la misma con que comenzó. Un string definido por
comillas simples puede contener en su interior comillas dobles; y
viceversa.
"Run" en la Barra de Tareas, o "Run" y luego "Run"en

el Menú.
Ud. debe decirle a BASIC-256 cuando desea comenzar a ejecutar su
programa. BASIC-256 no sabe automáticamente cuándo Ud. ha
finalizado de escribir su programa y desea ejecutarlo.
Debe hacer esto haciendo clic en el ícono “Run” ubicado en la Barra
de Herramientas; o haciendo click en "Run" en la Barra de Menú y
seleccionando luego “Run” en el Menú desplegable.
Para terminar el programa en el que está trabajando y empezar con uno completamente
nuevo, utilice el botón “New” (Nuevo) en la Barra de Herramientas. El botón le mostrará la
siguiente ventana de diálogo:
Página 20 of 258
Ilustración 2: BASIC-256 – Caja de Diálogo “New”
Si realmente desea sacar el programa de pantalla, presione “Yes”. Caso contrario, presione
“Cancel” (cancelar) y todo quedará como si no hubiere presionado el botón “New”.
"New" en la Barra de Herramientas - o –

"File" y luego "New" en el menú
El comando "New" le dice a BASIC-256 que Ud. desea abandonar lo
que está mostrándose en el Área de Programa y comenzar un
programa totalmente nuevo. NOTA!: Si Ud. no ha guardado en la
computadora el programa que tenía en la ventana (Capítulo 2),
Ud. perderá todos los cambios que hizo al mismo.
También puede, con el comando say, hacer decir a la computadora los números en voz
alta. Pruebe el siguiente programa:
1 say 123456789
Programa 2: Diga un Número
Después de escribir el programa en el Área de Programa, use el mouse para hacer clic en
el botón “Run” de la Barra de Herramientas. ¿Dijo BASIC-256 lo que esperaba?
números
BASIC-256 le permite ingresar números en formato decimal. No use
comas para separar los cientos o miles cuando ingrese números
grandes. Si necesita ingresar un número menor que cero,
simplemente coloque el signo negativo (-) precediéndolo.
Ejemplos: 1.56, 23456, -6.45 y .5
BASIC-256 es realmente bueno con números –

Aritmética Simple
El cerebro de la computadora (llamado la Unidad Central de Procesamiento o CPU por sus
siglas en inglés, Central Processing Unit) trabaja exclusivamente con números. Todo lo que
hace, como gráficos, sonido y todo lo demás es hecho manipulando números.
Las cuatro operaciones básicas (suma, resta, multiplicación y división) son ejecutadas
usando los operadores mostrados en la siguiente Tabla.
Operador Operación
Suma
+ expresión1 + expresión2
- Resta
Página 21 of 258
expresión1 - expresión2
Multiplicación
* expresión1 * expresión2
División
/ expresión1 / expresión2
Tabla 1: Operadores Matemáticos Básicos
Página 22 of 258
Pruebe el siguiente programa y preste atención a su súper-calculadora parlante.
1 say 12 * (2 + 10)
Programa 3: Diga la Respuesta
La computadora le debería haber dicho "144" (Verifique el volumen…).
1 say 5 / 2
Programa 4: Diga otra respuesta
¿Escuchó a la computadora decir "2.5"?
+
-
*
/
()
Las cuatro operaciones matemáticas básicas trabajan con números
para efectuar cálculos. Se requiere un valor numérico a ambos lados
de estos operadores. Es posible también usar paréntesis para
agrupar operaciones.
Ejemplo: 1 + 1, 5 * 7, 3.14 * 6 + 2, (1 + 2) * 3 y 5 - 5
Otro uso para el signo + (Concatenación)

El operador + también juntará strings. Esta operación es llamada “concatenación” (o “cat”
en la jerga de programación). Cuando concatenamos, juntamos dos strings, como vagones
de un tren, para formar una sola string más larga.
Probemos lo siguiente:
1 say "Hola " + "Juan."
Programa 5: Diga hola a Juan
La computadora debería haber dicho: “Hola Juan”
Probemos otra:
1 say 2 + " monedas mas"
Programa 6: Diga Dos Monedas Más
El signo + en el último ejemplo fue usado como operador de concatenación debido a que el
segundo término es un string. Como la computadora no sabe cómo hacer matemáticas con
strings, entonces concatena.
+ (concatenar)
Otro uso para el signo (+) es decirle a la computadora que concatene
(junte) strings.
Si uno o ambos operandos son del tipo string, la concatenación se
hará sin problemas y se obtendrá un string más largo. Si ambos
operandos son numéricos, entonces se sumarán.
Página 23 of 258
Área de Salida de Texto – El comando “print”

(imprimir)
Los programas que usan el comando say (este comando se conoce como Texto-a-Voz, o
en inglés, Text-to-Speech, o TTS) pueden ser muy útiles o divertidos, pero a veces es
necesario escribir información (strings y números) en pantalla de modo que la salida del
programa pueda ser leída. El comando print hace justamente eso.
En el Área de Programa, escriba el siguiente programa de dos líneas:
1 print "hola"
2 print "mundo"
Programa 7: Imprima Hola Mundo
Una vez ingresado el programa, haga clic con el mouse en “Run”, en la Barra de
Herramientas. En la ventana de Salida de Texto se mostrará “hola” en la primera línea y
“mundo” en la segunda.
print expresion
print expresion;
El comando print es usado para mostrar texto y números en el Area
de Salida de Texto de la ventana de BASIC-256. Cada comando print
comienza en una nueva línea, pero Ud. puede imprimir varias cosas
en una misma línea usando punto y coma (;) al final de la expresión.
El comando print, por defecto, avanza en el área de texto de modo que el siguiente print es
sobre la próxima línea. Si Ud. Coloca un “;” (punto y coma) al final de la expresión a ser
impresa, se suprimirá el avance de línea, de modo que el próximo print se hará, a
continuación, en la misma línea.
1 cls
2 print "Hola ";
3 print "mundo, ";
4 print "estoy aquí!."
Programa 8: Varios print en una sola línea
cls
El comando cls limpia toda la información mostrada en el Área de
Salida de Texto.
Que es un “Error de Sintaxis”? (“Syntax error")

Los programadores son casi humanos, y ocasionalmente cometen errores. “Errores de
sintaxis” son uno de los tipos de errores con los que nos vamos a encontrar. Un “Sintax
Error” es generado por BASIC-256 cuando no entiende algo en su programa. Usualmente,
los errores de sintaxis son ocasionados por errores de tipeo, falta de comas (,), espacios
incorrectos, paréntesis no cerrados, etc. BASIC-256 lo ayudará diciéndole el número de
línea en donde está el error y, aún más, intentará indicarle el lugar de la línea en donde se
encuentra.
Página 24 of 258
Ejercicios:
z a h d g p b a n n q m c
j g j r o i q l o c q o x
r u n t u u n i l c n s z
v w s y o b s s k c y l l
e n a t i s s p a n p a x
r s e p e q r t t f r p t
r b k r y o e a r m m r a
o r p i g n x d o i f n i
r x n r a y t i h l n a f
e g a t m d w n v e d g i
t m i a c v c e i j f d n
b o t c c a u s o r c i s
n a m z i z i g n c p r u
cls, concatenation, error, expression, print, program, quote, run, say,
stop, string, syntax
1.1. Escriba un programa de una línea para decir un trabalenguas:

Por ejemplo: “Peter Piper picked a peck of pickled peppers” o
alguno que Ud. sepa en castellano.
1.2. Agregue una segunda línea al programa anterior para mostrar
también el trabalenguas escrito en la pantalla.
1.3. Use la computadora como una calculadora parlante para resolver
el siguiente problema y decir la respuesta. Pedro tiene 5
caramelos y Juan tiene 9. Si quieren repartir todos los caramelos
de modo que ambos tengan el mismo número. Cuántos
caramelos tendrá cada uno?
1.4. Use la computadora como una calculadora parlante para resolver
el siguiente problema y decir la respuesta: Ud. está comprando
juguetes. Quiere 5 autos que cuestan 1,25$ cada uno y un barco
que cuesta 3.50$. Cuánto dinero necesita para comprar todo?
1.5. Escriba un programa de una línea para decir: “Uno más dos es
igual a tres” sin usar la palabra tres o el número 3.
Página 25 of 258
Capítulo 2: Dibujando Formas Básicas

En este capítulo nos volveremos gráficos. Aprenderá cómo dibujar rectángulos, círculos,
líneas y puntos de diferentes colores. Los programas se volverán más y más complejos, de
modo que también aprenderá como salvaguardar sus programas en medios de
almacenamiento a largo plazo (disco duro de su computadora o medios removibles) y cómo
cargarlos de vuelta de modo que pueda seguir trabajando en ellos.
Dibujando Rectángulos y Círculos

Empezaremos con los gráficos escribiendo un programa para nuestro equipo de deportes
favorito, las “Manchas Grises”. Sus colores son el azul y el gris.
1 # c2_greyspots.kbs
2 # un programa para nuestro equipo – las manchas grises
3 clg
4 color blue
5 rect 0,0,300,300
6 color grey
7 circle 149,149,100
8 say "Manchas Grises, Manchas Grises, Manchas Grises, vamos!"
Programa 9: Manchas Grises
Salida 9: Manchas Grises

Inspeccionemos línea por línea el programa anterior. La primera línea es llamada una
sentencia anotación o comentario. Un comentario es un lugar para el programador para
poner anotaciones en su programa de computación que son solo para su referencia; son
ignoradas por el sistema.
Los comentarios son un buen lugar para describir lo que hace un bloque de código
complejo, el nombre del programa, la fecha, quien escribió el programa, el porqué, etc.
#
rem
Las declaraciones # y rem definen “comentarios”.
Una declaración comentario permite al programador poner notas
descriptivas en el programa. La computadora “ve” las declaraciones #
o rem e ignora todo el resto del texto en la línea
© 2014James M. Reneau (CC BY-NC-SA 3.0 US) Página 26 of

258
En la línea 3 del programa puede verse la declaración clg. Es similar a la declaración cls
que vimos en el Capítulo 1, excepto que clg limpiará el Área de Salida Gráfica de la
pantalla.
clg
El comando clg borra el área de salida gráfica de modo que
tendremos un lugar limpio para visualizar nuestros dibujos.
La líneas 4 y 6 contienen una forma simple de declaración de color. Le dice a BASIC-256

que color usar para la próxima acción de dibujar. Ud. puede definir colores ya sea usando
uno de los dieciocho nombres de colores estándar o puede crear uno de un total de 16
millones de colores diferentes mezclando colores primarios (rojo, verde y azul).
Cuando use el método numérico para definir un color a medida, asegúrese de limitar los
valores entre 0 y 255. Cero (0) representa que no hay luz de ese componente de color, y
255 representa brillo máximo. El blanco brillante es representado por 255, 255, 255 (todos
los colores de luz en su máximo brillo). El negro es representado por 0, 0, 0 (no hay ningún
color). Esta representación numérica de los colores se conoce como triplete RGB. La
Ilustración 5 muestra los colores con su nombre y sus respectivos valores RGB.
color <nombre de color>

color rgb(rojo, verde, azul)
color puede también escribirse como colour.
La declaración color permite definir el color con que se seguirá
dibujando. Puede seguir la declaración con un nombre de color (black,
white, red, darkred, green, darkgreen, blue, darkblue, cyan, darkcyan,
purple, darkpurple, yellow, darkyellow, orange, darkorange, grey/gray,
darkgrey/darkgray). Puede también especificar uno de los 16 millones
de colores diferentes usando la función RGB() y especificando que
cantidad de rojo, verde y azul debe usarse.
Nombre del Color y valores RGB Nombre del Color y valores RGB
black (0,0,0) white (255,255,255)

red (255,0,0) darkred (128,0,0)
green (0,255,0) darkgreen (0,128,0)
blue (0,0,255) darkblue (0,0,128)
cyan (0,255,255) darkcyan (0,128,128)
purple (255,0,255) darkpurple (128,0,128)
yellow (255,255,0) darkyellow (128,128,0)
orange (255,102,0) darkorange (170,51,0)
grey/gray (164,164,164) darkgrey/darkgray (128,128,128)
Ilustración 3: Nombres de Colores

258
El área de salida gráfica, por defecto, es de 300 píxeles de ancho (x) por 300 píxeles de
alto (y). Un pixel es el punto más pequeño que puede ser mostrado en su monitor. El
vértice superior izquierdo es el origen (0,0), y el inferior derecho corresponde a (300,300).
Cada píxel puede ser representado por un par de números, el primero (x) mide cuán lejos
del eje X (lado superior) está, y el segundo (y) cuán lejos del eje Y (lado derecho). Este
modo de marcar los puntos en el plano se conoce en matemáticas como Sistema de
Coordenadas Cartesiano.
Ilustración 4: El Sistema de Coordenadas Cartesiano del área de salida gráfica
Ud. puede mostrar líneas de grilla en el área de salida gráfica de la

pantalla marcando la opción Graphics Window Grid Lines (Líneas de
Grilla en Ventana Gráfica) en el menú View (Ver).
Ilustración 5: Opción de líneas de Ilustración 6: Líneas de grilla en

grilla en menú View área de salida gráfica
Siguiendo el análisis del Programa 9, la línea 5 del mismo contiene rect. Es usado para
dibujar un rectángulo en pantalla. Toma cuatro números separados por comas; los 2
primeros corresponden a las coordenadas del vértice superior izquierdo y los dos últimos a
la del vértice inferior derecho (ver ilustración siguiente). Los 4 números son expresados en

258
unidades de píxeles.
altura
ancho
Ilustración 7: Rectángulo
Puede ver que el rectángulo en el programa comienza en el vértice superior izquierdo y

cubre toda el Área de Salida Gráfica.
rect x, y, ancho, altura

La declaración rect usa el color vigente y dibuja un rectángulo en la
ventana de salida gráfica. El vértice superior izquierdo del rectángulo
es especificado por los primeros dos números y su ancho y altura por
los otros dos argumentos.
La línea 7 del programa introduce la declaración circle para dibujar un círculo. Este toma 3
argumentos numéricos, los primeros 2 corresponden a las coordenadas cartesianas de su
centro (en píxeles) y el tercero su radio (en píxeles también).
Ilustración 8: Círculo
circle x, y, radius
La declaración circle usa el color de dibujo corriente y dibuja un
círculo lleno con su centro en (x, y) y radio r especificado.
A continuación un par de programas ejemplo que usan las nuevas declaraciones clg,
color, rect and circle. Ingrese los programas e introduzca modificaciones. Dibuje con ellos

258
una cara ceñuda, una cara alienígena o una que luzca como alguien que Ud. conozca.
1 # c2_rectanglesmile.kbs
2 # dibuje una cara sonriente con rectángulos
3
4 # limpie el area gráfica
5 clg
6
7 # dibuje la cara
8 color yellow
9 rect 0,0,299,299
10
11 # dibuje la boca
12 color black
13 rect 100,200,100,25
14
15 # ponga los ojos
16 color black
17 rect 75,75,50,50
18 rect 175,75,50,50
19
20 say "Hola!."
Programa 10: Cara con Rectángulos
Salida 10: Cara con Rectángulos
1 # c2_circlesmile.kbs
2 # cara sonriente hecha con círculos
3
4 # limpie la pantalla
5 clg
6 color white
7 rect 0,0,300,300
8
9 # dibuje la cara
10 color yellow

258
11 circle 150,150,150
12
13 # dibuje la boca
14 color black
15 circle 150,200,70
16 color yellow
17 circle 150,150,70
18
19 # coloque los ojos
20 color black
21 circle 100,100,30
22 circle 200,100,30
Programa 11: Cara sonriente con círculos
Salida 11: Cara sonriente con círculos
Guardando su Programa y Cargándolo Nuevamente

Ahora que los programas se están volviendo más complejos, Ud. puede querer guardar su
trabajo para poder cargarlos en el futuro.
Ud. puede guardar un programa usando el botón “Save” (Guardar) en la Barra de
Herramientas o con la opción “Save” en el menú “File” (Archivo). Se abrirá un diálogo
preguntándole por un nombre si es un nuevo programa, o si guardará los cambios que hizo
(reemplazando la versión anterior) si el archivo que esta editando ya existe.
Si no desea reemplazar la versión anterior de su programa y quiere guardar la nueva bajo
otro nombre, puede usar la opción “Save as” (Guardar como) en el menú File.
Para cargar un programa guardado previamente debe usar el botón “Open” (Abrir) en la
Barra de Herramientas o la opción “Open” en el menú “File”.
Dibujando con Líneas

La próxima declaración que veremos es line (línea). Dibuja una línea de 1 pixel de ancho,
con el color vigente, desde un punto hasta otro. El Programa 12 a continuación muestra un
ejemplo de cómo usar la declaración “line”.

258
1 # c2_triangle.kbs
2 # dibuja un triangulo
3 clg
4 color black
5 line 150, 100, 100, 200
6 line 100, 200, 200, 200
7 line 200, 200, 150, 100
Programa 12: Dibuje un Triángulo
Salida 12: Dibuje un Triángulo
line comienzo_x, comienzo_y, final_x, final_y

Dibuja una línea de un píxel de ancho desde un punto de comienzo
hasta un punto final, usando el color vigente.
El siguiente programa es una muestra de lo que se puede hacer solo con líneas. Dibuja un
cubo 3D en la pantalla.
1 # c2_cube.kbs
2 # use lineas para dibujar un cubo en 3D
3 clg
4 color black
5
6 # dibuje el cuadrado del fondo
7 line 150, 150, 150, 250
8 line 150, 250, 250, 250
9 line 250, 250, 250, 150
10 line 250, 150, 150, 150
11
12 # dibuje el cuadrado del frente
13 line 100, 100, 100, 200
14 line 100, 200, 200, 200
15 line 200, 200, 200, 100
16 line 200, 100, 100, 100
17

258
18 # conecte los vértices

19 line 100, 100, 150, 150
20 line 100, 200, 150, 250
21 line 200, 200, 250, 250
22 line 200, 100, 250, 150
Programa 13: Dibuje un Cubo
Salida 13: Dibuje un Cubo
Definiendo el Ancho de Línea y Dibujando el

Contorno de una Figura
Por defecto, el ancho de una línea dibujada en BASIC-256 es 1 píxel (dot). La declaración
penwidth (ancho de lápiz) puede ser usada para cambiar el modo en que las líneas (y el
contorno alrededor de una figura) se dibujan.
El siguiente programa nos muestra el uso de la declaración penwidth, un uso algo más
complejo de la declaración color y un ejemplo del color especial clear.
1 # c2_shapeoutline.kbs
2 # dibujar una forma con contorno
3
4 clg
5
6 penwidth 7
7 color blue, rgb(255,128,128)
8 circle 100,50,44
9
10 color black
11 penwidth 5
12 line 50,50,250,250
13
14 color red
15 penwidth 10
16 line 175,100,100,175
17
18 color green, clear
19 penwidth 10
20 rect 150,175,75,75

258
Programa 14: Penwidth y Contorno
Salida 14: Penwidth y Contorno
penwidth n
Cambia el ancho de la “punta de lápiz” con el que se dibuja. La punta
del lápiz representa el ancho de la línea que está siendo dibujada y
también el ancho de la línea a usar para el contorno de la forma.
color color_lápiz, color_relleno

Al comienzo de éste capítulo vimos la declaración color con un
solo color. Cuando un solo color es especificado, ambos, el color
de lápiz y el color de relleno son definidos al mismo valor.
Es posible definir el color para la punta y el color para relleno con
valores distintos usando la declaración color con dos colores.
clear
La palabra clear puede ser usada en una declaración de color para
decirle a BASIC-256 que solo dibuje el borde de la figura. Esto se
logra definiendo el color de relleno como “clear”.
Definiendo Puntos Individuales en Pantalla

La última sentencia gráfica que veremos en este capítulo es plot. La sentencia plot dibuja
un pixel (dot) en la pantalla. Para la mayoría de nosotros éste es muy pequeño y difícil de
ver. Mas tarde escribiremos programas que dibujan grupos de píxeles para hacer imágenes
más detalladas.
1 # c2_plot.kbs
2 # use plot para dibujar puntos
3

258
4 clg
5 color red
6 plot 99,100
7 plot 100,99
8 plot 100,100
9 plot 100,101
10 plot 101,100
11 color darkgreen
12 plot 200,200
Programa 15: Use Plot para dibujar puntos
Salida 15: Use Plot para dibujar puntos (marcados para enfatizar su ubicación)
plot x, y
Dibuja un punto (del tamaño de 1 pixel) del color corriente en la
posición x, y. O, lo que es equivalente, cambia el color del pixel en
coordenadas x, y al color corriente.
Al final de cada capítulo habrá uno o más “Programas Grandes” para

que los estudie, los tipee y experimente con ellos. Estos programas
contendrán solo tópicos que ya han sido cubiertos en el capítulo o en
capítulos anteriores.
El Programa Grande siguiente toma la idea de una cara y hace que esta hable. Antes de
que el programa diga cada palabra, la parte inferior de la cara se redibuja con una forma
diferente de boca. Esto crea una animación gruesa y hace la cara más divertida.
1 # c2_talkingface.kbs
2 # dibuje el fondo de cara con ojos
3
4 color yellow

258
5 rect 0,0,300,300
6 color black
7 rect 75,75,50,50
8 rect 175,75,50,50
9
10 # borre la vieja boca
11 color yellow
12 rect 0,150,300,150
13 # dibuje la nueva boca
14 color black
15 rect 125,175,50,100
16 # diga la palabra
17 say "Yo"
18
19 color yellow
20 rect 0,150,300,150
21 color black
22 rect 100,200,100,50
23 say "estoy"
24
25 color yellow
26 rect 0,150,300,150
27 color black
28 rect 125,175,50,100
29 say "complacido"
30
31 color yellow
32 rect 0,150,300,150
33 color black
34 rect 125,200,50,50
35 say "que"
36
37 color yellow
38 rect 0,150,300,150
39 color black
40 rect 100,200,100,50
41 say "seas"
42
43 color yellow
44 rect 0,150,300,150
45 color black
46 rect 125,200,50,50
47 say "mi"
48
49 # dibuje toda la cara nueva con una sonrisa.
50 color yellow
51 rect 0,0,300,300
52 color black
53 circle 150,175,100
54 color yellow
55 circle 150,150,100
56 color black
57 rect 75,75,50,50
58 rect 175,75,50,50

258
59 say "amigo"
Programa 16: Programa Grande – Cara que Habla
Salida 16: Programa Grande – Cara que Habla

258
Ejercicios:
r e t a n i d r o o c
e e a r a e l c r u m
m e l c r i c e s s r
a c k v c e c c u y o
r y j l n t i i t p l
k a g t a h d h w l o
q n e n p a g i q o c
y r g a r i d p j t e
c l r e e t s a v e h
e g p h h u e n i l d
j r x p e n w i d t h
center, circle, clear, clg, color, coordinate, cyan, graphics, height, line,
penwidth, plot, radius, rectangle, remark, save, width
2.1. Modifique el Programa 11: Cara sonriente con círculos para

mostrar la cara de Mr. Yuck (abajo). Puede necesitar usar la
sentencia penwidth para aumentar el grosor de las líneas que
dibuje.
2.2. Escriba un programa para dibujar un cuadrado y luego decir

“cuadrado”. Limpie la pantalla gráfica, dibuje un círculo y diga
“círculo”. Luego limpie de nuevo la pantalla y dibuje varias
líneas (en cualquier patrón que desee) y diga “líneas”.
2.3. Use colores, líneas y círculos para dibujar un blanco de tiro con
arco y flecha y una flecha clavada en su centro. Una vez que se
dibuje la frecha haga que la computadora diga “Blanco!”
2.4. Escriba un programa que dibuje cada uno de los cuartos de la

luna y diga el nombre del cuarto correspondiente. Ayuda: Dibuje
la luna como un círculo y luego dibuje un rectángulo sobre la
parte que no necesite.

258
Luna Nueva Cto. Luna Llena Cto. Creciente

Menguante

258
Capítulo 3: Sonido y Música

Ahora que ya tenemos color y gráficos, agreguemos sonidos y hagamos algo de música.
Veremos primero conceptos básicos de la física del sonido, variables numéricas y notación
musical. Ud. será capaz de traducir un tono en frecuencias y duraciones para hacer que la
computadora sintetice una voz.
Las Bases del Sonido – Cosas que necesita saber

sobre el sonido
El sonido es creado por aire que está vibrando y que impacta en nuestro tímpano. Estas
vibraciones son conocidas como “ondas de sonido”. Cuando el aire está vibrando
rápidamente, escucharemos una nota alta (aguda). Cuando lo hace lentamente,
escucharemos una nota baja (grave). La velocidad de vibración es llamada “frecuencia”
- baja frecuencia = nota

baja
- alta frecuencia = nota

alta
Ilustración 9: Ondas Sonoras
La frecuencia es medida en una unidad llamada hertz (Hz). Representa cuántos ciclos
(subidas y bajadas) la onda vibra en un segundo. Una persona normal puede oír
frecuencias desde los 20 Hz (sonidos muy bajos) hasta 20.000 Hz (sonidos muy altos).
BASIC-256 puede producir tonos en el rango de 50 Hz a 7000 Hz.
Otra propiedad del sonido es su longitud. Las computadoras actuales son muy rápidas y
pueden medir con precisión tiempos del orden de milisegundos. Un milisegundo (ms) es
una milésima (1/1000) de un segundo.
Hagamos algunos sonidos en nuestra computadora:
1 # c3_sounds.kbs
2 # sound = sonido
3 sound 233, 1000
4 sound 466, 500
5 sound 233, 1000
Programa 17: Reproducir tres notas individuales
Ud. debería haber oído un ruido como un “click” en sus parlantes entre las notas
reproducidas en el ejemplo anterior. Esto es causado porque la computadora necesita crear

258
el sonido y reproducirlo en cada una de las declaraciones. Así, entre declaraciones, la

computadora necesita “parar y preparar el próximo sonido”, algo así como un milisegundo.
Para mejorar esto, la declaración sound también puede ser escrita usando una lista de
frecuencias y duraciones, lo que suaviza la transición de una nota a otra.
1 # c3_soundslist.kbs
2 sound {233, 1000, 466, 500, 233, 1000}
Programa 18: Lista de Sonidos
Este segundo programa reproduce los mismos tres tonos y con la misma duración que el
anterior, pero la computadora crea y reproduce todos los sonidos en una sola sentencia,
haciendo que la reproducción sea más suave.
sound frequencia, duración

sound {frequencia1, duración1,
frequencia2, duración 2 ...}
sound numeric_array
La declaración básica de sound toma dos argumentos: (1) la
frecuencia del sonido, en ciclos por segundo [Hz], y (2) la
duración del tono, en milisegundos [ms].
La segunda forma de declaración sound usa llaves {} y puede
especificar varios tonos y duraciones en una lista.
La tercera forma de declaración de sound usa un array (arreglo,
variable conteniendo una lista de cosas) conteniendo una lista de
frecuencias y duraciones. No se preocupe por ahora, veremos arrays
en el capítulo 11.
¿Como hacemos para que BASIC-256 reproduzca un tono? La primera cosa que
necesitamos es convertir las notas musicales a frecuencias. La Ilustración 10 muestra dos
octavas de notas musicales, sus nombres y la frecuencia aproximada que la nota produce.
En música, Ud. también encontrará una marca especial llamada “pausa”. La pausa significa
no reproducir nada (silencio) por un cierto período de tiempo. Si en su programa está
usando una lista de sonidos, es posible insertar una pausa especificando una frecuencia =0
durante el tiempo necesario.

258
Ilustración 10: Notas Musicales

Tomemos una pequeña pieza musical (Ilustración 11) llamada Carga! y miremos los valores
de frecuencia para cada una de sus notas. ¿Porqué no podemos decirle directamente a la
computadora que reproduzca Carga!?. Ud. habrá notado en la ilustración que la G alta en
la música no está en las notas musicales; si una nota no está sobre el pentagrama, Ud.
puede duplicar (para hacerla más alta) o dividir por la mitad (para hacerla más baja) la
misma nota desde una octava más lejos.
Ilustración 11: Carga!
Ahora que tenemos las frecuencias necesitamos la duración para cada una de las notas.
La Tabla 2 muestra las notas y pausas más frecuentes, cuán largas estas son cuando son
comparadas entre sí, y unas pocas duraciones típicas.
Las duraciones en milisegundos (ms) pueden ser calculadas si se conoce el ritmo de la
música en beats (latidos) por minuto (BPM) usando la Fórmula 1:
Formula 1: Calculando la Duración de una Nota
Símbolo para A 100 A 120 A 140

NOMBRE DE NOTA Longitud
Nota - Reposo BPM BPM BPM
Dotted Whole 6.000 3600 ms 3000 ms 2571 ms

258
Whole 4.000 2400 ms 2000 ms 1714 ms
Dotted Half 3.000 1800 ms 1500 ms 1285 ms
Half 2.000 1200 ms 1000 ms 857 ms
Dotted Quarter 1.500 900 ms 750 ms 642 ms
Quarter 1.000 600 ms 500 ms 428 ms
Dotted Eighth 0.750 450 ms 375 ms 321 ms
Eighth 0.500 300 ms 250 ms 214 ms
Dotted Sixteenth 0.375 225 ms 187 ms 160 ms
Sixteenth 0.250 150 ms 125 ms 107 ms
Tabla 2: Notas Musicales y Duraciones Típicas
Ahora, con la tabla y la fórmula para calcular las duraciones de las notas, podemos escribir
el programa para reproducir “Carga!”
1 # c3_charge.kbs
2 # reproduzca carga!
3
4 sound {392, 375, 523, 375, 659, 375, 784, 250, 659, 250, 784, 250}
5 say "Carga!"
Programa 19: Carga!
Variables Numéricas
Las computadoras son realmente buenas recordando cosas, ahí donde nosotros los
humanos a veces tenemos problemas. El lenguaje BASIC nos permite dar nombres a
lugares en la memoria de la computadora y luego guardar información en ellos. Estos
lugares son llamados variables.
Hay cuatro tipos de variables: variables numéricas, variables string, variables array
numérico (numeric array variables) y variables array string (string array variables). En este
capítulo aprenderá a usar variables numéricas, las otras en capítulos porteriores.
variable numérica
Una variable numérica le permite asignar un nombre a un
bloque de memoria RAM de su computadora. En su programa, Ud.
podrá guardar y recuperar valores numéricos (enteros o decimales)
de estas variables.
El nombre de una variable numérica debe empezar con una letra,
puede contener letras y números y es sensible a mayúsculas y
minúsculas. Ud. no puede usar palabras reservadas por el lenguaje
BASIC-256 como nombre de sus variables (Ver apéndice I).
Ejemplos de nombres válidos: a, b6, micasa, x, zoo.

258
Los nombres de las variables son sensibles a mayúsculas y

minúsculas. Esto significa que una variable con nombre en
mayúsculas y una variable con las mismas letras pero en minúsculas
no son la misma, y no representan la misma ubicación en la memoria
de la computadora. Ejemplo: “TECLA” y “tecla” son variables
distintas. “tecla” y “Tecla”, también.
El Programa 20 es un ejemplo usando variables numéricas.
1 # c3_numericvariables.kbs
2 # uso de variables numericas
3
4 let numerador = 30
5 let denominador = 7
6 let result = numerador / denominador
7 print result
Programa 20: Variables Numéricas simples
El programa anterior usa tres variables. En la línea 4 guarda el valor 30 en la ubicación

llamada “numerador”. En la línea 5 guarda el valor 7 en la variable “denominador”. En la
línea 6 se toma el valor guardado en “numerador”, se lo divide por el guardado en
“denominador” y se guarda el resultado en una variable llamada “result”.
let variable = expresion

variable = expresion
La declaración let calculará una expresión (si es necesario) y
guardará el valor obtenido en una variable especificada. Este
proceso de llama “asignación” o “asignando una variable”.
La variable al lado izquierdo del signo igual tomará el valor de la

variable, número, función o expresión matemática que esté a la
derecha del signo igual.
En realidad, la declaración let es opcional. Ud. Puede directamente
asignar la variable usando el signo igual.
1 let a = 7
2 let b = a / 2 + .7
3 print a + b
Programa 21: Asignación de una variable
Salida 21: Asignación de una variable

258
Las declaraciones en el Programa 21 crearán dos lugares de almacenamiento en memoria

y guardarán el valor o resultado del cálculo en ellas. La línea 3 del programa sumará estos
valores e imprimirá el valor “11.2”. Ud. puede usar una variable numérica en cualquier lugar
en que necesite un número y el valor guardado en la variable será extraido de su lugar en
la memoria.
Las variables se llaman “variables” porque pueden ser cambiadas mientras el programa se
ejecuta. Mire el ejemplo en el Programa 22 (abajo). En la línea 1 el valor 99 es asignado a
la variable z. En la línea 2 la expresión z-1 es calculada y el resultado es guardado en la
misma variable z. En la última línea, el valor de z se imprime. ¿Puede Ud. decir que valor
será impreso?
1 z = 99
2 z=z-1
3 print z
Programa 22: Re-asignación de una Variable
Salida 22: Re-asignación de una Variable

Las variables y su valores asociados persisten, una vez que son creados, por todo el
tiempo que el programa esté corriendo. Una vez que el programa se detiene (ya sea
porque terminó correctamente o por un error) los valores de las variables son vaciados y la
memoria que reservaban es devuelta al sistema operativo de la computadora para ser
usada en otras tareas.
Ahora que hemos aprendido un poco más sobre variables, podemos reescribir el programa
Carga! Usando variables y la fórmula para calcular la duración de las notas (Fórmula 1).
1 # c3_charge2.kbs
2 # reproducir Carga - usando variables
3
4 beats = 120
5 dottedeighth = 1000 * 60 / beats * .75
6 eighth = 1000 * 60 / beats * .5
7
8 sound {392, dottedeighth, 523, dottedeighth, 659, dottedeighth, 784,
eighth, 659, eighth, 784, eighth}
9 say "Charge!"
Programa 23: Reproducir Charge! usando Variables
Abreviaciones en la Asignación de Variables

Otra cosa que Ud. aprenderá sobre programación de computadoras es que, a menudo, hay
más de un manera de hacer lo mismo. BASIC-256 y la mayoría de los lenguajes de
computación permiten formas abreviadas de adición y substracción cuando trabajan con
una variable. En los programas de los capítulos posteriores Ud. verá estas abreviaciones.
Declaración Abreviada Declaración Completa

258
variable+= expresión variable = variable + expresión

a+=9 a=a+9
variable -= expresión variable = variable - expresión
b -= a+2 b = b - (a + 2)
variable++ variable = variable + 1
foo++ foo = foo + 1
Variable-- Variable = variable - 1
bar-- bar = bar - 1
Tabla 3: Abreviaciones en Declaraciones de Variables
Para el “Programa Grande” de este capítulo tomaremos una pieza de

música de J.S. Bach y escribiremos un programa para reproducirla
La composición es parte de la obra “Pequeña” Fuga en G Menor” de
J.S. Bach.
Ilustración 12: Primeros cuatro compases de Pequeña Fuga en G Menor
1 # c3_littlefuge.kbs
2 # Musica de J.S.Bach - XVIII Pequeña Fuga en G Menor
4 tempo = 100 # beats por minuto
5 milimin = 1000 * 60 # milisegundos en un minuto
6 q = milimin / tempo # cuarto de nota es un beat
7 h = q * 2 # media nota (2 cuartos)
8 e = q / 2 # octavo de nota (1/2 cuarto)
9 s = q / 4 # dieciseisavo de nota (1/4 cuarto)
10 de = e + s # octavo punteado - octavo + dieciseisavo
11 dq = q + e # cuarto punteado - cuarto + octavo
12
13 sound {392, q, 587, q, 466, dq, 440, e, 392, e, 466, e, 440, e, 392, e, 370,
e, 440, e, 294, q, 392, e, 294, e, 440, e, 294, e, 466, e, 440, s, 392, s, 440, e,
294, e, 392, e, 294, s, 392, s, 440, e, 294, s, 440, s, 466, e, 440, s, 392, s, 440,
s, 294, s}
Programa 24 : Programa Grande – Fuga en G Menor

258
Ejercicios:
d j r a h e r t z q y t x
n a v a r i a b l e l z s
o s h a l f n g k j u e x
c s s h o r t c u t c g j
e i e h t h g i e a h i n
s g t u r l s l r t b k x
i n a t y f i b n d e d t
l m r s a i x e n e x l u
l e b y c n e u q e r f i
i n i b q t o e v a t c o
m t v z x s j w h o l e b
m u s i c r e t r a u q a
i j s q s e y t e t o n t
assignment, braces, eighth, frequency, half, hertz, millisecond, music,
note, octave, quarter, shortcut, sixteenth, sound, variable, vibrate,
whole
3.1. Escriba un programa usando una única declaración sound para

reproducir “Shave and a Hair Cut” (Afeitada y corte de cabello).
Recuerde que debe incluir los cuartos de pausa en el segundo
acorde de su sonido con una frecuencia de cero y duración de
un cuarto de nota.
3.2 Escriba la declaración sound dada a continuación e inserte la

asignación de variables antes de reproducir “Row Row Row your
Boat”. Las variables c, d, e, f, g y cc deben contener las
frecuencias de las notas del tono. La variable n4 debe contener
la longitud en ms de un cuarto de nota; n2 el doble de n4, y n8 la
mitad de n4.
sound {c,n4+n8, c,n4+n8, c,n4, d,n8, e,n4+n8,
e,n4, d,n8, e,n4, f,n8, g,n2+n4, cc,n8, cc,n8,
cc,n8, g,n8, g,n8, g,n8, e,n8, e,n8, e,n8, c,n8,
c,n8, c,n8, g,n4, f,n8, d,n4, e,n8, c,n2+n4}

258
3.3. Escriba un programa con dos variables “a” y “b” que asignará a
dos números. Imprima la suma de a y b, la diferencia de a y b, el
producto de a y b y el cociente de b dividido por a. Corra el
programa con diferentes valores de a y b. ¿Qué pasa cuando a o
b se les asigna el valor cero?

258
Capítulo 4: Pensando como un Programador
Capítulo 4: Pensando como un

Programador
Una de las cosas más difíciles de aprender es cómo pensar como un programador. Un
programador no es creado simplemente mediante libros o clases, sino que se desarrolla
desde adentro de la persona. Para ser un “buen” programador hay que desarrollar la
pasión por la tecnología, el auto-aprendizaje, el pensamiento lógico, y la inquietud para
crear y explorar.
Usted debería sentirse como el gran Cristóbal Colón, Neil Armstrong o Yuri Gagarin (el
primer ser humano en el espacio): Tiene un ilimitado universo para explorar y para crear
dentro de su computadora. Las únicas limitaciones sobre hasta dónde puede llegar son su
creatividad y sus deseos de aprender.
Un programa para desarrollar un juego o una aplicación interesante puede tener varios
miles de líneas de código. Esto puede volverse abrumador rápidamente, aún para los
programadores más experimentados. Por lo tanto, hay que ser ordenados. A menudo
deberemos aproximarnos a un problema complejo mediante un proceso de tres pasos,
como los siguientes:
1. Pensar y tener claro el problema
2. Dividir el problema en partes y describirlas con precisión
3. Convertir esas partes en programas en el lenguaje de computadora que vaya a usar.
Pseudocódigo
“Pseudocódigo” es la palabra extravagante que se usa para escribir y describir, paso a
paso, lo que su programa necesitará hacer. La palabra pseudocódigo viene del prefijo
griego “pseudo- “, que significa falso y “código” para las líneas de programa reales. No es
creado para que la computadora lo use directamente, sino para ayudarse a uno mismo a
entender la complejidad de un problema y dividirlo en piezas que tienen claramente
definido qué es lo que tienen que hacer.
No hay una única ni una mejor manera de escribir pseudocódigo. Hay docenas de
estándares, y cada uno de ellos puede ser el adecuado para un tipo particular de problema.
En esta introducción usaremos simples oraciones en castellano para explicar y entender
nuestro problema.
¿Como haría Ud. para escribir un programa para dibujar un colectivo escolar? (como el
mostrado en la Ilustración 13).
Ilustración 13: Bus escolar.

Podemos dividir el problema en dos pasos:
1. Dibujar las ruedas
2. Dibujar el cuerpo

258
Ahora, dividamos cada uno de los pasos en piezas más pequeñas y escribamos nuestro
pseudocódigo:
Seleccionar color negro

Dibujar ambas ruedas.
Seleccionar el color amarillo
Dibujar el cuerpo del bus.
Dibujar el frente del bus.
Tabla 4: Bus Escolar - Pseudocódigo
Ahora que tenemos nuestro programa desarrollado, todo lo que tenemos que hacer es
escribirlo en lenguaje de programación:
Seleccionar color negro color black

Dibujar ambas ruedas. circle 50,120,20 circle 200,120,20
Seleccionar el color amarillo. color yellow
Dibujar el cuerpo del bus. rect 50,0,200,100
Dibujar el frente del bus rect 0,50,50,50
Tabla 5: Bus Escolar – Pseudocódigo con sentencias BASIC-256
El programa completo del bus escolar (Programa 25) puede verse a continuación. Lea en
detalle el programa terminado y verá líneas de comentarios usados para ayudar al
programador a recordar los pasos usados durante la resolución inicial del problema.
1 # c4_schoolbus.kbs
2 # dibuja un bus escolar
3
4 clg
5
6 # dibujar ruedas
7 color black
8 circle 50,120,20
9 circle 200,120,20
10
11 # dibujar el cuerpo del bus
12 color yellow
13 rect 50,0,200,100
14 rect 0,50,50,50
Programa 25: Bus Escolar
En este ejemplo del Bus Escolar podemos ver que hay muchas maneras diferentes para
dividir el problema en pequeñas piezas. Podríamos haber dibujado el frente antes que el
cuerpo… podríamos listar decenas de maneras diferentes de abordar este simple
problema.
Una cosa muy importante para recordar: NO HAY MODO EQUIVOCADO de cómo encarar
un problema. Algunos serán mejores que otros (tendrán menos declaraciones, serán más
fáciles de leer y entender…), pero lo importante es resolver el problema.

258

258
Diagramas de Flujo
Otra de las técnicas que los programadores utilizan para entender un problema es el
llamado “Diagramas de Flujo”. Siguiendo el viejo adagio de que “una imagen es equivalente
a miles de palabras”, los programadores dibujan a veces n diagrama representando la
lógica del programa. El diagrama de flujo es uno de los métodos más viejos y comúnmente
usados de “dibujar” la estructura de un programa.
Esta breve introducción a los diagramas de flujo cubrirá solo una pequeña parte de lo que
puede hacerse con ellos, pero con unos pocos símbolos y conectores seremos capaces de
modelar procesos realmente complejos. Esta técnica le será útil no solo para programar,
sino para resolver diversos problemas con los que puede encontrarse. A continuación unos
pocos símbolos básicos:
Símbolo Nombre y Descripción
Flujo: Una flecha representa el moverse desde un

símbolo o paso en el proceso a otro. Se debe seguir la
dirección de la flecha
Terminal: Este símbolo nos dice donde comienza y

Terminal donde termina el diagrama de flujo. Cada diagrama de
flujo debe tener dos de éstos: un comienzo y un final.
Proceso: Este símbolo representa actividades o acciones

que el programa necesita ejecutar. Siempre debe haber
Proceso
solo una flecha saliendo de un proceso.
Entrada/Salida (E/S o I/O por Input/Output en inglés):

Este símbolo representa datos o ítems que están siendo
Entrada
& Salida
leídos por el sistema (entrada) o siendo escritos (salida)
por el mismo. Un ejemplo es guardar (salids) o cargar
(entrada) un archivo.
Decisión: El diamante de decisión se hace preguntas

simples con respuesta si/no o falso/verdadero. Siempre
debe haber 2 flechas saliendo de la decisión.
Dependiendo del resultado de la pregunta, se seguirá un
Decisi camino o el otro.
ón
Tabla 6: Símbolos esenciales de Diagramas de Flujo
La mejor manera de aprender a armar un diagrama de flujo es mirar con detalle algunos
ejemplos y meter nuestras manos en ellos.

258
Diagramas de Flujo: Ejemplo Uno

Ud. acaba de levantarse y su madre le ofrece dos opciones para el desayuno: Puede
comer su cereal preferido o huevos revueltos. Si Ud. no elige ninguna de las opciones, se
irá al colegio con hambre...
Ilustración 14: Desayuno – Diagrama de Flujo
Mire con cuidado la Ilustración 14 (arriba) y siga todas las flechas. Puede ver cómo este
diagrama representa la situación descripta?

258
Diagramas de Flujo: Ejemplo Dos

Otro ejemplo alimenticio. Ud. está sediento y desea comprar un refresco en una máquina
expendedora. Mire con detalle la Ilustración 15 (siguiente).
Ilustración 15: Máquina expendedora de bebidas – Diagrama de Flujo

258
Note en este segundo diagrama de flujo que hay un par de veces en que necesitamos repetir un
proceso. Ud. no ha visto aún cómo hacer esto en BASIC-256, pero lo aprenderá en los próximos
capítulos.
Ejercicios:
z d s y m b o l t r p
e m e w t a f r m r t
y d k c l u a v o s e
p q o z i h p g r p r
x r i c c s r n r e m
z f o w o a i e i t i
a u o c m d x o u s n
q l h m e p u p n q a
f o i q m s t e d u t
b n m h r u s w s b o
g e p r o b l e m p r
decision, flowchart, input, output, problem, process, programming,
pseudocode, steps, symbol, terminator
4.1. En sentencias completas, ¿puede Ud. escribir los pasos para

hacer un sándwich de jamón y queso? Asuma que las fetas de
jamón y de queso, el pan, la mayonesa y el cuchillo están en la
mesa, frente a Ud. ¿Podrá otra persona, que jamás hizo un
sándwich de jamón y queso, poder hacer uno siguiendo sus
instrucciones?
4.2. En un diagrama de flujo (o un diagrama similar), describa el
proceso que utiliza para abrir la puerta de su casa o
departamento. ¿Tiene las llaves? ¿Está la puerta cerrada con
llave? ¿O está abierta?
4.3. En pseudocódigo (oraciones cortas) ¿puede Ud. describir el
camino desde su escuela o trabajo, en automóvil, hasta la
estación de servicio más cercana? (No haga trampa y busque un
mapa en la web). ¿Las mismas instrucciones le servirán para
hacer el camino de vuelta? ¿O deberán ser cambiadas?

258
Capítulo 5: Su Programa Busca Consejo

Este capítulo introduce un nuevo tipo de variable (variables “string”) y muestra como
adquirir texto y respuestas numéricas del usuario.
NdT: En este contexto, puede entender string como una “cadena de caracteres”; esto es
por ejemplo, una o varias palabras. En este libro se usará la palabra en inglés con ese
significado.
Otro Tipo de Variable – La variable String

En el Capítulo 3 vimos variables numéricas, que pueden solo guardar números enteros o
decimales. A veces, necesitará guardar en la memoria de la computadora un “string”, esto
es, texto encerrado entre comillas (“”). Para hacer esto deberá usar un nuevo tipo de
variable llamada variable string. Una variable string se denota agregando el signo $ al final
del nombre de la variable.
Ud. puede asignar o recuperar valores de una variable string de la misma manera que con
una variable numérica. Recuerde: las reglas para el nombre de la variable, sensibilidad a
mayúsculas y minúsculas y palabras reservadas son las mismas tanto para variables
numéricas como para las de tipo string.
1 # c5_ilikejim.kbs
2 # Me gusta Ana – variables string
3
4 nombre$ = "Ana"
5 mensaje_1$ = '"' + nombre$ + '" es mi amiga.'
6 mensaje_2$ = "Me gusta " + nombre$ + "."
7
8 print mensaje_1$
9 say mensaje_1$
10 print mensaje_2$
11 say mensaje_2$
Programa 26: Me gusta Ana
"Ana" es mi amiga.
Me gusta Ana.
Salida 26: Me gusta Ana.
Variable String
Una variable string le permite asignar un nombre a un bloque de
memoria de la computadora. Ud. En su programa puede guardar o
recuperar texto y caracteres de una variable string.
El nombre de una variable string debe comenzar con una letra; puede
contener letras y números; es sensible a mayúsculas y minúsculas y
debe terminar con el signo $. Además, recuerde que Ud. no puede
usar las palabras reservadas por BASIC-256 como nombre de sus
variables (ver Apéndice I).
Ejemplos de nombres de variables string válidos: d$, c7$, book$, X$,
and bienVenido$.

258
Si Ud. asigna un valor numérico a una variable string, BASIC-256

convertirá el número a un string de caracteres y asignará este último
a la variable.
Si Ud. intenta asignar un string a una variable numérica, recibirá un
“error de sintaxis”.
Input – Obteniendo Texto o Números del Usuario

Hasta ahora habíamos puesto en el código del programa todo lo que éste debía saber para
funcionar. Ahora, veremos la sentencia “input”, que permite introducir un dato en el
programa durante su ejecución.
La sentencia input captura un string o un número que el usuario tipea en el área de entrada
texto y lo guarda en una variable.
Tomemos el Programa 26 y modifiquémoslo de modo que pregunte al usuario por un
nombre y luego diga hola a esa persona.
1 # c5_ilikeinput.kbs
2 # usando input para preguntar por un nombre
3
4 input "ingrese su nombre> ", name$
5 mensaje_1$ = name$ + " es mi amigo."
6 mensaje_2$ = "Me gusta " + name$ + "."
7
8 print mensaje_1$
9 say mensaje_1$
10 print mensaje_2$
11 say mensaje_2$
Programa 27: Me Gusta (preguntando el nombre)
Ingrese su nombre> Juan

Juan es mi amigo. Me gusta Juan.
Salida 27: Me Gusta (preguntando el nombre)
input "prompt", variablestring$

input "prompt", variablenumerica
input variablestring$
input variablenumerica
La sentencia input lee un string o un número que el usuario ingresa
en el área de entrada de texto de la pantalla y lo guarda en una
variable que puede ser usada posteriormente por el programa.
Un mensaje, si se especifica, se mostrará en el área de texto de la
pantalla y el cursor (prompt) se ubicará inmediatamente después del
mensaje. Si se desea que el usuario ingrese un número (se especifica
en el programa una variable numérica para guardar el dato de entrada)
y en su lugar ingresa un string que no puede ser convertido a número,
la sentencia input pondrá la variable a cero (0).

258
El Programa "Math-wiz" a continuación es un ejemplo de ingreso de datos numéricos por

parte del usuario.
1 # c5_mathwiz.kbs
2 # muestre varias operaciones matematicas
3
4 input "a? ", a
5 input "b? ", b
6 print a + "+" + b + "=" + (a+b)
7 print a + "-" + b + "=" + (a-b)
8 print b + "-" + a + "=" + (b-a)
9 print a + "*" + b + "=" + (a*b)
10 print a + "/" + b + "=" + (a/b)
11 print b + "/" + a + "=" + (b/a)
Programa 28: Math-wiz
a? 7
b? 56
7+56=63
7-56=-49
56-7=49
7*56=392
7/56=0.125
56/7=8
Salida 28: Math-wiz
Este Capítulo tiene dos “Programas Grandes”. El primero es uno

divertido que dirá su nombre y cuál será su edad dentro de 8 años. El
segundo es un generador de historias sin sentido.
1 # c5_sayname.kbs
2
3 input "Cual es su nombre?", name$
4 input "Cual es su edad?", age
5 saludo$ = "Un gusto conocerte, " + name$ + "."
6 print saludo$
7 say saludo$
8
9 saludo$ = "En 8 años tu edad será de " + (age+8) + " años. Wow, que
número!"
10 print saludo$
11 say saludo$
Programa 29: Nombre y Edad
Cual es su nombre?Jose
Cual es su edad?13

258
Un gusto conocerte, Jose.

En 8 años tu edad será de 21 años. Wow, que número!
Salida 29: Nombre y Edad
1 # c5_sillystory.kbs
2
3 print "Una Historia Tonta."
4
5 input "Ingrese un sustantivo? ", noun1$
6 input "Ingrese un verbo? ", verb1$
7 input "Ingrese una habitación en su casa? ", room1$
10 input "Ingrese un adjetivo? ", adj1$
13 input "Ingrese su nombre? ", name$
14
15 sentence$ = " Una Historia Tonta, por " + name$ + "."
16 print sentence$
17 say sentence$
18
19 sentence$ = "Un día, no hace mucho tiempo, ví un " + noun1$ + " " +
verb1$ + " bajando las escaleras."
20 print sentence$
21 say sentence$
22
23 sentence$ = "Estaba yendo a mi " + room1$ + " para " + verb2$ + " un " +
noun2$
24 print sentence$
25 say sentence$
26
27 sentence$ = "El " + noun1$ + " se hizo " + adj1$ + " cuando yo " + verb3$
+ " con un " + noun3$ + "."
28 print sentence$
29 say sentence$
30
31 sentence$ = "Fin."
32 print sentence$
33 say sentence$
Programa 30: Programa Grande – Generador de Historias Tontas
Una Historia Tonta.

Una Historia Tonta, por Mario.
Ingrese un sustantivo? auto
Ingrese un verbo? caminar
Ingrese una habitación en su casa? cocina

258
Ingrese un verbo? cantar

Ingrese un sustantivo? television
Ingrese un adjetivo? grange
Ingrese un verbo? jugar
Ingrese un sustantivo? computadora
Ingrese su nombre? Mario
Un día, no hace mucho tiempo, ví un auto caminar bajando las escaleras.
Estaba yendo a mi cocina para cantar un television
El auto se hizo grande cuando yo jugar con un computadora
Fin.
Salida 30: Programa Grande – Generador de Historias Tontas

258
Ejercicios:
e d l e p g a g j n
p l e a k x l k o g
y r b f b x p e z i
q s o a a h r f l s
q j t m i u i v k r
t s i r p r l w r a
a x f n i t a t g l
h l f y p n y v q l
p w r n i u g x z o
y v c l d z t w v d
default, dollarsign, input, prompt, string, variable
5.1. Escriba un programa que pregunte por tres nombres. Gúardelos

en variables string. Una vez que el usuario ingresó el tercer
nombre, haga que la computadora recite la siguiente canción
usando esos nombres:
[Nombre_1] y [Nombre_2]
Sentados arriba de un arbol,
B-E-S-A-N-D-O-S-E.
Primero vino el amor,
Luego el matrimonio,
Y al final [Nombre_3] en un coche de bebe!
5.2. Escriba un programa que pregunte por un adjetivo, un
sustantivo, un animal y un sonido. Una vez que el usuario
ingrese el último, construya una sola variable string (usando
concatenación) para decir un verso del Viejo MacDonald. Imprima
el resultado con una sola declaración y dígalo también con una
sola declaración.
(Adaptado de “The Old Macdonald Mad Lib”, de
http://www.madglibs.com)
[Adjetivo] MacDonald tiene un [Sustantivo],
E-I-E-I-O y en ese [Sustantivo] tiene un [Animal], E-I-E-I-O
with a [Sonido] [Sonido] aquí y un [Sonido] [Sonido] allí,
Aquí un [Sonido], allí un [Sonido], en todos lados un [Sonido]
[Sonido], [Adjetivo] MacDonald tiene un [Sustantivo], E-I-E-I-
O.

258
Capítulo 6: Decisiones, Decisiones, Decisiones
Capítulo 6: Decisiones, Decisiones,

Decisiones
La computadora es un as comparando cosas. En este capítulo exploraremos cómo
comparar dos expresiones, como trabajar con comparaciones complejas y como, de
manera opcional, ejecutar declaraciones dependiendo del resultado de nuestras
comparaciones. Vamos a ver también cómo generar números aleatorios.
Verdadero y Falso (True y False)

El lenguaje BASIC-256 tiene un tipo adicional de datos que pueden ser guardados en una
variable numérica. Es el tipo de datos “Booleano”. Los valores booleanos pueden
solamente tomar el valor “verdadero” o “falso” y son generalmente el resultado de
comparaciones y operaciones lógicas. Además, para hacer más fácil trabajar con ellos, hay
dos constantes booleanas que Ud. puede usar en sus expresiones; que son: true y false.
true
false
Las constantes booleanas true y false pueden ser usadas en
cualquier expresión numérica o lógica, pero son usualmente el
resultado de una comparación o un operador lógico. En realidad, la
constante true es guardada como un número “1” y la constante false
como un número “0”.
Operadores de Comparación
Previamente, hemos discutido los operadores aritméticos básicos. Ahora es tiempo de
mirar algunos operadores adicionales. En un programa, a menudo necesitamos comparar
dos valores para decidir qué hacer. Un operador comparación trabaja con dos valores y
devuelve true o false basado en el resultado de la comparación
Operador Operación
Menor que
expresión 1 < expresión 2
<
Devuelve true si la expresión 1 es menor que la expresión 2.
Caso contrario devuelve false.
Menor que o Igual a
expresión 1 <= expresión 2
<=
Devuelve true si la expresión 1 es menor que o igual a la expresión 2.
Caso contrario devuelve false
Mayor que
expresión 1 > expresión 2
>
Devuelve true si la expresión 1 es mayor que la expresión 2.
Mayor que o Igual a
expresión 1 >= expresión 2
>=
Devuelve true si la expresión 1 es mayor que o igual a la expresión 2.

258
Igual
expresión 1 = expresión 2
=
Devuelve true si la expresión 1 es igual a la expresión 2.
No Igual
<> expresión 1 <> expresión 2
Devuelve true si la expresión 1 no es igual a la expresión 2,.
Tabla 7: Operadores de Comparación
true
false
< <= > >= = <>
Las seis operaciones de comparación son :
Menor (<), menor o igual (<=), mayor (>), mayor o igual (>=), igual (=),
y no igual (<>).
Son usadas para comparar números y cadenas (strings). Las strings
son comparadas alfabéticamente de izquierda a derecha. Ud. puede
también usar paréntesis para agrupar operaciones.
Tomando decisiones simples - El operador If (Si…)

El operador IF (SI… en castellano) puede usar el resultado de una comparación para
ejecutar opcionalmente una sentencia o un conjunto de sentencias. El programa siguiente
(Programa 31) usa tres declaraciones IF para mostrar si su amigo es mayor, de la misma
edad o menor que Ud.
1 # c6_compareages.kbs
2 # compare dos edades
3
4 input "Cual es su edad? ", edad_mia
5 input "Cual es la edad de su amigo? ", edad_amigo
6
7 print "Usted es ";
8 if edad_mia < edad_amigo then print "menor que";
9 if edad_mia = edad_amigo then print "de la misma edad que";
10 if edad_mia > edad_amigo then print "mayor que";
11 print " su amigo."
Programa 31: Compare dos Edades
Cual es su edad? 13
Cual es la edad de su amigo? 12
Usted es mayor que su amigo.
Salida 31: Compare dos Edades

258
Ilustración 16: Compare dos Edades – Diagrama de Flujo
if condición then sentencia

Si la condición evalúa a true, ejecute la sentencia a continuación
de la cláusula then.

258
Números Aleatorios (Random Numbers)

Cuando desarrollamos juegos o simulaciones puede ser necesario simular eventos
aleatorios, como tirar unos dados, una ruleta u otro evento al azar. BASIC-256 tiene
incorporado un generador de números aleatorios para usar en estos casos.
rand
Cuando se usa rand en una expresión, éste devuelve un número
aleatorio. El número devuelto se encontrará siempre en el intervalo 0 a
1, pero nunca será 1 (0≤número<1).
A menudo Ud. querrá generar un número “n” entero en el intervalo
desde 1 hasta R. En ese caso, puede usarse la siguiente sentencia:
n = int (rand * R) + 1
int (number)
int (string)
La función int remueve la parte decimal de un número, y devuelve
solamente la parte entera. No efectúa ningún redondeo.
int también intentará convertir un string en un número entero. Si el
string no contiene un número, entonces int devolverá un cero (0).
Ej.:
int (3,0345) = 3
int (3,9983) = 3 (no hay redondeo)
int (nume7ro) = 7
int (numero) = 0
1 # c6_coinflip.kbs
2
3 moneda = rand
4 if moneda < .5 then print "Cara."
5 if moneda >= .5 then print "Cruz."
Programa 32: Tirando una Moneda
Cruz.
Salida 32: Tirando una Moneda
En el Programa 5.2, Ud. puede haberse tentado de usar la expresión

rand dos veces, una para cada declaración if. Si lo hubiera hecho,
esto hubiera originado lo que se conoce como “Error Lógico”.
Recuerde, cada vez que se ejecuta la función rand, esta devuelve un
nuevo número aleatorio, que es usualmente diferente (puede ser
igual, pero es muy muy poco probable).
Operadores Lógicos
A veces, es necesario juntar varias comparaciones simples. Esto puede hacerse con los
cuatro operadores lógicos: and, or, xor, y not (en castellano: y, ó, o excluyente y no). Los
operadores lógicos trabajan de manera muy similar a como lo hacen las conjunciones en el

258
lenguaje Inglés, excepto que “or” es usado como “uno” o “el otro” o “ambos”.
Operador Operación
AND And Lógico

expresión1 AND expresión2
Si ambas, expresión1 y expresión2 son verdaderas (true), devuelve true
Caso contrario, devuelve false (falso)
expresión1
AND
TRUE FALSE
TRUE TRUE FALSE
expresión2
FALSE FALSE FALSE
OR Or Lógico
expresión1 OR expresión2
Si cualquiera, expresión1 o expresión2 es verdadera, devuelve true.
Caso contrario devuelve false.
expresión1
OR
TRUE FALSE
TRUE TRUE TRUE
expresión 2
FALSE TRUE FALSE
XOR Or Lógico Exclusivo

expresión1 XOR expresión2
Si solo una de las dos expresiones es verdadera, devuelve true. Caso
contrario, devuelve false. El operador XOR trabaja como a menudo lo hace
"or" en el lenguaje: “Ud. puede degustar la torta xor comérsela”
expresión1
XOR
TRUE FALSE
TRUE FALSE TRUE
expresión 2
FALSE TRUE FALSE
NOT Negación Lógica (Not)

NOT expresión1
Devuelve lo opuesto a la expresión1. Si la expresión1 es verdadera,
devuelve false. Si la expresión1 es falsa, devuelve true.
NOT
TRUE FALSE
expresión1
FALSE TRUE

258
and or xor not

Las 4 operaciones lógicas: and lógico, or lógico, or lógico exclusivo y
negación lógica (no) unen o modifican comparaciones. Ud. puede
también usar paréntesis para agrupar operaciones.
Tomando decisiones con Resultados Complejos -

If/End If
Cuando estamos escribiendo un programa, a veces es necesario ejecutar múltiples líneas
de código cuando la condición es verdadera. Esto puede ser hecho con el formato
alternativo de la declaración if. Con esta declaración Ud. no coloca una sentencia a
continuación y en la misma línea que el if, sino que coloca una o más declaraciones en
líneas siguientes a la sentencia if y luego cierra el bloque de declaraciones con una
sentencia end if
if condición then
declaracion(es) a ejecutar cuando es true
end if
La declaración if / end if le permite crear un bloque de código a
ejecutar cuando la condición es verdadera (true). Es una buena
práctica indentar (usar sangrías) las líneas de código dentro del bloque
if/endif para mejorar la legibilidad del programa.
1 # c6_dado.kbs
2 # Tirar 2 dados (die) de 6 caras cada uno
3
4 die1 = int(rand * 6) + 1
5 die2 = int(rand * 6) + 1
6 total = die1 + die2
7 print "dado 1 = " + die1
8 print "dado 2 = " + die2
9 mensaje$ = "Ud. tiró " + total + "."
10
11 if total = 2 then
12 mensaje$ += " Ojos de Serpiente."
13 end if
14 if total = 12 then
15 mensaje$ += " Una docena."
16 end if
17 if die1 = die2 then
18 mensaje$ += " Doblete, tire nuevamente!"
19 end if
20
21 print mensaje$
22 say mensaje$
Programa 33: Tirando dados

258
dado 1 = 6
dado 2 = 6
Ud. tiró 12. Una docena. Doblete, tire nuevamente!
Salida 33: Tirando dados
Menú "Edit" + "Beautify".

La opción “Beautify” (embellecer) en el menú “Edit” limpiará el formato
de su programa para hacerlo más fácil de leer. Removerá todos los
espacios extras e indentará bloques de código (como en las
declaraciones if/end if).
Decidiendo en ambos sentidos - If/Else/End If

La tercera y última forma de una declaración if es la if/else/endif. Esta extiende la
declaración if/end if, permitiéndole crear un bloque de código a ejecutar si la condición es
verdadera y otro bloque a ejecutar si es falsa.
if condition then
declaracion(es) a ejecutar cuando es verdadera
else
declaracion(es) a ejecutar cuando es falsa
end if
Las declaraciones if, else y endif le permiten definir dos bloques
de código. El primer bloque, después de la cláusula then, ejecuta si
la condición es verdadera (true); y el segundo bloque, después de la
cláusula else, ejecutará cuando la condición sea falsa (false).
El siguiente Programa 34 reescribe el Programa 32 usando la cláusula else.
1 # c6_coinflip2.kbs
2 # tirar moneda con else
3
4 coin = rand
5 if coin < .5 then
6 print "Cara."
7 say "Cara."
8 else
9 print "Cruz."
10 say "Cruz."
11 end if
Programa 34: Tirando una Moneda con else
Cara.
Salida 34: Tirando una Moneda con else
Decisiones Anidadas

258
Una última cosa. Con las declaraciones if/end if y if/else/end if, es posible anidar un if
dentro de otro. Esto puede sonar confuso, pero veremos cómo trabaja en próximos
capítulos.
El programa grande de este capítulo es un programa para tirar un

dado de 6 caras y dibujar en la ventana de salida gráfica de la
pantalla el número de puntos.
1 # c6_dieroll.kbs
2 # tirar un dado de 6 caras y mostrar en la pantalla
3
4 # hw – alto y ancho de los puntos en el dado
5 hw = 70
6 # margin – espacio antes de cada punto
7 # 1/4 del espacio dejado después de dibujar 3 puntos
8 margin = (300 - (3 * hw)) / 4
9 # z1 – posición x e y de la parte superior de la fila de arriba y la columna
de puntos
10 z1 = margin
11 # z2 – posición x e y de la parte superior de la fila y la columna del medio
de puntos
12 z2 = z1 + hw + margin
13 # z3 – posición x e y de la parte de arriba de la fila de abajo y la columna
de puntos
14 z3 = z2 + hw + margin
15
16 # tire el dado
17 tiro = int(rand * 6) + 1
18
19 color black
20 rect 0,0,300,300
21
22 color white
23 # fila de arriba
24 if tiro <> 1 then rect z1,z1,hw,hw
25 if tiro = 6 then rect z2,z1,hw,hw
26 if tiro >= 4 and tiro <= 6 then rect z3,z1,hw,hw
27 # fila del medio
28 if tiro = 1 or tiro = 3 or tiro = 5 then rect z2,z2,hw,hw
29 # fila de abajo
30 if tiro >= 4 and tiro <= 6 then rect z1,z3,hw,hw
31 if tiro = 6 then rect z2,z3,hw,hw
32 if tiro <> 1 then rect z3,z3,hw,hw
33

258
34 message$ = "Ud. tiró un " + tiro + "."

35 print message$
36 say message$
Programa 35: Programa Grande – Tire un dado y dibújelo
Salida 35: Programa Grande – Tire un dado y dibújelo

258
Ejercicios:
b t t h e n m r n s
i o r w l f o r z e
e d o u l d d o d s
r n r l e w n t j l
a a e u e t a a r e
p n t l n a r r o o
m o a a d s n e p l
o t e u i h l p t e
c i r q f f s o h s
w f g e e s l a f s
and, boolean, compare, else, endif, equal, false, greater, if, less, not,
operator, or, random, then, true
6.1. Escriba un programa que tire una moneda y le diga si su

elección fue correcta. Asigne una variable con un número
aleatorio. Pida al usuario que ingrese una letra “a” o “z” (para
cara o cruz). Si el número es menor que 0.5 y el usuario
ingresó “a”; o el número fue mayor o igual que 0.5 y el usuario
ingresó “z”, avísele que ganó.
6.2. Modifique el programa que escribió anteriormente (en 6.1) para
también avisarle al usuario que perdió.
6.3. Escriba un programa para dibujar una piedra, un papel y unas
tijeras. Use dos variables numéricas para asignar un tiro
(número aleatorio) a cada una. Si la variable es menor que 1/3
(0.33333) será piedra, si es mayor o igual que 1/3 y menor que
2/3 será papel, y si es igual o mayor que 2/3 será tijeras.
Muestre en pantalla cuales fueron los dos tiros.
6.4. En el programa anterior (6.3) agregue sentencias para decir quien
ganó. Recuerde que “papel cubre piedra”, “piedra rompe tijeras” y
“tijeras cortan papel”. Si ambos jugadores tiraron lo mismo,
declare la vuelta como empatada.
6.5. Tome el programa anterior (6.4) y póngale gráficos y sonido.
Dibuje el papel como un rectángulo blanco, la piedra como un
círculo naranja oscuro (darkorange) y las tijeras como una X
roja. Haga que la computadora anuncie por el parlante al
ganador.

258
Capítulo 7: Bucles y Conteo – Hágalo de Nuevo y de Nuevo
Capítulo 7: Loops (bucles) y Conteo;

Hágalo de Nuevo y de Nuevo
Tan pronto nuestro programa ha comenzado pasa, una por una, por todas las instrucciones
y se detiene. Mientras esto está bien para programas simples, la mayoría de los programas
tendrán tareas que necesitan ser repetidas, cosas contadas, o ambos. Este capítulo le
mostrará las tres declaraciones de repetición (looping), cómo acelerar sus gráficos y cómo
desacelerar su programa
El Loop FOR
El loop (bucle) más común es el for. El loop for ejecuta repetidamente un bloque de
declaraciones un especificado número de veces, y lleva la cuenta de las veces que lo
ejecutó. La cuenta puede comenzar con cualquier número, y puede cambiar con cualquier
incremento. El Programa 36 muestra una declaración for simple usada para decir los
números del 1 al 10 inclusive. El Programa 37 cuenta de a 2, comenzando en 0 y
terminando en 10.
1 # c7_for.kbs
2 for t = 1 to 10
3 print t
4 say t
5 next t
Programa 36: Declaración for
1
2
3
4
5
6
7
8
9
10
Salida 36: Declaración for
1 # c7_forstep2.kbs
2 for t = 0 to 10 step 2
3 print t
4 say t
5 next t
Programa 37: for – Con incremento 2
0
2
4
6
8
10

258
Salida 37: for – Con incremento 2
for variable = expr1 to expr2 [step expr3]

declaracion(es)
next variable
Ejecuta un bloque especificado de código un número de veces
especificado. La variable comenzará con el valor de expr1 y será
incrementada por expr3 (o por 1 si step no es especificado) la
segunda y las subsecuentes veces que el loop se ejecute. El loop
termina cuando la variable excede expr2.
Usando un loop podemos fácilmente dibujar gráficos muy interesantes. El Programa 38

dibuja un Patrón Moiré. Este gráfico realmente interesante es causado por la imposibilidad
de la computadora de dibujar líneas rectas inclinadas perfectas. Lo que dibuja en realidad
son píxeles a modo de escalera que aproximan a la línea recta. Si Ud. vé muy de cerca las
líneas dibujadas en la pantalla, verá que realmente es dentada como un serrucho.
1 # c7_moire.kbs
2 # dibuje un patrón moire
3
4 clg
5 color black
7 line 0,0,300,t
8 line 0,0,t,300
9 next t
Programa 38: Patrón Moiré
Salida 38: Patrón Moiré

258
¿Qué clase de Patrón Moiré puede dibujar? Comience en el centro,

use diferentes valores de incremento (step), superponga una encima
de la otra, intente con diferentes colores.
La sentencia for puede tambiér ser usada para contar hacia atrás. Para hacer esto
simplemente tenemos que usar un incremento (step) negativo-
1 # c7_stepneg1.kbs
2
3 for t = 10 to 0 step -1
4 print t
5 pause 1.0
6 next t
Programa 39: Sentencia for – Cuenta hacia atrás.
10
9
8
7
6
5
4
3
2
1
0
Salida 39: Sentencia for – Cuenta hacia atrás.
pause segundos
La sentencia pause (pausa) indica a BASIC-256 que detenga
la ejecución del programa durante el número especificado de
segundos. El número de segundos puede ser un número decimal en
caso que se requiera una pausa muy controlada.
Haga Algo Hasta que le Diga que se Detenga

El próximo tipo de loop que veremos es el do/until (haga/hasta que). El do/until repite la
ejecución de un bloque de código (do) hasta que la condición lógica especificada (hasta
que) sea verdadera. La condición se verifica al final de cada iteración. El Programa 40 a
continuación usa un loop do/until, que repite la ejecución del programa hasta que el usuario
ingresa un número entre 1 y 10.
1 # c7_dountil.kbs
2
3 do
4 input "Ingrese un número entre 1 y 10? ",n
5 until n>=1 and n<=10
6 print "Ud. ingresó " + n + " y detuvo el loop"

258
Programa 40: Ingrese un nro. Entre 1 y 10
Ingrese un número entre 1 y 10? 66

Ingrese un número entre 1 y 10? -56
Ingrese un número entre 1 y 10? 3
Ud. ingresó 3 y detuvo el loop
Salida 40: Ingrese un nro. Entre 1 y 10
do
declaracion(es)
until condicion
Ejecute el bloque de declaraciones mientras la condición sea
falsa. Como la condición se verifica al final del loop, la/las
declaración(es) serán ejecutadas al menos una vez.
Haga Algo mientras le diga que lo Haga

El tercer tipo de loop es el while/end while (mientras/fin de mientras). Este verifica la
condición antes de ejecutar cada iteración, y si la evaluación es verdadera, ejecuta el
código en el loop. Como la condición se verifica antes del loop, la/las declaraciones serán
ejecutadas ninguna o más veces
A veces, necesitamos un programa que ejecute un loop indefinidamente, hasta que el
usuario detenga el programa (esto es lo que hace, por ejemplo, un procesador de texto:
mantiene el programa en ejecución en un loop que lee el teclado y ve si se ingresó un
caracter para mostrarlo en pantalla.Hasta que el usuario decide cerrarlo). Esto puede
lograrse fácilmente usando una constante booleana (ver Programa 41)
1 # c7_whiletrue.kbs
2 while true
3 print "Nunca Mas.";
4 end while
Programa 41: Loop para siempre
NuncaMas.
NuncaMas.
NuncaMas.
NuncaMas.
NuncaMas.
(… y seguirá hasta que Ud. lo detenga.)
Salida 41: Loop para siempre
while condicion
declaracion(es)
end while
Ejecuta el bloque de declaración(es) mientras que la
condición sea verdadera. Como la condición se verifica antes del
loop, la/s declaración(es) se ejecutarán ninguna o más veces.
El Programa 42 usa la sentencia while para contar de 1 a 10, igual que el Programa 36 lo
hacía con una sentencia for.
1 # c7_whilefor.kbs

258
2
3 t=1
4 while t <= 10
5 print t
6 t=t+1
7 end while
Programa 42: While contando hasta 10.
1
2
3
4
5
6
7
8
9
10
Salida 42: While contando hasta 10.
Continuando y Saliendo de Loops

A veces es necesario saltar fuera de un loop antes de que éste termine normalmente (exit)
o comenzar el próximo loop (continue) sin ejecutar todo el bloque de código.
1 # maquina de sumar
2 # c7_exitwhile.kbs
3
4 total = 0
5 while true
6 input "Ingrese un valor (-999 para salir) > ", v
7 if v = -999 then exit while
8 total = total + v
9 end while
10 print "La suma de lo ingresado es " + total
Programa 43: Maquina de sumar - Usando Exit While
Ingrese un valor (-999 para salir) > 34

Ingrese un valor (-999 para salir) > -34
Ingrese un valor (-999 para salir) > -999
La suma de lo ingresado es 278
Salida 43: Maquina de sumar - Usando Exit While

258
exit do
exit for
exit while
Salta fuera del loop corriente salteando el resto de código en el loop.
continue do
continue for
continue while
No ejecute el resto de código en este loop, pero continúe con el loop
normalmente.
Gráficos Acelerados
Cuando necesitamos ejecutar muchos gráficos rápidamente, como en una animación o un
juego, BASIC-256 ofrece un sistema gráfico rápido. Este modo se habilita con la sentencia
fastgraphics (graficosrapidos). Una vez que el modo gráfico rápido es habilitado, la salida
gráfica se actualizará solo cuando Ud. ejecute la sentencia refresh (refrescar).
fastgraphics refresh
Inicia el modo gráfico rápido. En este modo, la pantalla será
actualizada solo cuando se ejecute la sentencia refresh.
Una vez que el programa ejecuta la sentencia fastgraphics, no es
posible volver al modo gráfico estándar (lento).
1 # c7_kaleidoscope.kbs
2
3 clg
4 fastgraphics
5 for t = 1 to 100
6 r = int(rand * 256)
7 g = int(rand * 256)
8 b = int(rand * 256)
9 x = int(rand * 300)
10 y = int(rand * 300)
11 h = int(rand * 100)
12 w = int(rand * 100)
13 color rgb(r,g,b)
14 rect x,y,w,h
15 rect 300-x-w,y,w,h
16 rect x,300-y-h,w,h
17 rect 300-x-w,300-y-h,w,h
18 next t
19 refresh
Programa 44: Caleidoscopio

258
Salida 44: Caleidoscopio
En este capítulo el Programa Grande usa un loop while para animar

una pelota rebotando en el área de salida gráfica.
1 # c7_bouncingball.kbs
2
3 fastgraphics
4 clg
5
6 # posición inicial de la pelota
7 x = rand * 300
8 y = rand * 300
9 # size of ball
10 r = 10
11 # velocidad en direcciones x e y
12 dx = rand * r + 2
13 dy = rand * r + 2
14
15 color green
16 rect 0,0,300,300
17
18 while true
19 # borre la pelota vieja
20 color white
21 circle x,y,r
22 # calcule la nueva posicion
23 x = x + dx
24 y = y + dy

258
25 # si fuera de los bordes laterales rebote la pelota

26 if x < 0 or x > 300 then
27 dx = dx * -1
28 sound 1000,50
29 end if
30 # si fuera de bordes sup. o inf. Rebote la pelota
31 if y < 0 or y > 300 then
32 dy = dy * -1
33 sound 1500,50
34 end if
35 # dibuje la nueva pelota
36 color red
37 circle x,y,r
38 # refresque la pantalla
39 refresh
40 end while
Programa 45: Programa Grande – Pelota rebotando
Salida 45: Programa Grande – Pelota rebotando

258
Ejercicios:
f l g b w p e t s w i i
f a w t b q l i t n u i
t n s n v h p h b c f e
i a k t c v r o o e l l
x d r k g e w n o i l c
e x o u f r d e h l o i
i g f r y i a w l n l c
t x e n t g d p t i w k
g s d i o n e i h p h a
h w o a e d n z m i g w
x n s d z u u d w t c d
x o m i e h d g m o v s
condition, continue, do, endwhile, exit, fastgraphics, for, loop, next,
refresh, step, until, while
7.1. Escriba un programa que use for para sumar los enteros desde
1 a 42 y muestre la respuesta. Ayuda: antes de empezar el loop
asigne a la variable cero (0) para acumular el total.
7.2. Escriba un programa que pregunte al usuario ingresar un entero
entre 2 y 12 en un loop. Mantenga corriendo el loop mientras el
usuario ingrese un número en ese rango. Calcule el factorial (n!)
del número ingresado usando un loop for y muéstre el resultado
en pantalla.
Recuerde factoriales:
2!=2*1,
3!=3*2*1,
5! = 5*4*3*2*1
n!=n*(n-1)*(n-2)*…*3*2*1 = n*(n-1)!
7.3. Escriba un programa para mostrar los números 1 hasta 8
multiplicados por 1 hasta 8. Ayuda: Use un loop for dentro de otro
loop for. Formatee su salida para que luzca como lo siguiente:
1*1=1
1*2=2
1*3=3
1*4=4
1*5=5
1*6=6
1*7=7
1*8=8
2*1=2
2*2=4
2*3=6
…
7.4. Reescriba el programa anterior (7.3) para mostrar sus resultados
en forma de tabla, como la siguiente:

258
1 2 3 4 5 6 7 8
2 4 6 8 10 12 14 16
3 6 9 12 15 18 21 24
4 8 12 16 20 24 28 32
5 10 15 20 25 30 35 40
6 12 18 24 30 36 42 48
7 14 21 28 35 42 49 56
8 16 24 32 40 48 56 64

258
Capítulo 8: Gráficos Personalizados – Creando sus Propias Formas
Capítulo 8: Gráficos Personalizados -

Creando sus Propias Formas
Este capítulo le mostrará cómo dibujar texto de color y formas especiales en la ventana
gráfica. Serán cubiertos varios tópicos, incluyendo texto decorado, polígonos y formas, a
los que posicionaremos, cambiaremos de tamaño y rotaremos. Se introduce además el
concepto de ángulo y cómo medirlos en radianes.
Texto de Fantasía para Salida Gráfica

Ud. ya conoce la declaración print (Capítulo 1) y puede imprimir strings y números en al
área de salida texto. Las declaraciones texto y font le permitirán colocar números y textos
en una variedad de estilos, pero ahora en el área de salida gráfica.
1 # c8_graphichello.kbs
2 # dibujando texto
3
4 clg
5 color red
6 font "Tahoma",33,100
7 text 100,100,"Hello."
8 font "Impact",33,50
9 text 100,150,"Hello."
10 font "Courier New",33,50
11 text 100,250,"Hello."
Programa 46: Hola en el área de salida gráfica
Salida 46: Hola en el área de salida gráfica
text x, y, expresión
Dibuja el contenido de la expresión en el área de salida gráfica con
su esquina superior derecha especificada por x e y. Usa el tipo,
tamaño y peso de letra especificado en el última declaración font.

258
font font_name, size_in_point, weight

Define el font (tipo), size (tamaño) y weight (peso) para el próxima
declaración text a utilizar para dibujar (render) texto en el área de
salida gráfica.
Argumento Descripción
font_name String conteniendo el nombre del font del

sistema (Windows) a utilizar. Un font debe ser
previamente cargado en el sistema antes de ser
usado. Nombres de fonts comunes en Windows
incluyen: "Verdana", "Courier New", "Tahoma",
"Arial", and "Times New Roman".
size_in_point Altura del texto a ser renderizado (dibujado) en
una unidad conocida como “punto”. Hay 72
puntos en una pulgada. Equivalentemente, hay
28,3 puntos en un centímetro.
weight Número, en el rango de 1 a 100 representando
cuán oscura será la letra. Use 25 para suave, 50
para normal y 75 para negrita (bold).
Ilustración 17: Tipos de letra (fonts) comunes en Windows.
Cambiando el Tamaño del Area de Salida Gráfica

Por defecto, el área de salida gráfica de BASIC-256 es de 300x300 píxeles. Mientras esta
es suficiente para muchos programas, puede resultar muy pequeña para otros. Con la
declaración graphsize se puede redefinir el área de salida gráfica al tamaño que se
requiera. Su programa puede usar también las funciones graphwidth y graphheight para
averiguar el tamaño al que la ventana gráfica está definida.
1 # c8_resizegraphics.kbs
2 # cambiar el tamaño de la ventana grafica
3
4 graphsize 500,500
5 xcenter = graphwidth/2
6 ycenter = graphheight/2

258
7
8 color black
9 line xcenter, ycenter - 10, xcenter, ycenter + 10
10 line xcenter - 10, ycenter, xcenter + 10, ycenter
11
12 font "Tahoma",12,50
13 text xcenter + 10, ycenter + 10, "Center at (" +
xcenter + "," + ycenter + ")"
Programa 47: Redefiniendo el tamaño del área de salida gráfica
Salida 47: Redefiniendo el tamaño del área de salida gráfica
graphsize ancho, altura

Defina el área de salida gráfica al ancho y altura especificados.
graphwidth o graphwidth()
graphheight o graphheight()
Funciones que devuelven el ancho y alto del área de salida gráfica,
para que pueda usar esa información en su programa.
Creando un Polígono a Medida

En capítulos anteriores aprendimos a dibujar rectángulos y círculos. A menudo tendremos
que dibujar otras formas. La declaración poly nos permitirá dibujar polígonos en cualquier
lugar de la pantalla.
Dibujemos una gran flecha roja en medio del área de salida gráfica. Primero lo hagamos
en una hoja de papel de modo que podamos visualizar las coordenadas de los vértices.

258
(150,10
0)
(125,15 (175,15
0) 0)
(100,15 (200,15
0) 0)
(125,20 (175,20
0) 0)
Ilustración 18: Flecha Roja Grande
Ahora, empezando en la punta de la flecha y en sentido de las agujas del reloj, escribimos
los valores x e y.
1 # c8_bigredarrow.kbs
2 clg
3 color red
4 poly {150, 100, 200, 150, 175, 150, 175, 200, 125, 200, 125, 150, 100,
150}
Programa 48: Flecha Roja Grande
Salida 48: Flecha Roja Grande
poly {x1, y1, x2, y2 ...}

poly arreglo_numérico
Dibuja un polígono

258
Estampando un Polígono
La sentencia poly nos permite colocar un polígono en pantalla en una posición específica,
pero puede resultar difícil moverlo y/o ajustar su tamaño. Estos problemas son resueltos
por la sentencia stamp (sello). Esta sentencia toma una definición de polígono y nos
permite poner el polígono en cualquier posición especificada en la pantalla.
Opcionalmente, nos permite cambiar la escala (tamaño) del polígono y/o rotarlo.
Dibujemos un triángulo equilátero (los tres lados iguales) en un trozo de papel. Pongamos
el punto (0, 0) en su vértice superior y hacemos cada lado de 10 unidades de largo (ver
Ilustración 19).
(0,
0)
(-5, (5,
8.6)
Ilustración 19: Triángulo Equilátero
8.6)
Ahora, crearemos un programa usando la forma más simple de la sentencia stamp para
llenar la pantalla de triángulos. El Programa 49 hace justamente esto. Usa el “sello” de un
triángulo en dos loops for anidados para llenar la pantalla.
1 # c8_stamptriangle.kbs
2 # use un sello para dibujar muchos triángulos
3
4 clg
5 color black
6 for x = 25 to 200 step 25
7 for y = 25 to 200 step 25
8 stamp x, y, {0, 0, 5, 8.6, -5, 8.6}
9 next y
10 next x
Programa 49: Llenando la pantalla con triángulos

258
Salida 49: Llenando la pantalla con triángulos
stamp x, y, {x1, y1, x2, y2 ...}

stamp x, y, numeric_array
stamp x, y, scale, {x1, y1, x2, y2 ...}
stamp x, y, scale, numeric_array
stamp x, y, scale, rotate, {x1, y1, x2, y2 ...} stamp x, y,
scale, rotate, numeric_array
Dibuja un polígono con su origen (0, 0) en la posición (x, y) de la
pantalla. Opcionalmente puede cambiar su tamaño por una escala
decimal, donde 1 es su tamaño original. También puede rotar la
figura (en sentido de las agujas del reloj) alrededor de su origen en
un ángulo especificado en radianes (0 a 2π).
Los ángulos en BASIC-256 son expresados en una unidad de medida
conocida como “radian”. Los radianes van entre 0 y 2π. Puede
convertir grados a radianes con la fórmula: rad=grados* π/180
Ilustración 20: Grados y Radianes

258
Veamos otro ejemplo de uso de stamp. El Programa 50 usa el mismo triángulo que el
programa anterior, pero coloca 100 de ellos en posiciones al azar, con escala al azar y
rotados también al azar.
1 # c8_stamptriangle2.kbs
2 # stamp triangulos con tamaño, rotación y posición al azar
4 clg
5 color black
6 for t = 1 to 100
7 x = rand * graphwidth
8 y = rand * graphheight
9 s = rand * 7 # scale hasta 7 veces + grande
10 r = rand * 2 * pi # rotar hasta 2pi (360 grados)
11 stamp x, y, s, r, {0, 0, 5, 8.6, -5, 8.6}
12 next t
Programa 50: Cien triángulos al azar.
Salida 50: Cien triángulos al azar.
pi
La constante “pi” (π) puede ser usada en expresiones de modo que
Ud. No tenga que recordar su valor (aprox. 3.14159…).
Dieciséis Millones de Colores Diferentes

BASIC-256 le permite definir hasta 16.777.216 colores diferentes cuando dibuje. El
modelo RGB combina luz de color Rojo (R, red), Verde (G, green) y Azul (B, blue) para
formar los colores. Si los 3 colores básicos son puestos en cero, tendremos Negro (falta

258
total de luz). Si los 3 son colocados a su máximo valor posible de 255, tendremos Blanco.
1 # c8_512colors.kbs
2 # show a few of the 16 million colors
3 graphsize 256, 256
4 clg
5
6 for r = 0 to 255 step 32
7 for g = 0 to 255 step 32
8 for b = 0 to 255 step 32
9 color rgb(r,g,b)
10 rect b/8+g, r, 4, 32
11 next b
12 next g
13 next r
Programa 51: 512 colores de los 16 millones
Salida 51: 512 colores de los 16 millones
rgb(red, green, blue)

rgb(red, green, blue, alfa)
La función RGB devuelve un único número que representa un color
expresado por 3 o 4 valores. Los colores red, blue y green
representan la cantidad de c/u de estos colores que se incluye en el
color final (0:nada, 255:todo). El valor opcional alfa representa cuán
transparente es el color final (0:totalmente transparente; 255:
totalmente opaco o sólido)
2 # stamp triangulos de color, tamaño y rotación al azar
3
4 clg
5 penwidth 3

258
6
7 for t = 1 to 100
10 s = rand * 7 # scale hasta 7 veces +grande
11 r = rand * 2 * pi # rotacion hasta 2pi
12 rpen = rand * 256 # obtenga la parte RGB de un color para lápiz al
azar
13 gpen = rand * 256
14 bpen = rand * 256
15 rbrush = rand * 256 # color de llenado al azar
16 gbrush = rand * 256
17 bbrush = rand * 256
18 color rgb(rpen, gpen, bpen), rgb(rbrush, gbrush, bbrush)
19 stamp x, y, s, r, {0, 0, 5, 8.6, -5, 8.6}
20 next t
Programa 52: 100 Triángulos al azar de colores al azar.
Salida 52: 100 Triángulos al azar de colores al azar.
Adicionalmente a definir el color que queramos, podemos definir también el grado de

transparencia que dicho color tendrá. La función RGB tiene un cuarto argumento opcional
para definir la propiedad alfa, que es la transparencia del color. Alfa es un número entre 0 y
255. Cero es totalmente transparente (e invisible) mientras que 255 es totalmente opaco.
1 # c8_transparent.kbs
2 # mostrar la transparencia en los colores.
3 clg
4
5 color rgb(255,0,0,127)
6 circle 100,100,100
7 color rgb(0,255,0,127)
8 circle 200,100,100

258
9 color rgb(0,0,255,127)
10 circle 100,200,100
11
12 color rgb(0,0,0,127)
13 circle 200,200,100
Programa 53: Círculos transparentes
Salida 53: Círculos transparentes
2 # stamp randomly colored, sized and rotated triangles
3
4 clg
5 penwidth 3
6 for t = 1 to 100
9 s = rand * 7 # scale hasta 7 veces mayor
10 r = rand * 2 * pi # rotacion hasta 2pi
11 rpen = rand * 256 # obtenga la parte RGB de un color de lápiz al azar
12 gpen = rand * 256
13 bpen = rand * 256
14 apen = rand * 256
15 rbrush = rand * 256 # color de llenado al azar
16 gbrush = rand * 256
17 bbrush = rand * 256
18 abrush = rand * 256
19 color rgb(rpen, gpen, bpen, apen), rgb(rbrush, gbrush, bbrush, abrush)
20 stamp x, y, s, r, {0, 0, 5, 8.6, -5, 8.6}
21 next t
Programa 54: 100 Triángulos al azar con colores transparentes al azar.

258
Salida 54: 100 Triángulos al azar con colores transparentes al azar.
Hagamos una flor para alguien especial. El programa grande a

continuación dibuja flores usando rotación y stamp.
(0,
0)
(-5,
20)
(5,
20)
(0,
25)
Ilustración 21: Programa Grande: Una Flor para Ud. – Stamp de un pétalo.
1 # c8_aflowerforyou.kbs
2 # use stamps para dibujar una flor
3
4 clg
5
6 color green
7 rect 148,150,4,150

258
8
9 color rgb(255,128,128)
10 for r = 0 to 2*pi step pi/4
11 stamp graphwidth/2, graphheight/2, 2, r, {0, 0, 5, 20, 0, 25, -5, 20}
12 next r
13
14 color rgb(128,128,255)
15 for r = 0 to 2*pi step pi/5
16 stamp graphwidth/2, graphheight/2, 1, r, {0, 0, 5, 20, 0, 25, -5, 20}
17 next r
18
19 message$ = "A flower for you." # (Una flor para ti.)
20 color darkyellow
21 font "Tahoma", 14, 50
22 text 10, 10, message$
23 say message$
Programa 55 Programa Grande: Una Flor para Tí.
Salida 55: Programa Grande: Una Flor para Tí.

258
Ejercicios:
t n e r a p s n a r t j
k c r l s e u l b h e s
v g p r t r z a g c c g
b h d x a r x i t i f r
a s e m s d e f h g w a
p t e t f h i p p r i p
a o a e h o a a f e t h
e m i p r r n r n e h s
p w a n g g e t q n g i
l r u o t d e u u j i z
g r a p h w i d t h e e
s i p o l y g o n c w f
alpha, blue, degrees, font, graphheight, graphics, graphsize,
graphwidth, green, pi, point, polygon, radian, red, rgb, stamp, text,
transparent, weight
8.1. Use dos sentencias poly y una rect para dibujar una casa
simple, similar a la mostrada abajo. Su casa puede ser de los
colores que Ud. elija.
Use el hexágono a continuación como una guía para ayudarse a

resolver los problemas 8.2 a 8.4. Los lados del hexágono son de una
unidad de longitud y el origen (0, 0) está en el centro del dibujo.

258
(0, -1)
(-0.886, (0.886,
-0.5) -0.5)
(-0.886, (0.886,
0.5) 0.5)
(0,
1)
8.2. Use la sentencia color con un pincel claro y una sentencia poly
para dibujar un hexágono en el centro de la pantalla gráfica, con
cada lado de 100 píxeles de longitud.
8.3. Reescriba el programa anterior (8.2) usando la sentencia stamp.
Use la característica de escala de stamp de modo que pueda
dibujar un hexágono de cualquier tamaño cambiando solo un
número.
8.4. Ponga la sentencia stamp del programa (8.3) dentro de un loop
for y dibuje una serie de hexágonos anidados cambiando la
escala de uno al siguiente. Experimente con el argumento step y
con rotar el hexágono al mismo tiempo.

258
Capítulo 9: Funciones y Subroutinas – Reusando Código
Capítulo 9: Funciones y Subrutinas –

Reusando Código
Este capítulo introduce el uso de funciones y subrutinas. Los programadores crean
funciones y subrutinas para probar pequeñas partes de un programa, poder reusar esas
partes cuando es necesario, extender el lenguaje de programación y simplificar la
estructura de sus programas.
Funciones
Una función es un pequeño programa dentro de uno de mayor tamaño que hace algo muy
específico. Ud puede invocar una función y enviarle valores (o ninguno si no hace falta) y
ésta le devolverá un valor como resultado. Ud ya conoce algunas funciones propias de
BASIC-256, como rand y rgb. Ahora crearemos las nuestras.
Entrada(s)
Salida
Ilustración 22: Diagrama de Bloques de una Función
Function nombredefuncion ( argumento(s) )

Declaración(es)
End Function
Function nombredefuncion$ ( argumentos(s) )
Declaración(es)
End Function
La declaración Function (Función) crea un nuevo block de código y
le asocia al mismo un nombre único. Se recomienda que no nombre
a su función con el mismo nombre de una variable en su programa;
esto causará confusión.
Dentro de los paréntesis requeridos Ud. puede definir una lista de
variables que recibirán valores en la parte del programa principal
desde donde se “llama” a la función. Estas variables pertenecen a la
función y no están disponibles para usar en el programa que llama a
la función.
Una definición de función debe ser cerrada o terminada por una
sentencia End Function (Fin de Función). Esto le dice a la
computadora que la definición de la función termina ahí.
El valor a ser devuelto por una función puede ser definido de dos
maneras: 1) usando la sentencia return (devolver) con el valor a
continuación; ó 2) definiendo el nombre de la función al valor dentro
de la función que se desea devolver.

258
Return valor
Ejecute la sentencia return dentro de una función para devolver un
valor y transferir el control del programa nuevamente al código
desde donde se llamó a la función.
end
Terminar el programa (fin).
1 # c9_minimum.kbs
2 # función para encontrar el minimo
3
4 input "Ingrese un numero ", a
5 input "Ingrese un segundo número ", b
6
7 print "El menor de los números es ";
8 print minimo(a,b)
9 end
10
11 function minimo(x,y)
12 # devuelve el menor de dos números (x,y) pasados por argumento
13 if x<y then return x
14 return y
15 end function
Programa 56: Función Mínimo
Ingrese un numero 7
Ingrese un segundo número 3
El menor de los números es 3
Salida 56: Función Mínimo
1 # c9_gameroller.kbs
2 # Juego de Dados
3
4 print "Tirador de Dados"
5 s = get ("Caras del dado",6)
6 n = get ("Numero de dados", 2)
7 total = 0
8 for x = 1 to n
9 d = die(s)
10 print d

258
11 total = total + d
12 next x
13 print "Total = "+ total
14 end
15
16 function get (message$, default)
17 # lea un numero de pantalla
18 # si ingresaron cero tome el valor por defecto
19 input message$ + " (default " + default + ")? ", n
20 if n = 0 then n = default
21 return n
22 end function
23
24 function die(caras)
25 # tire un dado y devuelva el valor de la cara
26 return int(rand*caras)+1
27 end function
Programa 57: Juego de Dados
Tirador de Dados
Caras del dado (default 6)? 6
Numero de dados (default 2)? 3
6
3
1
Total = 10
Salida 57: Juego de Dados
En los ejemplos anteriores hemos creado funciones que devuelven un valor numérico. Pero
también se pueden crear funciones que devuelvan un valor string. Una función string, como
una variable, debe tener el símbolo “$” después de su nombre para especificar que
devolverá un string.
1 # c9_repeatstring.kbs
2 # funcion string simple – haga copias
3
4 a$ = "ja"
5 b$ = repeat$(a$,20)
6 print a$
7 print b$
8 end
9
10 function repeat$(w$,n)
11 a$ = ""
12 for t = 1 to n
13 a$ += w$
14 next t
15 return a$

258
16 end function
Programa 58: Función String Simple
ja
jajajajajajajajajajajajajajajajajajajaja
Salida 58: Función String Simple
Note en los ejemplos anteriores que las variables dentro de una función existen solo dentro
de la función. Si una variable con el mismo nombre es usado fuera de la función, esta NO
cambia el valor de la variable dentro de la función.
Subrutinas
Al igual que las funciones, una subrutina es un programa pequeño que efectúa algo bien
específico. Las subrutinas permiten que un bloque de código sea usado en distintas partes
del programa sin tener que reescribirlo. Una subrutina puede tener valores que se le
pasaron en su llamado y que le dicen a la subrutina cómo comportarse.
Las subrutinas son como las funciones, excepto que no devuelven un valor y que no se
pueden invocar solo por su nombre, sino que se debe usar la sentencia call para
ejecutarlas.
Subroutine nombresubroutina( argumento(s) )

declaraciones
End Subroutine
La sentencia subroutine (subrutina) crea un bloque de
declaraciones de programa y asigna a ese bloque un nombre único.
Se recomienda no usar como nombre de una subrutina el mismo
nombre que el de una variable en el programa porque puede
generar confusión.
Entre los paréntesis requeridos, es posible definir una lista de
variables que recibirá valores de la parte del programa que “llama” a
la subrutina. Estas variables son locales a la subrutina y no están
directamente disponibles para el programa que la llama.
La definición de una subrutina debe terminar con la sentencia End
Subroutine (Fin de Subrutina)
Call subroutinename ( valor(es) )

La sentencia call le dice a BASIC-256 que transfiera el control del
programa a la subrutina y pase a la misma el(los) valor(es) a
procesar como argumentos.

258
Return
Ejecute la sentencia return dentro de una subrutina para devolver el
control del programa nuevamente al código desde donde se la llamó.
Esta versión de return no incluye un valor de retorno (como en el
caso de las funciones) dado que una subrutina no devuelve un valor.

258
1 # c9_subroutineclock.kbs
2 # muestre un reloj digital en pantalla
3
4 fastgraphics
6 color blue
7 rect 0, 0, 300, 300
8 color yellow
9 text 0, 0, "My Clock."
10 while true
11 call displaytime()
12 pause 1.0
13 end while
14 end
15
16 subroutine displaytime()
17 color blue
18 rect 100, 100, 200, 100
19 color yellow
20 text 100, 100, hour + ":" + minute + ":" + second
21 refresh
22 end subroutine
Programa 59: Subrutina Reloj
Nota:
En el programa anterior, hour, minute y second en la subrutina displaytime son funciones
propias de BASIC-256. Vea el concepto siguiente para una descripción más detallada.
Salida 59: Subrutina Reloj

258
hour o hour() [hora]

minute o minute() [minuto]
second o second() [segundo]
day o day() [día]
month o month() [mes]
year o year() [año]
Las funciones year, month, day, hour, minute y second
devuelven los componentes de un sistema de reloj. Ellas le permiten a
su programa saber los datos completos de hora y fecha.
year Devuelve el corriente año del sistema (4 dígicos)

Devuelve el corriente mes, desde 0 a 11.
month
0 - Enero, 1 - Febrero...
day Devuelve el día del mes: 1…, 28, 29, 30, o 31.
Devuelve la hora, 0 a 23 en formato de 24 horas
hour
0=12 AM, 1=1 AM, … 12=12 PM, 13=1 PM, 23=11 PM …
minute Devuelve los minutos 0 a 59 de la hora corriente.
second Devuelve los segundos: 0 a 59 del minuto corriente.
1 # c9_subroutineclockimproved.kbs
2 # reloj mejorado
3
4 fastgraphics
6 color blue
7 rect 0, 0, 300, 300
8
9 call displayyear()
10 while true
11 call displaytime()
12 pause 1.0
13 end while
14
15 end
16
17 subroutine displayyear()
18 color blue
19 rect 50,50, 200, 100
20 color yellow
21 text 50,50, padnumber$(month) + "/" + padnumber$(day) + "/" +
padnumber$(year)
22 refresh
23 end subroutine
24
25 subroutine displaytime()

258
26 color blue
27 rect 50,100, 200, 100
28 color yellow
29 text 50, 100, padnumber$(hour) + ":" + padnumber$(minute) + ":" +
padnumber$(second)
30 refresh
31 end subroutine
32
33 function padnumber$(n)
34 padnumber$ = string(n)
35 if n < 10 then
36 padnumber$ = "0" + padnumber$
37 end if
38 end function
Programa 60: Subrutina Reloj Mejorado
Salida: 60: Subrutina Reloj Mejorado
Usando el Mismo Código en Múltiples Programas

Una vez que el programador crea una subrutina o función, puede reusar estos bloques de
código en otros programas. Puede cortar y pegar el código de un programa a otro. Pero,
¿qué ocurre cuando necesita hacer pequeños cambios y se desea que los cambios se
hagan en todos los programas que usan ese código? En este caso es donde la sentencia
include (incluir) viene a nuestra ayuda.
La sentencia include (incluir) le dice a BASIC-256, en tiempo de compilación (cuando Ud.
presiona el botón Run), que copie e incluya el código guardado en otro archivo. En el
Programa 61 (abajo) puede ver que las funciones han sido guardadas como archivos
individuales (c9_function_dado.kbs y c9_inputnumberfunction.kbs) y luego son
incorporadas al programa principal mediante la sentencia include.
1 # c9_gamerollerinclude.kbs
2 # Tirador de Dados
3
4 include "e2_c9_function_dado.kbs"
5 include "e2_c9_inputnumberfunction.kbs"
6
7 print "die roller"
8 s = inputnumber("caras del dado ",6)
9 n = inputnumber("numero de dados ", 2)
10 total = 0

258
11 for x = 1 to n
12 d = dado(s)
13 print d
14 total = total + d
15 next x
16 print "total "+ total
17 end
Programa 61: Tirador de Dados – Con Funciones included.
1 # c9_function_dado.kbs
2 # funcion para tirar un dado de N caras
3
4 function dado (caras)
5 # tire un dado y devuelva a caras
6 return int(rand*caras)+1
7 end function
Programa 62: Tirador de Dados – Función die
1 # c9_inputnumberfunction.kbs
2
3 function inputnumber (prompt$, default)
4 # lea un numero de pantalla
5 # si ingresaron cero tome el valor por defecto
6 input prompt$ + " (default " + default + ") ?", n
7 if n = 0 then n = default
8 return n
9 end function
Programa 63: Tirador de Dados – Función inputnumber
Ahora que hemos separado las funciones, podemos usarlas en diferentes programas sin
tener que cambiar el código de la función o re-escribirlas.
1 # c9_addingmachine.kbs
2 # una linda maquina de sumar
3 include "e2_c9_inputnumberfunction.kbs"
4
5 print "Maquina de Sumar"
6 print "Presione STOP para terminar"
7
8 total = 0
9 while true
10 a = inputnumber("+ ",0)
11 total = total + a
12 print total

258
13 end while
14 end
Programa 64: Máquina de Sumar – Usando la función inputnumber
Maquina de Sumar
Presione STOP para terminar
+ (default 0) ?6
6
+ (default 0) ?
6
+ (default 0) ?55
61
+ (default 0) ?
Salida: Máquina de Sumar – Usando la función: inputnumber
include “nombre_archivo” (constante string)

Incluye código desde un archivo externo en tiempo de compilación.
El nombre del archivo (nombre_archivo) debe colocarse entre
comillas (“”) y no puede ser una variable u otra expresión.
Rótulos (Labels), Goto y Gosub

Esta sección discute el concepto de labels (rótulos) y sobre cómo causar que su programa
salte a ellos. Estos métodos son lo que usamos antes de que incorporáramos los
conceptos de subrutinas y funciones.
CUIDADO: El uso de estas sentencias favorece el crear programas poco elegantes,
enmarañados y excesivamente complejos de seguir y entender, por lo que su uso
debe ser evitado siempre que sea posible.
En el Programa 41: Loop para Siempre, vimos un ejemplo de un loop eterno. Esto también
puede hacerse usando un label y la sentencia goto, como vemos a continuación.
1 # c9_goto.kbs
2 top:
3 print "Hola"
4 goto top
Programa 65: Goto con Label
Hola
Hola
Hola
Hola
Hola
Hola
(... y se repite para siempre…)

258
Programa 65: Goto con Label
label:
Un label (rótulo) le permite dar un nombre a un lugar en su
programa de modo que pueda saltar directamente a esa ubicación.
Es posible tener múltiples “labels” en un programa, pero cada uno
de ellos puede existir solo en un lugar.
Un nombre de label es seguido por un doble punto (:), debe estar en
una línea que no tenga ninguna otra declaración, debe comenzar con
una letra, pudiendo contener letras y números y es sensible a
mayúsculas y minúsculas.
No es permitido usar palabras reservadas por BASIC-256 (ver
Apéndice I) como nombre de un label, así como tampoco nombres de
funciones o subrutinas.
Ejemplos de nombres de labels válidos: far999:, About:, aqui08:.
goto label
La sentencia goto causa que la ejecución salte a la sentencia
inmediatamente siguiente a la línea label.
Las subrutinas y funciones nos permiten reusar bloques de código. La sentencia gosub
también le permite al programador reusar código. Las variables en un block gosub son
globales, esto es, son válidas en todo lugar del programa.
El Programa 66 muestra un ejemplo de una subrutina que es llamada tres veces.
1 # c9_gosub.kbs
2 # un uso de gosub simple
3
4 x = 10
5 for t = 1 to 3
6 print "x igual a: " + x
7 gosub muestralinea
8 next t
9 end
10
11 muestralinea:
12 print "------------------"
13 x=x*2
14 return
Programa 66: Gosub
x igual a: 10
------------------
x igual a: 20
------------------
x igual a: 40

258
------------------
Salida 66: Gosub
gosub label
La sentencia gosub causa que la ejecución salte a la subrutina
definida por el label.
En el Programa Grande de este capítulo haremos un programa para

tirar dos dados, dibujarlos en pantalla y dar el total de puntos.
Usaremos una función “incluida” para generar un número de puntos
al azar y una subrutina para dibujar la imagen, de modo que solo
tengamos que escribirla una vez.
1 # c9_roll2dice2.kbs
2 # tirar dos dados en modo gráfico
3
4 include "e2_c9_diefunction.kbs"
5 clg
6 total = 0
7
8 roll = die(6)
9 total = total + roll
10 call dibujedado(30,30, roll)
11
12 roll = die(6)
13 total = total + roll
14 call dibujedado(130,130, roll)
15
16 print "Ud. tiró " + total + "."
17 end
18
19 subroutine dibujedado(x,y,n)
20 # defina x, y para el vértice superior izquierdo y
21 # n para el numero de puntos
22 # dibuje dado de 70x70 pixeles con puntos de 10x10 pixels
23 color black
24 rect x,y,70,70
25 color white
26 # fila superior
27 if n <> 1 then rect x + 10, y + 10, 10, 10
28 if n = 6 then rect x + 30, y + 10, 10, 10
29 if n >= 4 and n <= 6 then rect x + 50, y + 10, 10, 10
30 # mitad

258
31 if n = 1 or n = 3 or n = 5 then rect x + 30, y + 30,10, 10

32 # fila inferior
33 if n >= 4 and n <= 6 then rect x + 10, y + 50, 10, 10
34 if n = 6 then rect x + 30, y + 50, 10, 10
35 if n <> 1 then rect x + 50, y + 50, 10, 10
36 end subroutine
Programa 67: Programa Grande – Tirar dos dados gráficamente
Salida 67: Programa Grande – Tirar dos dados gráficamente

258
Ejercicios:
g o t o d e j j v e q y
k x a w r n x d s q a n
u i d r x i o p i d r o
l n h r g t z c s c e i
k c l e p u j d e p t t
g l e t a o m n h s a c
o u b u l r h e t v n n
s d a r l b f r n h i u
u e l n a u i a e t m f
b m z j c s l e r n r n
e t u n i m e y a o e b
h o u r s o w w p m t n
argument, call, day, end, file, function, gosub, goto, hour, include, label,
minute, month, parenthesis, return, second, subroutine,
terminate, year
9.1. Escribir una subrutina que acepte dos números representando un

punto en la pantalla. Haga que la rutina dibuje una cara sonriente
con 20 píxeles de radio en ese punto. Puede usar círculos,
rectángulos o polígonos como necesite. Llame a esa subrutina en
un loop de 100 iteraciones y en cada una de ellas dibuje una cara
en una posición al azar para llenar la pantalla.
9.2. Escriba un programa que pregunte por dos puntos x1, y1 y x2,
y2 y muestre la fórmula de la recta que pasa por ellos, en
formato: y=mx+n
Escriba una función que devuelva la pendiente (m), que puede
calcularse con la ecuación:
(y1− y2) / (x1−x2)
9.3. En matemáticas, el término “factorial” de un número se define
como el producto de números consecutivos y se nota como el
número seguido de un signo de admiración (!). El símbolo n!
significa:
n! = n * (n-1) * (n-2) * … * 4 * 3 * 2 * 1

258
donde n es un número entero y 0!=1 por definición.

a) Escriba una función que acepte un número como argumento y
devuelva su factorial.
b) Escriba un programa que llame a esta nueva función (Item a)
dentro de un loop for para escribir 1! a 10!. Su salida deberá
verse como lo siguiente:
1! es igual a 1
2! es igual a 2
3! es igual a 6
4! es igual a 24
5! es igual a 120
6! es igual a 720
7! es igual a 5040
8! es igual a 40320
9! es igual a 362880
10! es igual a 3628800
9.4. Una función recursiva es un tipo especial de función que
se llama a sí misma. Conociendo que n! = n * (n-1)! y
que 0!=1, reescriba 9.3.a) como una función recursiva
para calcular el factorial.

258
Capítulo 10: Control del Mouse – Moviendo Cosas
Capítulo 10: Control del Mouse -

Moviendo Cosas
Este capítulo le mostrará cómo hacer que su programa responda al mouse. Hay dos modos
diferentes para hacer esto: modo seguimiento (tracking mode) y modo click (clicking
mode). Ambos modos serán discutidos mediante programas ejemplo.
Modo Seguimiento
En modo seguimiento, hay tres funciones numéricas (mousex, mousey y mouseb) que
devuelven las coordenadas del puntero del mouse sobre el área de salida gráfica. Si el
puntero del mouse no está en la ventana gráfica, sus movimientos no serán registrados
(devolverán la última posición del puntero en la ventana gráfica).
1 # c10_mousetrack.kbs
2 # Siguiendo el Mouse con un circulo
3
4 print "Mueva el mouse en la ventana gráfica."
5 print "Presione el boton Izquierdo para salir."
6 fastgraphics
7 # siga ejecutando hasta que el usuario presione el botón izq.
9 while mouseb <> 1
10 # limpie la pantalla
11 color white
12 rect 0, 0, graphwidth, graphheight
13 # dibuje un Nuevo circulo
14 color red
15 circle mousex, mousey, 10
16 refresh
17 end while
18
19 print "Listo."
20 end
Programa 68: Siguiendo el Mouse
Salida 68: Siguiendo el Mouse

258
mousex or mousex()
mousey or mousey()
mouseb or mouseb()
Estas tres funciones devuelven la ubicación corriente del puntero del
mouse en el área gráfica. Cualquier movimiento del mouse fuera del
área gráfica no será registrado, pero se devolverá la última posición
conocida dentro de dicha área.
mousex Devuelve la coordenada X de la posición del puntero del

mouse. Rango desde 0 a graphwidth-1.
mousey Devuelve la coordenada Y de la posición del puntero del
mouse. Rango desde 0 to graphheight-1.
mouseb Devuelve este valor cuando no ha sido apretado

0
ningún botón.
Devuelve este valor cuando se apretó el botón
1
“izquierdo” del mouse.
2
“derecho” del mouse.
4
“central” del mouse.
Si se aprietan varios botones del mouse al mismo tiempo,

el valor devuelto será la suma de de los valores
correspondientes a los botones apretados.
Modo Click
El segundo modo de controlar el mouse es llamado modo "Click". En modo click, la
posición del mouse y el botón (o combinación de botones) son guardados cuando ocurre
un click. Una vez que el click es procesado por el programa, la instrucción clickclear puede
ser ejecutada para reiniciar el click, de modo que próximo click pueda ser guardado.
1 # c10_mouseclick.kbs
2 # X marca el punto en donde se hizo el click
3
4 print "Mueva el mouse en la ventana gráfica."
5 print "Presione botón izquierdo para marcar su punto "
6 print "Presions botón derecho para salir."
7 clg
8 clickclear
9 while clickb <> 2
10 # limpie último click y espere a que se presione un botón
11 clickclear
12 while clickb = 0
13 pause .01
14 end while
15 #

258
16 color blue
17 stamp clickx, clicky, 5, {-1, -2, 0, -1, 1, -2, 2, -1, 1, 0, 2, 1, 1, 2, 0, 1, -1, 2,
-2, 1, -1, 0, -2, -1}
18 end while
19 print "Terminado."
20 end
Programa 69: Mouse Modo Click
Salida 69: Mouse Modo Click
clickx or clickx()
clicky or clicky()
clickb or clickb()
Los valores de las tres funciones click son actualizados cada vez
que un botón del mouse es presionado cuando el puntero esté en el
área gráfica. La última ubicación del mouse cuando se recibió el
último click está disponible usando estas tres funciones.
clickclear
El comando clickclear reinicia a cero las funciones clickx, clicky
y clickb de modo que se registre un nuevo click cuando clickb sea
diferente de cero (0).
El Programa Grande de este capítulo usa el mouse para mover

deslizadores de color y de ese modo que podemos ver los
16.777.216 colores diferentes en la pantalla.

258

258
1 # c10_colorchooser.kbs
2 fastgraphics
3
4 print "Selector de Color – Encuentre uno"
5 print "Click & arrastre los deslizadores rojo, verde y azul"
6
7 # variables para guardar los componentes de color
8 r = 128
9 g = 128
10 b = 128
11
12 call display(r,g,b)
13
14 while true
15 # espere por un click
16 while mouseb = 0
17 pause .01
18 end while
19 # cambie color con deslizadores
20 # deslizador rojo y rango es 0 >= red < 75
21 if mousey < 75 then
22 r = mousex
23 if r > 255 then r = 255
24 end if
25 # deslizador verde y rango es 75 >= red < 150
26 if mousey >= 75 and mousey < 150 then
27 g = mousex
28 if g > 255 then g = 255
29 end if
30 # deslizador azul y rango es 150 >= red < 225
31 if mousey >= 150 and mousey < 225 then
32 b = mousex
33 if b > 255 then b = 255
34 end if
35 call display(r,g,b)
36 end while
37 end
38
39 subroutine colorline(r,g,b,x,y)
40 # dibuje parte de la barra de color
41 # el color r,g,b de x,y a x,y+37
42 color rgb(r, g, b)
43 line x, y, x, y+37
44 end subroutine
45

258
46 subroutine redsliderbar(r,g,b)
47 # dibuje la barra roja desde 0,0 a 255,74
49 color rgb(255, 0, 0)
50 text 260, 10, "r"
51 for t = 0 to 255
52 # rojo y tonos rojos
53 call colorline(t, 0, 0, t, 0)
54 call colorline(t, g, b, t, 38)
55 next t
56 color black
57 rect r-1, 0, 3, 75
58 end subroutine
59
60 subroutine greensliderbar(r,g,b)
61 # dibuje la barra verde desde 0,75 a 255,149
63 color rgb(0, 255, 0)
64 text 260, 85, "g"
65 for t = 0 to 255
66 # verde y tonos verdes
67 call colorline(0, t, 0, t, 75)
68 call colorline(r, t, b, t, 113)
69 next t
70 # slider
71 color black
72 rect g-1, 75, 3, 75
73 end subroutine
74
75 subroutine bluesliderbar(r,g,b)
76 # dibuje la barra azul desde 0,150 a 255,224
78 color rgb(0, 0, 255)
79 text 260, 160, "b"
80 for t = 0 to 255
81 # azul y tonos azules
82 call colorline(0, 0, t, t, 150)
83 call colorline(r, g, t, t, 188)
84 next t
85 # deslizador
86 color black
87 rect b-1, 150, 3, 75
88 end subroutine
89
90 subroutine display(r, g, b)
91 clg
92 call redsliderbar(r,g,b)

258
93 call greensliderbar(r,g,b)
94 call bluesliderbar(r,g,b)
95 # dibuje muestra
96 color black
98 text 5, 235, "(" + r + "," + g + "," + b + ")"
99 color rgb(r,g,b)
100 rect 151,226,150,75
101 refresh
102 end subroutine
Programa 70: Programa Grande – Selector de Color
Salida 70: Programa Grande – Selector de Color

258
Ejercicios:
r f m t x v t x n j
j a a o h k s f o u
n c e y u t c l e c
b e x l e s h i y l
k n z m c s e w l i
c t m o r k u b k c
i e z u n i c o g k
l r p s g s g i m y
c j i e h w l h l m
c x l x m f z a t c
center, clickb, clickclear, clickx, clicky, left, mouseb, mousex, mousey,
right
10.1. Cree un programa que dibuje una serie de líneas conectadas y

muestre los puntos en la pantalla mientras las líneas se dibujan.
Cuando se cliquee el botón izquierdo del mouse dibuje un
pequeño círculo, imprima las coordenadas, dibuje una línea a la
coordenada anterior (si no es el primer punto) y recuerde el
punto de modo que pueda ser el de partida para la próxima
línea. Repita esto hasta que el usuario haga click en el botón
derecho.
46,62
187,59
178,132
108,96
10.2. Crear un programa que le permita al usuario usar el mouse

como un pincel. Cuando el usuario tenga el botón izquierdo del
mouse apretado, dibuje un punto en esa posición. Para hacer
la línea más ancha puede dibujar un círculo de radio 2 o 3.
Para adquirir habilidades extras: cuando el usuario presione el
botón derecho haga que el color de dibujo cambie al azar.

258
10.3. Use la carita sonriente del Problema 9.1 para hacer un

programa de dibujo con mouse con la sonrisa. Cuando el usuario
clickee en un punto de la pantalla, dibuje una carita allí.

258
Capítulo 11: Control del Teclado - Usando el Teclado
Capítulo 11: Control del Teclado –

Usando el Teclado para hacer Cosas.
Este capítulo le mostrará cómo hacer que su programa responda al usuario cuando éste
presione una tecla (flechas de desplazamiento, letras y teclas especiales) en el teclado.
Obteniendo la última tecla presionada

La función key devuelve el último código de teclado generado por el sistema cuando una
tecla es presionada. Ciertas teclas (como control-C y F1) son capturadas por la ventana de
BASIC-256 y no serán devueltas por la función key. Después de que el valor de la última
tecla ha sido devuelto, el valor de la función será puesto a cero (0) hasta que otra tecla sea
presionada.
Los valores de tecla para caracteres imprimibles (0-9, símbolos, letras) son los mismos que
los valores UNICODE en mayúsculas, independientemente del estado de las teclas
“Bloq.Mayús” (Caps-Lock) ó “Mayus ó ↑ ”(Shift).
1 # c11_readkey.kbs
2 print "Presione una tecla - Q para salir."
3 do
4 k = key
5 if k <> 0 then
6 if k >=32 and k <= 127 then
7 print chr(k) + "=";
8 end if
9 print k
10 end if
11 until k = asc("Q")
12 end
Programa 71: Leer el Teclado
Presione una tecla - Q para salir.

A=65
Z=90
M=77
16777248
&=38
7=55
Salida 71: Leer el Teclado
key
key()
La función key devuelve el valor de la última tecla presionada por el
usuario. Una vez que el valor de la tecla es leído por la función, el
mismo es puesto a cero para denotar que ninguna tecla ha sido
presionada.

258
Unicode
El estándar Unicode fue creado para asignar valores numéricos a
letras y caracteres de todos los sistemas de escritura usados en
todo el mundo. Hay más de 107.000 caracteres diferentes definidos
en la versión 5.0 del estándar Unicode. Ver: http://www.unicode.org
asc(expresión)
La función asc devuelve un número entero representando el valor
Unicode del primer caracter del string expresión.
chr(entero)
La función chr devuelve un string conteniendo un solo caracter con
el valor Unicode del argumento entero.
Otro ejemplo de un programa de teclado podría ser uno para mostrar una letra y tomar el
tiempo que le insume al usuario presionar la tecla correspondiente. Este programa también
introduce la sentencia msec que devuelve la cantidad de milisegundos (1/1000 de
segundo) transcurrido desde que el programa comenzó a ejecutarse.
1 # c11_msec.kbs
2
3 # obtenga el código para un carácter al azar entre A-Z
4 c = asc("A") + int(rand*26)
5
6 # muestre la letra (a partir de su código numerico)
7 print "Presione '" + chr(c) + "'"
8
9 time = msec # tome el tiempo inicial
10 do # espere por una tecla presionada
11 k = key
12 until k = c
13 time = msec – time # calcule el tiempo transcurrido
14 print "Le tomó " + (time/1000) + " segundos presionar la tecla."
Programa 72: Prueba de Velocidad con el Teclado
Presione 'C'
Le tomó 1.833 segundos presionar la tecla.
Salida 72: Prueba de Velocidad con el Teclado

258
msec()
msec
La función msec devuelve el tiempo que el programa ha estado
corriendo, en milisegundos (1/1000 de un segundo).
Veamos ahora un ejemplo un poco más complejo. El Programa 73 dibuja una pelota roja en
pantalla y el usuario puede moverla usando el teclado.
1 # c11_moveball.kbs
2 # mover una pelota en pantalla con el teclado
3
4 print "Use i para arriba, j para izquierda, k para derecha, m para abajo y q
para salir."
5
6 fastgraphics
7 clg
8
9 # posición de la pelota
10 # comience en el centro de la pantalla
11 x = graphwidth /2
12 y = graphheight / 2
13 r = 20 # tamaño de la perota (radio)
14
15 # dibuje la pelota inicialmente en pantalla
16 call drawball(x, y, r)
17
18 # loop y espere hasta que el usuario presione una tecla
19 while true
20 k = key
21 if k = asc("I") then
22 y=y-r
23 if y < r then y = graphheight - r
25 end if
26 if k = asc("J") then
27 x=x-r
28 if x < r then x = graphwidth - r
30 end if
31 if k = asc("K") then
32 x=x+r
33 if x > graphwidth - r then x = r
35 end if
36 if k = asc("M") then
37 y=y+r

258
38 if y > graphheight - r then y = r

40 end if
41 if k = asc("Q") then exit while
42 end while
43 print "Terminado."
44 end
45
46 subroutine drawball(ballx, bally, ballr)
47 color white
49 color red
50 circle ballx, bally, ballr
51 refresh
52 end subroutine
Programa 73: Mover la Pelotal
Salida 73: Mover la Pelota
El Programa Grande de este capítulo es un juego usando el teclado.

Letras al azar caerán por la pantalla y el usuario suma puntos
presionando la tecla correspondiente tan rápido como pueda.
1 # c11_fallinglettergame.kbs
2
3 speed = .15 # velocidad de caida – menor = + rapido
4 nletters = 10 # letras para jugar
5 score = 0
6 misses = 0
7 color black
8 fastgraphics
9

258
10 clg
12 text 20, 80, "Juego de Lluvia de Letras"
14 text 20, 140, "Presione una tecla para comenzar"
15 refresh
16 # “limpie” el teclado y espere por una tecla presionada
17 k = key
18 while key = 0
19 pause speed
20 end while
21
22 misses = nletters # primero asume que perdió todas
23 for n = 1 to nletters
24 letter = int((rand * 26)) + asc("A")
25 x = 10 + rand * 225
26 for y = 0 to 250 step 20
27 clg
28 # muestre letra
30 text x, y, chr(letter)
31 # muestre score y puntos
33 value = (250 - y)
34 text 10, 270, "Valor "+ value
35 text 200, 270, "Score "+ score
36 refresh
37 k = key
38 if k <> 0 then
39 if k = letter then
40 score = score + value
41 misses-- # no perdió esta!
42 else
43 score = score - value
44 end if
45 exit for
46 end if
47 pause speed
48 next y
49 next n
50 clg
52 text 20, 40, " Juego de Lluvia de Letras"
53 text 20, 80, "Game Over"
54 text 20, 120, "Score: " + score
55 text 20, 160, "Perdió: " + misses
56 refresh

258
57 end
Programa 74: Programa Grande - Juego de Lluvia de Letras
Salida 74: Programa Grande - Juego de Lluvia de Letras

258
Ejercicios:
k g c v f k e t
e a o w y c o u
y b n o h o z n
t b t r b l n i
f u r r t s g c
i t o a t p y o
h j l m e a b d
s i c s a c j e
arrow, asc, capslock, chr, control, key, shift, unicode
11.1. Tome el Programa 72 de este capítulo y modifíquelo para

mostrar 10 letras, una por vez, y espere a que el usuario
presione una tecla. Una vez que el usuario ha presionado
todas las teclas correctas, muestre el tiempo total que le llevó
hacerlo.
Como adicional, agregue lógica para contar el número de
errores y también permitir al usuario reintentar una letra hasta
que la ingrese correctamente.
press 'A'
press 'M'
press 'O'
error
press 'U'
press 'X'
press 'V'
press 'K'
press 'C'
press 'Z'
press 'Z'
Le tomó 15.372 segundos encontrarlas.
Y cometió 1 error(es).
11.2. Escriba un juego gráfico como --- que muestra un número en
pantalla y espera una cantidad aleatoria de tiempo (pruebe 0.5
a 1.5 segundos) para que el usuario presione dicho número. Si
lo hace, reproduzca un sonido divertido y muestre el siguiente
número. Si se equivoca o no es lo suficientemente rápido, un
sonido triste. Cuando haya errado 5 veces, muéstrele cuantas
veces acertó.

258
11.3. Cree un programa que simule un piano usando las teclas del
teclado. Espere en un loop de modo que cuando el usuario
presione una tecla, el programa haga un sonido por un período
de tiempo corto. Asigne sonidos de distinta frecuencia a las
teclas en el teclado

258
Capítulo 12: Imágenes, WAVs y Sprites

Este capítulo introduce declaraciones multimedia y gráficas realmente avanzadas. Veremos
cómo uardar imágenes a un archivo, cargarlas nuevamente, reproducir archivos .WAV y
divertidas animaciones usando sprites.
Guardando Imágenes a un Archivo

Hasta ahora hemos visto cómo crear formas y gráficos usando sentencias gráficas
incorporadas a BASIC-256. La sentencia imgsave le permitirá guardar sus imágenes en un
archivo en diversos formatos gráficos.
El Programa 75 dibuja una serie de pentágonos, cada uno un poco más grande que el
anterior y rotado, para hacer una flor geométrica. Podría ser útil guardar esta imagen para
usarla en otra ocasión. Con ese objeto, el programa crea un archivo en formato PNG
(Portable Network Graphics) y nombre "c12_5pointed.png" que podrá ser usado luego en
un sitio Web, una presentación o cualquier otro lugar en donde se necesite.
1 # c12_5pointed.kbs
2 #
3 graphsize 100,100
4 clg
5 color black,clear
6 for s = 1 to 50 step 2
7 stamp 50,50,s,s,{0,-1, .95,-.31, .59,.81, -.59,.81,-.95,-.31}
8 next s
9 #
10 imgsave "c12_5pointed.png"
Programa 75: Guardar una Imagen
Salida 75: Guardar una Imagen
imgsave nombre_archivo
imgsave nombre_archivo, tipo
Guarda la salida gráfica en un archivo imagen de nombre
nombre_archivo. Si tipo no es especificado, la gráfica será
guardada por defecto como un archivo Portable Network Graphics
(PNG). Opcionalmente puede guardar la imagen como “.BMP” o
“.JPG” especificando el tipo como último argumento.

258
Recuperando Imágenes desde un Archivo

La declaración imgload le permite cargar una figura desde un archivo y mostrarla desde
sus programas BASIC-256. Las imágenes pueden ser las que Ud. guardó con anterioridad
o provenir de otras fuentes.
1 # c12_imgloadball.kbs
2 # cargar una imagen desde un archivo
3 clg
4 for i = 1 to 50
5 imgload rand * graphwidth, rand * graphheight, "greenball.png"
6 next i
Programa 76: Imgload un Gráfico
Salida 76: Imgload un Gráfico

El Programa 76 muestra un ejemplo de esta sentencia en acción. El último argumento es el
nombre de un archivo en su computadora. Necesita estar en la misma carpeta que el
programa, a menos que Ud. especifique en imgload la ruta completa a él. Note que las
coordenadas (x, y) representan el CENTRO de la imagen cargada y no el vértice superior
izquierdo.
La mayoría del tiempo Ud. guardará el programa, las imágenes y/o

archivos de sonido en una misma carpeta ANTES de correrlo. Esto
definirá su directorio de trabajo de modo que BASIC-256 podrá
encontrar los archivos a cargar.
imgload x, y, filename
imgload x, y, escala, filename
imgload x, y, escala, rotacion, filename
Lee la imagen encontrada en el archivo filename y la muestra en la
ventana gráfica. Los valores de x e y representan la ubicación en
donde colocar el “centro” de la imagen. Las imágenes pueden ser
cargadas desde diversos formatos gráficos, incluyendo: BMP, PNG,
GIF, JPG, y JPEG. Opcionalmente, puede re-escalarlas (escala,
cambiar el tamaño) mediante una escala decimal, donde 1 es
tamaño completo. También puede rotar la imagen alrededor de su
centro en sentido a las agujas del reloj especificando rotación

258
como un ángulo expresado en radianes (0 a 2)
La declaración imgload también le permite opcionalmente cambiar la escala y rotar la

imagen de la misma manera que la declaración stamp lo hace. Mire el Programa 77
siguiente como ejemplo.
1 # c12_imgloadpicasso.kbs
2 # mostrar imagen con rotación y re-escalado
3 # foto de http://i988.photobucket.com/albums/af3/...
4 # /fikarvista/picasso_selfport1907.jpg
5
6 graphsize 500,500
7 clg
8 for i = 1 to 50
9 imgload graphwidth/2, graphheight/2, i/50, 2*pi*i/50,
"picasso_selfport1907.jpg"
10 next i
11 say "Hola Picasso."
Programa 77: Imgload un Gráfico con Cambio de Escala y Rotación
Salida 77: Imgload un Gráfico con Cambio de Escala y Rotación
Reproduciendo Sonidos desde un archivo WAV

Ya hemos explorado hacer sonido y música con el comando sound y texto-a-voz con el
comando say. BASIC-256 también puede reproducir sonidos guardados en archivos WAV.
La reproducción de sonido de un archivo WAV ocurrirá en segundo plano (background).
Una vez que la reproducción comienza el programa continúa ejecutando la línea de código
siguiente al llamado mientras que el sonido continúa reproduciéndose. El siguiente ejemplo
asume que los archivos canción_1.wav y canción_2.wav se encuentran en el mismo
directorio que el programa y son provistos por Ud.
1 # c12_numberpopper.kbs
2 # reproducción de archivos .wav
3 fastgraphics
4 wavplay "cancion_1.wav"

258
5 speed = .05
6 for t = 1 to 3
7 n = int(rand * 6 + 1)
8 for pt = 1 to 200 step 10
9 font "Tahoma",pt,100
10 clg
11 color black
12 text 10,10, n
13 refresh
14 pause speed
15 next pt
16 speed = speed / 2
17 next t
18 # wait for sound to complete
29 wavwait
20 wavplay "canción_2.wav"
21 wavwait
22 end
Programa 78: Tirando Números con Música de fondo.
wavplay filename
wavplay ( filename )
wavwait
wavstop
La sentencia wavplay carga un archivo de audio (.wav) desde la
carpeta corriente y lo reproduce. La reproducción será sincrónica, lo
que significa que el programa continuará ejecutándose con la
siguiente declaración en el programa tan pronto el audio comience a
reproducirse.
Wavstop hará que el archivo de audio en reproducción, se detenga.
Wavwait hará que el programa se detenga y espere a que la
reproducción del audio termine para continuar ejecutándose.
Moviendo Imágenes - Sprites

Sprites son objetos gráficos especiales que pueden moverse alrededor en la pantalla sin
tener que re-dibujar la pantalla completa. Adicionalmente a ser móviles, permiten detectar
cuándo un sprite se superpone (colisiona) con otro. Los sprites hacen mucho más fácil la
programación de animaciones y juegos complejos.
1 # c12_sprite1ball.kbs
2 # sonidos de http://www.freesound.org/people/NoiseCollector
3 color white
5
6 spritedim 1
7 spriteload 0, "blueball.png"
8 spriteplace 0, 100,100
9 spriteshow 0

258
10 dx = rand * 10
11 dy = rand * 10
12 while true
13 if spritex(0) <=0 or spritex(0) >= graphwidth -1 then
14 dx = dx * -1
15 wavplay "4359__NoiseCollector__PongBlipF4.wav"
16 end if
17 if spritey(0) <= 0 or spritey(0) >= graphheight -1 then
18 dy = dy * -1
19 wavplay "4361__NoiseCollector__pongblipA_3.wav"
20 endif
21 spritemove 0, dx, dy
22 pause .05
23 end while
Programa 79: Rebote una Pelota con Sprite y Efectos Sonoros
Salida 79: Rebote una Pelota con Sprite y Efectos Sonoros

Como puede ver en el Programa 79, el código para hacer que la pelota rebote alrededor de
la pantalla con efectos de sonido es mucho más fácil y elegante que los programas
anteriores para hacer este tipo de animación.
Cuando usemos sprites debemos decirle a BASIC-256 cuántas de ellos habrá (spritedim),
deberemos definirlos (spriteload, spritepoly o spriteplace), hacerlos visibles
(spriteshow) y finalmente moverlos (spritemove).
Además de estas sentencias hay funciones que nos dirán dónde está el sprite en la
pantalla (spritex, spritey), su tamaño (spritew y spriteh) y si es visible o no (spritev).
spritedim numerodesprites
spritedim ( numerodesprites )
La sentencia spritedim inicializa, o aloja en memoria, lugar
suficiente para guardar el número especificado de sprites
(numerodesprites). Puede alojar tantos sprites como su programa
requiera, pero tenga presente que demasiados puede hacer la
ejecución de su programa demasiada lenta.

258
spriteload spritenumero, nombredearchivo

spriteload ( spritenumero, nombredearchivo )
Esta sentencia lee un archivo gráfico (GIF, BMP, PNG, JPG, or JPEG)
de una ruta especificada y crea un sprite con él.
Por defecto, el sprite será ubicado con su centro en (0,0) (el centro de
la pantalla) y estará oculto. Ud. deberá mover el sprite a la posición
deseada al inicio (spritemove or spriteplace) y luego mostrarlo
(spriteshow).
spritehide spritenumero
spritehide ( spritenumero )
spriteshow spritenumero
spriteshow ( spritenumero )
La sentencia spriteshow causa que un sprite cargado, creado u
oculto, sea mostrado en el área gráfica.
Spritehide hace que el sprite especificado no se muestre en la
pantalla. A pesar de estar oculto, el sprite sigue existiendo y puede
ser mostrado luego.
spriteplace spritenumero, x, y
spriteplace ( spritenumero, x, y )
La sentencia spriteplace le permite ubicar el centro de un sprite
en una ubicación especificada en el área gráfica.
spritemove spritenumero, dx, dy

spritemove ( spritenumero, dx, dy )
Mueve el sprite especificado dx pixeles hacia la derecha y dy pixeles
hacia abajo. Pueden especificarse números negativos para hacer el
movimiento en las direcciones opuestas.
El centro de un sprite no se moverá más allá del borde de la ventana
de salida gráfica corriente (0,0) a (graphwidth-1, graphheight-1).
Es posible mover un sprite oculto, pero permanecerá oculto hasta
que Ud. lo muestre con la sentencia showsprite.
spritev(spritenumero)
Esta función devuelve true si un sprite cargado está siendo mostrado
en el área gráfica de salida. Devolverá false si no es visible.
spriteh(spritenumero)
spritew(spritenumero)
spritex(spritenumero)
spritey(spritenumero)
Estas funciones devuelven diversa información sobre el sprite cargado.
spriteh Devuelve la altura de un sprite en pixeles.

258
spritew Devuelve el ancho de un sprite in pixeles.

spritex Devuelve la position sobre el eje X del centro del sprite.
spritey Devuelve la position sobre el eje Y del centro del sprite.
En el ejemplo siguiente (Programa 80) tenemos dos sprites. El primero (número 0) es

estacionario mientras que el segundo (número 1) rebotará entre las paredes y el sprite
estacionario.
1 # c12_spritebumper.kbs
2 # muestre dos sprites con colisión
3 color white
5 spritedim 2
6
7 # Parachoques estacionario
8 spriteload 0, "paddle.png"
9 spriteplace 0,graphwidth/2,graphheight/2
10 spriteshow 0
11
12 # Pelota moviendose
13 spriteload 1, "greenball.png"
14 spriteplace 1, 50, 50
15 spriteshow 1
16 dx = rand * 5 + 5
17 dy = rand * 5 + 5
18
19 while true
20 if spritex(1) <=0 or spritex(1) >= graphwidth -1 then
21 dx = dx * -1
22 end if
23 if spritey(1) <= 0 or spritey(1) >= graphheight -1 then
24 dy = dy * -1
25 end if
26 if spritecollide(0,1) then
27 dy = dy * -1
28 print "bump"
29 end if
31 pause .05
32 end while
Programa 80: Dos Sprites con Colisión

258
Salida 80: Dos Sprites con Colisión
Spritecollide (sprite1, sprite2)
Esta función devuelve true si los dos sprites, sprite1 y sprite2,

colisionan o se superponen entre ellos.
Los sprites también pueden ser creados usando un polígono como vimos en el Capítulo 8.
Esto se implementa usando la sentencia spritepoly.
1 # c12_spritepoly.kbs
2 # crea un sprite de un polígono que sigue al mouse
4 spritedim 1
5 color red, blue
6 penwidth 1
7 spritepoly 0, {15,0, 30,10, 20,10, 20,30, 10,30, 10, 10, 0,10}
9 color green
11
12 spriteshow 0
13 while true
14 spriteplace 0, mousex, mousey
15 pause .01
16 end while
Programa 81: Creando el Sprite de un Polígono

258
Salida 81: Creando el Sprite de un Polígono
spritepoly spritenumero, { puntos }

spritepoly ( spritenumero, { puntos } )
spritepoly spritenumero, variable_array
spritepoly ( spritenumero, variable_array )
Crea un nuevo sprite de la lista de puntos definiendo un polígono. El
vértice superior izquierdo del polígono debe estar en la posición (0, 0)
y el tamaño del sprite será automáticamente definido.
El Programa Grande de este capítulo usa sprites y sonido para crear

un juego de frontón.
1 # c12_sprite_paddleball.kbs
2 # juego de fronton hecho con sprites
3 # sonidos de http://www.freesound.org/people/NoiseCollector
4
5 print "Juego de Frontón"
6 print "Las teclas J y K mueven la raqueta. "
7 input "Presione enter para comenzar >", wait$
8
9 color white
11
12 spritedim 2
13 color blue, darkblue
14 spritepoly 0, {0,0, 80,0, 80,20, 70,20, 70,10, 10,10, 10,20, 0,20}
16 spriteshow 0
17 spriteload 1, "greenball.png"

258
19 spriteshow 1
20 penwidth 2
21
22 dx = rand * .5 + .25
23 dy = rand * .5 + .25
24
25 bounces = 0
26
27 while spritey(1) + spriteh(1) - 5 < spritey(0)
28 k = key
29 if chr(k) = "K" then
30 spritemove 0, 20, 0
31 end if
32 if chr(k) = "J" then
33 spritemove 0, -20, 0
34 end if
35 if spritecollide(0,1) then
36 # rebote y aumente velocidad
37 dy = dy * -1
38 dx = dx * 1.1
39 bounces = bounces + 1
40 wavstop
41 wavplay "96633__CGEffex__Ricochet_metal5.wav"
42 # mover sprite fuera de la paleta
43 while spritecollide(0,1)
45 end while
46 end if
47 if spritex(1) <=0 or spritex(1) >= graphwidth -1
then
48 dx = dx * -1
49 wavstop
50 wavplay "4359__NoiseCollector__PongBlipF4.wav"
51 end if
52 if spritey(1) <= 0 then
53 dy = dy * -1
54 wavstop
55 wavplay "4361__NoiseCollector__pongblipA_3.wav"
56 end if
58 # ajuste la velocidad aqui
59 pause .002
60 end while
61
62 print "Ud. Rebotó la pelota " + bounces + " veces."
Programa 82: Juego de Frontón con Sprites

258
Sample Output 82: Juego de Frontón con Sprites

258
Ejercicios:
i s d d i m e n s i o n o z u
s e j i e s c a l e h e w d w
k p v c i r z n r o y d a s o
z j r p m a u o z l u i v p h
a e m i t s t t o m e l w r s
c f v f t a m p c c l l a i e
q o h o t e e i a i g o i t t
w j l i m t l l d w p c t e i
q a o l i e p o a e f e w h r
w n v r i e t v a i t t j i p
q b p p t s s i m d h i s d s
o s v i l t i a r m t r r e c
u u r w o a g o y p s p r p z
h p a p g e y a n d s s e f s
s f t s b k i m g l o a d u o
collision, dimension, image, imgload, picture, rotation, scale,
spritecollide, spritedim, spritehide, spriteload, spritemove,
spriteplace, spritepoly, spriteshow, wavplay, wavstop, wavwait
12.1. Escriba un programa para dibujar una moneda, en una ventana

gráfica que tiene 100x100 pixeles con una cara sobre ella.
Guarde la imagen como “cabeza.png”. Haga que el mismo
programa limpie la pantalla, dibuje el otro lado de la moneda y
guárdelo como “cola.png”. Haga las monedas con su diseño
propio.
12.2. Ahora escriba un programa simple para tirar una moneda que
muestre el resultado usado las imágenes creadas en el
problema Genere un número aleatorio y pruebe: si el número
es menor que 0.5 muestre la cabeza, caso contrario la cola.
Como un extra, haga que cabezas y colas aparezcan en la
pantalla de manera aleatoria hasta que el usuario presione una
tecla.
12.3. Use un programa de audio para grabar dos archivos WAV con
su voz, uno diciendo “cabeza!” y otro diciendo “cola!”. Agregue

258
este audio al programa escrito en 12.2
12.4. Modifique el Programa 82 para crear un juego tipo “ping-pong”

para dos jugadores. Necesitará agregar un tercer sprite para el
nuevo jugador en la parte de arriba y asignarle dos teclas para
que mueva su raqueta.

258
Capítulo 13: Imprimiendo

Con BASIC-256 un programa puede generar información de salida que Ud. quiera enviar a
una impresora o a un archivo PDF. La página de impresión es tratada como si fuera una
gran área gráfica, en donde Ud. puede dibujar textos, formas, polígonos, líneas, puntos o
stamps usando las mismas sentencias aprendidas en los capítulos anteriores.
Encendiendo y Apagando la Impresora

Para comenzar a imprimir, todo lo que necesita es encender la impresora con el comando
printer on. Una vez que finalizó de crear la(s) páginas(s) para imprimir deberá ejecutar la
sentencia printer off.
1 # c13_printpage.kbs
2 # imprimir una pagina con texto
3
4 printer on
5 x = 100 # empiece la 1ra. linea 100 pixes debajo.
6
7 font "Times New Roman", 30, 100
8 for t = 1 to 10
9 text 0, x, "The number t is " + t
10 x = x + textheight()
11 next t
12 printer off
Programa 83 : Imprimiendo una Página con Texto
Salida 83: Imprimiendo una Página con Texto

258
printer on
printeron
Enciende la impresora.
Una vez que la impresora está encendida, las sentencias gráficas
(line, plot, text, rect, circle, poly, stamp, graphwidth, graphheight,
textwidth y textheight) ahora dibujarán y devolverán información de la
página de impresión
printer off
printeroff
Finaliza la impresión del documento corriente.
Si su salida está siendo enviada a un dispositivo de impresión, el
documento empezará a imprimirse. Si su salida está direccionada a
un archive PDF, el archivo será escrito y guardado en la ubicación
especificada.
textwidth (string)
textheight()
textwidth (ancho de texto) y textheight (alto de texto) devuelven el
ancho y alto respectivamente de un string en pixels cuando es
dibujado en la salida gráfica o dispositivo de impresión con la
sentencia text.
textwidth devuelve el ancho real del string.
textheight devuelve la altura estándar, en píxeles, del font activo.
Puede cambiar el destino y las propiedades de impresión seleccionando la pestaña

"Printing” (Impresión) en la ventana de “Preferences (Preferencias)". Podrá seleccionar
cualquier impresora configurada en Windows y el tamaño y orientación de la página.
Ilustración 23: Preferencias – Pestaña de Impresión (Printing Tab)
Adicionalmente, podrá también seleccionar la resolución a usar en la impresión. La

258
resolución por defecto (Resolución de Pantalla) dibuja en la página de la impresora de una

manera similar a como se dibuja en la pantalla. En esta resolución hay aproximadamente
96 píxeles por pulgada (0.260 mm/pixel). En el modo de Alta Resolución, Ud. dibujará en la
página en la resolución nativa de la impresora. Para la mayoría de las impresoras y para
salida PDF, la resolución será de 1200 píxeles por pulgada (0.021 mm/pixel)
Recuerde que la sentencia font usa la unidad de punto (point) para medir el tamaño del
texto que está siendo dibujado en la salida gráfica (un punto es 1/72 de una pulgada, o
0.035 mm). De este modo el texto permanecerá constante en tamaño independientemente
del modo de impresión seleccionado.
1 # c13_drawpage.kbs
2 # Draw on the page
3
4 printer on
5
6 # coloque el texto en el CENTRO de la pagina
7 color black
8 font "Arial", 40, 500
9 words$ = "Center"
10 x = ( graphwidth - textwidth(words$) ) / 2
11 y = ( graphheight - textheight() ) / 2
12 text x,y,words$
13
14 # dibuje un circulo alrededor del texto
15 # llenelo con color “clear”
16 color black, clear
17 penwidth 5
18 circle graphwidth/2, graphheight/2, 100
19
20 # dibuje un triangulo usando poly
21 color black, grey
22 penwidth 10
23 poly {200,100, 300,300, 100,300 }
24
25 # dibuje un patrón moire en la pagina
26 color black
27 penwidth 1
28 for t = 0 to 400 step 3
29 line graphwidth, graphheight, graphwidth-400, graphheight-t
30 line graphwidth, graphheight, graphwidth-t, graphheight-400
31 next t
32
33 printer off
Programa 84: Imprimiendo una Página con Gráficos

258
Salida 84: Imprimiendo una Página con Gráficos
printer page
printerpage
Si necesita imprimir una nueva página, ejecute la sentencia
printer page. La misma guardará la página corriente y toda
nueva salida irá a la próxima página.
printer cancel
printercancel
Si ha empezado a imprimir un documento y decide que no necesita
terminarlo, la sentencia printer cancel apagará la impresora y
no producirá mas salida por el dispositivo.
El Programa Grande de este capítulo usa sentencias de impresión

para generar e imprimir una tabla de multiplicar.
1 # c13_multtable.kbs
2 # imprima la tabla de multiplicar del 12 hasta 12
3 printer on
4 color black
5 font "Arial", 12, 100
6
7 # size of a cell on grid
8 w = 700/13
9 h = textheight()*2
10 #
11 pad = 5

258
12
13 # dibuje la grilla
14 penwidth 2
15 for x = 0 to 14
16 line x*w,0,x*w,14*h
17 next x
18 for y = 0 to 14
19 line 0,y*h,14*w,y*h
20 next y
21
22 # ponga los números de fila y de columna
23 font "Arial", 12, 100
24 for x = 0 to 12
25 text (x+1)*w+pad,pad,x
26 next x
27 for y = 0 to 12
28 text pad,(y+1)*h+pad,y
29 next y
30
31 # ponga los productos
32 font "Arial", 12, 50
33 for x = 0 to 12
34 for y = 0 to 12
35 text (x+1)*w+pad,(y+1)*h+pad,(x*y)
36 next y
37 next x
38 printer off
Programa 85: Tabla de Multiplicar
Salida 85: Tabla de Multiplicar

258
Ejercicios:
k l a n d s c a p e
j f d r e p a p t g
p o r t r a i t x a
b s g n i t t e s p
t h g i e h t x e t
r e s o l u t i o n
o k p r i n t e r o
m a r g i n d f d p
g h t d i w t x e t
o z c a n c e l x p
cancel, landscape, margin, page, paper, pdf, portrait, printer,
resolution, settings, textheight, textwidth
13.1. Tome el programa del Problema 5.1 o 5.1 y haga que imprima la
lírica de las canciones en una página después que el usuario
tipee palabras para llenar los blancos.
Puede necesitar mantener una variable con el número de línea
que esté enviando a la salida de modo que pueda calcular
cuán abajo en la página debe comenzar la línea.
13.2. Use la subrutina de la cara sonriente que creó en el Problema 9.1
para crear una página con una cara sonriente en cada una de las
4 esquinas y la palabra “SONRISA” centrada en la página.

258
Capítulo 14: Arreglos – Colecciones de Información
Capítulo 14: Arrays - Colecciones de

Información
Hemos usado strings y variables numéricas simples en muchos programas, pero éstas
podían contener solo un valor a la vez. A menudo tenemos que trabajar con listas o
conjuntos de valores. Podemos hacer esto de manera conveniente con arrays. BASIC
provee arrays de tipo uni- o bi-dimensionales (1D ó 2D). Este capítulo le mostrará cómo
crear, inicializar, usar y re-dimensionar arrays.
NdT: Un array es una colección de cosas, y usaremos el término en inglés en este
contexto. Un array-1D puede visualizarse como objetos colocados en una fila. Un array 2-D
puede visualizarse como objetos colocados en los casilleros de un tablero de ajedrez, en
filas y columnas. En matemáticas, un array-1D es equivalente a un “vector”; un array-2D a
una “matriz”.
Arrays Numéricos Uni-Dimensionales

Un array uni-dimensional (1D) nos permite crear una lista en memoria y acceder a los ítems
en esa lista usando una dirección numérica (llamada índice) que denota la posición de un
dado objeto en la fila.
Los arrays pueden contener números o strings. Esto lo definimos nosotros mediante el tipo
de variable que usemos en la declaración dim para crearlo, como vemos en el ejemplo
siguiente.
1 # c14_arraynumeric1d.kbs
2 # array numérico uni-dimensional
3 dim a(10) # se crea el array “a” de 10 elementos. Es un array
4 # numérico porque “a” denota una variable numérica
5
6 a[0] = 100
7 a[1] = 200
8 a[3] = a[1] + a[2]
9 input "Ingrese un numero> ", a[9]
10 a[8] = a[9] - a[3]
11 for t = 0 to 9
12 print "a[" + t + "] = " + a[t]
13 next t
Programa 86: Array Numérico Uni-dimensional
Ingrese un numero> 63
a[0] = 100
a[1] = 200
a[2] = 0
a[3] = 200
a[4] = 0
a[5] = 0
a[6] = 0
a[7] = 0
a[8] = -137
a[9] = 63

258
Salida 86: Array Numérico Uni-dimensional
dim variable (items)  array numérico

dim variable$(items)  array de strings ($)
dim variable (filas, columnas)
dim variable$(filas, columnas)
La sentencia dim crea un array en la memoria de la computadora,
de tamaño items (nro. de elementos) especificado como argumento.
Los argumentos definiendo el tamaño (ítems, filas y columnas)
deben ser valores enteros mayores o igual a uno (1).
La sentencia dim inicializa los elementos de un nuevo array a cero
(0) si es numérico o al string vacío ("") si es un array de strings.
variable [index]
variable [indexfila, indexcolumna]
variable$[index]
variable$[indexfila, indexcolumna]
Puede usar una “referencia” al array (una variable con índice(s) en
corchetes cuadrados) casi en cualquier lugar en el que pueda usar
una variable simple. El índice o índices deben ser valores enteros
entre cero (0) y uno menos que el tamaño del array (como fue
definido al crearlo, con la sentencia dim).
Puede ser confuso, pero BASIC-256 usa cero (0) como índice del
primer elemento en un array. Así, el último elemento es el tamaño
menos uno (1). En computación arrays numerados de esta manera
se conocen como “cero-indexados”.
Podemos usar arrays numéricos para dibujar varias pelotas rebotando en la pantalla de
una sola vez. El Programa 85 usa 5 arrays para guardar la posición de cada pelota, su
dirección y su color. Se usan loops para inicializar los arrays y para animar las pelotas. El
programa también usa la función rgb() para calcular y guardar los valores de color para
cada una de las pelotas.
1 # c14_manyballbounce.kbs
2 # use arrays para mantener la direccion, posición,
3 # y color de varias pelotas en pantalla
4 fastgraphics
5 r = 10 # tamaño de la pelota
6 balls = 50 # numero de pelotas
7 dim x(balls)
8 dim y(balls)
9 dim dx(balls)
10 dim dy(balls)
11 dim colors(balls)
12
13 for b = 0 to balls-1
14 # posición inicial de las pelotas
15 x[b] = 0
16 y[b] = 0
17 # velocidad en dirección x e y

258
18 dx[b] = rand * r + 2
19 dy[b] = rand * r + 2
20 # cada pelota tiene su propio color
21 colors[b] = rgb(rand*256, rand*256, rand*256)
22 next b
23
24 color green
25 rect 0,0,300,300
26 while true
27 # limpie pantalla (erase screen)
28 clg
29 # ubique y dibuje las pelotas
30 for b = 0 to balls -1
31 x[b] = x[b] + dx[b]
32 y[b] = y[b] + dy[b]
33 # si off los bordes laterales rebotan la pelota
34 if x[b] < 0 or x[b] > 300 then
35 dx[b] = dx[b] * -1
36 end if
37 # si off los bordes sup e inf rebotan la pelota
38 if y[b] < 0 or y[b] > 300 then
39 dy[b] = dy[b] * -1
40 end if
41 # dibuje nueva pelota
42 color colors[b]
43 circle x[b],y[b],r
44 next b
45 # refresque el display
46 refresh
47 pause .05
48 end while
Programa 87: Varias Pelotas Rebotando.

258
Salida 87: Varias Pelotas Rebotando.
Otro ejemplo de pelota rebotando puede verse en el Programa 88. Este segundo ejemplo
usa sprites y dos arrays para seguir la dirección en la que cada sprite se está moviendo.
1 # c14_manyballsprite.kbs
2 # otro modo de rebotar pelotas, usando sprites.
3 fastgraphics
4 color white
6 n = 20
7 spritedim n
8 dim dx(n)
9 dim dy(n)
10
11 for b = 0 to n-1
12 spriteload b, "greenball.png"
13 spriteplace b,graphwidth/2,graphheight/2
14 spriteshow b
15 dx[b] = rand * 5 + 2
16 dy[b] = rand * 5 + 2
17 next b
18
19 while true
20 for b = 0 to n-1
21 if spritex(b) <=0 or spritex(b) >= graphwidth -1 then
22 dx[b] = dx[b] * -1
23 end if
24 if spritey(b) <=0 or spritey(b) >= graphheight -1 then
25 dy[b] = dy[b] * -1
26 end if
27 spritemove b, dx[b], dy[b]
28 next b
29 refresh
30 end while
Programa 88: Varias Pelotas Rebotando Usando Sprites

258
Salida 88: Varias Pelotas Rebotando Usando Sprites
Arrays de Strings
Los arrays también pueden ser usados para guardar valores string. Para crear un array de
strings, use una variable string en la sentencia dim. Todas las reglas vistas para arreglos
numéricos son válidas para strings, excepto que el tipo de los datos es diferente. Puede ver
el uso de un array de strings en el Programa 89 a continuación.
1 # c14_listoffriends.kbs
2 # use un array de strings para guardar nombres
3 print "Haga una lista de mis amigos"
4 input "Cuantos amigos tiene? ", n
5
6 dim names$(n)
7
8 for i = 0 to n-1
9 input "Ingrese el nombre de un amigo? ", names$[i]
10 next i
11 cls
12 print "Mis amigos:"
13 for i = 0 to n-1
14 print "Amigo numero ";
15 print i + 1;
16 print ": " + names$[i]
17 next i
18 end
Programa 89: Lista de Mis Amigos
Haga una lista de mis amigos

Cuantos amigos tiene? 3
Ingrese el nombre de un amigo? Alicia
Ingrese el nombre de un amigo? Luciano

258
Ingrese el nombre de un amigo? Franco

(- la pantalla se limpia –)
Mis amigos:
Amigo numero 1: Alicia
Amigo numero 2: Luciano
Amigo numero 3: Franco
Salida 89: Lista de Mis Amigos
Asignando Arrays
Hemos visto el uso de llaves ({}) para reproducir música, dibujar polígonos y definir stamps.
Las llaves pueden usarse también para crear y asignar un array completo con los valores
que deseemos.
1 # c14_arrayassign.kbs
2 # usando una lista de valores para crear un array asignado
3
4 numero = {56, 99, 145}
5 nombre$ = {"Alicia", "Franco", "Luciano"}
6
7 for i = 0 to 2
8 print number[i] + " " + name$[i]
9 next i
Programa 90: Asignando un Array con una Lista
56 Alicia
99 Franco
145 Luciano
Salida 90: Asignando un Array con una Lista
array = {valor0, valor1, … }

array$ = {valor0, valor1, … }
Se define una variable como un array y se le asignan valores
(comenzando con el índice 0) desde una lista encerrada entre llaves.
Esto funciona tanto para arrays numéricos como strings.
Sonidos y Arrays
En el Capítulo 3 vimos como usar una lista de frecuencias y duraciones (colocadas entre
llaves) para reproducir múltiples sonidos de una vez. La sentencia sound también aceptará
una lista de frecuencias y duraciones desde un array. El array deberá tener un número par
de elementos; las frecuencias deberían ser guardadas en los elementos pares (0,2,4,…) y
las duraciones en los impares (1,3,5,…).
El Programa 91 a continuación una simple fórmula lineal para hacer un sonido “espacial”.
1 # c14_spacechirp.kbs
2 # reproduzca un sonido espacial
4 # valores pares 0,2,4... - frecuencia
5 # valores impares 1,3,5... - duracion

258
7 # el sonido empieza a 100hz y aumenta en 40Hz para cada uno

8 # del total de 50 sonidos en la lista. Duracion siempre 10.
9 dim a(100)
10 for i = 0 to 98 step 2
11 a[i] = i * 40 + 100
12 a[i+1] = 10
13 next i
14 sound a
15 end
Programa 91: Sonido Espacial
Qué clase de sonidos extraños puede hacer su computadora?

Experimente con las fórmulas en el programa anterior para cambiar
las frecuencias y las duraciones.
Gráficos y Arrays
En el Capítulo 8 vimos el uso de listas para crear polígonos y stamps. Los arrays también
pueden usarse para dibujar polígonos, stamps y sprites. Su uso ayuda a simplificar y a
hacer más elegante su código permitiendo que una figura sea definida una sola vez, sea
guardada en un array y usada tantas veces y en los lugares que su programa lo necesite
En un array usado para una figura, los elementos pares (0,2,4,…) contienen los valores x
para cada uno de los puntos, mientras que los elementos impares (1,3,5,…) contienen los
valores y de esos puntos. El array tendrá dos valores para cada punto en la figura.
En el Programa siguiente usaremos el stamp del capítulo de mouse para dibujar una gran
X con sombra. La sombra se logra “estampando” una forma gris corrida en la dirección en
que se quiera la sombra y luego estampando la forma que produce la sombra.
1 # c14_shadowstamp.kbs
2 # crear un stamp desde un array
3
4 xmark = {-1, -2, 0, -1, 1, -2, 2, -1, 1, 0, 2, 1, 1, 2, 0, 1, -1, 2, -2, 1, -1, 0, -2,
-1}
5 clg
6 color grey
7 stamp 160,165,50,xmark
8 color black
9 stamp 150,150,50,xmark
Programa 92: Stamp con Sombra

258
Salida 92: Stamp con Sombra

Los arrays pueden también ser usados para crear polígonos matemáticamente. En el
Programa 39 creamos un array de 10 elementos (5 puntos) y asignamos posiciones al azar
a cada uno de los puntos para dibujar polígonos al azar. BASIC-256 llenará las formas
(polígonos) lo mejor que pueda, pero cuando se cruzan líneas, el llenado no es perfecto y a
veces deja espacios y huecos, como verá a continuación.
1 # c14_randompoly.kbs
2 # dibujar 5 poligonos pegados (lados compartidos) al azar
3 dim shape(10)
4
6 x = 300 * rand
7 y = 300 * rand
8 shape[t] = x
9 shape[t+1] = y
10 next t
11 clg
12 color black
13 poly shape
Programa 93: Crear Polígonos Pegados al Azar

258
Salida 93: Crear Polígonos Pegados al Azar
Avanzado: Arrays Bi-Dimensionales

Hasta ahora en este capítulo hemos explorado arrays como listas de números y strings.
Podemos llamar a esos arrays como uni-dimensionales (1-D) debido a que sus valores
todos juntos pueden verse como ubicados en una línea (en matemáticas, el análogo a un
array uni-dimensional es un “vector”).
Los arrays también pueden ser creados con dos dimensiones, representando filas y
columnas. En este caso son arrays bi-dimensionales (2-D) (en matemáticas, estos pueden
asociarse a “matrices”)
El Programa 94 a continuación usa ambos tipos de arrays, 1-D y 2-D, para calcular
promedios de estudiantes.
1 # c14_grades.kbs
2 # calculate average grades for each student
3 # and whole class using a two dimensional array
4
5 nstudents = 3 # number of students
6 nscores = 4 # number of scores per student
7
8 dim students$(nstudents)
9 dim grades(nstudents, nscores)
10
11 # guarde las notas como columnas y los estudiantes como filas
12 # primer estudiante
13 students$[0] = "Panqui"
14 grades[0,0] = 90
15 grades[0,1] = 92
16 grades[0,2] = 81
17 grades[0,3] = 55
18 # segundo estudiante
19 students$[1] = "Lucho"

258
20 grades[1,0] = 66
21 grades[1,1] = 99
22 grades[1,2] = 98
23 grades[1,3] = 88
24 # tercer estudiante
25 students$[2] = "Ali"
26 grades[2,0] = 79
27 grades[2,1] = 81
28 grades[2,2] = 87
29 grades[2,3] = 73
30 total = 0
31 for row = 0 to nstudents-1
32 studenttotal = 0
33 for column = 0 to nscores-1
34 studenttotal = studenttotal + grades[row, column]
35 total = total + grades[row, column]
36 next column
37 print "El promedio de " + students$[row] + "es ";
38 print studenttotal / nscores
39 next row
40 print "El promedio de la clase es ";
41 print total / (nscores * nstudents)
42 end
Programa 94: Calculadora de Notas
El promedio de Panqui es 79.5

El promedio de Lucho es 87.75
El promedio de Ali es 80
El promedio de la clase es 82.416667
Salida 94: Calculadora de Notas

258
Realmente Avanzado - Tamaño de Arrays y Pasando

Arrays a Subrutinas y Funciones
A veces necesitamos escribir código que debería trabajar con un array de cualquier
tamaño. Si especificamos un signo de pregunta en la posición de un índice, fila o columna
dentro de los corchetes cuadrados de un array, BASIC-256 devolverá el tamaño
dimensionado.
En el Programa 90 modificamos el Programa 87 para mostrar el array independientemente
de su longitud. Ud. verá el signo [?] usado en la línea 18 para devolver el tamaño real del
array.
1 # c14_size.kbs
2 # Longitud de array y pasando a una subroutina
3
4 print "El Array de Numeros:"
5 number = {77, 55, 33}
6 call showarray(ref(number))
7
8 print "El Array de Numeros al Azar:"
9 dim r(5)
10 for a = 0 to r[?] - 1
11 r[a] = int(rand*10)+1
12 next a
13 call showarray(ref(r))
14 #
15 end
16 #
17 subroutine showarray(ref(a))
18 print "tiene " + a[?] + " elementos."
19 for i = 0 to a[?] - 1
20 print "elemento " + i + " " + a[i]
21 next i
22 end subroutine
Programa 95: Tamaño de Array
El Array de Numeros:
tienes 3 elementos.
elemento 0 77
elemento 1 55
elemento 2 33
El Array de Numeros al Azar:
tiene 5 elementos.
elemento 0 7
elemento 1 5
elemento 2 1
elemento 3 9
elemento 4 10

258
Salida 95: Tamaño de Array
array [?]
array$[?]
array [?,]
array$[?,]
array [,?]
array$[,?]
La referencia [?] devuelve la longitud de un array uni-dimensional o el
número total de elementos (filas*columnas) de un array bi-
dimensional.
En un array bi-dimensional, la referencia [?,] devuelve el número de
filas mientras que [,?] devuelve el número de columnas.
ref(array)
ref(array$)
La función ref() se usa para pasar a una subrutina o función, una
referencia a un array. La referencia al array debe ser especificada en
la creación de la subroutina/función y cuando es llamada.
Si la subrutina cambia un elemento en el array referenciado, el valor
también cambia fuera de la subrutina.
Note que esto es un comportamiento diferente al de otras variables,
cuyos valores al pasar a una subrutina/función son “copiados” a
nuevas variables dentro de la subrutina o función. Esto es, aunque
los valores sean cambiados dentro de la subrutina/función, estos
cambios no se reflejan fuera de las mismas, ya que lo que se cambió
fue una copia.
Realmente Muy Avanzado – Re-dimensionando

Arrays
BASIC-256 también le permite re-dimensionar un array existente. La sentencia redim le
permite cambiar el tamaño de un array preservando los datos existentes. Si el nuevo array
es mayor, los nuevos elementos serán llenados con cero (0) o el string vacío (""). Si el
nuevo array es mas pequeño que el original, los valores más allá del nuevo tamaño serán
truncados (cut-off).
1 # c14_redim.kbs
2 # se crea un array de 3 elementos
3 number = {77, 55, 33}
4 # se crea un nuevo elemento al final
5 redim number(4)
6 number[3] = 22
7 #
8 for i = 0 to 3
9 print i + " " + number[i]
10 next i
Programa 96: Re-Dimensionando un Array
0 77

258
1 55
2 33
3 22
Salida 96: Re-Dimensionando un Array
redim variable(ítems)
redim variable$(items)
redim variable(rows, columns)
redim variable$(rows, columns)
La sentencia redim cambia el tamaño de un array en la memoria de
la computadora. Los datos guardados con anterioridad serán
mantenidos, si se ajustan al nuevo tamaño.
Cuando se re-dimensionan arrays 2-D, los valores son copiados de
manera lineal. Los datos pueden ser “corridos” de manera indeseada
si Ud. está cambiando el número de columnas.
El Programa Grande de este capítulo usa tres arreglos numéricos

para guardar las posiciones y velocidades de la basura espacial que
cae. Ud. no está jugando a atrapar la basura, sino tratando de evitarla
para sumar puntos.
1 # c14_spacewarp.kbs
2 # Game: Lluvia de basura espacial
3
4 # defina pelotas y arrays para ellas
5 balln = 5
6 dim ballx(balln)
7 dim bally(balln)
8 dim ballspeed(balln)
9 ballr = 10 # radio de las pelotas
10
11 # defina valores minimo y maximo
12 minx = ballr
13 maxx = graphwidth - ballr
14 miny = ballr
15 maxy = graphheight - ballr
16
17 # score initial
18 score = 0
19
20 # defina tamaño del jugador, dist.p/moverse y ubicación
21 playerw = 30
22 playerm = 10
23 playerh = 10
24 playerx = (graphwidth - playerw)/2

258
25
26 # defina otras variables
27 keyj = asc("J") # valor para la tecla 'j'
28 keyk = asc("K") # valor para la tecla 'k'
29 keyq = asc("Q") # valor para la tecla 'q'
30 growpercent = .20 # crecimiento al azar – mayor, mas rapido
31 speed = .15 # velocidad - menor, mas rapido
32
33 print "SpaceWarp – Use teclas j y k para esquivar la basura espacial."
34 print "q para Salir"
35
36 fastgraphics
37
38 # defina positiones pelotas inicial y velocidad
39 for n = 0 to balln-1
40 bally[n] = miny
41 ballx[n] = int(rand * (maxx-minx)) + minx
42 ballspeed[n] = int(rand * (2*ballr)) + 1
43 next n
44
45 more = true
46 while more
47 pause speed
48 score = score + 1
49
50 # limpie pantalla
51 color black
53
54 # dibuje pelotas y verifique si hay colisiones
55 color white
56 for n = 0 to balln-1
57 bally[n] = bally[n] + ballspeed[n]
58 if bally[n] > maxy then
59 # ball fell off of bottom - put back at top
60 bally[n] = miny
61 ballx[n] = int(rand * (maxx-minx)) + minx
62 ballspeed[n] = int(rand * (2*ballr)) + 1
63 end if
64 circle ballx[n], bally[n], ballr
65 if ((bally[n]) >= (maxy-playerh-ballr)) and
((ballx[n]+ballr) >= playerx) and ((ballx[n]-ballr)
<= (playerx+playerw)) then more = false
66 next n
67
68 # dibuje jugador (draw player)
69 color red

258
70 rect playerx, maxy - playerh, playerw, playerh

71 refresh
72
73 # haga el jugador mas grande (make player bigger)
74 if (rand<growpercent) then playerw = playerw + 1
75
76 # lea tecla del jugador y mueva si tecla fue presionada
77 k = key
78 if k = keyj then playerx = playerx - playerm
79 if k = keyk then playerx = playerx + playerm
80 if k = keyq then more = false
81
82 # mantenga jugador en pantalla
83 if playerx < 0 then playerx = 0
84 if playerx > graphwidth - playerw then playerx =
graphwidth - playerw
85
86 end while
87
88 print "score " + string(score)
89 print "Usted esta M-U-E-R-T-O."
90 end
Programa 97: Big Program – Lluvia de Basura Espacial
Salida 97: Big Program – Lluvia de Basura Espacial

258
Ejercicios:
a t d v i t f p a u
y o y n s z o n c b
e r d q a i m n o e
o e o s c o l u m n
x e d m c z d y v i
c o l l e c t i o n
a r r a y m n h z y
y h t s i l e g d f
d i m e n s i o n l
y j n f z r o w l t
array, collection, column, dimension, index, list, memory, row
14.1. Escriba un programa que pregunte al usuario cuántos números

desea sumar y muestre el total. Cree un array de tamaño igual
a la cantidad de números a sumar, requiera al usuario que
ingrese los números y vaya guardándolos en el array. Una vez
que todos los números son ingresados, haga un loop sumando
a través de los elementos del array y muestre el resultado.
14.2. Agregue al Problema 14.1 lógica para mostrar el promedio
después de calcular el total.
14.3. Agregue al Problema 14.1 lógica para mostrar los valores
mínimos y máximos. Ayuda: Para calcular el mínimo: 1) copie el
primer elemento del array en una variable, 2) compare todos los
elementos restantes del array con esta variable, y si encuentra
uno menor, guarde éste en la variable como el nuevo mínimo.
14.4. Tome el programa del Problema 14.2 y 14.3 y cree funciones
para calcular y devolver el mínimo, máximo y el promedio. Pase
el array a la función y use el operador de array lenght para
hacer que las funciones trabajen con cualquier array que se les
pase.
14.5. Escriba un programa que pregunte por una secuencia de
números, como en el Problema 14.1. Una vez que el usuario ha
ingresado los números al arreglo, muestre una tabla de cada
número multiplicado por cada uno de los otros números. Ayuda:
Necesitará un loop anidado dentro de otro loop.
n> 5
numero 0> 4
numero 1> 7
numero 2> 9
numero 3> 12
numero 4> 45
16 28 36 48 180
28 49 63 84 315
36 63 81 108 405
48 84 108 144 540

258
180 315 405 540 2025

258
Capítulo 15: Matemáticas, Más diversion con Números
Capítulo 15: Matemáticas – Más

diversión con Números
En este capítulo veremos algunos operadores matemáticos y funciones que trabajan con
números. Los temas serán divididos en cuatro secciones: 1) operadores nuevos, 2)
funciones enteras nuevas, 3) funciones de punto flotante nuevas y 4) funciones
trigonométricas.
Operadores Nuevos
Además de las operaciones matemáticas básicas que hemos visto hasta ahora, hay tres
operadores básicos adicionales en BASIC-256. Operadores para estas tres operaciones
existen en la mayoría de los lenguajes de computación. Estos son los operadores: módulo,
división entera y potencia.
Operación Operador Descripción

Módulo % Devuelve el resto de una división entera.
Devuelve el número total de veces que un
División Entera \
número entero puede ser dividivo por otro.
Potencia ^ Eleva un número a la potencia de otro número.
Operador Módulo
El operador módulo (%) devuelve el resto de una división entera.
1 # c15_modulo.kbs
2 input "ingrese un número: ", n
3 if n % 2 = 0 then print "divisible por 2"
5 if n % 5 = 0 then print "divisible por5"
7 end
Programa 98: El Operador Módulo
Ingrese un número: 10
divisible por 2
divisible por 5
Salida 98: El Operador Módulo
expresion1 % expresion2
El operador módulo efectúa una división entera de expression1 por
expression2 y devuelve el resto de este proceso.
Si una o ambas expresiones no son enteros, serán convertidas a
entero eliminando la parte decimal (al igual que la función int()) antes
de efectuar la operación de división.
Ud. puede no haberlo pensado, pero el operador módulo (%) es usado muy a menudo por
los programadores. Dos usos de los más comunes son: 1) probar si un número se divide

258
por otro (Programa 98), y 2) para limitar un número a un rango específico (Programa 99).
1 # re-escritura de moveball.kbs usando el operador modulo
2 # para mantener la pelota en la pantalla.
3
4 print "Use i para moverse hacia arriba, j para la izquierda, k para la
derecha, m para abajo y q para salir"
5 fastgraphics
6 clg
7 ballradius = 20
8 # posición de la pelota
9 # comience en el centro de la pantalla
10 x = graphwidth /2
11 y = graphheight / 2
12
13 # dibuje la pelota inicialmente en pantalla
14 call drawball(x, y, ballradius)
15
16 # loop y espere que el usuario presione una tecla
17 while true
18 k = key
19 if k = asc("I") then
20 # y puede hacerse negativo, + graphheight lo mantiene positivo
21 y = (y - ballradius + graphheight) % graphheight
23 end if
24 if k = asc("J") then
25 x = (x - ballradius + graphwidth) % graphwidth
27 end if
28 if k = asc("K") then
29 x = (x + ballradius) % graphwidth
31 end if
32 if k = asc("M") then
33 y = (y + ballradius) % graphheight
35 end if
36 if k = asc("Q") then end
37 end while
38
39 subroutine drawball(bx, by, br)
40 color white
42 color red
43 circle bx, by, br
44 refresh
45 end subroutine

258
Programa 99: Moviendo la Pelota - Uso de Módulo para mantenerla en pantalla
Operador División Entera

El operador división entera (\) efectúa una división normal, pero trabaja solo con números
enteros (whole numbers) y devuelve un valor entero. Como ejemplo, 13 dividido en 4 es 3 y
resto 1. Así, el resultado de la división entera es 3.
1 # c15_integerdivision.kbs
2 input "dividendo ", dividendo
3 input "divisor ", divisor
4 print dividendo + " / " + divisor + " is ";
5 print dividendo \ divisor;
6 print "r";
7 print dividendo % divisor;
Programa 100: Verifique su división Larga
dividendo 43
divisor 6
43 / 6 is 7r1
Salida 100: Verifique su división Larga
expr1 \ expr2
La división entera (\) efectúa la división expr1 / expr2 y devuelve
el número de veces que expr1 cabe en expr2.
Si una o ambas expresiones no son enteros, serán convertidas a
entero eliminando la parte decimal (al igual que la función int()) antes
de efectuar la operación de división.
Operator Potencia
El operador potencia (^) eleva un número a la potencia de otro número.
1 # c15_power.kbs
2 for t = 0 to 16
3 print "2 ^ " + t + " = ";
4 print 2 ^ t
5 next t
Programa 101: Las Potencias de Dos
2 ^ 0 = 1
2 ^ 1 = 2
2 ^ 2 = 4
2 ^ 3 = 8
2 ^ 4 = 16
2 ^ 5 = 32
2 ^ 6 = 64
2 ^ 7 = 128

258
2 ^ 8 = 256
2 ^ 9 = 512
2 ^ 10 = 1024
2 ^ 11 = 2048
2 ^ 12 = 4096
2 ^ 13 = 8192
2 ^ 14 = 16384
2 ^ 15 = 32768
2 ^ 16 = 65536
Salida 101: Las Potencias de Dos
expr1 ^ expr2
El operador potencia (^) eleva expr1 a la potencia de expr2.
La expresión matemática a = bc debe ser escrita en BASIC-256
como a = b^c.
Nuevas Funciones Enteras

Las tres nuevas funciones enteras de este capítulo tratan sobre cómo convertir strings y
números de punto flotante a enteros. Las tres funciones manejan la parte decimal en la
conversión de manera diferente.
En la función int(), la parte decimal es simplemente descartada. Esto puede causar
problemas si lo que se quiere es redondear y hay números negativos.
Las funciones ceil() (techo) y floor() (piso) solucionan el problema de descarte en int().
Ceil() redondea hacia arriba, esto es, convierte el valor al entero inmediatamente mayor.
Floor() redondea hacia abajo, esto es, convierte el valor al entero inmediatamente menor.
Podríamos haber estado tentados en redondear un número simplemente sumándole 0.5 y
descartando la parte decimal. Esto funciona para números positivos pero no para
negativos. El BASIC-256, para redondear, debemos siempre usar una fórmula como:
a = floor (b+0.5).
Función Descripción
Convierte una expresión (string, valor

entero o decimal) en un entero.
int (expression) Cuando convierte un valor de punto
flotante, la parte decimal es truncada
(eliminada). Si un string no contiene un
número, devuelve cero (0).
Convierte un valor de punto flotante en el
valor entero mayor más próximo
ceil (expression)
(redondeo hacia arriba).
Ej.: a = floor (7.6) = 8
floor (expression) Convierte una expresión de punto flotante
al valor entero menor más próximo
(redondeo hacia abajo).

258
Ej.: a = floor (7.6) = 7

258
1 # c15_intceilfloor.kbs
2 for t = 1 to 10
3 n = rand * 100 - 50
4 print n;
5 print " int=" + int(n);
6 print " ceil=" + ceil(n);
7 print " floor=" + floor(n)
8 next t
Programa 102: Diferencia entre Int, Ceiling y Floor
-46.850173 int=-46 ceil=-46 floor=-47

-43.071987 int=-43 ceil=-43 floor=-44
23.380133 int=23 ceil=24 floor=23
4.620722 int=4 ceil=5 floor=4
-26.608505 int=-26 ceil=-26 floor=-27
-18.813465 int=-18 ceil=-18 floor=-19
23.482759 int=23 ceil=24 floor=23
-45.463169 int=-45 ceil=-45 floor=-46
Salida 102: Diferencia entre Int, Ceiling y Floor
Nuevas Funciones de Punto Flotante

Las funciones matemáticas que cierran este capítulo son las que necesitará para escribir
algunos programas. Aunque no son muy usadas, debe conocer su existencia y
seguramente las usará si desarrolla programas gráficos complejos.
Convierte expresion (valor string, entero o

decimal) a un valor decimal.
float (expresión) Util para convertir strings a números. Si un
string no contiene un número, devuelve cero
(0).
Convierte un valor entero o punto flotante a su
abs (expresión)
valor absoluto.
Devuelve el logaritmo natural (base e) de un
log (expresión)
número.
Devuelve el logaritmo (base 10) de un
log10 (expresión)
número.

258
Avanzado: Funciones Trigonométricas

Trigonometría es el estudio de ángulos y su medición. BASIC-256 incluye soporte para las
funciones trigonométricas comunes. La medida angular usada son los radianes (0-2). Si
está usando grados (0-360) en su programa, deberá convertirlos a radianes antes de usar
estas funciones trigonométricas.
cos (expresion) Devuelve el coseno de un ángulo
sin (expresion) Devuelve el seno de un ángulo
tan (expresion) Devuelve la tangente de un ángulo
degrees (expresion) Convierte radianes (0 - 2π) a grados (0-360).
radians (expresion) Convierte grados (0-360) a radianes (0 - 2π).
Devuelve el coseno inverso (arco coseno) de un
acos (expresion)
ángulo
Devuelve el seno inverso (arco seno) de un
asin (expresion)
ángulo
Devuelve la tangente inversa (arco tangente) de
atan (expresion)
un ángulo
La discusión de las primeras tres funciones refiere a los lados de un triángulo recto. La
Ilustración 24 muestra un triangulo recto con sus lados y ángulos identificados.
Ilustración 24: Triangulo Recto

Seno:
El seno (sin) es la razón de la longitud del lado opuesto sobre la longitud de la hipotenusa.
El seno se repite cada 2π radianes y puede tener valores en el rango de -1 a 1. Ud. ya ha

visto diagramas de ondas “senoidales” en el Capítulo 3 donde se discutieron conceptos de
música.

258
Ilustración 25: La función sin()

Coseno:
El coseno (cos) es la razón de la longitud del lado adyacente sobre la longitud de la
hipotenusa.
El coseno se repite cada 2π radianes y puede tener valores en el rango de -1 a 1. La

Ilustración 24 muestra una amplitud de una onda cosenoidal entre 0 y 2π radianes.
Ilustración 26: La función cos()
Tangente:
La tangente (tan) es la razón de la longitud del lado opuesto sobre la longitud del lado
adyacente.
La tangente se repite cada π radianes y puede tener valores en el rango de a .

La tangente tiene este rango debido a que a medida que el ángulo se aproxima a /2
radianes, el lado opuesto (a) se va haciendo cada vez más pequeño; y será efectivamente
cero cuando el ángulo sea exactamente /2 radianes.
Ilustración 27: La función tan()
Función Degrees (Grados):

258
La función degrees() convierte un ángulo en radianes a grados. La fórmula usada es:

grados = (radianes*360) / 2
Función Radians (Radianes):

La función radians() convierte un ángulo en grados a radianes La fórmula usada es:
radianes = (grados*2 ) / 360
Recuerde que TODAS las funciones trigonométricas en BASIC-256 usan radianes y no

grados para medir ángulos.
Arco Seno (Seno Inverso):

La función seno inverso asin() devuelve un ángulo en radianes para un valor especificado
de seno. Esta función hace lo opuesto a la función sin().
Ilustración 28: La función asin()
Arco Coseno (Coseno Inverso):

La función coseno inverso acos() devuelve un ángulo en radianes para un valor
especificado de coseno. Esta función hace lo opuesto a la función cos().
Ilustración 29: La función acos()
Arco Tangente (Tangente Inversa):

La función tangente inversa atan() devuelve un ángulo en radianes para un valor
especificado de tangente. Esta función hace lo opuesto a la función tan().

258
Ilustración 30: La función atan()
El Programa Grande de este capítulo le permitirá al usuario ingresar

dos números positivos y luego efectuar una división larga. Este
programa usa logaritmos para calcular cuán largos son los números,
módulo y división entera para obtener los dígitos individuales. Es un
programa bastante complejo. No se asuste ni abandone si no entiende
exactamente como trabaja por ahora…
1 # c15_handyclock.kbs
2
3 fastgraphics
4 while true
5 clg
6 # draw outline
7 color black, white
8 penwidth 5
9 circle 150,150,105
10 # dibuje las 60 marcas (cada 5 haga una mas larga)
11 color black
12 penwidth 1
13 for m = 0 to 59
14 a = 2 * pi * m / 60
15 if m % 5 = 0 then
16 pip = 5
17 else
18 pip = 1
19 end if
20 circle 150-sin(a)*95,150-cos(a)*95,pip
21 next m
22 # dibuje las manecillas
23 h = hour % 12 * 60/12 + minute/12 + second /3600
24 call drawhand(150,150,h,50,6,green)
25 m = minute + second / 60
26 call drawhand(150,150,m,75,4,red)
27 call drawhand(150,150,second,100,3,blue)

258
28 refresh
29 pause 1
30 end while
31
32 subroutine drawhand(x, y, f, l, w, handcolor)
33 # pase la ubicación x e y
34 # f como ubicación en la cara del reloj 0-59
35 # longitud, ancho, y color de la manecilla
36 color handcolor
37 stamp x, y, 1, f/60*2*pi - pi / 2, {0,-w,l,0,0,w}
38 end subroutine
Programa 103: Programa Grande – Reloj con Manecillas
Salida 103: Programa Grande – Reloj con Manecillas

258
Ejercicios:
e c e i l i n g n d a b
f t z n n u r a r b g s
c y i t a e t e s m o k
f s r s g a m p h c t j
a a r e o a l t a n i s
t o t o i p i l e p d n
t n l n o r p c c o e a
i a d u a l a o o w g i
r e o g d j f s s e r d
r o o l d o i x k r e a
r l p a f n m w c s e r
d s h y p o t e n u s e
abs, acos, adjacent, asin, atan, ceiling, cos, degrees, float, floor,
hypotenuse, int, integer, logarithm, modulo, opposite, power, radians,
remainder, sin, tan
15.1. Haga que el usuario ingrese un número decimal. Muestre el

número como un entero y la fracción de 1000 más próxima
posible.
15.2. Tome el programa del Problema 15.1 y use un loop para reducir la
fracción dividiendo numerador y denominador por factores
comunes.
15.3. Escriba un programa para dibujar un polígono regular con
cualquier número de lados (3 o más). Coloque el centro en el
centro de la ventana gráfica y haga que sus vértices estén a 100
pixeles de este centro. Ayuda: Un círculo puede ser dibujado
dibujando puntos a una distancia específica de un punto. El
código a continuación dibuja un círculo con radio de 100 pixeles
alrededor del punto (150, 150).
for a = 0 to 2*pi step .01
plot 150-100*sin(a),150-100*cos(a)
next a
6 lados 7 lados 12 lados

258
Capítulo 16: Trabajando con Strings

Hemos usado strings para guardar información no-numérica, capturar el ingreso de datos y
construir salidas para el usuario. Este capítulo muestra varias funciones nuevas que le
permitirán manipular valores string.
Las Funciones String

BASIC-256 incluye ocho funciones para la manipulación de “strings”. La Tabla 8 muestra un
resumen de ellas.
string(expresion) Convierte expresión (valor string, entero o

decimal) a un valor string.
length(string) Devuelve la longitud (en nro. de caracteres) de
string.
left(string, longitud) Devuelve un string de longitud caracteres
comenzando desde la izquierda.
right(string, longitud) Devuelve un string de longitud caracteres
comenzando desde la derecha.
mid(string, start, longitud) Devuelve un string de longitud caracteres
comenzando desde la posición start en el string.
upper(expresion) Devuelve el string expresion en mayúsculas
lower(expresion) Devuelve el string expresion en minúsculas.
instr(oracion, sub) Busca el substring sub en el string oracion y
devuelve su ubicación
Tabla 8: Resumen de Funciones String
La Función String()
La función string() toma una expresión en cualquier formato y la devuelve como un string.
Esta función es un modo conveniente de convertir un número entero o punto flotante en
caracteres de modo que pueda ser manejado como un string.
1 # c16_string.kbs
2 # convierte un numero a string
3
4 a$ = string(10 + 13)
5 print a$
6 b$ = string(2 * pi)
7 print b$
Programa 104: La función String
23
6.283185
Salida 104: La función String

258
string(expresion)
Convierte expresion (string, entero o punto flotante) a un valor
string
La función Length()
La función length() (longitud) toma una expresión string y devuelve su longitud (en
caracteres o letras).
1 # c16_length.kbs
2 # encuentre el largo de un string
3 # debería imprimir 6, 0, y 17
4 print length("Hola.")
5 print length("")
6 print length("Programando Rulz!")
Programa 105: La función Length
6
0
17
Salida 105: La función Length
length(expression)
Devuelve la longitud (nro. De caracteres) del string expression.
Devuelve cero (0) para el string vacío "".
Funciones Left(), Right() y Mid()

Las funciones left(), right() y mid() (izquierda, derecha y medio) extraen sub-strings (o
partes de una string) de una string de mayor longitud.
1 # c16_leftrightmid.kbs
2 # mostrar funcionamiento de funciones: right, left y mid
3 a$ = "abcdefghijklm"
4 print left(a$,4) # imprime primeras 4 letras
5 print right(a$,2) # imprime últimas 2 letras
6 print mid(a$,4,3) # imprime letras 4ta. a 7ma.
7 print mid(a$,10,9) # imprime letras 10ma. a 11va.
Programa 106: Las funciones Left, Right y Mid
abcd
kl
def
jklm

258
Salida 106: Las funciones Left, Right y Mid
left(bstring, largo)
Devuelve un sub-string de longitud largo a partir del extremo
izquierdo de bstring. Si largo es igual o mayor que la longitud de
bstring, devolverá bstring completa.
right(bstring, largo)
Devuelve un sub-string de longitud largo a partir del extremo derecho
de bstring. Si largo es igual o mayor que la longitud de bstring,
devolverá bstring completa.
mid(bstring, start, largo)

Devuelve un sub-string de longitud largo a partir de la posición
start de bstring. El parámetro start especifica donde el sub-
string comienza (start=3 => 3ra. letra de bstring).
Las funciones Upper() y Lower()

Las funciones upper() y lower() (superior e inferior) simplemente devuelven el string
pasados a ellas como argumento pero en minúsculas o mayúsculas respectivamente.
Estas funciones son especialmente útiles cuando se desea hacer una comparación entre
strings y no interesa si hay diferencias de mayúsculas o minúsculas.
1 # c16_upperlower.kbs
2
3 a$ = "Hola."
4
5 print lower(a$) # imprima todo en minusculas
6 print upper(a$) # imprima todo en MAYUSCULAS
Programa 107: Las funciones Upper y Lower
hola.
HOLA.
Salida 107: Las funciones Upper y Lower
lower(bstring)
upper(bstring)
Devuelve una copia de bstring pero en minúsculas o mayúsculas
respectivamente. Caracteres no-alfabéticos no serán modificados.

258
La función Instr()
La función instr() busca, dentro de un string, la ocurrencia de un sub-string. El valor
devuelto es la posición en el string donde comienza el sub-string. Si el sub-string no se
encuentra, la función devolverá cero (0).
1 # c16_instr.kbs
2 # un string dentro de otro
3
4 a$ = "abcdefghijklm"
5 print 'la ubicación de "hi" es ';
6 print instr(a$,"hi")
7 print 'la ubicación de "bye" es ';
8 print instr(a$,"bye")
Programa 108: La función Instr()
la ubicación de "hi" es 8
la ubicación de "bye" es 0
Salida 108: La función Instr()
instr(haystack, needle)
Encuentra el sub-string (needle) en el string haystack. Devuelve

la posición inicial del sub-string contando a partir del primer carácter
del string. Si el sub-string no es encontrado, devuelve cero (0).
El sistema de numeración decimal (base 10) usa 10 dígitos diferentes

(0-9) para representar números. El número 23 puede ponerse como:
23 = 2*101 + 3*100
Imagine cómo sería si hubiera solo 5 dígitos (0-4) (base 5). En este
caso, para representar el mismo número de ítems, el número 23 se
volvería 43:
43 = 4*51 + 3*50
Este tipo de transformación de llama radix o conversión de base.
Internamente, la computadora no entiende los números en
base 10 o 5, sino que trabaja en base 2 (llamado sistema
binario), con lo que tiene que convertir todo antes de
guardarlo en memoria.
El programa Grande de este capítulo convierte un número
entero positivo, desde cualquier base (2 a 36), en donde se
usan letras para los dígitos 11 al 26) a cualquier otra base.
1 # c16_radix.kbs
2 # convierte un numero de una base (2-36) a otra
3
4 # letras usadas para los dígitos 11 al 26

258
5 digits$ = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
6
7 frombase = getbase("desde base")
8 input "numero en base " + frombase + " >", number$
9 number$ = upper(number$)
10
11 # convierta numero a base 10 y guárdelo en n
12 n=0
13 for i = 1 to length(number$)
14 n = n * frombase
15 n = n + instr(digits$, mid(number$, i, 1)) - 1
16 next i
17
18 tobase = getbase("to base")
19
20 # ahora construya string en tobase
21 result$ = ""
22 while n <> 0
23 result$ = mid(digits$, n % tobase + 1, 1) + result$
24 n = n \ tobase
25 end while
26
27 print "en base " + tobase + " el numero es " + result$
28 end
29
30 function getbase(message$)
31 # obtenga la base desde 2 a 36
32 do
33 input message$+"> ", base
34 until base >= 2 and base <= 36
35 return base
36 end function
Programa 109: Big Program - Radix Conversion
desde base> 10
numero en base 10 >999 a base> 16
en base 16 el numero es 3E7
Salida 109: Big Program - Radix Conversion

258
Ejercicios:
u r h t g n e l
p g i r a g k f
p r n l c f l r
e q i i e f e t
r d r g r f x s
v i i r h t t n
p m m x o t s i
r e w o l f w i
instr, left, length, lower, mid, right, string, upper
16.1. Haga que el usuario ingrese un string y repítala en pantalla

16.2. Modifique 16.1 para crear un programa que verifique si la
misma es un palíndromo (palabra o frase que dice lo mismo al
derecho y al revés). Remueva todos los caracteres del string
que no son letras antes de invertirlo. Compare los resultados e
imprima un mensaje si el texto es palíndromo.
Ingrese un string >never odd or even
neveroddoreven
neveroddoreven
es un palíndromo.
16.3. Ud. Trabaja para una pequeña tienda de reventa que oculta el
costo original de los productos en la etiqueta del precio usando
un código alfabético. El código es “roygbivace”, donde la letra
“r” es usada para 0, “o” para 1, … y “e” para 9. Escriba un
programa que convierta el costo a código y el código a costo.
costo o codigo >9.84
ecb
costo or codigo >big
4.53
16.4: Ud. y su amigo necesitan comunicarse de manera que otros no
puedan leer fácilmente sus mensajes. El cifrador Cesar
(http://en.wikipedia.org/wiki/Caesar_cipher) es un modo fácil
(aunque no demasiado seguro) de codificar sus mensajes. Si
Ud. y su amigo acuerdan en correr el mismo número de letras,
podrán compartir fácilmente un mensaje secreto. Para
decodificar un mensaje se debe aplicar un corrimiento de 26
menos el corrimiento original. Una muestra de algunos de los
corrimientos para las letras A-D se muestran en la tabla abajo.
Note que las letras dieron una vuelta.
Corrimiento A B C D
1 B C D E
13 M N O P
25 Z A B C
Escriba un programa que pregunte al usuario el corrimiento y
que ingrese un string a codificar; y muestre el texto

258
codificado.
Corrimiento (shift) >4
mensaje >i could really go for some pizza
M GSYPH VIEPPC KS JSV WSQI TMDDE
Corrimiento (shift) >22

mensaje >M GSYPH VIEPPC KS JSV WSQI TMDDE
I COULD REALLY GO FOR SOME PIZZA

258
Capítulo 17: Files – Guardando Información para Después
Capítulo 17: Files – Guardando

Información para Después
Hemos explorado la memoria de corto tiempo RAM de la computadora con variables y
arrays pero, ¿cómo guardamos estos valores para usarlos con posterioridad?
(RAM = Random Access Memory = Memoria de Acceso Aleatorio en castellano)
Hay muchas técnicas diferentes para el almacenamiento de datos a largo tiempo. BASIC-
256 soporta escribir y leer información desde archivos en su disco rígido. Este proceso de
entrada y salida de datos se denota usualmente como E/S (o I/O por sus siglas en ingles,
Input/Output)
Este capítulo le mostrará como leer valores desde un archivo y también cómo escribirlos
para almacenamiento a largo plazo.
Leyendo Líneas desde un Archivo

Nuestro primer programa usando archivos le mostrará diversas declaraciones y constantes
que deberá usar para manejar archivos de datos. Hay varias declaraciones nuevas en el
programa siguiente.
1 # c17_readlfile.kbs
2 # leer un archivo de texto simple
3
4 input "Archivo> ", fn$
5 if not exists(fn$) then
6 print fn$ + " El archivo no existe."
7 end
8 end if
9 #
10 n=0
11 open fn$
12 while not eof
13 l$ = readline
14 n=n+1
15 print n + " " + l$
16 end while
17 #
18 print "El archivo " + fn$ + " tiene " + size + " bytes."
19 close
Programa 110: Leer Líneas desde un Archivo
Archivo> e2_c17_test.txt
1 These are the times that
2 try men's souls.
3 - Thomas Paine
El archivo e2_c17_test.txt tiene 57 bytes long.
Salida 110: Leer Líneas desde un Archivo

258
exist(expresión)
Busca en la computadora un archivo con nombre expresión
(string). El disco y la ruta de acceso debe ser especificada como
parte del nombre del archivo; pero si éstos se omiten, entonces se
buscará el archivo en el directorio corriente.
Devuelve true si el archivo existe, false caso contrario.
open expresión
open (expresión)
open unumero, expresión
open (unumero, expresión)
Abre el archivo de nombre expresión para leer y escribir y le asigna
unumero como número de unidad de E/S. A partir de este momento
su programa se referirá a ese archivo por su número de unidad
(unumero), no por su nombre.
BASIC-256 puede tener un total de ocho (8) archivos abiertos
simultáneamente (unidades E/S número 0 a 7). Si no se especifica
unumero, entonces el archivo será abierto como unidad cero (0).
Si el archivo no existe, entonces será creado de modo que se pueda
escribir en él (ver write y writeline). Asegúrese de ejecutar la sentencia
close cuando el programa haya terminado de usar el archivo.
eof
eof()
eof(unumero)
La función eof devuelve el valor true si se alcanzó el final del archivo
y false caso contrario (aún quedan más datos)
Si no se especifica unumero, entonces el archivo que se usará será
la unidad cero (0).
readline
readline()
readline(unumero)
Devuelve un string con el contenido de la línea corriente del archivo
abierto (hasta encontrar EOL). Si estamos al final del archivo
[eof(filename)=true], entonces devuelve un string vacío (“”).
la unidad cero (0).
size
size()
size(unumero)
Esta función devuelve la longitud de un archivo abierto, en Bytes.

258
la unidad cero (0).
close
close()
close unumero
close(unumero)
La sentencia close completa cualquier operación de E/S pendiente y
libera el número asignado a esa unidad.
Si no se especifica unumero, entonces el archivo que se cerrará será
la unidad cero (0).
Escribiendo Líneas a un Archivo

En el Programa 110 vimos como leer líneas desde un archivo. Los dos programas
siguientes muestran variaciones de cómo escribir información en un archivo. En el
Programa 111 abrimos y borramos cualquier dato que pueda haber habido en el archivo
para escribir los propios. En el programa 112, adjuntamos nuestros datos al final del
archivo, manteniendo todos los datos previos sin tocar.
1 # c17_resetwrite.kbs
2 # escriba texto a un archivo, vuelva al comienzo y
3 # muestre el texto
4
5 open "e2_c17_resetwrite.dat"
6 print "Ingrese una línea en blanco para cerrar el archivo."
7
8 # limpie el archivo (reset) y vuelva a empezar
9 reset
10 while true
11 input ">", l$
12 if l$ = "" then exit while
13 writeline l$
14 end while
15
16 # vaya al inicio y muestre contenido
17 seek 0
18 k=0
19 while not eof()
20 k=k+1
21 print k + " " + readline()
22 end while
23
24 close
25 end
Programa 111: Limpie el archivo y escriba líneas

258
Ingrese una línea en blanco para cerrar el archivo.

>Estos son algunos
>datos que estoy ingresando
>en este programa.
>
1 Estos son algunos
2 datos que estoy ingresando
3 en este programa.
Salida 111: Limpie el archivo y escriba líneas
reset or
reset() or
reset unumero
reset(unumero)
Borre todos los datos en un archivo abierto y mueva el puntero del
archivo al comienzo del mismo.
la unidad cero (0).
seek expresión
seek(expresión)
seek unumero,expresión
seek (unumero,expresión)
Posiciona el puntero del archivo para la próxima operación de
escritura o lectura. Para mover el puntero al comienzo del archivo use
el valor cero (0). Para moverlo al final del archivo (EOF) use la
función size() como argumento de la sentencia seek
la unidad cero (0).
writeline expresión
writeline(expresión)
writeline unumero, expresión
writeline (unumero, expresión)
Escribe el contenido de expresión a un archivo abierto y agrega al
final una marca EOL (End Of Line, Fin de Línea). El puntero del
archivo será posicionado al final de la escritura, de modo que queda
posicionado para escribir una nueva línea
Si no se especifica unumero, el archivo que se usará será la
unidad cero (0).
1 # c17_appendwrite.kbs
2 # agregar nuevas líneas al final del archivo
3 # luego mostrarlas en pantalla

258
4
5 open "e2_c17_appendwrite.dat"
6 print "Ingrese una línea en blanco para cerrar el archivo."
7
8 # mueva el puntero al final del archivo y agregue
9 seek size
10 while true
11 input ">", l$
12 if l$ = "" then exit while
13 writeline l$
14 end while
15
16 # mueva puntero al comienzo del archivo y muestre contenido
17 seek 0
18 k=0
19 while not eof()
20 k=k+1
21 print k + " " + readline()
22 end while
23
24 close
25 end
Programa 112: Agregue Líneas al Final de un Archivo
Ingrese una línea en blanco para cerrar el archivo.

>sed sed sed
>vim vim vim
>
1 bar bar bar
2 foo foo foo
3 grap grap grap
4 sed sed sed
5 vim vim vim
Salida 112: Agregue Líneas al Final de un Archivo
La Función Read() y la Sentencia Write

En los primeros tres programas de este capítulo hemos discutido la función readline() y la
sentencia writeline. Existen otras dos sentencias para leer y escribir en un archivo: la
funciٕón read() (leer) y la sentencia write (escribir).
read
read()
read(unumero)
Lee la siguiente palabra o número (token) desde un archivo. Los
tokens están delimitados por espacios, tabs o EOL (el carácter End-
Of-Line). Múltiples delimitadores entre tokens serán tratados como
uno solo.

258
Si no se especifica unumero, el archivo que se usará será la unidad

cero (0).
write expresión
write (expresión)
write unumero,expresión
write (unumero,expresión)
Escribe el string expresión en un archivo. No adiciona EOL u otro
delimitador. Si no se especifica unumero, el archivo que se usará
será la unidad cero (0).
Este programa usa un archivo de texto para ayudarnos a

mantener una lista de números de TE de nuestros amigos.
1 # c17_phonelist.kbs
2 # Agregue un nro. Telefónico a la lista y muéstrelo
3
4 filename$ = "c17_phonelist.txt"
5
6 print "phonelist.kbs - Maneje su directorio telefónico."
7 do
8 input "Agregar, Listar, Salir (a/l/s)? ",action$
9 if left(lower(action$),1) = "a" then call addrecord(filename$)
10 if left(lower(action$),1) = "l" then call listfile(filename$)
11 until left(lower(action$),1) = "s"
12 end
13
14 subroutine listfile(f$)
15 if exists(f$) then
16 # liste nombres y TE números en el archivo
17 open f$
18 print "el archivo tiene " + size + " bytes"
19 while not eof
20 # lea siguiente línea del archivo e imprimala
21 print readline
22 end while
23 close
24 else
25 print "No hay TEs en el archivo. Agregue primero."
26 end if
27 end subroutine
28

258
29 subroutine addrecord(f$)
30 input "Nombre a agregar? ", name$
31 input "Nro. TE a agregar? ", phone$
32 open f$
33 # seek to the end of the file
34 seek size()
35 # we are at end of file - add new line
36 writeline name$ + ", " + phone$
37 close
38 end subroutine
Programa 113: Programa Grande – Lista Telefónica
phonelist.kbs - Maneje su directorio telefónico.

Agregar, Listar, Salir (a/l/s)?l
El archivo tiene 46 bytes
jim, 555-5555
sam, 555-7777
doug, 555-3333
Agregar, Listar, Salir (a/l/s)? a
Nombre a agregar? ang
Nro. TE a agregar? 555-0987
Agregar, Listar, Salir (a/l/s)? l
El archivo tiene 61 bytes
jim, 555-5555
sam, 555-7777
doug, 555-3333
ang, 555-0987
Agregar, Listar, Salir (a/l/s)? q
Salida 113: Programa Grande – Lista Telefónica

258
Ejercicios:
e n i l e t i r w e
s y r o t c e r i d
n e k o t s q h e r
e f m e t s f l e p
p p s s i i i a s c
o e i z l m d e l e
r x e e i l e o r o
e e r t i k s y e f
t k e n z e l j a d
b r e w r i t e d n
close, delimiter, directory, eof, exists, file, open, read, readline, reset,
seek, size, token, write, writeline, words
17.1 Crear un archivo en el directorio donde Ud. guarda sus

programas llamado “números.txt”. Abralo con un editor de
textos (Notepad en Windows o gEdit in LINUX) y tipee una lista
de números decimales. Ponga cada uno en una línea
separada.
Ahora escriba un programa para leer los números del archivo,
una línea por vez. Calcule la suma total de los números y el
promedio. Recuerde usar la función float() para convertir el
string que lee desde el archivo a un valor numérico antes de
sumarlo.
17.2. Cree un archivo en el directorio donde Ud. guarda sus
programas llamado “gente.txt”. Abralo con un editor de textos y
tipee los datos siguientes:
Jose,M,47
Maria,F,23
Roberto,M,17
Juan,M,13
Susana,F,16
Escriba un programa que lea los datos del archivo gente.txt.
Use funciones para el manejo de strings del Capítulo 16 para
cortar cada línea en 3 partes: 1) Nombre, 2) Sexo y 3) Edad.
Cuente el total de las edades, el nro. de personas y el nro. de
mujeres mientras lee el archivo. Una vez que haya leído todos
los registros, muestre el porcentaje de hombres y la edad
promedio de todas las personas.
17.3. Cree un archivo en el directorio donde Ud. guarda sus
programas llamado “tareas.txt”. Abralo con un editor de textos y
tipee los datos siguientes:
Alicia,88,45
Luciano,90,33
Franco,54,29

258
Pablo,57,30
Escriba un programa que lea los datos del archivo tareas.txt y
escriba un nuevo archivo llamado “findegrado.txt” con los
nombres de los estudiantes, una coma, y su nota. Calcule la
nota para cada estudiante en base al promedio de sus
calificaciones. El archivo de salida debería tener algo asi como:
Alicia,66.5
…

258
Capítulo 18: Files – Stacks (Pilas), Queues (Colas)
Capítulo 18: Pilas, Colas, Listas y

Ordenamiento
Este capítulo introduce unos pocos temas avanzados que son usualmente cubiertos en el
Nivel 1 de un curso sobre Ciencias de la Computación, grado Universitario. Los primeros
tres tópicos (Stack, Queue y Linked List) son modos muy comunes de almacenar
información en sistemas computacionales. Específicamente, los últimos dos son algoritmos
para ordenar información.
Stack
Un stack (pila de cosas, de datos) es una de las estructuras de datos más comunes
usadas por los programadores para muy diversas tareas. Un stack trabaja como una “pila
de descarte”. Cuando se agrega una pieza de datos a un stack (esta acción se llama “push”
en inglés), esta se agrega en la parte superior del mismo y de ese modo los datos van
“apilándose” unos sobre otros. Cuando se saca una pieza del stack, se toma siempre la de
arriba (proceso llamado “pop” en inglés) quedando disponible la que estaba
inmediatamente debajo. La Ilustración 31 siguiente muestra gráficamente el proceso.
Ilustración 31: Qué es un Stack

El funcionamiento de un stack se describe como “último-en-entrar, primero-en-salir” o
LIFO por sus siglas en ingles (Last-In, First-Out). El dato más recientemente ingresado será
el próximo ítem a salir.
El Programa 114 implementa un stack usando un array y un puntero al ítem agregado más
recientemente. En la subrutina “push” verá la lógica que re-dimensiona el array para estar
seguro que hay suficiente lugar disponible en el stack para virtualmente agregar cualquier
número de ítems.
1 # c18_stack.kbs
2 # implementando un stack usando un array
3
4 dim stack(1) # array para contener el stack con tamaño inicial
5 nstack = 0 # numero de elementos en el stack
6 global stack, nstack
7

258
8 call push(1)
9 call push(2)
10 call push(3)
11 call push(4)
12 call push(5)
13 while not vacio()
14 print pop()
15 end while
16 end
17
18 function vacio()
19 # devuelva true si el comienzo está vacío
20 return nstack=0
21 end function
22
23 function pop()
24 # tome el primer numero del stack y devuelvalo
25 # o imprima un mensaje y devuelva -1
26 if nstack = 0 then
27 print "stack vacio"
28 return -1
29 end if
30 nstack = nstack - 1
31 value = stack[nstack]
32 return value
33 end function
34
35 subroutine push(valor)
36 # ponga el numero en la variable “valor” sobre el stack
37 # agrande el stack si esta lleno
38 if nstack = stack[?] then redim stack(stack[?] + 5)
39 stack[nstack] = valor
40 nstack = nstack + 1
41 end subroutine
Programa 114: Stack
5
4
3
2
1
Salida 114: Stack

258
global variable
global variable, variable...
Global le dice a BASIC-256 que las variables a continuación
podrán ser vistas en todo el programa (tanto dentro como fuera de
funciones o subrutinas). El uso de variables “globales” no es
usualmente recomendado, excepto cuando hay real necesidad de
compartir valores o arrays. Aún así, su uso debe ser minimizado.
Queue
El queue (cola, pronunciado Qiu en inglés) es otro tipo de estructura de datos muy común.
El queue, en su forma más simple, es como la cola en el comedor de la escuela: El primero
en la línea es el primero en salir a comer. La ilustración 32 muestra el diagrama de bloques
de un queue (compárelo con el de stack arriba). Este tipo de estructura es descripto como
“primero que entra, primero que sale” o FIFO (en inglés, First-In, First-Out).
Ilustración 32: Que es un “Queue”
El término enqueue (en inglés pronunciado in-qiu) y dequeue (pronounciado dee-q) son
los nombres usados para describir las acciones de agregar un nuevo ítem al final de la fila
(tail o cola) o remover un ítem del frente de la fila (head o cabeza).
El Programa 115 usa un array y dos punteros que siguen y mantienen la pista de la cabeza
(head) y la cola (tail) de la fila.
1 # c18_queue.kbs
2 # implementando un queue usando un array
3 global queuesize, queue, queuetail, queuehead, inqueue
4 call createqueue(5)
5
6 call enqueue(1)
7 call enqueue(2)
8
9 print dequeue()

258
10 print
11
12 call enqueue(3)
13 call enqueue(4)
14
15 print dequeue()
16 print dequeue()
17 print
18
19 call enqueue(5)
20 call enqueue(6)
21 call enqueue(7)
22
23 # vacie el queue
24 while inqueue > 0
25 print dequeue()
26 end while
27 end
28
30 subroutine createqueue(z)
31 # máximo nro. de entradas en la queue a cualquier tiempo
32 queuesize = z
33 # array para contener la queue con valor inicial
34 dim queue(z)
35 # ubicación en la queue de la próxima entrada nueva
36 queuetail = 0
37 # ubicación en la queue de la próxima entrada a ser devuelta (servida)
38 queuehead = 0
39 # numero de entradas en la queue
40 inqueue = 0
41 end subroutine
42
43 function dequeue()
44 if inqueue = 0 then
45 print "queue is empty"
46 value = -1
47 else
48 value = queue[queuehead]
49 inqueue--
50 queuehead++
51 if queuehead = queuesize then queuehead = 0
52 end if
53 return value
54 end function
55
56 subroutine enqueue(value)
57 if inqueue = queuesize then

258
58 print "queue is full"

59 else
60 queue[queuetail] = value
61 inqueue++
62 queuetail++
63 if queuetail = queuesize then queuetail = 0
64 end if
65 end subroutine
Programa 115: Queue
2
3
4
5
6
7
Sample Output 115: Queue
Linked List
En la mayoría de los libros, la discusión del material de este capítulo comienza con linked
list (lista encadenada, enlazada). Pero, debido a que BASIC-256 maneja la memoria de
manera diferente que muchos otros lenguajes de programación, esta discusión fue
postergada hasta después de haber introducidolos conceptos de stack y queues.
Una linked list es una secuencia de nodos que contienen datos y un puntero o índice al
próximo nodo de la lista. O sea que, además de los nodos con información ahora también
necesitamos un puntero (pointer) que apunte al primer nodo. Llamamos al primer nodo la
“cabeza” (head). Analice la Ilustración 33 y verá como cada nodo apunta a otro.
Ilustración 33: Linked List (Lista Encadenada)
Una ventaja de una linked list sobre un array es la facilidad que ofrece para insertar o
borrar un nodo. Para borrar un nodo, todo lo que necesita es cambiar el puntero del nodo
anterior (Ilustración 34) y liberar el nodo descartado de modo que pueda ser reusado.

258
Ilustración 34: Borrando un ítem (o nodo) de una Linked List
Insertar un nuevo nodo es tan simple como crear un nuevo nodo: apuntando el nuevo nodo
al nodo precedente a donde se quiere insertar y modificando el pointer del nodo precedente
para apuntar al nodo que se está insertando. La Ilustración 35 muestra el proceso de
insertar un nuevo nodo en la segunda posición de la lista.
Ilustración 35: Insertando un nuevo ítem (o nodo) en una Linked List
Las linked list son una de las estructuras de datos más simples. En el lenguaje BASIC
(debido a no ser compilado, sino interpretado) no es posible alojar memoria como en otros
lenguajes de programación, de modo que si se quiere usar linked list, es necesario simular
su comportamiento mediante el uso de arrays.
En el Programa 116 usamos el array data$ para guardar el texto en la lista, el array
nextitem contiene el índice al próximo nodo y el array freeitem contiene una pila (stack) de
índices de arrays libres (no usados).
1 # c18_linkedlist.kbs
2 # crer una “linked list” usando arrays
3
4 # data$ es array conteniendo los strings de datos en la lista
5 # nextitem es un array con punteros al próximo ítem de datos
6 # si nextitem es -2:esta libre o si -1:es el final
7
8 global head, data$, nextitem
9 call initialize(6)
10
11 # lista de 3 personas
12 call append("Bob")
13 call append("Sue")
14 call append("Guido")
15 call displaylist()
16 call displayarrays()

258
17 call wait()
18
19 print "eliminar persona 2"
20 call delete(2)
23 call wait()
24
25 print "insertar Mary al frente de la lista (#1)"
26 call insert("Mary",1)
29 call wait()
30
31 print "insertar John en posicion 2"
32 call insert("John",2)
35 call wait()
36
37 print "eliminar persona 1"
38 call delete(1)
41 call wait()
42 end
43
44 subroutine wait()
45 input "Intro para continuar> ",foo$
46 print
47 end subroutine
48
49 subroutine initialize(n)
50 head = -1 # comienzo de lista (-1 pointer a ningún lado)
51 dim data$(n)
52 dim nextitem(n)
53 # inicialice items como libres
54 for t = 0 to data$[?]-1
55 call freeitem(t)
56 next t
57 end subroutine
58
59 subroutine freeitem(i)
60 # elemento libre en el array, en posicion i
61 data$[i] = ""
62 nextitem[i] = -2
63 end subroutine

258
64
65 function findfree()
66 # encuentre un ítem libre (un item apuntando a -2)
67 for t = 0 to data$[?]-1
68 if nextitem[t] = -2 then return t
69 next t
70 print 'no hay elementos libres para alojar'
71 end
72 end function
73
74 function createitem(text$)
75 # crear un nuevo ítem en la lista
76 # y devolver índice a la nueva ubicacion
77 i = findfree()
78 data$[i] = text$
79 nextitem[i] = -1
80 return i
81 end function
82
83 subroutine displaylist()
84 # muestre la lista siguiendo la linked list
85 print "list..."
86 k=0
87 i = head
88 do
89 k=k+1
90 print k + " ";
91 print data$[i]
92 i = nextitem[i]
93 until i = -1
94 end subroutine
95
96 subroutine displayarrays()
97 # muestre datos realmente guardados y como
98 print "arrays..."
99 for i = 0 to data$[?]-1
100 print i + " " + data$[i] + " >" + nextitem[i] ;
101 if head = i then print " <<head";
102 print
103 next i
104 end subroutine
105
106 subroutine insert(text$, n)
107 # inserte text$ en la posición n
108 index = createitem(text$)
109 if n = 1 then
110 nextitem[index] = head

258
111 head = index

112 else
113 k=2
114 i = head
115 while i <> -1 and k <> n
116 k=k+1
117 i = nextitem[i]
118 end while
119 if i <> -1 then
120 nextitem[index] = nextitem[i]
121 nextitem[i] = index
122 else
123 print "No es posible insertar mas allá de la lista"
124 end if
125 end if
126 end subroutine
127
128 subroutine delete(n)
129 # elimine elemento n de la linked list
130 if n = 1 then
131 # elimine head – haga el segundo elemento la nueva head
132 index = head
133 head = nextitem[index]
134 call freeitem(index)
135 else
136 k=2
137 i = head
138 while i <> -1 and k <> n
139 k=k+1
140 i = nextitem[i]
141 end while
142 if i <> -1 then
143 index = nextitem[i]
144 nextitem[i] = nextitem[nextitem[i]]
145 call freeitem(index)
146 else
147 print "
123 print "No es posible borrar mas allá del final de la lista "
148 end if
159 end if
150 end subroutine
151
152 subroutine append(text$)
153 # apendice text$ al final de la linked list
154 index = createitem(text$)
155 if head = -1 then
156 # no hay cabeza aun – haga al ítem cabeza

258
157 head = index

158 else
159 # muévase al final de la lista y agregue un nuevo item
160 i = head
161 while nextitem[i] <> -1
162 i = nextitem[i]
163 end while
164 nextitem[i] = index
165 endif
166 end subroutine
Programa 116: Linked List
Re-escriba el Programa 116 para implementar un stack y un queue

usando una linked list.

258
Ordenamiento Lento e Ineficiente – Ordenamiento

Burbuja
El Ordenamiento Burbuja (Bubble Sort) es probablemente el peor algoritmo jamás
inventado para ordenar una lista de valores. Es muy lento e ineficiente excepto para
pequeños conjuntos de ítems. Es un clásico ejemplo de un algoritmo horrible.
La única cosa positiva que puede decirse de él es que es simple de explicar e implementar.
La Ilustración 36 muestra el diagrama de flujo para el algoritmo. El ordenamiento burbuja
pasa a través del array, una y otra vez, barriendo el orden de ítems adyacentes hasta que
el ordenamiento está completo.

258
Ilustración 36: Ordenamiento Burbuja – Diagrama de Flujo
1 # c18_bubblesortf.kbs
2 # implementando un ordenamiento simple
4 # El ordenamiento burbuja es uno de los algoritmos MAS
5 # LENTOS para ordenar, pero el mas fácil de implementar
6 # y entender
7 # El algoritmo para el ordenamiento burbuja es:
8 # 1. Pase a través del array barriendo valores adyacentes
9 # de modo que el menor valor quede primero.
10 # 2. Ejecute el paso 1 una y otra vez hasta que no haya

258
11 # reacomodamientos (el array está ordenado)

12 #
13 dim d(20)
14
15 # llene el array con números no ordenados
16 for i = 0 to d[?]-1
17 d[i] = int(rand * 1000)
18 next i
19
20 print "*** NO-Ordenados ***"
21 call displayarray(ref(d))
22 call bubblesort(ref(d))
23
24 print "*** Ordenados ***"
26 end
27
28 subroutine displayarray(ref(array))
29 # imprima los valores del array
30 for i = 0 to array[?]-1
31 print array[i] + " ";
32 next i
33 print
34 end subroutine
35
36 subroutine bubblesort(ref(array))
37 do
38 sorted = true
39 for i = 0 to array[?] - 2
40 if array[i] > array[i+1] then
41 sorted = false
42 temp = array[i+1]
43 array[i+1] = array[i]
44 array[i] = temp
45 end if
46 next i
47 until sorted
48 end subroutine
Programa 117: Ordenamiento Burbuja

*** NO-Ordenados ***
878 95 746 345 750 232 355 472 649 678 758 424 653 698 482 154 91 69 895
414
*** Ordenados ***
69 91 95 154 232 345 355 414 424 472 482 649 653 678 698 746 750 758 878
895
Salida 117: Ordenamiento Burbuja

258
Un Ordenamiento Mejor – Ordenamiento por

Inserción
El Ordenamiento por Inserción (Insertion sort) es otro algoritmo para ordenar una lista
de ítems. Es usualmente más rápido que el Ordenamiento Burbuja; en el peor caso puede
tardar lo mismo.
El Ordenamiento por Inserción toma su nombre de cómo trabaja. El ordenamiento se hace
a través de los elementos del array (índice=1 hasta longitud=-1) e inserta los valores en la
ubicación correcta en los elementos del array anterior. La Ilustración 37 muestra, paso-a-
paso, su funcionamiento.
Ilustración 37: Ordenamiento por Inserción – Paso-a-Paso.

258
1 # c18_insertionsort.kbs
2 # implementando un ordenamiento eficiente
3
4 # El Ordenamiento por Insercion hace un loop a través de
5 # los items comenzando en el segundo elemento.
6
7 # toma el elemento corriente y lo inserta en la posicion
8 # ordenada correcta en los elementos previamente ordenados
9
10 # moviéndose desde atrás de la ubicación corriente y
11 # corriendo los elementos con un valor mayor hacia
12 # adelante para hacer lugar al corriente valor en el
13 # lugar correcto (en un array parcialmente ordenado).
14
15 dim d(20)
16
17 # llene el array con números desordenados
18 for i = 0 to d[?]-1
19 d[i] = int(rand * 1000)
20 next i
21
22 print "*** Desordenado ***"
24
25 call insertionsort(ref(d))
26
27 print "*** Ordenado ***"
29 end
30
31 subroutine displayarray(ref(a))
32 # imprima los valores del array
33 for i = 0 to a[?]-1
34 print a[i] + " ";
35 next i
36 print
37 end subroutine
38
39 subroutine insertionsort(ref(a))
40 for i = 1 to a[?] - 1
41 currentvalue = a[i]
42 j=i-1
43 done = false
44 do
45 if a[j] > currentvalue then
46 a[j+1] = a[j]
47 j=j-1

258
48 if j < 0 then done = true

49 else
50 done = true
51 endif
52 until done
53 a[j+1] = currentvalue
54 next i
55 end subroutine
Programa 118: Ordenamiento por Inserción
*** Desordenado ***

913 401 178 844 574 289 583 806 332 835 439 52 140 802 365 972 898 737
297 65
*** Ordenado ***
52 65 140 178 289 297 332 365 401 439 574 583 737 802 806 835 844 898
913 972
Salida 118: Ordenamiento por Inserción

258
Ejercicios:
k f i f o e q i q h m t o
n o f i l u x q q y e r b
i h p v e o d t q y u o d
l m p u f d s r c t e s e
v o e k x v m o i s u n u
p g f c i l e s a i q o e
q l f a u h m e l l n i u
v o i t q s o l l i e t q
i b c s z u r b o d t r e
z a i v e p y b c s z e d
d l e y d j h u a r o s p
z y n g o v c b t y l n q
m x t s n y i t e i q i b
allocate, bubblesort, dequeue, efficient, enqueue, fifo, global,
insertionsort, lifo, link, list, memory, node, pop, push, queue, stack
18.1 Re-escriba la función “Bubble Sort” para ordenar “strings”, no

números. Agregue un segundo argumento true/false para hacer
que el ordenamiento sea sensible/insensible a mayúsculas/
minúsculas.
18.2 Implemente el “Ordenamiento por Inserción usando funciones
“linked list” de modo que los ítems sean movidos lógicamente,
no físicamente.
18.3 Desarrolle una función para hacer “Ordenamiento por
Combinación (Merge Sort en ingles) (ver http://en.wikipedia.org/
wiki/Merge_sort) sobre un array de números. Cree arrays de
números aleatorios de diferente longitud y ordénelos usando
Ordenamiento Burbuja, por Inserción y por el nuevo método por
Combinación. ¿Cuál es el más rápido?

258
Capítulo 19: Atrapando Errores durante Ejecución
Capítulo 19: Atrapando Errores en

Tiempo de Ejecución
Mientras ha trabajado con los programas ejemplos y ha creado sus propios programas,
debe haber notado errores que ocurren cuando el programa está corriendo. Estos errores
son llamados “errores en tiempo de ejecución” (runtime errors). BASIC-256 incluye un
grupo de comandos especiales que le permitirán a su programa recuperarse o manejar
estos errores.
Muchos de estos errores ocurren cuando se quiere ejecutar una operación matemática
inválida o cuando se pretende usar una variable que no está asignada. El Programa 119
trabaja bien la mayoría del tiempo, pero dará un error y dejará de correr si el denominador
es cero (recuerde, una división por cero tiende a infinito…).
1 # c19_divider.kbs
2 # división simple
3
4 print "Divida dos numeros"
5 while true
6 input "numerador? ", n
7 input "denominador? ", d
8 q = n/d
9 print "El cociente es " + q
10 end while
Programa 119: División simple que puede dar Error en Tiempo de Ejecución.
Divida dos numeros

numerador? 6
denominador? 9
El cociente es 0.6666667
numerador? 5
denominador? 2
El cociente es 2.5
numerador? 9
denominador? 0
ERROR on line 8: Division by zero.
Salida 119: División simple que puede dar Error en Tiempo de Ejecución.
Pruebe (try) una declaración y Atrape (catch) un

Error
El bloque try/catch/end try (pruebe/atrape/fin de prueba) está estructurado de modo tal
que si un ocurre un error en tiempo de ejecución “atrapable” en el bloque de código
ubicado entre las sentencias try and catch, el código inmediatamente a continuación de
catch hasta end try será ejecutado. El siguiente ejemplo muestra el programa que divide
anterior, pero ahora atrapando el error de división por cero.
1 # c19_trycatch.kbs
2 # simple try catch

258
3
4 print "Dividir dos Números"
5 while true
6 input "numerador? ", n
7 input "denominador? ", d
8 try
9 q = n/d
10 print "El cociente es " + q
11 catch
12 print "No es posible dividir " + n + " por " + d
13 end try
14 end while
Programa 120: Simple Programa que divide y Atrapa error
Dividir dos Números

numerador? 5
denominador? 6
numerador? 99
denominador? 0
No es posible dividir 99 por 0
numerador? 4
denominador? 3
Numerador ?
Salida 120: Simple Programa que divide y Atrapa error
try
declaraciones(s) a probar
catch
declaraciones a ejecutar si ocurre un error
end try
Atrapar errores cuando no tiene significado puede causar problemas y enmascarar u

ocultar otros problemas en su programa. Esta técnica de atrapar errores debe ser usada
únicamente cuando sea claramente necesaria, en caso contrario se debe evitar.
Encontrando cuál Error

Algunas veces, conocer que un error ha ocurrido no es suficiente. Hay funciones que
devuelven el número de error (lasterror), la línea de código en donde ocurrió
(lasterrorline), un mensaje de texto describiendo brevemente el error (lasterrormessage)
y/o mensajes de error adicionales específicos del comando.
1 # c19_trap.kbs
2 # atrapado de error con informe
3

258
4 try
5 print "z = " + z
6 catch
7 print "Error Atrapado"
8 print " Error = " + lasterror
9 print " En línea = " + lasterrorline
10 print " Mensaje = " + lasterrormessage
11 end try
12 print "Programa aún corriendo después del error."
Programa 121: Try/Catch – Con Mensajes
Error Atrapado
Error = 12
En línea = 4
Mensaje = Unknown variable z  (variable z desconocida)
Programa aún corriendo después del error.
Salida 121: Try/Catch – Con Mensajes
lasterror or lasterror()
lasterrorline or lasterrorline()
lasterrormessage or lasterrormessage()
lasterrorextra or lasterrorextra()
Las cuatro funciones lasterror devolverán información sobre el
último error atrapado. Estos valores permanecerán sin cambios hasta
que eventualmente otro error sea encontrado.
Devuelve el número del último error

atrapado. Si no han sido atrapados errores,
lasterror esta función devolverá cero. Ver Apéndice G:
Errores y Advertencias para una lista
completa de errores “atrapables”.
Devuelve el número de línea del programa
lasterrorline
en donde el último error fue atrapado
Devuelve un string describiendo el último
lasterrormessage
error.
Devuelve un string con información adicional
sobre el error. Para la mayoría de los errores
lasterrorextra
esta función no devolverá ninguna
información.
Errores de Conversión de Tipo

BASIC-256, por defecto, retornará cero (0) cuando sea incapaz de convertir un string a un
número. Ud. ya lo debe haber visto en el Capítulo 5 usando la sentencia input. Lo mismo
ocurrirá cuando las funciones int() y float() convierten un string a un número.
Opcionalmente, Ud. puede decirle a BASIC-256 que muestre una advertencia atrapable o

258
arroje un error que detenga la ejecución de su programa. Esto puede hacerse

seleccionando la opción en el diálogo “Preferences”, en la pestaña User (ver ilistración
siguiente).
Ilustración 38: Preferences – Conversión de Tipo: Ignore/Advierta/Error
1 # c19_inputnumber.kbs
2
3 input "Ingrese un numero> ",a
4 print a
Programa 122: Error de Conversión de Tipo
Cuando el programa se corre con la opción “ignorados”, su salida será:

Ingrese un numero> foo
0
Salida 122: Error de Conversión de Tipo - Opción Ignorar
Cuando el programa se corre con la opción “advertencias” (warn), su salida será la

mostrada a continuación. Note que el programa continúa corriendo pero muestra un
mensaje o advertencia. La sentencias try/catch/end try capturan la advertencia de modo
que puede mostrar un mensaje personalizado o efectuar algún procesamiento especial.
Ingrese un numero> sdfsdf
WARNING on line 3: Unable to convert string to number, zero used.
0 (No es posible convertir el string a un número, se usa cero)
Salida 122: Error de Conversión de Tipo – Opción Advertencia (Warn)
En el tercer caso, cuando el programa se corre con la opción “error” habilitada, cuando
ocurre una conversión de tipo inválida se muestra un error y la ejecución del programa se
detiene. Este error es atrapable con try/catch/end try.
Ingrese un numero> abcd
ERROR on line 3: Unable to convert string to number.
(No es posible convertir el string a un número)
Salida 122: Error de Conversión de Tipo – Opción Error
Creando una Subrutina para Atrapar Errores

258
Hay una segunda manera de atrapar errores en tiempo de ejecución: usando una
subrutina. Cuando un error de este tipo ocurre, el programa llamará a la rutina
especificada. Cuando la subrutina devuelva el control al programa, este continuará en la
línea siguiente a la de donde se hizo el llamado a la subrutina.
En el Programa 123 siguiente vemos que el programa llama a la subrutina cuando trata de
leer el valor de z (una variable no definida). Si intentamos correr el mismo programa con la
línea 1 comentada o removida, el programa terminará inmediatamente después de que
ocurra el error.
1 # c19_simpletrap.kbs
2 # atrapando error con subrutina
3
4 onerror atrap # se define subrutina a llamar
5 print "z = " + z
6 print "Aún corriendo después del error"
7 end
8
9 subroutine atrap()
10 print "Se atrapó un error."
11 end subroutine
Programa 123: Captura de Error Simple con Subrutina
Se atrapó un error.
z=0
Aún corriendo después del error
Salida 123: Captura de Error Simple con Subrutina
onerror nombresub
Crea una trampa de errores que saltará automáticamente a la
subrutina nombresub cuando ocurra un error.
Ud. puede usar las funciones lasterror, lasterrorline, lasterrormessage, y lasterrorextra

dentro de su subrutina “trampa” para mostrar un mensaje o efectuar cualquier
procesamiento que desee. Adicionalmente, Ud. puede no definir una trampa onerror
dentro de un try/catch.
Desactivando la Rutina para Atrapar Errores

A veces, en un programa podemos querer atrapar errores en una parte pero no en otras. La
sentencia offerror desconecta el atrapado de errores. Esto causa que cualquier error
encontrado detenga el programa.
1 # c19_trapoff.kbs
2 # Atrapado de errores con informe.
3
4 onerror errortrap
5 print "z = " + z

258
6 print "Aún corriendo después del primer error"

7
8 offerror
9 print "z = " + z
10 print " Aún corriendo después del segundo error"
11 end
12
13 subroutine errortrap()
14 print "Atrapado de Errores - Activado"
15 end subroutine
Programa 124: Deshabilitando la Captura de Errores
Atrapado de Errores - Activado

z=0
Aún corriendo después del primer error
ERROR on line 6: Unknown variable
Sample Output 124: Deshabilitando la Captura de Errores

258
Ejercicios:
e u q r l w f e p j x s p w n c
p g u b i r r h f j w w w o c p
b l a s t e r r o r e x t r a p
q e e s v w j l p g a m w l o q
t a n n s r q o i i t m r a n o
r f x i d e o u c a t c h t e y
y h z r l t m r f k o s k v r i
q o i b m r r r r s i e f b r f
x l f x o z o y o e l b b i o a
y k m f z o r r q r t s k e r a
z a h l e i r y r p r s f g y m
i l i l n r e j f e p e a n r l
a q c m t q r k o g t l t l u u
r e u k z b b o u f l s g s t j
m s u h l a r x r m v w a q a l
u b z r l h a l k p a r t l n l
catch, endtry, error, lasterror, lasterrorextra, lasterrorline,
lasterrormessage, offerror, onerror, trap, try
19.1. Ajuste la preferencia “manejo de errores de conversión de tipo

en tiempo de ejecución” (runtime handling of bad type
conversión) a “advertencia” (warn) o “error” (error) y escriba un
programa simple que le requiera al usuario ingresar un número.
Si el usuario entra algo que no es un número, atrape la
Advertencia/Error y pregunte nuevamente.
Ingrese un numero > gdf2345
Entrada incorrecta. Intente nuevamente.
Ingrese un numero > fdg545
Ingrese un numero > 43fdgdf
enter a number> 22 You entered 22
19.2. En base a la lógica desarrollada para el Problema 19.1, escriba
una función que toma un argumento (el mensaje a mostrar),
repetidamente requiere al usuario por un número hasta que
efectivamente ingrese uno, y devuelva la entrada numérica
ingresada.
19.3. Escriba un programa que ocasione muchos errores y atrápelos.
Asegúrese de revisar el Apéndice G: Errores y Advertencias
(Errors and Warnings) para una lista completa.

258
Capítulo 20: Programación de Bases de Datos
Capítulo 20: Programación de Bases de

Datos
Este capítulo le mostrará cómo BASIC-256 puede conectarse a una base de datos
relacional simple y utilizarla para guardar y recuperar información.
Qué es una Base de Datos (BD)

Una Base de Datos es simplemente una colección organizada de números, strings y otros
tipos de información. El tipo más común de Base de Datos es la del tipo “Relacional”. Estas
tienen cuatro elementos principales: tablas, filas, columnas y relaciones (ver Tabla 9)
Una Tabla consiste en un número predefinido de columnas y cualquier
Tabla número de filas, con información acerca del sujeto u objeto específico.
También conocida como una relación.
Filas También llamada una “tupla”
Columnas Esto puede también ser referido como un atributo.
Una referencia de una clave de una tabla como una columna de otra
Relaciones
tabla. Esto crea una conexión entre tablas.
Table 9: Componentes Principales de una BD Relacional.
El Lenguaje SQL
Hoy en día, la mayoría de las bases de datos relacionales usan el lenguaje SQL para
implementar la manipulación de datos. SQL es el acrónimo de Structured Query Language.
El lenguaje SQL original fue desarrollado por IBM en 1970. Es un lenguaje muy poderoso y
ha sido adoptado durante todos estos años como un estándar para programación de BD.
En la actualidad hay diversas implementaciones con pequeñas diferencias entre ellas.
BASIC-256 usa SQLite como “motor” de Base de Datos. Puede encontrar información
detallada sobre SQLite y su sintaxis en su sitio Web: http://www.sqlite.org.
Creando e Ingresando Datos a la Base de Datos

La biblioteca SQLite no requiere la instalación de un Server de BD o la implementación de
algún otro sistema complejo. LA BD y todas sus partes son guardadas como un simple
archivo en su computadora. Este archivo puede ser copiado a otra computadora y aún
usado sin inconvenientes.

258
Ilustración 39: Diagrama de Relaciones entre Entidades de la BD

El primer programa (Programa 125: Crear una BD) crea filas y tablas de una nueva BD de
prueba. Las tablas están representadas por el Diagrama de Relaciones entre Entidades
(Entity Relationship Diagram o ERD en ingles) como se muestra en la Ilustración 39.
1 # c20_createpetsdb.kbs
2 # crear la BD "mascotas.sqlite"
3
4 # borre BD vieja si existe
5 file$ = "mascotas.sqlite3"
6 if exists(file$) then kill(file$)
7
8 # abrir archivo de BD
9 # owner=dueño, pet=mascota, petname=nombre de la mascota
10 dbopen file$
11 stmt$ = "CREATE TABLE owner (owner_id INTEGER,
ownername TEXT, phonenumber TEXT, PRIMARY KEY
(owner_id));"
12 print stmt$
13 dbexecute stmt$
14
15 stmt$ = "CREATE TABLE pet (pet_id INTEGER, owner_id
INTEGER, petname TEXT, type TEXT, PRIMARY KEY
(pet_id), FOREIGN KEY (owner_id) REFERENCES owner
(owner_id));"
16 print stmt$
17 dbexecute stmt$
18
19 dbclose
20 print file$ + " creada OK."
21 end
Programa 125: Crear una DB
CREATE TABLE owner (owner_id INTEGER, ownername TEXT, phonenumber

TEXT, PRIMARY KEY
(owner_id));

258
CREATE TABLE pet (pet_id INTEGER, owner_id

INTEGER, petname TEXT, type TEXT, PRIMARY KEY (pet_id), FOREIGN KEY
(owner_id) REFERENCES owner (owner_id));
mascotas.sqlite3 creada OK.
Salida 125: Crear una DB
Aquí Ud. ha visto tres nuevas sentencias de BD: dbopen: abre una archivo de BD o lo crea
si no existe, dbexecute: ejecuta un comando SQL en la BD abierta, y dbclose: cierra el
archivo de BD abierto.
dbopen filename
Abre un archivo de BD SQLite de nombre filename. Si la BD no
existe, entonces crea una nueva vacía.
dbexecute sqlsentencia
Ejecuta la sentencia SQLite sqlsentencia sobre el archivo BD
SQLite abierto. No devuelve ningún valor, pero un error en tiempo de
ejecución atrapable ocurrirá si hubiera cualquier problema al ejecutar la
sentencia sobre la BD.
dbclose
Cierra el archivo BD SQlite corriente abierto. Este comando asegura
que todos los datos fueron escritos en el archivo BD.
Estas mismas tres sentencias pueden ser usadas para ejecutar otros comandos SQLite. El
comando INSERT INTO en el Programa 126 agrega nuevas filas de datos a las tablas. El
comando UPDATE (Programa 127) cambiará la información de una fila existente.
1 # c20_addpetsdb.kbs
2 # agregue filas a la BD
3 file$ = "mascotas.sqlite3"
4 dbopen file$
5
6 call addowner(1, "Jim", "555-3434")
7 call addpet(1, 1, "Spot", "Cat")
8 call addpet(2, 1, "Fred", "Cat")
9 call addpet(3, 1, "Elvis", "Cat")
10
11 call addowner(2, "Sue", "555-8764")
12 call addpet(4, 2, "Alfred", "Dog")
13 call addpet(5, 2, "Fido", "Cat")
14

258
15 call addowner(3, "Amy", "555-4321")

16 call addpet(6, 3, "Bones", "Dog")
17
18 call addowner(4, "Dee", "555-9659")
19 call addpet(7, 4, "Sam", "Goat")
20 dbclose
21 end
22
23 subroutine addowner(owner_id, ownername$, phonenumber$)
24 stmt$ = "INSERT INTO owner (owner_id, ownername,
phonenumber) VALUES (" + owner_id + "," + chr(34) +
ownername$ + chr(34) + "," + chr(34) + phonenumber$ +
chr(34) + ");"
25 print stmt$
26 try
27 dbexecute stmt$
28 catch
29 print "No se puede agregar dueño (owner) " + owner_id + " " +
lasterrorextra
30 end try
31 end subroutine
32
33 subroutine addpet(pet_id, owner_id, petname$, type$)
34 stmt$ = "INSERT INTO pet (pet_id, owner_id,
petname, type) VALUES (" + pet_id + "," + owner_id +
"," + chr(34) + petname$ + chr(34) + "," + chr(34) +
type$ + chr(34) + ");"
35 print stmt$
36 try
37 dbexecute stmt$
38 catch
39 print "No se puede agregar mascota " + pet_id + " " + lasterrorextra
40 end try
41 endsubroutine
Programa 126: Inserta Filas en una BD
INSERT INTO owner (owner_id, ownername, phonenumber) VALUES

(1,"Jim","555-3434");
INSERT INTO pet (pet_id, owner_id, petname, type) VALUES (1,1,"Spot","Cat");
INSERT INTO pet (pet_id, owner_id, petname, type) VALUES (2,1,"Fred","Cat");
INSERT INTO pet (pet_id, owner_id, petname, type) VALUES (3,1,"Elvis","Cat");
(2,"Sue","555-8764");
INSERT INTO pet (pet_id, owner_id, petname, type) VALUES (4,2,"Alfred","Dog");
INSERT INTO pet (pet_id, owner_id, petname, type) VALUES (5,2,"Fido","Cat");
(3,"Amy","555-4321");

258
INSERT INTO pet (pet_id, owner_id, petname, type) VALUES (6,3,"Bones","Dog");

(4,"Dee","555-9659");
INSERT INTO pet (pet_id, owner_id, petname, type) VALUES 7,4,"Sam","Goat");
Salida 126: Inserta Filas en una BD
1 # c20_updatepetsdb.kbs
2 # actualice una fila de la BD
3 dbopen "mascotas.sqlite3"
4
5 # cree y cargue datos
6 s$ = "UPDATE owner SET phonenumber = " + chr(34) +
"555-5555" + chr(34) + " where owner_id = 1;"
7 print s$
8 dbexecute s$
9 dbclose
Programa 127: Actualizar una Fila en una BD
UPDATE owner SET phonenumber = "555-5555" where owner_id = 1;

Sample Output 127: Actualizar una Fila en una BD
Recuperando Información desde una BD

Hasta ahora hemos visto como abrir, cerrar y ejecutar comandos SQLite que no devuelven
ningún valor. Una BD será bastante inútil si no podemos extraer información de ella.
El comando SELECT en lenguaje SQL nos permite extraer los datos que deseamos.
Después de que SELECT es ejecutado, se crea un conjunto de registros (record set) que
contiene las filas y las columnas de datos que fueron extraídos de la BD. El Programa 128
muestra tres comandos SELECT diferentes y cómo los datos son leídos en su programa
BASIC-256.
1 # c20_showpetsdb.kbs
2 # muestre datos de la BD pets
4 dbopen "mascotas.sqlite3"
5
6 # muestre dueños y sus Nros de TE
7 print "Dueños y Numeros de Teléfonos"
8 dbopenset "SELECT ownername, phonenumber FROM owner ORDER BY
ownername;"
9 while dbrow()
10 print dbstring(0) + " " + dbstring(1)
11 end while
12 dbcloseset
13
14 print
15
16 # muestre dueños y sus mascotas
17 print "Dueños con Mascotas"
18 dbopenset "SELECT owner.ownername, pet.pet_id, pet.petname, pet.type

258
FROM owner JOIN pet ON pet.owner_id = owner.owner_id ORDER BY ownername,

petname;"
19 while dbrow()
20 print dbstring(0) + " " + dbint(1) + " " + dbstring(2) + " " + dbstring(3)
21 end while
22 dbcloseset
23 print
24
25 # muestre el numero promedio de mascotas
26 print "Número promedio de Mascotas"
27 dbopenset "SELECT AVG(c) FROM (SELECT COUNT(*) AS c FROM owner
JOIN pet ON pet.owner_id = owner.owner_id GROUP BY owner.owner_id) AS
numpets;"
28 while dbrow()
29 print dbfloat(0)
30 end while
31 dbcloseset
32
33 # envuelva todo
34 dbclose
Programa 128: Seleccionando conjuntos de datos de una BD.
Dueños y Numeros de Teléfonos
Amy 555-9932
Dee 555-4433
Jim 555-5555
Sue 555-8764
Dueños con Mascotas
Amy 6 Bones Dog
Dee 7 Sam Goat
Jim 3 Elvis Cat
Jim 2 Fred Cat
Jim 1 Spot Cat
Sue 4 Alfred Cat
Sue 5 Fido Dog
Número promedio de Mascotas
1.75
Salida 128: Seleccionando conjuntos de datos de una BD.
dbopenset sqlstatement
Ejecuta un comando SELECT sobre la BD y crea un “conjunto de
registros” (“record set”) para permitir al programa leer el resultado. El
conjunto de registros puede contener 0 o más filas como fueron
extraídos por SELECT.

258
dbrow ó dbrow ()
Función para avanzar el resultado de la última dbopenset a la
próxima fila. Devuelve false si estamos al final de los datos
seleccionados.
Después de un comando dbopenset y antes de que pueda leer
ningún dato, Ud. debe avanzar a la primera fila usando dbrow,

258
dbint (column)
dbfloat (column)
dbstring (column)
Estas funciones devolverán datos de la corriente fila del conjunto de
registros. Ud. debe conocer el número de la columna numérica (basada
en cero) de los datos deseados.
dbint Devuelve el dato de la celda como un entero.
dbfloat Devuelve el dato de la celda como un número de

punto flotante.
dbstring Devuelve el dato de la celda como un string.
dbcloseset
Cierra y descarta los resultados del último comando dbopenset.
El Programa Grande de este capítulo es uno que crea, mantiene y

lista números telefónicos guardados en un archivo BD.
Ponga especial atención a la función quote$ usada al crear las
sentencias SQL. Esta encierra todos los strings en las sentencias
entre comillas simples, después de cambiar las comillas simples en
un string por comillas dobles. Este duplicación de comillas dentro de
comillas es la manera de insertar un signo de pregunta en una
sentencia SQL.
1 # c20_rolofile.kbs
2 # un ejemplo de BD para mantener una lista de nros. de TE
3
4 dbopen "rolofile.sqlite3"
5 call createtables()
6
7 do
8 print
9 print "rolofile - phone numbers"
10 print "1-agregar una persona"
11 print "2-listado de personas"
12 print "3-agregar No. de telefono"
13 print "4-listado de Nos. de telefonos "
14 input "0-exit >", opcion
15 print
16
17 if opcion=1 then call addperson()

258
18 if opcion=2 then call listpeople()

19 if opcion=3 then call addphone()
20 if opcion=4 then call listphone()
21 until opcion = 0
22 dbclose
23 end
24
25 function quote$(a$)
26 # ponga srting entre comillas simples (para una sentencia sql)
27 # si contiene una comilla simple hágala doble
28 return "'" + replace(a$,"'","''") + "'"
29 end function
30
31 function inputphonetype$()
32 do
33 input "Tipo de TE (h-home, c-cell, f-fax, w-work) > ", type$
34 until type$ = "h" or type$ = "c" or type$ = "f" or type$ = "w"
35 return type$
36 end function
37
38 subroutine createtables()
39 # incluya la cláusula IF NOT EXISTS para evitar error si la
40 # tabla ya existe.
41 dbexecute "CREATE TABLE IF NOT EXISTS person
(person_id TEXT PRIMARY KEY, name TEXT);"
42 dbexecute "CREATE TABLE IF NOT EXISTS phone
(person_id TEXT, phone TEXT, type TEXT, PRIMARY KEY
(person_id, phone));"
43 end subroutine
44
45 subroutine addperson()
46 print "Agregar una Persona"
47 input "person id > ", person_id$
48 person_id$ = upper(person_id$)
49 if ispersononfile(person_id$) or person_id$ = "" then
50 print "La persona ya existe o la entrada está vacía"
51 else
52 input "person name > ", person_name$
53 if person_name$ = "" then
54 print "Por favor, ingrese el nombre"
55 else
56 dbexecute "INSERT INTO person (person_id,name)
VALUES (" + quote$(person_id$) + "," + quote$
(person_name$) + ");"
57 print person_id$ + " agregada."
58 end if
59 end if

258
60 end subroutine
61
62 subroutine addphone()
63 print "Agregar un Número de Teléfono"
64 input "person id > ", person_id$
66 if not ispersononfile(person_id$) then
67 print "La persona no existe el el archivo"
68 else
69 input "phone number > ", phone$
70 if phone$ = "" then
71 print "Por favor, ingrese un nro. de Teléfono"
72 else
73 type$ = inputphonetype$()
74 dbexecute "INSERT INTO phone (person_id,
phone, type) values (" + quote$(person_id$) + "," +
quote$(phone$) + "," + quote$(type$) + ");"
75 print phone$ + " agregado."
76 end if
77 end if
78 end subroutine
79
80 function ispersononfile(person_id$)
81 # devuelve true/false dependiendo de si la persona está en la tabla de
personas.
82 onfile = false
83 dbopenset "select person_id from person where
person_id = " + quote$(person_id$)
84 if dbrow() then onfile = true
85 dbcloseset
86 return onfile
87 end function
88
89 subroutine listpeople()
90 dbopenset "select person_id, name from person order by
person_id"
91 while dbrow()
92 print dbstring("person_id") + " " + dbstring("name")
93 end while
94 dbcloseset
95 end subroutine
96
97 subroutine listphone()
98 input "person id to list (return for all) > ",person_id$
100 stmt$ = "SELECT person.person_id, person.name,
phone.phone, phone.type FROM person LEFT JOIN phone

258
ON person.person_id = phone.person_id"
101 if person_id$ <> "" then stmt$ += " WHERE
person.person_id = " + quote$(person_id$)
102 stmt$ += " ORDER BY person.person_id"
103 dbopenset stmt$
104 while dbrow()
105 print dbstring("person_id") + " " +
dbstring("name") + " " + dbstring("phone") + " " +
dbstring("type")
106 end while
107 dbcloseset
108 end subroutine
Programa 129: BD para Mantener una Lista dr Númerous Telefónicos

258
Ejercicios:
y p z t c e l e s o x x d
e l i b a m l n a x x t b
t q x h o o e t g n e d i
a s t p s t l n e s t f n
e e a e a n i f n t t s t
r q t d s r o e b m a d r
c n p u t e p i n d b m e
i u e s c o s m t c l u s
d q b p b e u o l a e y n
b d u d o l x o l z l f i
r m o e o b s e p c w e m
o x h c r e d t b o b y r
w c g h t y j c r d s d m
column, create, dbclose, dbcloseset, dbexecute, dbfloat, dbint,
dbopen, dbopenset, dbrow, dbstring, insert, query, relationship, row,
select, sql, table, update
20.1. Tome el Programa Grande de este capítulo y modifíquelo para

crear una aplicación para hacer un seguimiento de notas de
estudiantes para varios cursos. Ud. necesitará las siguientes
opciones de menú para permitir al usuario a:
 Ingresar un código del curso, nombre de la materia, puntos
posibles y puntaje de una materia y guardar esta información
en una tabla BD.
 Crear un modo para que el estudiante vea todas las notas
para un curso después de que ingrese el código del curso.
 Crear una opción para ver una lista de todos los
cursos con el total de puntos posibles, total de notas
obtenidas y porcentaje de las notas obtenidas versus
las posibles.

258
Capítulo 21: Conectandose a la Red
Capítulo 21: Conectándose a la Red

Este Capítulo discute como usar las sentencias de red de BASIC-256. Conectándose en
red en BASIC-256 permite conexiones zócalo (socket) simples usando el protocolo TCP
(Transmission Control Protocol). Este capítulo no pretende ser una introducción completa a
programación socket TCP/IP; en su lugar se dan conceptos simples y aplicados que le
permitirán ampliar su conocimiento con posterioridad.
Conección Socket
Los sockets de flujo (de datos) TCP crean una conexión entre dos computadoras o
programas. Paquetes de información pueden ser enviados y recibidos de modo bi-
direccional sobre la conexión.
Para comenzar una conexión necesitamos que una computadora o programa actúe como
servidor (server, esperando por una llamada) y la otra como cliente (client, para que haga
la llamada). La ilustración 40 muestra gráficamente como la conexión server/cliente se
establece.
SERVER 2 CLIENT
El SERVER atiende pedido del CLIENTE a

conectarse
El CLIENTE se conecta al Puerto

Ilustración 40: Comunicación por Zócalo (Socket Communication)
Comunicación bi-direccional entre CLIENTE
De manera idéntica ayuna comunicación telefónica, la persona que hace la llamada (cliente)
SERVER
necesita conocer el número de teléfono de la persona a quien desea llamar (server). En
lenguaje de redes, ese número se conoce como “dirección IP”. BASIC-256 usa
direcciones IP en versión 4 (IPv4), que tienen la forma de cuatro números separados por
dos puntos (:). Por ejemplo A:B:C:D, donde A, B, C y D son valores enteros en el rango 0 a
255 inclusive.
Además de tener direcciones IP tanto el server como el cliente, para poder hablar entre
ellos hace falta que ambos definan un puerto (zócalo, conector) para establecer la
conexión. Puede pensar a un “puerto” como una extensión telefónica (interno) en una
compañía grande. A una persona se le asigna un número de una extensión telefónica (port)
para contestar (server). Si Ud. desea hablar con esa persona (cliente) llama a la compañía
(IP) y luego a la extensión (port).
Esto ocurre porque a una computadora/programa (server), con seguridad Ud. no es el
único que quiere conectarse. Entonces, la manera de que todas las computadoras
(clientes) pueden conectarse con “ese” server (que tiene su dirección IP) es que cada una
lo haga por un “puerto” diferente.
Los puertos son numerados, entre 0 y 65535. Pero no todos son usables, Internet y
muchas aplicaciones tienen puertos “reservados” en el rango 0-1023, por lo que se
recomienda que evite usar este último rango de puertos.

258
Un Server y un Cliente Simples:

1 # c21_simpleserver.kbs
2 # envie un mensaje al cliente sobre port 999
3
4 print "Escuchando el port 9999 en " + netaddress()
5 NetListen 9999
6 NetWrite "El server simple envió este mensaje."
7 NetClose
Programa 130: Server de Red Simple
1 # c21_simpleclient.kbs
2 # conectar al server simple y obtener el mensaje
3 #
4 input "¿Cual es la dirección IP del server simple?", addr$
5 if addr$ = "" then addr$ = "127.0.0.1"
6 #
7 NetConnect addr$, 9999
8 print NetRead
9 NetClose
Programa 131: Cliente de Red Simple
Escuchando el port 9999 en xx.xx.xx.xx

Salida 130 Simple Network Server
¿Cual es la dirección IP del server simple?

El server simple envió este mensaje."
Salida 131: Simple Network Client
netaddress
netaddress ( )
Función que devuelve un string conteniendo el valor numérico IPv4
de la dirección de red asociada a la computadora
netlisten nro_puerto
netlisten (nro_puerto)
netlisten nro_socket, nro_puerto
netlisten (nro_socket, nro_puerto)
Abre una conexión de red (server) sobre un port específico y espera
a que se conecte otro programa (cliente). Si nro_socket no se
especifica, se usará el socket número cero (0).

258
netclose
netclose ( )
netclose nro_socket
netclose (nro_socket)
Cierra la conexión de red especificada (socket). Si socketnumber
no se especifica, se cerrará el socket número cero (0).
netwrite string
netwrite (string)
netwrite nro_socket, string
netwrite (nro_socket, string)
Envía un string a la conexión de red abierta especificada. Si
nro_socket no es especificado, usará el zócalo cero (0) para escribir.
netconnect servername, nro_port

netconnect (servername, nro_port)
netconnect nro_socket, servername, nro_port
netconnect (nro_socket, servername, nro_port)
Abre una conexión de Red (client) a un server. La dirección IP o
nombre de host del server son especificadas en el argumento
servername, junto con el puerto de red específico.. Si nro_socket
no es especificado, usará el zócalo cero (0) para la conexión
netread
netread ( )
netread (nro_socket)
Lee datos de la conexión de red especificada y lo devuelve como un
string. Esta función es “bloqueante” (espera hasta que un dato es
recibido). Si nro_socket no es especificado, usará el zócalo cero (0)
para la conexión.
Chat en la Red
El siguiente ejemplo agrega una nueva función (netdata) a las declaraciones de red que ya
hemos visto. Esta nueva función permitirá a nuestros clientes de red procesar otros
eventos, como presionar teclas, y luego leer datos de la red únicamente cuando hay datos
para leer.
El programa de chat por red combina los programas de cliente y servidor en uno solo. Si
Ud. inicia la aplicación y no puede conectarse a un server, el error es capturado y el
programa entonces se convierte en un server. Este es uno de los diversos métodos
disponibles para permitir a un único programa cumplir con ambos roles.
1 # c21_chat.kbs
2 # use port 9999 para chat simple

258
3
4 input "Chat a la direccion (¿volver por server o host local?)", addr$
5 if addr$ = "" then addr$ = "127.0.0.1"
6 #
7 # trate de conectarse al server
8 # si no hay uno, vuélvase uno.
9 try
10 NetConnect addr$, 9999
11 catch
12 print "Arrancando server – Esperando por cliente chat"
13 NetListen 9999
14 end try
15 print "Conectado"
16
17 while true
18 # obtenga tecla apretada y envíela
19 k = key
20 if k <> 0 then
21 call show(k)
22 netwrite string(k)
23 end if
24 # obtenga tecla de la red y muéstrela
25 if NetData() then
26 k = int(NetRead())
27 call show(k)
28 end if
29 pause .01
30 end while
31 end
32
33 subroutine show(keyvalue)
34 if keyvalue=16777220 then
35 print
36 else
37 print chr(keyvalue);
38 end if
39 end subroutine
Programa 132: Chat por Red
Lo siguiente se observa cuando el usuario en el lado del cliente tipea el mensaje "HOLA
SERVER" y luego el usuario en el server responde "HOLA CLIENTE".
Chat a la direccion (¿volver por server o host local?)

Arrancando server – esperando por cliente chat
Conectado
HOLA SERVER
HOLA CLIENT

258
Salida 132.1: Chat por Red (Server)
Chat a la direccion (¿volver por server o host local?)

Conectado
HI SERVER
HI CLIENT
Salida 132.2: Chat por Red (Client)
netdata or netdata()
netdata ( nro_scket )
Devuelve true si hay datos de red esperando a ser leídos. Esto
permite al programa continuar con las operaciones sin esperar que
arribe un nuevo paquete de datos de red.
El Programa Grande de este capítulo crea un juego de batalla de

tanques de guerra para dos jugadores a través de la red. Cada
jugador es el tanque blanco en su pantalla siendo el negro el del otro
jugador. Use las teclas de flechas para girar y moverse. Dispare con
la barra espaciadora.
1 # c21_battle.kbs
2 # usa port 9998 para server
3
4 spritedim 4
5 call tanksprite(0,white) # yo
6 call tanksprite(1,black) # oponente
7 call projectilesprite(2,blue) # mi tiro
8 call projectilesprite(3,red) # tiro del oponente
9
10 kspace = 32
11 kleft = 16777234
12 kright = 16777236
13 kup = 16777235
14 kdown = 16777237
15
16 dr = pi / 20 # cambio de direccion
17 dxy = 2.5 # velocidad de movimiento
18 shotdxy = 5 # velocidad del proyectil
19 port = 9998 # puerto para comunicarse
20
21 print "Tank Battle – Ud es el tanque blanco."
22 print "Su misión es disparar y matar al tanque negro. "
23 print "Use flechas para moverse y la barra espaciadora"
24 print "para disparar."

258
25 print
26
27 input "Es Ud. el server? (y or n)", mode$
28 if mode$ = "y" then
29 print "Ud. es el server. Esperando que un cliente se conecte."
30 NetListen port
31 else
32 input "Dirección del Server para conectarse (Intro para local host)?", addr$
33 if addr$ = "" then addr$ = "127.0.0.1"
34 NetConnect addr$, port
35 end if
36
37 # defina mi posición por defecto y envíesela a mi oponente
38 x = 100
39 y = 100
40 r=0
41 # projectil: posición dirección y visible
42 p = false
43 px = 0
44 py = 0
45 pr = 0
46 call writeposition(x,y,r,p,px,py,pr)
48
49 # actualice la pantalla
50 color green
52 spriteshow 0
53 spriteshow 1
54 spriteplace 0, x, y, 1, r
55 while true
56 # adquiera tecla apretada y mueva el tanque en pantalla
57 k = key
58 if k <> 0 then
59 if k = kup then
60 x = ( graphwidth + x + sin(r) * dxy ) % graphwidth
61 y = ( graphheight + y - cos(r) * dxy ) % graphheight
62 end if
63 if k = kdown then
64 x = ( graphwidth + x - sin(r) * dxy ) % graphwidth
65 y = ( graphheight + y + cos(r) * dxy ) % graphheight
66 end if
67 if k = kleft then r = r - dr
68 if k = kright then r = r + dr
69 if k = kspace then
70 pr = r
71 px = x
72 py = y

258
73 p = true
74 spriteshow 2
75 end if
76 spriteplace 0, x, y, 1, r
77 call writeposition( x, y, r, p, px, py, pr )
78 if spritecollide( 0, 1 ) then
79 netwrite "F"
80 print "Ud. embistió al otro tanque y ambos murieron. Game Over."
81 end
82 end if
83 end if
87
84 # mueva mi proyectil (si hay uno)
85 if p then
86 px = px + sin( pr ) * shotdxy
87 py = py - cos( pr ) * shotdxy
88 spriteplace 2, px, py, 1, pr
89 if spritecollide( 1, 2 ) then
90 NetWrite "W"
91 print "Ud. mató a su oponente. Game over."
92 end
93 end if
94 if px<0 or px > graphwidth or py <0 or py> graphheight then
95 p = false
96 spritehide 2
97 end if
98 call writeposition( x, y, r, p, px, py, pr )
99 end if
100 #
101 # adquiera posición desde la red y
102 # defina las variables de ubicación para el oponente
103 # dé vuelta las coordenadas como las decodificamos
104 while NetData()
105 position$ = NetRead()
106 while position$ <> ""
107 if left(position$,1) = "W" then
108 print "Ud. está muerto - Game Over."
109 end
110 end if
111 if left(position$,1) = "F" then
112 print "Ud. fue impactado y ambos murieron-Game Over"
113 end
114 end if
115 op_x = graphwidth - unpad( ref( position$ ),3)
116 op_y = graphheight - unpad( ref( position$ ), 3)
117 op_r = pi + unpad( ref( position$ ), 5)
118 op_p = unpad( ref( position$ ), 1)

258
119 op_px = graphwidth - unpad( ref( position$ ), 3)

120 op_py = graphheight - unpad( ref( position$ ), 3)
121 op_pr = pi + unpad( ref( position$ ), 5)
122 # display opponent
123 spriteplace 1, op_x, op_y, 1, op_r
124 if op_p then
125 spriteshow 3
126 spriteplace 3, op_px, op_py, 1, op_pr
127 else
128 spritehide 3
129 end if
130 end while
131 end while
132 #
133 pause .05
134 end while
135
136 subroutine writeposition(x,y,r,p,px,py,pr)
137 position$ = lpad$( int( x ), 3 ) + lpad$( int( y ), 3 ) + lpad$( r, 5 ) + lpad$(
p, 1 ) + lpad$( int( px ), 3 ) + lpad$( int( py ), 3 ) + lpad$ ( pr, 5 )
138 NetWrite position$
139 end subroutine
140
141 function lpad$( n, l )
142 # devuelva un número sin espacios en blanco a la isquierda
143 s$ = left( n, l )
144 while length( s$ ) < l
145 s$ = " " + s$
146 end while
147 return s$
148 end function
149
150 function unpad( ref( l$ ), l )
151 # devuelva un número con un espacio eliminado al comienzo
152 # y el string acortado en 1 que es lo que se saco
153 n = float( left( l$, l ) )
154 if length( l$ ) > l then
155 l$ = mid( l$, l + 1, 99999 )
156 else
157 l$ = ""
158 end if
159 return n
160 end function
161
162 subroutine tanksprite( spritenumber , c )
163 color c
164 spritepoly spritenumber, {0,0, 7,0, 7,7, 14,7, 20,0, 26,7, 33,7, 33,0, 40,0,

258
40,40, 33,40, 33,33, 7,33, 7,40, 0,40}

165 end subroutine
166
167 subroutine projectilesprite( spritenumber, c)
168 color c
169 spritepoly spritenumber, {3,0, 3,8, 0,8}
170 end subroutine
Programa 133: Batalla de Tanques en Red
Salida 132: Batalla de Tanques en Red

258
Ejercicios:
m r d t n s i p n n
j r f d o c k e e e
v v r c l r t g s t
p h k i o s d e o c
k e e w i a r k l o
t n t l e v v c c n
t e t r e t t n t n
n e t r c x g o e e
n e x p o r t m n c
n e t i r w t e n t
client, listen, netclose, netconnect, netlisten, netread, network,
netwrite, port, server, socket, tcp
21.1. Modifique el Problema 12.4 para crear un juego de ping-pong

para dos jugadores en una red cliente/servidor
21.2. Escriba una aplicación cliente/servidor implementando el juego
piedra-papel-tijeras de modo que dos jugadores puedan
competir.
21.3. Escriba un server de red para chat que pueda conectar a varios
clientes al mismo tiempo. Necesitará un proceso en el server
para asignar a cada cliente un puerto diferente en el server
para permitir el tráfico múltiple.

258
Apéndice A
Apéndice A: Instalando BASIC-256 en

su PC Windows©
Este Apéndice lo guiará paso a paso a través de los procesos de descargar e instalar
BASIC-256 en su computadora con MS Windows©. Estas instrucciones fueron escritas para
Windows XP y con Firefox como navegador para la web. La instalación y configuración
específica para su PC puede ser algo diferente, pero los pasos a seguir deberían ser los
mismos.
1 – Descargando el programa:
Conéctese a Internet, navegue hasta el sitio http://www.basic256.org y siga el link de
descarga. Una vez que esté en la página Sourceforge del proyecto, haga click en el botón
verde "Download Now!" (Ilustración 41) para comenzar la descarga.
Ilustración 41: BASIC-256 en Sourceforge
El proceso de descarga podrá preguntarle eventualmente que es lo que quiere hacer con el
archivo. Seleccione el botón "Save File" (Ilustración 42).
Ilustración 42: Guardando el Archivo de Instalación

258
Apéndice A
El navegador deberá mostrarle la ventana de descargas en donde se estará descargando

el instalador de BASIC-256. Cuando finalice, la ventana lucirá como la Ilustración 43 (en el
caso de usar Firefox). No cierre esta ventana aún, la necesitará para comenzar la
instalación.
Ilustración 43: Instalador descargado
2 - Instalando
Una vez finalizada la descarga del archivo (Ilustración 43) haga click con el mouse sobre el
archivo descargado en la lista de descarga. Verá a continuación uno o dos diálogos
preguntándole si realmente desea ejecutar el archivo (Ilustración 44) (Ilustración 45).
Deberá presionar los botones “OK” o “Run” de esos diálogos.
Ilustración 44: Advertencia de Apertura de Archivo
Ilustración 45: Advertencia de seguridad sobre apertura de archivo

258
Apéndice A
Una vez aceptadas las advertencias de seguridad verá el instalador de BASIC-256.

Presione “Next” en la primera ventana (Ilustración 46)
Ilustración 46: Instalador – Ventana de Bienvenida.
Lea y acepte la licencia de software GNU GPL y presione "I Agree" (Acepto) (Ilustración
47). La licencia GNU GPL es una de las licencias de software "Open Source" y "Free" más
comúnmente usadas. Ud. tiene el derecho de usar, dejar de usar y modificar los programas
liberados bajo GPL. Esta licencia solo se aplica al software BASIC-256 y no al contenido de
este libro.
Ilustración 47: Instalador – Ventana de Licencia GPL
La próxima ventana de instalación le preguntará qué es lo que desea instalar (Ilustración

48). Si está instalando BASIC-256 en un dispositivo USB u otro tipo de dispositivo de
almacenamiento removible, se sugiere que desmarque la opción "Start Menu Shortcuts"
(“Atajos en Menú Inicio”). Para la mayoría de los usuarios que están instalando en un disco
duro se recomienda hacer una instalación completa. Presione "Next"

258
Apéndice A
Ilustración 48: Instalador – Qué Instalar
La Ilustración 49 muestra la última ventana antes de que la instalación comience. Esta

ventana le pregunta en qué carpeta desea instalar los archivos ejecutables de BASIC-256.
Si está instalando sobre un disco duro, debería aceptar la ruta por defecto.
Ilustración 49: Instalador – Donde Instalar
La Instalación está completa cuando vea la siguiente ventana (Ilustración 50). Presione
"Close" (“Cerrar”).

258
Apéndice A
Ilustración 50: Instalación Completa
3 – Iniciando BASIC-256
Ud. puede ahora buscar en Start (Inicio) > All Programs (Todos los Programas) >
(Ilustración 51)
Ilustración 51: Botón Start XP
Deberá ver un ítem en el menú para BASIC-256. Desde este menú Ud. puede abrir el
programa, desinstalarlo o ver la documentación (Ilustración 52).
Ilustración 52: Menú BASIC-256 en All Programs

258
Apéndice B
Apéndice B: Nombres y Números de

Color
Listado de nombres de colores estándar usados en declaraciones de color. Se listan
también los correspondientes valores RGB
Color Valores RGB MUESTRA
Black 0, 0, 0
White 255, 255, 255
red 255, 0, 0
darkred 128, 0, 0
green 0, 255, 0
darkgreen 0, 128, 0
blue 0, 0, 255
darkblue 0, 0, 128
cyan 0, 255, 255
darkcyan 0, 128, 128
purple 255, 0, 255
darkpurple 128, 0, 128
yellow 255, 255, 0
darkyellow 128, 128, 0
orange 255, 102, 0
darkorange 176, 61, 0
gray /grey 160, 160, 160
darkgray / darkgrey 128, 128, 128
clear

258
Apéndice C
Apéndice C: Tonos Musicales

La siguiente Tabla lo ayudará a convertir las teclas de un piano en frecuencias para usar en
las sentencias de sonido.
F - 175
F# - 185
G - 196
G# - 208
A - 220
A# - 233
B – 247
Middle C - 262
C# - 277
D - 294
D# - 311
E - 330
F - 349
F# - 370
G - 392
G# - 415
A - 440
A# - 466
B - 494
C - 523
C# - 554
D - 587
D# - 622
E - 659
F - 698
F# - 740
G - 784
G# - 831
A - 880
A# - 932

258
Apéndice D
Apéndice D: Valores de Teclas

Los valores de teclas son devueltos por la función key() y representan la última tecla
presionada desde la última lectura de una tecla. Esta Tabla lista los valores de teclas
usados por un teclado Inglés Standard. Existen otros valores de teclas.
Códigos de Teclado Inglés (EN)
Tecla # Tecla # Tecla # Tecla #
Space 32 A 65 L 76 W 87
0 48 B 66 M 77 X 88
1 49 C 67 N 78 Y 89
2 50 D 68 O 79 Z 90
3 51 E 69 P 80 ESC 16777216
4 52 F 70 Q 81 Backspace 16777219
5 53 G 71 R 82 Enter 16777220
6 54 H 72 S 83 Left Arrow 16777234
7 55 I 73 T 84 Up Arrow 16777235
8 56 J 74 U 85 Right Arrow 16777236
9 57 K 75 V 86 Down Arrow 16777237

258
Apéndice E
Apéndice E: Valores de Caracteres

Unicode Latín (Inglés)
Esta Tabla muestra los valores de letras y símbolos (caracteres) Unicode para Latín
Estándar (Inglés). Estos valores se corresponden con los valores ASCII que son usados
desde 1960.
Puede encontrar conjuntos de caracteres adicionales en http://www.unicode.org.
CHR # CHR # CHR # CHR # CHR # CHR #

NUL 0 SYN 22 , 44 B 66 X 88 n 110
SOH 1 ETB 23 - 45 C 67 Y 89 o 111
STX 2 CAN 24 46 D 68 Z 90 p 112
ETX 3 EM 25 / 47 E 69 [ 91 q 113
ET 4 SUB 26 0 48 F 70 \ 92 r 114
ENQ 5 ESC 27 1 49 G 71 ] 93 s 115
ACK 6 FS 28 2 50 H 72 ^ 94 t 116
BEL 7 GS 28 3 51 I 73 _ 95 u 117
BS 8 RS 30 4 52 J 74 ` 96 v 118
HT 9 US 31 5 53 K 75 a 97 w 119
LF 10 Space 32 6 54 L 76 b 98 x 120
VT 11 ! 33 7 55 M 77 c 99 y 121
FF 12 " 34 8 56 N 78 d 100 z 122
CR 13 # 35 9 57 O 79 e 101 { 123
SO 14 $ 36 : 58 P 80 f 102 | 124
SI 15 % 37 ; 59 Q 81 g 103 } 125
DLE 16 & 38 < 60 R 82 h 104 ~ 126
DC1 17 ' 39 = 61 S 83 i 105 DEL 127
DC2 18 ( 40 > 62 T 84 j 106
DC3 19 ) 41 ? 63 U 85 k 107
DC4 20 42 @ 64 V 86 l 108
NAK 21 + 43 A 65 W 87 m 109
Nota: Adaptado de Unicode Standard 5.2
0-31 and 127 son no-imprimibles

258
Apéndice F
Apéndice F: Palabras Reservadas

Las siguientes palabras son usadas por el lenguaje BASIC-256. En consecuencia, NO es
permitido usar ninguna de las mismas para nombres de variables o rótulos de
declaraciones GOTO o GOSUB.
# cyan
abs dark
acos darkblue
and darkcyan
arc darkgeeen
asc darkgray
asin darkgrey
atan darkorange
black darkpurple
blue darkred
call darkyellow
catch day
ceil dbclose
changedir dbcloseset
chord dbexecute
chr dbfloat
circle dbint
clear dbnull
clg dbopen
clickb dbopenset
clickclear dbrow
clickx dbstring
clicky debuginfo
close degrees
cls dim
color dir
colour do
confirm editvisible
continue else
continuedo end
continuefor endfunction
continuewhile endif
cos endsubroutine
count endtry
countx endwhile
currentdir eof

258
Apéndice F
error_arrayindex error_none
error_arrayindexmissing error_nonnumeric
error_arraysizelarge error_nosuchvariable
error_arraysizesmall error_notanumber
error_byref error_notimplemented
error_byreftype error_penwidth
error_colornumber error_permission
error_dbcolno error_polyarray
error_dbconnnumber error_polypoints
error_dbnotopen error_printernotoff
error_dbnotset error_printernoton
error_dbnotsetrow error_printeropen
error_dbopen error_putbitformat
error_dbquery error_radix
error_dbsetnumber error_radixstring
error_divzero error_rgb
error_filenotopen error_spritena
error_filenumber error_spritenumber
error_fileopen error_spriteslice
error_filereset error_strend
error_filewrite error_stringmaxlen
error_folder error_strneglen
error_fontsize error_strstart
error_fontweight exists
error_for1 exitdo
error_for2 exitfor
error_freedb exitwhile
error_freedbset exp
error_freefile explode
error_freenet explodex
error_imagefile false
error_imagesavetype fastgraphics
error_imagescale float
error_infinity floor
error_logrange font
error_netaccept for
error_netbind freedb
error_netconn freedbset
error_nethost freefile
error_netnone freenet
error_netread frombinary
error_netsock fromhex
error_netsocknumber fromoctal

258
Apéndice F
error_netsockopt fromradix
error_netwrite getbrushcolor
getcolor netconnect
getpenwidth netdata
getsetting netlisten
getslice netread
global netwritenext
gosub next
goto not
graphheight offerror
graphsize onerror
graphwidth open
gray openb
green or
grey orange
hour ostype
if outputvisible
imgload pause
imgsave penwidth
implode pi
include pie
input pixel
instr plot
instrx poly
int portin
key portout
kill print
lasterror printercancel
lasterrorextra printeroff
lasterrorline printeron
lasterrormessage printerpage
left purple
length putslice
line radians
log rand
log10 read
lower readbyte
md5 readline
mid rect
minute red
month redim
mouseb ref
mousex refresh
mousey rem
msec replace

258
Apéndice F
netaddress replacex
netclose reset
return tan
rgb text
right textheight
say textwidth
second then
seek throwerror
setsetting to
sin tobinary
size tohex
sound tooctal
spritecollide toradix
spritedim true
spriteh try
spritehide until
spriteload upper
spritemove version
spriteplace volume
spritepoly wavplay
spriteshow wavstop
spriteslice wavwait
spritev while
spritew white
spritex write
spritey writebyte
sqr writeline
stamp xor
step year
string yellow
system

258
Apéndice G
Apéndice G: Errores y Advertencias
Error # Descripción del Error (ESP)
0 ERROR_NONE
2 ERROR_FOR1 "Ilegal FOR – Nro. Inicio > Nro. final "
3 ERROR_FOR2 "Ilegal FOR – Nro. Inicio < Nro. final"
5 ERROR_FILENUMBER "Número de Archivo inválido"
6 ERROR_FILEOPEN "No es posible abrir el archivo"
7 ERROR_FILENOTOPEN "Archivo no abierto."
8 ERROR_FILEWRITE "No es posible escribir en el archivo "
9 ERROR_FILERESET "No es posible reiniciar el archivo "
10 ERROR_ARRAYSIZELARGE "Dimensión del Arreglo demasiado grande "
11 ERROR_ARRAYSIZESMALL "Dimensión del Arreglo demasiado pequeña"
12 ERROR_NOSUCHVARIABLE "Variable desconocida"
15 ERROR_ARRAYINDEX "Indice del Arreglo fuera de límites"
16 ERROR_STRNEGLEN "Longitud de la sub-string menor que cero"
17 ERROR_STRSTART "Posición inicial menor que cero"
"El string no suficientemente largo para el carácter

18 ERROR_STREND
inicial dado"
19 ERROR_NONNUMERIC "Valor no-numérico en expresión numérica"
"Valores RGB de Color deben estar en el rango 0 a

20 ERROR_RGB
255."
21 ERROR_PUTBITFORMAT "String de entrada a putbit incorrecta"
22 ERROR_POLYARRAY "El argumento no es un array para poly()/stamp()"
23 ERROR_POLYPOINTS "Insuficientes puntos en el array para poly()/stamp()"
24 ERROR_IMAGEFILE "No es posible cargar el archivo imagen"
25 ERROR_SPRITENUMBER "Número de Sprite fuera de rango."
26 ERROR_SPRITENA "El Sprite no ha sido asignado."
27 ERROR_SPRITESLICE "No es posible cortar la imagen."
28 ERROR_FOLDER "Nombre de Directorio inválido."

258
Apéndice G
29 ERROR_INFINITY "La operación retornó infinito."
30 ERROR_DBOPEN "No es posible abrir la base de datos SQLITE"
"Error de query en la base de datos (seguido de

31 ERROR_DBQUERY
mensaje)."
32 ERROR_DBNOTOPEN "La base de datos debe abrirse primero."
33 ERROR_DBCOLNO "Número de columna fuera de rango"
34 ERROR_DBNOTSET "El Registro debe abrirse primero."
35 ERROR_TYPECONV “No es posible convertir el string a número.”
36 ERROR_NETSOCK "Error al abrir el socket de red."
37 ERROR_NETHOST "Error al buscar el host de red."
38 ERROR_NETCONN "No es posible conectarse al host de red."
39 ERROR_NETREAD "No es posible leer de la conexión de red."
40 ERROR_NETNONE "La conexión de red no ha sido abierta."
41 ERROR_NETWRITE "No es posible escribir a la conexión de red."
"No es posible definir las opciones del socket de

42 ERROR_NETSOCKOPT
red."
43 ERROR_NETBIND "No es posible conectarse al socket de red."
44 ERROR_NETACCEPT "No es posible aceptar conexión a la red."
45 ERROR_NETSOCKNUMBER "Número de Socket inválido"
"Ud. No tiene permiso para utilizar esta

46 ERROR_PERMISSION
declaración/función."
47 ERROR_IMAGESAVETYPE "Tipo para guardar imagen inválido."
50 ERROR_DIVZERO "División por cero"
"Función/Subrutina espera una referencia a una

51 ERROR_BYREF
variable en el llamado."
"Función/Subrutina: referencia a un tipo de
52 ERROR_BYREFTYPE
variable incorrecta en el llamado"
53 ERROR_FREEFILE "No hay números de archivo libres para alocar "
54 ERROR_FREENET "No hay conexiones a la red libres para alocar"
"No hay conexiones libres a la base de datos

55 ERROR_FREEDB
para alocar"
56 ERROR_DBCONNNUMBER "Número de conexión a la Base de Datos inválido

258
Apéndice G
"No hay conjuntos de datos libre para alocar para

57 ERROR_FREEDBSET
esa conexión a la base de datos "
58 ERROR_DBSETNUMBER "Número de conjunto de datos inválido"
"Ud. debe avanzar el conjunto de datos usando

59 ERROR_DBNOTSETROW
DBROW antes de poder leer datos desde él "
"El ancho de la punta de dibujo debe ser un
60 ERROR_PENWIDTH
número no negativo "
"El valor de color debe estar en el rango -1 a
61 ERROR_COLORNUMBER
16,777,215"
"La variable array %VARNAME% no tiene valor
62 ERROR_ARRAYINDEXMISSING
sin un índice"
"Escala para la imagen debe ser mayor o igual
63 ERROR_IMAGESCALE
que cero "
"El tamaño de fuente, en puntos, debe ser mayor
64 ERROR_FONTSIZE
o igual que cero "
"El peso de la fuente debe ser mayor o igual a
65 ERROR_FONTWEIGHT
cero "
"No es posible convertir radix string de vuelta a
66 ERROR_RADIXSTRING
un número decimal "
"La base de la conversión Radix debe estar entre
67 ERROR_RADIX
2 y 36"
"No es posible calcular el logaritmo o raíz de un
68 ERROR_LOGRANGE
número negativo"
"El string excede la longitud máxima posible de
69 ERROR_STRINGMAXLEN
16,777,216 caracteres"
"La operación matemática devolvió un valor
70 ERROR_NOTANUMBER
indefinido”.
71 ERROR_PRINTERNOTON "La impresora no está encendida"
72 ERROR_PRINTERNOTOFF "La impresora ya está encendida."
73 ERROR_PRINTEROPEN "No es posible abrir la impresora"
"Característica no implementada en este

65535 ERROR_NOTIMPLEMENTED
ambiente."
WARNING # Descripción del Error (ESP)
65537 WARNING_TYPECONV "No es posible convertir un string a número, se

usó cero"

258
Apéndice H
Apéndice H: Glosario
Lista de términos usados en este libro.
algoritmo (algorithm)
Un proceso paso a paso para resolver el problema
algebra booleana (boolean algebra)

Tipo de álgebra con solo valores verdadero/falso creada por Charles Boole, más de 150
años atrás.
ángulo (angle)
Un ángulo es formado cuando dos segmentos de recta comienzan en el mismo punto en el
plano. La medida de un ángulo es la cantidad de rotación de una línea respecto a la otra en
el plano, expresada usualmente en grados o radianes.
área de salida gráfica (graphics output area)

El área de la pantalla el donde los gráficos (no texto) es mostrado.
área de salida texto (text output area)

El área de la pantalla donde se muestra texto. También es usada para mostrar los errores.
argumento (argument)
Un dato incluido en una declaración o un llamado a una función usado para pasar
información. En BASIC-256, los argumentos NO son cambiados por la declaración o la
función.
arreglo (array)
Una colección de datos, guardada en la memoria de la computadora, que es accedida o
referenciada por uno o más índices enteros. Ver también arreglo numérico, arreglo uni-
dimensional, arreglo bi-dimensional y string array.
arreglo bi-dimensional (two dimensional array)

Una estructura en memoria que contendrá datos ordenados en filas y columnas.Ver
arreglo numérico (numeric array)

Una serie o arreglo (array) de números.
arreglo uni-dimensional (one dimensional array)

Una estructura en memoria que contiene una lista de datos que son localizados mediante
un índice. Ver también arreglo.
ASCII
Acronismo por American Standard Code for Information Interchange (Código Americano
Estándar para Intercambio de Información). Define un código numérico usado para
representar letras y símbolos usados en el lenguaje Inglés. Ver también Unicode.
asíncrono (asynchronous)
Procesos o eventos pasando uno después de otro.
base de datos (Database)

Un conjunto organizado de datos. La mayoría de las bases de datos son computadorizadas
y consisten en tablas de información similar que son separadas en filas y columnas Ver
también columna, filas y tabla.

258
Apéndice H
columna – base de datos (column -database)

Define una única pieza de información que será común a todas las filas de una base de
datos.
constante (constant)
Un valor que no puede ser cambiado.
declaración (statement)
A single complete action. Statements perform something and do not return a value.
dirección IP (IP address)

Abreviación de dirección de Protocolo Internet (Internet Protocol). Una dirección IP es un
rótulo numérico único asignado a un dispositivo en una red. Tiene la forma nn:nn:nn:nn.
entero (integer)
Un valor numérico sin punto decimal. Típicamente tiene un rango de -2.147.483.648 a
2.147.483.647.
error de sintaxis (syntax error)
Un error con la estructura de una declaración de modo que el programa no puede ejecutar.
error lógico (logical error)

Un error que causa que el programa no se comporte como lo esperado.
estructura de datos (data structure)

Es una manera de guardar y usar información de manera eficiente en una computadora.
falso (false)
Valor booleano representando NO VERDADERO. En BASIC-256 es realmente un nombre
para representar el entero cero (0). Ver también Algebra Booleana (Boolean Algebra) y
verdadero (true).
fila – base de datos (row - database)

También llamada “registro” o “tupla”. Una fila puede ser pensada como un miembro singular
de una tabla.
fuente (Font)
Un estilo de dibujar letras
frecuencia (frequency)
El número de ocurrencias de un evento en un especificado período de tiempo (Ver también
hertz).
función (function)
Un tipo especial de declaración en BASIC-256 que puede tomar como entrada cero o mas
valores, hacer cálculos y devolver información a su programa.
grados (degrees)
Unidad de medida angular. Los angulos en el plano pueden ser medidos en grados entre 0
y 360. Un ángulo recto mide 90 grados. Ver también ángulo y radian.
hertz (hz)
Unidad de frecuencia en ciclos por segundo. En honor al físico alemán Heinrich Hertz. Ver
también frecuencia.

258
Apéndice H
lista (list)
Una colección de valores que puede ser usado para asignar arreglos (arrays) y en algunas
declaraciones. En BASIC-256, las listas son representadas por una serie de valores
separados por coma (,) todos dentro de paréntesis ({}).
constante nominada (named constant)

Un valor que es representado por un nombre, que no puede ser cambiado.
número de coma flotante (floating point number)

Un valor numérico que puede tener o no un punto decimal. Típicamente, un número de
punto flotante tiene un rango de ± 1.7x10±308 con 15 dígitos de precisión.
operador (operator)
Actúa sobre una o más piezas de datos para efectuar una acción.
pixel
El punto más pequeño identificable en una pantalla de computadora.
pseudocódigo (pseudocode)
Descripción de lo que un programa necesita hacer en un lenguaje natural (no de
computadora) La palabra contiene el prefijo “pseudo” que significa falso y “código” por
lenguaje de computación
punto (point)
Unidad de medida usada para el tamaño de texto. 1 punto = 1/72". Un carácter definido en
12 puntos tendrá 12/72" or 1/6" de alto.
Puerto (port)
Un número definido por software usado para crear y comunicarse con un zócalo (socket).
radian
Unidad de medida angular. Angulos en el plano pueden tener medidas en radianes
comprendidas entre 0 y 2π. Un ángulo recto mide π/2 radianes. Ver también ángulo y
grados.
radio (radius)
Distancia de un crculo a su centro. Tambien la mitad del dímetro del circulo
RGB
Acronismo por Red Green Blue (Rojo-Verde-Azul).
rótulo (label)
Un nombre asociado a un lugar específico (línea) de un programa. Usado para efectuar un
saldo con las sentencias GOTO y GOSUB.
sincrónico (synchronous)
Ocurriendo al mismo tiempo
sistema de coordenadas cartesiano (cartesian coordinate system)

Un método de identificar inequívocamente un punto en un plano por un par de distancias
medidas desde un origen (0,0). Las dos distancias son medidas a lo largo de ejes
perpendiculares.

258
Apéndice H
sprite
Una imagen que es integrada en una escena gráfica.
SQL
Acrónimo para Structured Query Language (Lenguaje de Consulta Estructurado). SQL es el
lenguaje mós usado para operar datos en una base de datos relacional.
string
Una secuencia de caracteres (letras, números y símbolos). Son definidas colocándola entre
comillas (").
string array
Un conjunto o arreglo de strings.
string empty
Un string sin ningún carácter y longitud cero (0). Se representa por dos apóstrofes
(quotation marks) (""). Ver también string.
string variable
Una variable que puede ser usada para guardar valores string. Una variable string se
denota colocando un signo pesos ($) al final del nombre de la variable.
sub-string
Parte de un string
subrutina (subroutine)
Un bloque de código o porción de un programa largo que efectúa una tarea específica
independientemente del resto del programa. Una pieza de software que puede ser usada y
reusada por diferentes partes del programa.
tabla - base de datos (table - database)

Datos organizados en filas y columnas. Una tabla tiene un número definido de columnas y
una o más filas.
verdadero (true)
Valor booleano representando NO FALSO. En BASIC-256 es realmente un nombre para
representar el entero uno (1). Ver también Algebra Booleana (Boolean Algebra) y falso
(false).
Unicode
Estándar moderno usado para representar caracteres y símbolos de todos los lenguajes
del mundo como números enteros.
variable (variable)
Una ubicación con nombre en la memoria de la computadora que puede ser cambiada o
alterada.
variable numérica (numeric variable)

Una variable que puede ser usada para guardar números enteros o de coma flotante.
zócalo (Socket)
Un terminal por software que permite la comunicación bi-direccional (2 way) en una red

258
Apéndice H
entre dos procesos sobre una única o dos computadoras.

258

Tutorial Basic256 PDF

Cargado por

Copyright:

Formatos disponibles

Tutorial Basic256 PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Tutorial Basic256 PDF

Cargado por

Copyright:

Formatos disponibles

Capítulo 1: Conociendo BASIC-256 – Diga Hola

Entonces, ¿Usted Desea

James M. Reneau, Ph.D.

Traducción al castellano por Oswy (Mayo 2014)

Para BASIC-256 Version 1.0.0.6 o posterior

So You Want to Learn to Program?

James M. Reneau, Ph.D. - [email protected]

Copyright C) 2010, 2014

Create Space Print ISBN: 978-1494859398

The work released under Creative Commons Attribution-Noncommercial-

Bajo esta licencia usted es libre de: NOTIMPLEMENTED

Bajo las siguientes condiciones:

Traducción al castellano de la versión original en inglés por Osvaldo Lovotti

Capítulo 1: Conociendo BASIC-256 – Diga Hola..................................................15

Capítulo 2: Dibujando Formas Básicas.................................................................23

Capítulo 3: Sonido y Música...................................................................................37

Capítulo 4: Pensando como un Programador......................................................46

Capítulo 5: Su Programa Busca Consejo.............................................................53

Capítulo 6: Decisiones, Decisiones, Decisiones..................................................59

Números Aleatorios (Random Numbers).........................................................................62

Capítulo 7: Loops (bucles) y Conteo; Hágalo de Nuevo y de Nuevo.................69

Capítulo 8: Gráficos Personalizados - Creando sus Propias Formas...............79

Capítulo 9: Funciones y Subrutinas – Reusando Código...................................93

Capítulo 10: Control del Mouse - Moviendo Cosas...........................................108

Capítulo 12: Imágenes, WAVs y Sprites..............................................................125

Capítulo 13: Imprimiendo......................................................................................138

Capítulo 14: Arrays - Colecciones de Información............................................144

Capítulo 15: Matemáticas – Más diversión con Números.................................161

Capítulo 16: Trabajando con Strings...................................................................173

Capítulo 17: Files – Guardando Información para Después.............................180

Capítulo 18: Pilas, Colas, Listas y Ordenamiento..............................................189

Capítulo 19: Atrapando Errores en Tiempo de Ejecución.................................206

Capítulo 20: Programación de Bases de Datos..................................................213

Capítulo 21: Conectándose a la Red...................................................................225

Apéndice A: Instalando BASIC-256 en su PC Windows©.................................235

Apéndice B: Nombres y Números de Color........................................................240

Apéndice C: Tonos Musicales..............................................................................241

Apéndice D: Valores de Teclas.............................................................................242

Apéndice E: Valores de Caracteres Unicode Latín (Inglés)..............................243

Apéndice F: Palabras Reservadas.......................................................................244

Apéndice G: Errores y Advertencias...................................................................248

Programa 1: Diga “Hola”.........................................................................................19

Programa 2: Diga un Número.................................................................................20

Programa 3: Diga la Respuesta..............................................................................22

Programa 4: Diga otra respuesta...........................................................................22

Programa 5: Diga hola a Juan................................................................................22

Programa 6: Diga Dos Monedas Más....................................................................22

Programa 7: Imprima Hola Mundo.........................................................................23

Programa 8: Varios print en una sola línea...........................................................23

Programa 9: Manchas Grises.................................................................................25

Programa 10: Cara con Rectángulos.....................................................................29

Programa 11: Cara sonriente con círculos...........................................................30

Programa 12: Dibuje un Triángulo.........................................................................31

Programa 13: Dibuje un Cubo................................................................................32

Programa 14: Penwidth y Contorno......................................................................33

Programa 15: Use Plot para dibujar puntos.........................................................34

Programa 16: Programa Grande – Cara que Habla..............................................36

Programa 17: Reproducir tres notas individuales...............................................39

Programa 18: Lista de Sonidos..............................................................................40