...

Entonces, ¿Usted Desea Aprender a Programar?

by user

on
Category: Documents
0

views

Report

Comments

Transcript

Entonces, ¿Usted Desea Aprender a Programar?
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)
Página 1 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 2 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
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-NoncommercialShare 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]
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 3 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 4 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 5 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 6 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 7 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 8 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 9 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 10 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 11 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 12 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
Programa 132: Chat por Red................................................................................230
Programa 133: Batalla de Tanques en Red.........................................................235
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 13 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 14 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 15 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 16 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 17 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 18 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
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
Paste (Pegar)
Insertar el texto desde el portapapeles al programa en la
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í.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 19 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
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:
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 20 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 21 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
expresión1 - expresión2
*
Multiplicación
expresión1 * expresión2
/
División
expresión1 / expresión2
Tabla 1: Operadores Matemáticos Básicos
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 22 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 23 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
Á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
2
3
4
cls
print "Hola ";
print "mundo, ";
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 24 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 1: Conociendo BASIC-256 – Diga Hola
Ejercicios:
z
j
r
v
e
r
r
o
r
e
t
b
n
a
g
u
w
n
s
b
r
x
g
m
o
a
h
j
n
s
a
e
k
p
n
a
i
t
m
d
r
t
y
t
p
r
i
r
t
a
c
z
g
o
u
o
i
e
y
g
a
m
c
c
i
p
i
u
b
s
q
o
n
y
d
v
a
z
b
q
n
s
s
r
e
x
t
w
c
u
i
a
l
i
s
p
t
a
d
i
n
e
s
g
n
o
l
k
a
t
r
o
h
v
i
o
n
n
c
c
c
n
f
m
i
l
e
j
r
c
q
q
n
y
p
r
m
f
n
d
f
c
p
m
o
s
l
a
p
r
n
a
g
d
i
r
c
x
z
l
x
t
a
i
f
i
n
s
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
Página 25 of 258
Traducción al castellano por Oswy (Mayo 2014)
Capítulo 2: Dibujando Formas Básicas
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)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 26 of
Capítulo 2: Dibujando Formas Básicas
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 27 of
Capítulo 2: Dibujando Formas Básicas
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
grilla en menú View
Ilustración 6: Líneas de grilla en
á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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 28 of
Capítulo 2: Dibujando Formas Básicas
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 29 of
Capítulo 2: Dibujando Formas Básicas
una cara ceñuda, una cara alienígena o una que luzca como alguien que Ud. conozca.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# c2_rectanglesmile.kbs
# dibuje una cara sonriente con rectángulos
# limpie el area gráfica
clg
# dibuje la cara
color yellow
rect 0,0,299,299
# dibuje la boca
color black
rect 100,200,100,25
# ponga los ojos
color black
rect 75,75,50,50
rect 175,75,50,50
say "Hola!."
Programa 10: Cara con Rectángulos
Salida 10: Cara con Rectángulos
1
2
3
4
5
6
7
8
9
10
# c2_circlesmile.kbs
# cara sonriente hecha con círculos
# limpie la pantalla
clg
color white
rect 0,0,300,300
# dibuje la cara
color yellow
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 30 of
Capítulo 2: Dibujando Formas Básicas
11
12
13
14
15
16
17
18
19
20
21
22
circle 150,150,150
# dibuje la boca
color black
circle 150,200,70
color yellow
circle 150,150,70
# coloque los ojos
color black
circle 100,100,30
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”.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 31 of
Capítulo 2: Dibujando Formas Básicas
1
2
3
4
5
6
7
# c2_triangle.kbs
# dibuja un triangulo
clg
color black
line 150, 100, 100, 200
line 100, 200, 200, 200
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# c2_cube.kbs
# use lineas para dibujar un cubo en 3D
clg
color black
# dibuje el cuadrado del fondo
line 150, 150, 150, 250
line 150, 250, 250, 250
line 250, 250, 250, 150
line 250, 150, 150, 150
# dibuje el cuadrado del frente
line 100, 100, 100, 200
line 100, 200, 200, 200
line 200, 200, 200, 100
line 200, 100, 100, 100
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 32 of
Capítulo 2: Dibujando Formas Básicas
18
19
20
21
22
# conecte los vértices
line 100, 100, 150, 150
line 100, 200, 150, 250
line 200, 200, 250, 250
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# c2_shapeoutline.kbs
# dibujar una forma con contorno
clg
penwidth 7
color blue, rgb(255,128,128)
circle 100,50,44
color black
penwidth 5
line 50,50,250,250
color red
penwidth 10
line 175,100,100,175
color green, clear
penwidth 10
rect 150,175,75,75
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 33 of
Capítulo 2: Dibujando Formas Básicas
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
2
3
# c2_plot.kbs
# use plot para dibujar puntos
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 34 of
Capítulo 2: Dibujando Formas Básicas
4
5
6
7
8
9
10
11
12
clg
color red
plot 99,100
plot 100,99
plot 100,100
plot 100,101
plot 101,100
color darkgreen
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
2
3
4
# c2_talkingface.kbs
# dibuje el fondo de cara con ojos
color yellow
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 35 of
Capítulo 2: Dibujando Formas Básicas
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
rect 0,0,300,300
color black
rect 75,75,50,50
rect 175,75,50,50
# borre la vieja boca
color yellow
rect 0,150,300,150
# dibuje la nueva boca
color black
rect 125,175,50,100
# diga la palabra
say "Yo"
color yellow
rect 0,150,300,150
color black
rect 100,200,100,50
say "estoy"
color yellow
rect 0,150,300,150
color black
rect 125,175,50,100
say "complacido"
color yellow
rect 0,150,300,150
color black
rect 125,200,50,50
say "que"
color yellow
rect 0,150,300,150
color black
rect 100,200,100,50
say "seas"
color yellow
rect 0,150,300,150
color black
rect 125,200,50,50
say "mi"
# dibuje toda la cara nueva con una sonrisa.
color yellow
rect 0,0,300,300
color black
circle 150,175,100
color yellow
circle 150,150,100
color black
rect 75,75,50,50
rect 175,75,50,50
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 36 of
Capítulo 2: Dibujando Formas Básicas
59
say "amigo"
Programa 16: Programa Grande – Cara que Habla
Salida 16: Programa Grande – Cara que Habla
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 37 of
Capítulo 2: Dibujando Formas Básicas
Ejercicios:
r
e
m
a
r
k
q
y
c
e
j
e
e
e
c
y
a
n
r
l
g
r
t
a
l
k
j
g
e
g
r
p
x
a
r
c
v
l
t
n
a
e
h
p
n
a
r
c
n
a
p
r
e
h
e
i
e
i
e
t
h
a
i
t
u
n
d
l
c
c
i
d
g
d
s
e
w
r
c
e
c
i
h
i
p
a
n
i
o
r
s
u
t
w
q
j
v
i
d
o
u
s
y
p
l
o
t
e
l
t
c
m
r
o
l
o
c
e
h
d
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 38 of
Capítulo 2: Dibujando Formas Básicas
Luna Nueva
Cto.
Menguante
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Luna Llena
Cto. Creciente
Página 39 of
Capítulo 3: Sonido y Música
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
2
3
4
5
# c3_sounds.kbs
# sound = sonido
sound 233, 1000
sound 466, 500
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 40 of
Capítulo 3: Sonido y Música
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 41 of
Capítulo 3: Sonido y Música
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
NOMBRE DE NOTA
Símbolo para
Longitud
Nota - Reposo
Dotted Whole
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
6.000
A 100
BPM
A 120
BPM
A 140
BPM
3600 ms
3000 ms
2571 ms
Página 42 of
Capítulo 3: Sonido y Música
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
2
3
4
5
# c3_charge.kbs
# reproduzca carga!
sound {392, 375, 523, 375, 659, 375, 784, 250, 659, 250, 784,
say "Carga!"
250}
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 43 of
Capítulo 3: Sonido y Música
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
2
3
4
5
6
7
# c3_numericvariables.kbs
# uso de variables numericas
let numerador = 30
let denominador = 7
let result = numerador / denominador
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
2
3
let a = 7
let b = a / 2 + .7
print a + b
Programa 21: Asignación de una variable
Salida 21: Asignación de una variable
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 44 of
Capítulo 3: Sonido y Música
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 45 of
Capítulo 3: Sonido y Música
variable+= expresión
a+=9
variable = variable + expresión
a=a+9
variable -= expresión
b -= a+2
variable = variable - expresión
b = b - (a + 2)
variable++
foo++
variable = variable + 1
foo = foo + 1
Variable-bar--
Variable = variable - 1
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 46 of
Capítulo 3: Sonido y Música
Ejercicios:
d
n
o
c
e
s
i
l
l
i
m
m
i
j
a
s
s
i
g
n
m
e
n
t
u
j
r
v
h
s
e
t
a
r
b
i
v
s
s
a
a
a
h
h
u
t
s
y
b
z
i
q
h
r
l
o
t
r
y
a
c
q
x
c
s
e
i
f
r
h
l
f
i
n
t
s
r
e
r
a
n
t
g
s
i
x
e
o
j
e
y
t z q y t x
b l e l z s
g k j u e x
c u t c g j
i e a h i n
l r t b k x
b n d e d t
e n e x l u
u q e r f i
e v a t c o
w h o l e b
t r a u q a
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}
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 47 of
Capítulo 3: Sonido y Música
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?
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 48 of
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 49 of
Capítulo 4: Pensando como un Programador
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
Dibujar ambas ruedas.
Seleccionar el color amarillo.
Dibujar el cuerpo del bus.
Dibujar el frente del bus
color black
circle 50,120,20 circle 200,120,20
color yellow
rect 50,0,200,100
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
2
3
4
5
6
7
8
9
10
11
12
13
14
# c4_schoolbus.kbs
# dibuja un bus escolar
clg
# dibujar ruedas
color black
circle 50,120,20
circle 200,120,20
# dibujar el cuerpo del bus
color yellow
rect 50,0,200,100
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 50 of
Capítulo 4: Pensando como un Programador
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 51 of
Capítulo 4: Pensando como un Programador
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
Proceso
Entrada
& Salida
Decisi
ón
Terminal: Este símbolo nos dice donde comienza y
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
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
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
camino o el otro.
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 52 of
Capítulo 4: Pensando como un Programador
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?
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 53 of
Capítulo 4: Pensando como un Programador
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 54 of
Capítulo 4: Pensando como un Programador
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
e
y
p
x
z
a
q
f
b
g
d
m
d
q
r
f
u
l
o
n
e
s y
e w
k c
o z
i c
o w
o c
h m
i q
m h
p r o
m
t
l
i
c
o
m
e
m
r
b
b
a
u
h
s
a
d
p
s
u
l
o l
f r
a v
p g
r n
i e
x o
u p
t e
s w
e m p
t
m
o
r
r
i
u
n
d
s
r
r
r
s
p
e
t
s
q
u
b
p
t
e
r
m
i
n
a
t
o
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?
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 55 of
Capítulo 5: Su Programa Busca Consejo
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
2
3
4
5
6
7
8
9
10
11
# c5_ilikejim.kbs
# Me gusta Ana – variables string
nombre$ = "Ana"
mensaje_1$ = '"' + nombre$ + '" es mi amiga.'
mensaje_2$ = "Me gusta " + nombre$ + "."
print mensaje_1$
say mensaje_1$
print mensaje_2$
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$.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 56 of
Capítulo 5: Su Programa Busca Consejo
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
2
3
4
5
6
7
8
9
10
11
# c5_ilikeinput.kbs
# usando input para preguntar por un nombre
input "ingrese su nombre> ", name$
mensaje_1$ = name$ + " es mi amigo."
mensaje_2$ = "Me gusta " + name$ + "."
print mensaje_1$
say mensaje_1$
print mensaje_2$
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
input
input
input
"prompt", variablestring$
"prompt", variablenumerica
variablestring$
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).
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 57 of
Capítulo 5: Su Programa Busca Consejo
El Programa "Math-wiz" a continuación es un ejemplo de ingreso de datos numéricos por
parte del usuario.
1
2
3
4
5
6
7
8
9
10
11
# c5_mathwiz.kbs
# muestre varias operaciones matematicas
input "a? ", a
input "b? ", b
print a + "+" + b + "=" + (a+b)
print a + "-" + b + "=" + (a-b)
print b + "-" + a + "=" + (b-a)
print a + "*" + b + "=" + (a*b)
print a + "/" + b + "=" + (a/b)
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 58 of
Capítulo 5: Su Programa Busca Consejo
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$
8 input "Ingrese un verbo? ", verb2$
9 input "Ingrese un sustantivo? ", noun2$
10 input "Ingrese un adjetivo? ", adj1$
11 input "Ingrese un verbo? ", verb3$
12 input "Ingrese un sustantivo? ", noun3$
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 59 of
Capítulo 5: Su Programa Busca Consejo
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 60 of
Capítulo 5: Su Programa Busca Consejo
Ejercicios:
e
p
y
q
q
t
a
h
p
y
d
l
r
s
j
s
x
l
w
v
l
e
b
o
t
i
f
f
r
c
e
a
f
a
m
r
n
y
n
l
p
k
b
a
i
p
i
p
i
d
g
x
x
h
u
r
t
n
u
z
a
l
p
r
i
l
a
y
g
t
g
k
e
f
v
w
t
v
x
w
j
o
z
l
k
r
g
q
z
v
n
g
i
s
r
a
l
l
o
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-IO.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 61 of
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.
Caso contrario devuelve false
>=
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.
Caso contrario devuelve false
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 62 of
Capítulo 6: Decisiones, Decisiones, Decisiones
=
<>
Igual
expresión 1 = expresión 2
Devuelve true si la expresión 1 es igual a la expresión 2.
Caso contrario devuelve false
No Igual
expresión 1 <> expresión 2
Devuelve true si la expresión 1 no es igual a la expresión 2,.
Caso contrario devuelve false
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
2
3
4
5
6
7
8
9
10
11
# c6_compareages.kbs
# compare dos edades
input "Cual es su edad? ", edad_mia
input "Cual es la edad de su amigo? ", edad_amigo
print "Usted es ";
if edad_mia < edad_amigo then print "menor que";
if edad_mia = edad_amigo then print "de la misma edad que";
if edad_mia > edad_amigo then print "mayor que";
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 63 of
Capítulo 6: Decisiones, Decisiones, Decisiones
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 64 of
Capítulo 6: Decisiones, Decisiones, Decisiones
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
2
3
4
5
# c6_coinflip.kbs
moneda = rand
if moneda < .5 then print "Cara."
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 65 of
Capítulo 6: Decisiones, Decisiones, Decisiones
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
expresión2
OR
TRUE
FALSE
TRUE
TRUE
FALSE
FALSE
FALSE
FALSE
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
expresión 2
XOR
TRUE
FALSE
TRUE
TRUE
TRUE
FALSE
TRUE
FALSE
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
expresión 2
NOT
TRUE
FALSE
TRUE
FALSE
TRUE
FALSE
TRUE
FALSE
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
expresión1
TRUE
FALSE
FALSE
TRUE
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 66 of
Capítulo 6: Decisiones, Decisiones, Decisiones
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# c6_dado.kbs
# Tirar 2 dados (die) de 6 caras cada uno
die1 = int(rand * 6) + 1
die2 = int(rand * 6) + 1
total = die1 + die2
print "dado 1 = " + die1
print "dado 2 = " + die2
mensaje$ = "Ud. tiró " + total + "."
if total = 2 then
mensaje$ += " Ojos de Serpiente."
end if
if total = 12 then
mensaje$ += " Una docena."
end if
if die1 = die2 then
mensaje$ += " Doblete, tire nuevamente!"
end if
print mensaje$
say mensaje$
Programa 33: Tirando dados
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 67 of
Capítulo 6: Decisiones, Decisiones, Decisiones
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
2
3
4
5
6
7
8
9
10
11
# c6_coinflip2.kbs
# tirar moneda con else
coin = rand
if coin < .5 then
print "Cara."
say "Cara."
else
print "Cruz."
say "Cruz."
end if
Programa 34: Tirando una Moneda con else
Cara.
Salida 34: Tirando una Moneda con else
Decisiones Anidadas
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 68 of
Capítulo 6: Decisiones, Decisiones, Decisiones
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 69 of
Capítulo 6: Decisiones, Decisiones, Decisiones
34
35
36
message$ = "Ud. tiró un " + tiro + "."
print message$
say message$
Programa 35: Programa Grande – Tire un dado y dibújelo
Salida 35: Programa Grande – Tire un dado y dibújelo
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 70 of
Capítulo 6: Decisiones, Decisiones, Decisiones
Ejercicios:
b
i
e
r
a
p
m
o
c
w
t
o
d
n
a
n
o
t
i
f
t
r
o
r
e
t
a
e
r
g
h
w
u
l
u
l
a
u
q
e
e
l
l
e
e
n
d
i
f
e
n
f
d
w
t
a
s
h
f
s
m
o
d
n
a
r
n
l
s
l
r
r
o
t
a
r
e
p
o
a
n
z
d
j
r
o
p
t
h
f
s
e
s
l
e
o
l
e
s
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 71 of
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 72 of
Capítulo 7: Bucles y Conteo – Hágalo de Nuevo y de Nuevo
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
2
3
4
5
6
7
8
9
# c7_moire.kbs
# dibuje un patrón moire
clg
color black
for t = 1 to 300 step 3
line 0,0,300,t
line 0,0,t,300
next t
Programa 38: Patrón Moiré
Salida 38: Patrón Moiré
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 73 of
Capítulo 7: Bucles y Conteo – Hágalo de Nuevo y de Nuevo
¿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) negativo1
2
3
4
5
6
# c7_stepneg1.kbs
for t = 10 to 0 step -1
print t
pause 1.0
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
2
3
4
5
6
# c7_dountil.kbs
do
input "Ingrese un número entre 1 y 10? ",n
until n>=1 and n<=10
print "Ud. ingresó " + n + " y detuvo el loop"
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 74 of
Capítulo 7: Bucles y Conteo – Hágalo de Nuevo y de Nuevo
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 75 of
Capítulo 7: Bucles y Conteo – Hágalo de Nuevo y de Nuevo
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
2
3
4
5
6
7
8
9
10
# maquina de sumar
# c7_exitwhile.kbs
total = 0
while true
input "Ingrese un valor (-999 para salir) > ", v
if v = -999 then exit while
total = total + v
end while
print "La suma de lo ingresado es " + total
Programa 43: Maquina de sumar - Usando Exit While
Ingrese un valor (-999 para salir)
Ingrese un valor (-999 para salir)
Ingrese un valor (-999 para salir)
Ingrese un valor (-999 para salir)
Ingrese un valor (-999 para salir)
La suma de lo ingresado es 278
>
>
>
>
>
34
-34
234
44
-999
Salida 43: Maquina de sumar - Usando Exit While
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 76 of
Capítulo 7: Bucles y Conteo – Hágalo de Nuevo y de Nuevo
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 77 of
Capítulo 7: Bucles y Conteo – Hágalo de Nuevo y de Nuevo
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# c7_bouncingball.kbs
fastgraphics
clg
# posición inicial de la pelota
x = rand * 300
y = rand * 300
# size of ball
r = 10
# velocidad en direcciones x e y
dx = rand * r + 2
dy = rand * r + 2
color green
rect 0,0,300,300
while true
# borre la pelota vieja
color white
circle x,y,r
# calcule la nueva posicion
x = x + dx
y = y + dy
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 78 of
Capítulo 7: Bucles y Conteo – Hágalo de Nuevo y de Nuevo
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# si fuera de los bordes laterales rebote la pelota
if x < 0 or x > 300 then
dx = dx * -1
sound 1000,50
end if
# si fuera de bordes sup. o inf. Rebote la pelota
if y < 0 or y > 300 then
dy = dy * -1
sound 1500,50
end if
# dibuje la nueva pelota
color red
circle x,y,r
# refresque la pantalla
refresh
end while
Programa 45: Programa Grande – Pelota rebotando
Salida 45: Programa Grande – Pelota rebotando
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 79 of
Capítulo 7: Bucles y Conteo – Hágalo de Nuevo y de Nuevo
Ejercicios:
f
f
t
i
x
e
i
t
g
h
x
x
l
a
n
a
d
x
g
x
s
w
n
o
g
w
s
k
r
o
f
e
d
o
s
m
b
t
n
t
k
u
r
n
i
a
d
i
w
b
v
c
g
f
y
t
o
e
z
e
p
q
h
v
e
r
i
g
n
d
u
h
e
l
p
r
w
d
a
d
e
n
u
d
t
i
h
o
n
e
w
p
i
z
d
g
s
t
b
o
o
h
l
t
h
m
w
m
w
n
c
e
i
l
n
i
p
i
t
o
i
u
f
l
l
o
l
w
h
g
c
v
i
i
e
l
c
i
c
k
a
w
d
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:
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 80 of
Capítulo 7: Bucles y Conteo – Hágalo de Nuevo y de Nuevo
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
7
14
21
28
35
42
49
56
8
16
24
32
40
48
56
64
Página 81 of
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
2
3
4
5
6
7
8
9
10
11
# c8_graphichello.kbs
# dibujando texto
clg
color red
font "Tahoma",33,100
text 100,100,"Hello."
font "Impact",33,50
text 100,150,"Hello."
font "Courier New",33,50
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 82 of
Capítulo 8: Gráficos Personalizados – Creando sus Propias Formas
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
2
3
4
5
6
# c8_resizegraphics.kbs
# cambiar el tamaño de la ventana grafica
graphsize 500,500
xcenter = graphwidth/2
ycenter = graphheight/2
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 83 of
Capítulo 8: Gráficos Personalizados – Creando sus Propias Formas
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 84 of
Capítulo 8: Gráficos Personalizados – Creando sus Propias Formas
(150,10
0)
(125,15
0)
(100,15
0)
(125,20
0)
(175,15
0)
(200,15
0)
(175,20
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
2
3
4
150}
# c8_bigredarrow.kbs
clg
color red
poly {150, 100, 200, 150, 175, 150, 175, 200, 125, 200, 125, 150, 100,
Programa 48: Flecha Roja Grande
Salida 48: Flecha Roja Grande
poly {x1, y1, x2, y2 ...}
poly arreglo_numérico
Dibuja un polígono
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 85 of
Capítulo 8: Gráficos Personalizados – Creando sus Propias Formas
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,
8.6)
Ilustración 19: Triángulo Equilátero
(5,
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
2
3
4
5
6
7
8
9
10
# c8_stamptriangle.kbs
# use un sello para dibujar muchos triángulos
clg
color black
for x = 25 to 200 step 25
for y = 25 to 200 step 25
stamp x, y, {0, 0, 5, 8.6, -5, 8.6}
next y
next x
Programa 49: Llenando la pantalla con triángulos
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 86 of
Capítulo 8: Gráficos Personalizados – Creando sus Propias Formas
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 87 of
Capítulo 8: Gráficos Personalizados – Creando sus Propias Formas
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
2
# c8_stamptriangle2.kbs
# stamp triangulos con tamaño, rotación y posición al azar
4
5
6
7
8
9
10
11
12
clg
color black
for t = 1 to 100
x = rand * graphwidth
y = rand * graphheight
s = rand * 7
# scale hasta 7 veces + grande
r = rand * 2 * pi
# rotar hasta 2pi (360 grados)
stamp x, y, s, r, {0, 0, 5, 8.6, -5, 8.6}
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 88 of
Capítulo 8: Gráficos Personalizados – Creando sus Propias Formas
total de luz). Si los 3 son colocados a su máximo valor posible de 255, tendremos Blanco.
1
2
3
4
5
6
7
8
9
10
11
12
13
# c8_512colors.kbs
# show a few of the 16 million colors
graphsize 256, 256
clg
for r = 0 to 255 step 32
for g = 0 to 255 step 32
for b = 0 to 255 step 32
color rgb(r,g,b)
rect b/8+g, r, 4, 32
next b
next g
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)
1
2
3
4
5
# c8_stamptriangle3.kbs
# stamp triangulos de color, tamaño y rotación al azar
clg
penwidth 3
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 89 of
Capítulo 8: Gráficos Personalizados – Creando sus Propias Formas
6
7 for t = 1 to 100
8
x = rand * graphwidth
9
y = rand * graphheight
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
2
3
4
5
6
7
8
# c8_transparent.kbs
# mostrar la transparencia en los colores.
clg
color rgb(255,0,0,127)
circle 100,100,100
color rgb(0,255,0,127)
circle 200,100,100
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 90 of
Capítulo 8: Gráficos Personalizados – Creando sus Propias Formas
9
10
11
12
13
color rgb(0,0,255,127)
circle 100,200,100
color rgb(0,0,0,127)
circle 200,200,100
Programa 53: Círculos transparentes
Salida 53: Círculos transparentes
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# c8_stamptriangle4.kbs
# stamp randomly colored, sized and rotated triangles
clg
penwidth 3
for t = 1 to 100
x = rand * graphwidth
y = rand * graphheight
s = rand * 7
# scale hasta 7 veces mayor
r = rand * 2 * pi # rotacion hasta 2pi
rpen = rand * 256 # obtenga la parte RGB de un color de lápiz al azar
gpen = rand * 256
bpen = rand * 256
apen = rand * 256
rbrush = rand * 256 # color de llenado al azar
gbrush = rand * 256
bbrush = rand * 256
abrush = rand * 256
color rgb(rpen, gpen, bpen, apen), rgb(rbrush, gbrush, bbrush, abrush)
stamp x, y, s, r, {0, 0, 5, 8.6, -5, 8.6}
next t
Programa 54: 100 Triángulos al azar con colores transparentes al azar.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 91 of
Capítulo 8: Gráficos Personalizados – Creando sus Propias Formas
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
2
3
4
5
6
7
# c8_aflowerforyou.kbs
# use stamps para dibujar una flor
clg
color green
rect 148,150,4,150
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 92 of
Capítulo 8: Gráficos Personalizados – Creando sus Propias Formas
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
color rgb(255,128,128)
for r = 0 to 2*pi step pi/4
stamp graphwidth/2, graphheight/2, 2, r, {0, 0, 5, 20, 0, 25, -5, 20}
next r
color rgb(128,128,255)
for r = 0 to 2*pi step pi/5
stamp graphwidth/2, graphheight/2, 1, r, {0, 0, 5, 20, 0, 25, -5, 20}
next r
message$ = "A flower for you." # (Una flor para ti.)
color darkyellow
font "Tahoma", 14, 50
text 10, 10, message$
say message$
Programa 55 Programa Grande: Una Flor para Tí.
Salida 55: Programa Grande: Una Flor para Tí.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 93 of
Capítulo 8: Gráficos Personalizados – Creando sus Propias Formas
Ejercicios:
t
k
v
b
a
p
a
e
p
l
g
s
n
c
g
h
s
t
o
m
w
r
r
i
e
r
p
d
e
e
a
i
a
u
a
p
r
l
r
x
m
t
e
p
n
o
p
o
a
s
t
a
s
f
h
r
g
t
h
l
p
e
r
r
d
h
o
r
g
d
w
y
s
u
z
x
e
i
a
n
e
e
i
g
n
l
a
i
f
p
a
r
t
u
d
o
a
b
g
t
h
p
f
n
q
u
t
n
r
h
c
i
g
r
e
e
n
j
h
c
t
e
c
f
w
i
t
h
g
i
e
w
j
s
g
r
a
p
h
s
i
z
e
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 94 of
Capítulo 8: Gráficos Personalizados – Creando sus Propias Formas
(0, -1)
(-0.886,
-0.5)
(0.886,
-0.5)
(-0.886,
0.5)
(0.886,
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 95 of
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 96 of
Capítulo 9: Funciones y Subroutinas – Reusando Código
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# c9_minimum.kbs
# función para encontrar el minimo
input "Ingrese un numero ", a
input "Ingrese un segundo número ", b
print "El menor de los números es ";
print minimo(a,b)
end
function minimo(x,y)
# devuelve el menor de dos números (x,y) pasados por argumento
if x<y then return x
return y
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
2
3
4
5
6
7
8
9
10
# c9_gameroller.kbs
# Juego de Dados
print "Tirador de Dados"
s = get ("Caras del dado",6)
n = get ("Numero de dados", 2)
total = 0
for x = 1 to n
d = die(s)
print d
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 97 of
Capítulo 9: Funciones y Subroutinas – Reusando Código
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
total = total + d
next x
print "Total = "+ total
end
function get (message$, default)
# lea un numero de pantalla
# si ingresaron cero tome el valor por defecto
input message$ + " (default " + default + ")? ", n
if n = 0 then n = default
return n
end function
function die(caras)
# tire un dado y devuelva el valor de la cara
return int(rand*caras)+1
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# c9_repeatstring.kbs
# funcion string simple – haga copias
a$ = "ja"
b$ = repeat$(a$,20)
print a$
print b$
end
function repeat$(w$,n)
a$ = ""
for t = 1 to n
a$ += w$
next t
return a$
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 98 of
Capítulo 9: Funciones y Subroutinas – Reusando Código
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 99 of
Capítulo 9: Funciones y Subroutinas – Reusando Código
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 100 of
Capítulo 9: Funciones y Subroutinas – Reusando Código
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# c9_subroutineclock.kbs
# muestre un reloj digital en pantalla
fastgraphics
font "Tahoma", 20, 100
color blue
rect 0, 0, 300, 300
color yellow
text 0, 0, "My Clock."
while true
call displaytime()
pause 1.0
end while
end
subroutine displaytime()
color blue
rect 100, 100, 200, 100
color yellow
text 100, 100, hour + ":" + minute + ":" + second
refresh
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 101 of
Capítulo 9: Funciones y Subroutinas – Reusando Código
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)
month
Devuelve el corriente mes, desde 0 a 11.
0 - Enero, 1 - Febrero...
day
Devuelve el día del mes: 1…, 28, 29, 30, o 31.
hour
Devuelve la hora, 0 a 23 en formato de 24 horas
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
5
font "Tahoma", 20, 100
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()
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 102 of
Capítulo 9: Funciones y Subroutinas – Reusando Código
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
2
3
4
5
6
7
8
9
10
# c9_gamerollerinclude.kbs
# Tirador de Dados
include "e2_c9_function_dado.kbs"
include "e2_c9_inputnumberfunction.kbs"
print "die roller"
s = inputnumber("caras del dado ",6)
n = inputnumber("numero de dados ", 2)
total = 0
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 103 of
Capítulo 9: Funciones y Subroutinas – Reusando Código
11
12
13
14
15
16
17
for x = 1 to n
d = dado(s)
print d
total = total + d
next x
print "total "+ total
end
Programa 61: Tirador de Dados – Con Funciones included.
1
2
3
4
5
6
7
# c9_function_dado.kbs
# funcion para tirar un dado de N caras
function dado (caras)
# tire un dado y devuelva a caras
return int(rand*caras)+1
end function
Programa 62: Tirador de Dados – Función die
1
2
3
4
5
6
7
8
9
# c9_inputnumberfunction.kbs
function inputnumber (prompt$, default)
# lea un numero de pantalla
# si ingresaron cero tome el valor por defecto
input prompt$ + " (default " + default + ") ?", n
if n = 0 then n = default
return n
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
2
3
4
5
6
7
8
9
10
11
12
# c9_addingmachine.kbs
# una linda maquina de sumar
include "e2_c9_inputnumberfunction.kbs"
print "Maquina de Sumar"
print "Presione STOP para terminar"
total = 0
while true
a = inputnumber("+ ",0)
total = total + a
print total
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 104 of
Capítulo 9: Funciones y Subroutinas – Reusando Código
13
14
end while
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…)
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 105 of
Capítulo 9: Funciones y Subroutinas – Reusando Código
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
2
3
4
5
6
7
8
9
10
11
12
13
14
# c9_gosub.kbs
# un uso de gosub simple
x = 10
for t = 1 to 3
print "x igual a: " + x
gosub muestralinea
next t
end
muestralinea:
print "------------------"
x=x*2
return
Programa 66: Gosub
x igual a: 10
-----------------x igual a: 20
-----------------x igual a: 40
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 106 of
Capítulo 9: Funciones y Subroutinas – Reusando Código
-----------------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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# c9_roll2dice2.kbs
# tirar dos dados en modo gráfico
include "e2_c9_diefunction.kbs"
clg
total = 0
roll = die(6)
total = total + roll
call dibujedado(30,30, roll)
roll = die(6)
total = total + roll
call dibujedado(130,130, roll)
print "Ud. tiró " + total + "."
end
subroutine dibujedado(x,y,n)
# defina x, y para el vértice superior izquierdo y
# n para el numero de puntos
# dibuje dado de 70x70 pixeles con puntos de 10x10 pixels
color black
rect x,y,70,70
color white
# fila superior
if n <> 1 then rect x + 10, y + 10, 10, 10
if n = 6 then rect x + 30, y + 10, 10, 10
if n >= 4 and n <= 6 then rect x + 50, y + 10, 10, 10
# mitad
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 107 of
Capítulo 9: Funciones y Subroutinas – Reusando Código
31
32
33
34
35
36
if n = 1 or n = 3 or n = 5 then rect x + 30, y + 30,10, 10
# fila inferior
if n >= 4 and n <= 6 then rect x + 10, y + 50, 10, 10
if n = 6 then rect x + 30, y + 50, 10, 10
if n <> 1 then rect x + 50, y + 50, 10, 10
end subroutine
Programa 67: Programa Grande – Tirar dos dados gráficamente
Salida 67: Programa Grande – Tirar dos dados gráficamente
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 108 of
Capítulo 9: Funciones y Subroutinas – Reusando Código
Ejercicios:
g
k
u
l
k
g
o
s
u
b
e
h
o
x
i
n
c
l
u
d
e
m
t
o
t
a
d
h
l
e
b
a
l
z
u
u
o
w
r
r
e
t
u
r
n
j
n
r
d
r
x
g
p
a
l
l
a
c
i
s
e
n
i
t
u
o
r
b
u
s
m
o
j
x
o
z
j
m
h
f
i
l
e
w
j
d
p
c
d
n
e
r
a
e
y
w
v
s
i
s
e
h
t
n
e
r
a
p
e
q
d
c
p
s
v
h
t
n
o
m
q
a
r
e
t
a
n
i
m
r
e
t
y
n
o
i
t
c
n
u
f
n
b
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 109 of
Capítulo 9: Funciones y Subroutinas – Reusando Código
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 110 of
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
2
3
4
5
6
7
9
10
11
12
13
14
15
16
17
18
19
20
# c10_mousetrack.kbs
# Siguiendo el Mouse con un circulo
print "Mueva el mouse en la ventana gráfica."
print "Presione el boton Izquierdo para salir."
fastgraphics
# siga ejecutando hasta que el usuario presione el botón izq.
while mouseb <> 1
# limpie la pantalla
color white
rect 0, 0, graphwidth, graphheight
# dibuje un Nuevo circulo
color red
circle mousex, mousey, 10
refresh
end while
print "Listo."
end
Programa 68: Siguiendo el Mouse
Salida 68: Siguiendo el Mouse
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 111 of
Capítulo 10: Control del Mouse – Moviendo Cosas
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
0
Devuelve este valor cuando no ha sido apretado
ningún botón.
1
Devuelve este valor cuando se apretó el botón
“izquierdo” del mouse.
2
Devuelve este valor cuando se apretó el botón
“derecho” del mouse.
4
Devuelve este valor cuando se apretó el botón
“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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# c10_mouseclick.kbs
# X marca el punto en donde se hizo el click
print "Mueva el mouse en la ventana gráfica."
print "Presione botón izquierdo para marcar su punto "
print "Presions botón derecho para salir."
clg
clickclear
while clickb <> 2
# limpie último click y espere a que se presione un botón
clickclear
while clickb = 0
pause .01
end while
#
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 112 of
Capítulo 10: Control del Mouse – Moviendo Cosas
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 113 of
Capítulo 10: Control del Mouse – Moviendo Cosas
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 114 of
Capítulo 10: Control del Mouse – Moviendo Cosas
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# c10_colorchooser.kbs
fastgraphics
print "Selector de Color – Encuentre uno"
print "Click & arrastre los deslizadores rojo, verde y azul"
# variables para guardar los componentes de color
r = 128
g = 128
b = 128
call display(r,g,b)
while true
# espere por un click
while mouseb = 0
pause .01
end while
# cambie color con deslizadores
# deslizador rojo y rango es 0 >= red < 75
if mousey < 75 then
r = mousex
if r > 255 then r = 255
end if
# deslizador verde y rango es 75 >= red < 150
if mousey >= 75 and mousey < 150 then
g = mousex
if g > 255 then g = 255
end if
# deslizador azul y rango es 150 >= red < 225
if mousey >= 150 and mousey < 225 then
b = mousex
if b > 255 then b = 255
end if
call display(r,g,b)
end while
end
subroutine colorline(r,g,b,x,y)
# dibuje parte de la barra de color
# el color r,g,b de x,y a x,y+37
color rgb(r, g, b)
line x, y, x, y+37
end subroutine
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 115 of
Capítulo 10: Control del Mouse – Moviendo Cosas
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
subroutine redsliderbar(r,g,b)
# dibuje la barra roja desde 0,0 a 255,74
font "Tahoma", 30, 100
color rgb(255, 0, 0)
text 260, 10, "r"
for t = 0 to 255
# rojo y tonos rojos
call colorline(t, 0, 0, t, 0)
call colorline(t, g, b, t, 38)
next t
color black
rect r-1, 0, 3, 75
end subroutine
subroutine greensliderbar(r,g,b)
# dibuje la barra verde desde 0,75 a 255,149
font "Tahoma", 30, 100
color rgb(0, 255, 0)
text 260, 85, "g"
for t = 0 to 255
# verde y tonos verdes
call colorline(0, t, 0, t, 75)
call colorline(r, t, b, t, 113)
next t
# slider
color black
rect g-1, 75, 3, 75
end subroutine
subroutine bluesliderbar(r,g,b)
# dibuje la barra azul desde 0,150 a 255,224
font "Tahoma", 30, 100
color rgb(0, 0, 255)
text 260, 160, "b"
for t = 0 to 255
# azul y tonos azules
call colorline(0, 0, t, t, 150)
call colorline(r, g, t, t, 188)
next t
# deslizador
color black
rect b-1, 150, 3, 75
end subroutine
subroutine display(r, g, b)
clg
call redsliderbar(r,g,b)
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 116 of
Capítulo 10: Control del Mouse – Moviendo Cosas
93
94
95
96
97
98
99
100
101
102
call greensliderbar(r,g,b)
call bluesliderbar(r,g,b)
# dibuje muestra
color black
font "Tahoma", 13, 100
text 5, 235, "(" + r + "," + g + "," + b + ")"
color rgb(r,g,b)
rect 151,226,150,75
refresh
end subroutine
Programa 70: Programa Grande – Selector de Color
Salida 70: Programa Grande – Selector de Color
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 117 of
Capítulo 10: Control del Mouse – Moviendo Cosas
Ejercicios:
r
j
n
b
k
c
i
l
c
c
f
a
c
e
n
t
e
r
j
x
m
a
e
x
z
m
z
p
i
l
t
o
y
l
m
o
u
s
e
x
x
h
u
e
c
r
n
g
h
m
v
k
t
s
s
k
i
s
w
f
t
s
c
h
e
u
c
g
l
z
x
f
l
i
w
b
o
i
h
a
n
o
e
y
l
k
g
m
l
t
j
u
c
l
i
c
k
y
m
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 118 of
Capítulo 10: Control del Mouse – Moviendo Cosas
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í.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 119 of
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
2
3
4
5
6
7
8
9
10
11
12
# c11_readkey.kbs
print "Presione una tecla - Q para salir."
do
k = key
if k <> 0 then
if k >=32 and k <= 127 then
print chr(k) + "=";
end if
print k
end if
until k = asc("Q")
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 120 of
Capítulo 11: Control del Teclado - Usando el Teclado
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
2
3
4
5
6
7
8
9
10
11
12
13
14
# c11_msec.kbs
# obtenga el código para un carácter al azar entre A-Z
c = asc("A") + int(rand*26)
# muestre la letra (a partir de su código numerico)
print "Presione '" + chr(c) + "'"
time = msec
# tome el tiempo inicial
do
# espere por una tecla presionada
k = key
until k = c
time = msec – time # calcule el tiempo transcurrido
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 121 of
Capítulo 11: Control del Teclado - Usando el Teclado
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
24
call drawball(x, y, r)
25
end if
26
if k = asc("J") then
27
x=x-r
28
if x < r then x = graphwidth - r
29
call drawball(x, y, r)
30
end if
31
if k = asc("K") then
32
x=x+r
33
if x > graphwidth - r then x = r
34
call drawball(x, y, r)
35
end if
36
if k = asc("M") then
37
y=y+r
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 122 of
Capítulo 11: Control del Teclado - Usando el Teclado
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
if y > graphheight - r then y = r
call drawball(x, y, r)
end if
if k = asc("Q") then exit while
end while
print "Terminado."
end
subroutine drawball(ballx, bally, ballr)
color white
rect 0, 0, graphwidth, graphheight
color red
circle ballx, bally, ballr
refresh
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
2
3
4
5
6
7
8
9
# c11_fallinglettergame.kbs
speed = .15 # velocidad de caida – menor = + rapido
nletters = 10 # letras para jugar
score = 0
misses = 0
color black
fastgraphics
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 123 of
Capítulo 11: Control del Teclado - Usando el Teclado
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
clg
font "Tahoma", 20, 50
text 20, 80, "Juego de Lluvia de Letras"
font "Tahoma", 16, 50
text 20, 140, "Presione una tecla para comenzar"
refresh
# “limpie” el teclado y espere por una tecla presionada
k = key
while key = 0
pause speed
end while
misses = nletters # primero asume que perdió todas
for n = 1 to nletters
letter = int((rand * 26)) + asc("A")
x = 10 + rand * 225
for y = 0 to 250 step 20
clg
# muestre letra
font "Tahoma", 20, 50
text x, y, chr(letter)
# muestre score y puntos
font "Tahoma", 12, 50
value = (250 - y)
text 10, 270, "Valor "+ value
text 200, 270, "Score "+ score
refresh
k = key
if k <> 0 then
if k = letter then
score = score + value
misses-- # no perdió esta!
else
score = score - value
end if
exit for
end if
pause speed
next y
next n
clg
font "Tahoma", 20, 50
text 20, 40, " Juego de Lluvia de Letras"
text 20, 80, "Game Over"
text 20, 120, "Score: " + score
text 20, 160, "Perdió: " + misses
refresh
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 124 of
Capítulo 11: Control del Teclado - Usando el Teclado
57
end
Programa 74: Programa Grande - Juego de Lluvia de Letras
Salida 74: Programa Grande - Juego de Lluvia de Letras
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 125 of
Capítulo 11: Control del Teclado - Usando el Teclado
Ejercicios:
k
e
y
t
f
i
h
s
g
a
b
b
u
t
j
i
c
o
n
t
r
o
l
c
v
w
o
r
r
a
m
s
f
y
h
b
t
t
e
a
k
c
o
l
s
p
a
c
e
o
z
n
g
y
b
j
t
u
n
i
c
o
d
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ó.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 126 of
Capítulo 11: Control del Teclado - Usando el Teclado
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 127 of
Capítulo 12: Imágenes, WAVs y Sprites
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
2
3
4
5
6
7
8
9
10
# c12_5pointed.kbs
#
graphsize 100,100
clg
color black,clear
for s = 1 to 50 step 2
stamp 50,50,s,s,{0,-1, .95,-.31, .59,.81, -.59,.81,-.95,-.31}
next s
#
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 128 of
Capítulo 12: Imágenes, WAVs y Sprites
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 129 of
Capítulo 12: Imágenes, WAVs y Sprites
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
2
3
4
# c12_numberpopper.kbs
# reproducción de archivos .wav
fastgraphics
wavplay "cancion_1.wav"
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 130 of
Capítulo 12: Imágenes, WAVs y Sprites
5
6
7
8
9
10
11
12
13
14
15
16
17
18
29
20
21
22
speed = .05
for t = 1 to 3
n = int(rand * 6 + 1)
for pt = 1 to 200 step 10
font "Tahoma",pt,100
clg
color black
text 10,10, n
refresh
pause speed
next pt
speed = speed / 2
next t
# wait for sound to complete
wavwait
wavplay "canción_2.wav"
wavwait
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
2
3
4
5
6
7
8
9
# c12_sprite1ball.kbs
# sonidos de http://www.freesound.org/people/NoiseCollector
color white
rect 0, 0, graphwidth, graphheight
spritedim 1
spriteload 0, "blueball.png"
spriteplace 0, 100,100
spriteshow 0
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 131 of
Capítulo 12: Imágenes, WAVs y Sprites
10
11
12
13
14
15
16
17
18
19
20
21
22
23
dx = rand * 10
dy = rand * 10
while true
if spritex(0) <=0 or spritex(0) >= graphwidth -1 then
dx = dx * -1
wavplay "4359__NoiseCollector__PongBlipF4.wav"
end if
if spritey(0) <= 0 or spritey(0) >= graphheight -1 then
dy = dy * -1
wavplay "4361__NoiseCollector__pongblipA_3.wav"
endif
spritemove 0, dx, dy
pause .05
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 132 of
Capítulo 12: Imágenes, WAVs y Sprites
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 133 of
Capítulo 12: Imágenes, WAVs y Sprites
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# c12_spritebumper.kbs
# muestre dos sprites con colisión
color white
rect 0, 0, graphwidth, graphheight
spritedim 2
# Parachoques estacionario
spriteload 0, "paddle.png"
spriteplace 0,graphwidth/2,graphheight/2
spriteshow 0
# Pelota moviendose
spriteload 1, "greenball.png"
spriteplace 1, 50, 50
spriteshow 1
dx = rand * 5 + 5
dy = rand * 5 + 5
while true
if spritex(1) <=0 or spritex(1) >= graphwidth -1 then
dx = dx * -1
end if
if spritey(1) <= 0 or spritey(1) >= graphheight -1 then
dy = dy * -1
end if
if spritecollide(0,1) then
dy = dy * -1
print "bump"
end if
spritemove 1, dx, dy
pause .05
end while
Programa 80: Dos Sprites con Colisión
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 134 of
Capítulo 12: Imágenes, WAVs y Sprites
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
2
4
5
6
7
9
10
11
12
13
14
15
16
# c12_spritepoly.kbs
# crea un sprite de un polígono que sigue al mouse
spritedim 1
color red, blue
penwidth 1
spritepoly 0, {15,0, 30,10, 20,10, 20,30, 10,30, 10, 10, 0,10}
color green
rect 0, 0, graphwidth, graphheight
spriteshow 0
while true
spriteplace 0, mousex, mousey
pause .01
end while
Programa 81: Creando el Sprite de un Polígono
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 135 of
Capítulo 12: Imágenes, WAVs y Sprites
Salida 81: Creando el Sprite de un Polígono
spritepoly
spritepoly
spritepoly
spritepoly
spritenumero, { puntos }
( spritenumero, { puntos } )
spritenumero, variable_array
( 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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# c12_sprite_paddleball.kbs
# juego de fronton hecho con sprites
# sonidos de http://www.freesound.org/people/NoiseCollector
print "Juego de Frontón"
print "Las teclas J y K mueven la raqueta. "
input "Presione enter para comenzar >", wait$
color white
rect 0, 0, graphwidth, graphheight
spritedim 2
color blue, darkblue
spritepoly 0, {0,0, 80,0, 80,20, 70,20, 70,10, 10,10, 10,20, 0,20}
spriteplace 0, 100,270
spriteshow 0
spriteload 1, "greenball.png"
spriteplace 1, 100,100
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 136 of
Capítulo 12: Imágenes, WAVs y Sprites
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
then
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
spriteshow 1
penwidth 2
dx = rand * .5 + .25
dy = rand * .5 + .25
bounces = 0
while spritey(1) + spriteh(1) - 5 < spritey(0)
k = key
if chr(k) = "K" then
spritemove 0, 20, 0
end if
if chr(k) = "J" then
spritemove 0, -20, 0
end if
if spritecollide(0,1) then
# rebote y aumente velocidad
dy = dy * -1
dx = dx * 1.1
bounces = bounces + 1
wavstop
wavplay "96633__CGEffex__Ricochet_metal5.wav"
# mover sprite fuera de la paleta
while spritecollide(0,1)
spritemove 1, dx, dy
end while
end if
if spritex(1) <=0 or spritex(1) >= graphwidth -1
dx = dx * -1
wavstop
wavplay "4359__NoiseCollector__PongBlipF4.wav"
end if
if spritey(1) <= 0 then
dy = dy * -1
wavstop
wavplay "4361__NoiseCollector__pongblipA_3.wav"
end if
spritemove 1, dx, dy
# ajuste la velocidad aqui
pause .002
end while
print "Ud. Rebotó la pelota " + bounces + " veces."
Programa 82: Juego de Frontón con Sprites
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 137 of
Capítulo 12: Imágenes, WAVs y Sprites
Sample Output 82: Juego de Frontón con Sprites
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 138 of
Capítulo 12: Imágenes, WAVs y Sprites
Ejercicios:
i
s
k
z
a
c
q
w
q
w
q
o
u
h
s
s
e
p
j
e
f
o
j
a
n
b
s
u
p
f
d
j
v
r
m
v
h
l
o
v
p
v
r
a
t
d
i
c
p
i
f
o
i
l
r
p
i
w
p
s
i
e
i
m
t
t
t
m
i
i
t
l
o
g
b
m
s
r
a
s
a
e
t
e
e
s
t
a
e
k
e
c
z
u
t
m
e
l
p
t
s
i
g
y
i
n
a
n
o
t
p
i
l
o
v
i
a
o
a
m
s
l
r
z
o
c
a
d
a
a
m
r
y
n
g
i
e
o
l
m
c
i
w
e
i
d
m
p
d
l
o
h
y
u
e
l
g
p
f
t
h
t
s
s
o
n
e
d
i
l
l
o
c
e
t
i
r
p
s
a
o
w
a
v
w
a
i
t
w
j
s
r
r
e
d
z
d
s
p
r
i
t
e
h
i
d
e
p
f
u
u
w
o
h
s
e
t
i
r
p
s
c
z
s
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 139 of
Capítulo 12: Imágenes, WAVs y Sprites
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 140 of
Capítulo 13: Imprimiendo
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
2
3
4
5
6
7
8
9
10
11
12
# c13_printpage.kbs
# imprimir una pagina con texto
printer on
x = 100 # empiece la 1ra. linea 100 pixes debajo.
font "Times New Roman", 30, 100
for t = 1 to 10
text 0, x, "The number t is " + t
x = x + textheight()
next t
printer off
Programa 83 : Imprimiendo una Página con Texto
Salida 83: Imprimiendo una Página con Texto
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 141 of
Capítulo 13: Imprimiendo
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 142 of
Capítulo 13: Imprimiendo
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# c13_drawpage.kbs
# Draw on the page
printer on
# coloque el texto en el CENTRO de la pagina
color black
font "Arial", 40, 500
words$ = "Center"
x = ( graphwidth - textwidth(words$) ) / 2
y = ( graphheight - textheight() ) / 2
text x,y,words$
# dibuje un circulo alrededor del texto
# llenelo con color “clear”
color black, clear
penwidth 5
circle graphwidth/2, graphheight/2, 100
# dibuje un triangulo usando poly
color black, grey
penwidth 10
poly {200,100, 300,300, 100,300 }
# dibuje un patrón moire en la pagina
color black
penwidth 1
for t = 0 to 400 step 3
line graphwidth, graphheight, graphwidth-400, graphheight-t
line graphwidth, graphheight, graphwidth-t, graphheight-400
next t
printer off
Programa 84: Imprimiendo una Página con Gráficos
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 143 of
Capítulo 13: Imprimiendo
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
2
3
4
5
6
7
8
9
10
11
# c13_multtable.kbs
# imprima la tabla de multiplicar del 12 hasta 12
printer on
color black
font "Arial", 12, 100
# size of a cell on grid
w = 700/13
h = textheight()*2
#
pad = 5
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 144 of
Capítulo 13: Imprimiendo
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
# dibuje la grilla
penwidth 2
for x = 0 to 14
line x*w,0,x*w,14*h
next x
for y = 0 to 14
line 0,y*h,14*w,y*h
next y
# ponga los números de fila y de columna
font "Arial", 12, 100
for x = 0 to 12
text (x+1)*w+pad,pad,x
next x
for y = 0 to 12
text pad,(y+1)*h+pad,y
next y
# ponga los productos
font "Arial", 12, 50
for x = 0 to 12
for y = 0 to 12
text (x+1)*w+pad,(y+1)*h+pad,(x*y)
next y
next x
printer off
Programa 85: Tabla de Multiplicar
Salida 85: Tabla de Multiplicar
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 145 of
Capítulo 13: Imprimiendo
Ejercicios:
k
j
p
b
t
r
o
m
g
o
l
f
o
s
h
e
k
a
h
z
a
d
r
g
g
s
p
r
t
c
n
r
t
n
i
o
r
g
d
a
d
e
r
i
e
l
i
i
i
n
s
p
a
t
h
u
n
n
w
c
c
a
i
t
t
t
t
d
t
e
a
p
t
e
x
i
e
f
x
l
p
t
x
s
e
o
r
d
e
x
e
g
a
p
t
n
o
p
t
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 146 of
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
2
3
4
5
6
7
8
9
10
11
12
13
# c14_arraynumeric1d.kbs
# array numérico uni-dimensional
dim a(10)
# se crea el array “a” de 10 elementos. Es un array
# numérico porque “a” denota una variable numérica
a[0] = 100
a[1] = 200
a[3] = a[1] + a[2]
input "Ingrese un numero> ", a[9]
a[8] = a[9] - a[3]
for t = 0 to 9
print "a[" + t + "] = " + a[t]
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 147 of
Capítulo 14: Arreglos – Colecciones de Información
Salida 86: Array Numérico Uni-dimensional
dim
dim
dim
dim
variable (items)
 array numérico
variable$(items)
 array de strings ($)
variable (filas, columnas)
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# c14_manyballbounce.kbs
# use arrays para mantener la direccion, posición,
# y color de varias pelotas en pantalla
fastgraphics
r = 10
# tamaño de la pelota
balls = 50 # numero de pelotas
dim x(balls)
dim y(balls)
dim dx(balls)
dim dy(balls)
dim colors(balls)
for b = 0 to balls-1
# posición inicial de las pelotas
x[b] = 0
y[b] = 0
# velocidad en dirección x e y
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 148 of
Capítulo 14: Arreglos – Colecciones de Información
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
dx[b] = rand * r + 2
dy[b] = rand * r + 2
# cada pelota tiene su propio color
colors[b] = rgb(rand*256, rand*256, rand*256)
next b
color green
rect 0,0,300,300
while true
# limpie pantalla (erase screen)
clg
# ubique y dibuje las pelotas
for b = 0 to balls -1
x[b] = x[b] + dx[b]
y[b] = y[b] + dy[b]
# si off los bordes laterales rebotan la pelota
if x[b] < 0 or x[b] > 300 then
dx[b] = dx[b] * -1
end if
# si off los bordes sup e inf rebotan la pelota
if y[b] < 0 or y[b] > 300 then
dy[b] = dy[b] * -1
end if
# dibuje nueva pelota
color colors[b]
circle x[b],y[b],r
next b
# refresque el display
refresh
pause .05
end while
Programa 87: Varias Pelotas Rebotando.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 149 of
Capítulo 14: Arreglos – Colecciones de Información
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
5
rect 0, 0, graphwidth, graphheight
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 150 of
Capítulo 14: Arreglos – Colecciones de Información
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# c14_listoffriends.kbs
# use un array de strings para guardar nombres
print "Haga una lista de mis amigos"
input "Cuantos amigos tiene? ", n
dim names$(n)
for i = 0 to n-1
input "Ingrese el nombre de un amigo? ", names$[i]
next i
cls
print "Mis amigos:"
for i = 0 to n-1
print "Amigo numero ";
print i + 1;
print ": " + names$[i]
next i
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 151 of
Capítulo 14: Arreglos – Colecciones de Información
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
2
3
4
5
6
7
8
9
# c14_arrayassign.kbs
# usando una lista de valores para crear un array asignado
numero = {56, 99, 145}
nombre$ = {"Alicia", "Franco", "Luciano"}
for i = 0 to 2
print number[i] + " " + name$[i]
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
2
4
5
#
#
#
#
c14_spacechirp.kbs
reproduzca un sonido espacial
valores pares 0,2,4... - frecuencia
valores impares 1,3,5... - duracion
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 152 of
Capítulo 14: Arreglos – Colecciones de Información
7
8
9
10
11
12
13
14
15
# el sonido empieza a 100hz y aumenta en 40Hz para cada uno
# del total de 50 sonidos en la lista. Duracion siempre 10.
dim a(100)
for i = 0 to 98 step 2
a[i] = i * 40 + 100
a[i+1] = 10
next i
sound a
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 153 of
Capítulo 14: Arreglos – Colecciones de Información
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
2
3
4
5
6
7
8
9
10
11
12
13
# c14_randompoly.kbs
# dibujar 5 poligonos pegados (lados compartidos) al azar
dim shape(10)
for t = 0 to 8 step 2
x = 300 * rand
y = 300 * rand
shape[t] = x
shape[t+1] = y
next t
clg
color black
poly shape
Programa 93: Crear Polígonos Pegados al Azar
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 154 of
Capítulo 14: Arreglos – Colecciones de Información
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# c14_grades.kbs
# calculate average grades for each student
# and whole class using a two dimensional array
nstudents = 3 # number of students
nscores = 4 # number of scores per student
dim students$(nstudents)
dim grades(nstudents, nscores)
# guarde las notas como columnas y los estudiantes como filas
# primer estudiante
students$[0] = "Panqui"
grades[0,0] = 90
grades[0,1] = 92
grades[0,2] = 81
grades[0,3] = 55
# segundo estudiante
students$[1] = "Lucho"
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 155 of
Capítulo 14: Arreglos – Colecciones de Información
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
grades[1,0] = 66
grades[1,1] = 99
grades[1,2] = 98
grades[1,3] = 88
# tercer estudiante
students$[2] = "Ali"
grades[2,0] = 79
grades[2,1] = 81
grades[2,2] = 87
grades[2,3] = 73
total = 0
for row = 0 to nstudents-1
studenttotal = 0
for column = 0 to nscores-1
studenttotal = studenttotal + grades[row, column]
total = total + grades[row, column]
next column
print "El promedio de " + students$[row] + "es ";
print studenttotal / nscores
next row
print "El promedio de la clase es ";
print total / (nscores * nstudents)
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 156 of
Capítulo 14: Arreglos – Colecciones de Información
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# c14_size.kbs
# Longitud de array y pasando a una subroutina
print "El Array de Numeros:"
number = {77, 55, 33}
call showarray(ref(number))
print "El Array de Numeros al Azar:"
dim r(5)
for a = 0 to r[?] - 1
r[a] = int(rand*10)+1
next a
call showarray(ref(r))
#
end
#
subroutine showarray(ref(a))
print "tiene " + a[?] + " elementos."
for i = 0 to a[?] - 1
print "elemento " + i + " " + a[i]
next i
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 157 of
Capítulo 14: Arreglos – Colecciones de Información
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 bidimensional.
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
2
3
4
5
6
7
8
9
10
# c14_redim.kbs
# se crea un array de 3 elementos
number = {77, 55, 33}
# se crea un nuevo elemento al final
redim number(4)
number[3] = 22
#
for i = 0 to 3
print i + " " + number[i]
next i
Programa 96: Re-Dimensionando un Array
0 77
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 158 of
Capítulo 14: Arreglos – Colecciones de Información
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# c14_spacewarp.kbs
# Game: Lluvia de basura espacial
# defina pelotas y arrays para ellas
balln = 5
dim ballx(balln)
dim bally(balln)
dim ballspeed(balln)
ballr = 10
# radio de las pelotas
# defina valores minimo y maximo
minx = ballr
maxx = graphwidth - ballr
miny = ballr
maxy = graphheight - ballr
# score initial
score = 0
# defina tamaño del jugador, dist.p/moverse y ubicación
playerw = 30
playerm = 10
playerh = 10
playerx = (graphwidth - playerw)/2
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 159 of
Capítulo 14: Arreglos – Colecciones de Información
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
52
rect 0, 0, graphwidth, graphheight
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 160 of
Capítulo 14: Arreglos – Colecciones de Información
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 161 of
Capítulo 14: Arreglos – Colecciones de Información
Ejercicios:
a
y
e
o
x
c
a
y
d
y
t
o
r
e
e
o
r
h
i
j
d
y
d
o
d
l
r
t
m
n
v
n
q
s
m
l
a
s
e
f
i
s
a
c
c
e
y
i
n
z
t
z
i
o
z
c
m
l
s
r
f
o
m
l
d
t
n
e
i
o
p
n
n
u
y
i
h
g
o
w
a
c
o
m
v
o
z
d
n
l
u
b
e
n
i
n
y
f
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 162 of
Capítulo 14: Arreglos – Colecciones de Información
180 315 405 540 2025
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 163 of
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
Módulo
%
Descripción
Devuelve el resto de una división entera.
División Entera
\
Devuelve el número total de veces que un
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
2
3
4
5
6
7
# c15_modulo.kbs
input "ingrese un número: ", n
if n % 2 = 0 then print "divisible
if n % 3 = 0 then print "divisible
if n % 5 = 0 then print "divisible
if n % 7 = 0 then print "divisible
end
por 2"
por 3"
por5"
por 7"
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 164 of
Capítulo 15: Matemáticas, Más diversion con Números
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
22
call drawball(x, y, ballradius)
23
end if
24
if k = asc("J") then
25
x = (x - ballradius + graphwidth) % graphwidth
26
call drawball(x, y, ballradius)
27
end if
28
if k = asc("K") then
29
x = (x + ballradius) % graphwidth
30
call drawball(x, y, ballradius)
31
end if
32
if k = asc("M") then
33
y = (y + ballradius) % graphheight
34
call drawball(x, y, ballradius)
35
end if
36
if k = asc("Q") then end
37
end while
38
39
subroutine drawball(bx, by, br)
40
color white
41
rect 0, 0, graphwidth, graphheight
42
color red
43
circle bx, by, br
44
refresh
45
end subroutine
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 165 of
Capítulo 15: Matemáticas, Más diversion con Números
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
2
3
4
5
6
7
# c15_integerdivision.kbs
input "dividendo ", dividendo
input "divisor ", divisor
print dividendo + " / " + divisor + " is ";
print dividendo \ divisor;
print "r";
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
2
2
2
2
2
2
2
^
^
^
^
^
^
^
^
0
1
2
3
4
5
6
7
=
=
=
=
=
=
=
=
1
2
4
8
16
32
64
128
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 166 of
Capítulo 15: Matemáticas, Más diversion con Números
2
2
2
2
2
2
2
2
2
^
^
^
^
^
^
^
^
^
8 = 256
9 = 512
10 = 1024
11 = 2048
12 = 4096
13 = 8192
14 = 16384
15 = 32768
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
int (expression)
Convierte una expresión (string, valor
entero o decimal) en un entero.
Cuando convierte un valor de punto
flotante, la parte decimal es truncada
(eliminada). Si un string no contiene un
número, devuelve cero (0).
ceil (expression)
Convierte un valor de punto flotante en el
valor entero mayor más próximo
(redondeo hacia arriba).
Ej.: a = floor (7.6) = 8
floor (expression)
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Convierte una expresión de punto flotante
al valor entero menor más próximo
(redondeo hacia abajo).
Página 167 of
Capítulo 15: Matemáticas, Más diversion con Números
Ej.: a = floor (7.6) = 7
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 168 of
Capítulo 15: Matemáticas, Más diversion con Números
1
2
3
4
5
6
7
8
# c15_intceilfloor.kbs
for t = 1 to 10
n = rand * 100 - 50
print n;
print " int=" + int(n);
print " ceil=" + ceil(n);
print " floor=" + floor(n)
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
3.413543 int=3 ceil=4 floor=3
-26.608505 int=-26 ceil=-26 floor=-27
-18.813465 int=-18 ceil=-18 floor=-19
7.096065 int=7 ceil=8 floor=7
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.
Función
Descripción
float (expresión)
Convierte expresion (valor string, entero o
decimal) a un valor decimal.
Util para convertir strings a números. Si un
string no contiene un número, devuelve cero
(0).
abs (expresión)
Convierte un valor entero o punto flotante a su
valor absoluto.
log (expresión)
Devuelve el logaritmo natural (base e) de un
número.
log10 (expresión)
Devuelve el logaritmo (base 10) de un
número.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 169 of
Capítulo 15: Matemáticas, Más diversion con Números
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.
Función
Descripción
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π).
acos (expresion)
Devuelve el coseno inverso (arco coseno) de un
ángulo
asin (expresion)
Devuelve el seno inverso (arco seno) de un
ángulo
atan (expresion)
Devuelve la tangente inversa (arco tangente) de
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 170 of
Capítulo 15: Matemáticas, Más diversion con Números
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):
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 171 of
Capítulo 15: Matemáticas, Más diversion con Números
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().
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 172 of
Capítulo 15: Matemáticas, Más diversion con Números
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# c15_handyclock.kbs
fastgraphics
while true
clg
# draw outline
color black, white
penwidth 5
circle 150,150,105
# dibuje las 60 marcas (cada 5 haga una mas larga)
color black
penwidth 1
for m = 0 to 59
a = 2 * pi * m / 60
if m % 5 = 0 then
pip = 5
else
pip = 1
end if
circle 150-sin(a)*95,150-cos(a)*95,pip
next m
# dibuje las manecillas
h = hour % 12 * 60/12 + minute/12 + second /3600
call drawhand(150,150,h,50,6,green)
m = minute + second / 60
call drawhand(150,150,m,75,4,red)
call drawhand(150,150,second,100,3,blue)
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 173 of
Capítulo 15: Matemáticas, Más diversion con Números
28
29
30
31
32
33
34
35
36
37
38
refresh
pause 1
end while
subroutine drawhand(x, y, f, l, w, handcolor)
# pase la ubicación x e y
# f como ubicación en la cara del reloj 0-59
# longitud, ancho, y color de la manecilla
color handcolor
stamp x, y, 1, f/60*2*pi - pi / 2, {0,-w,l,0,0,w}
end subroutine
Programa 103: Programa Grande – Reloj con Manecillas
Salida 103: Programa Grande – Reloj con Manecillas
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 174 of
Capítulo 15: Matemáticas, Más diversion con Números
Ejercicios:
e
f
c
f
a
t
t
i
r
r
r
d
c
t
y
s
a
o
n
a
e
o
l
s
e
z
i
r
r
t
l
d
o
o
p
h
i
n
t
s
e
o
n
u
g
l
a
y
l
n
a
g
o
i
o
a
d
d
f
p
i
u
e
a
a
p
r
l
j
o
n
o
n
r
t
m
l
i
p
a
f
i
m
t
g
a
e
p
t
l
c
o
s
x
w
e
n
r
s
h
a
e
c
o
s
k
c
n
d
b
m
c
n
p
o
w
e
r
s
u
a
g
o
t
i
d
e
g
r
e
e
s
b
s
k
j
s
n
a
i
d
a
r
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
7 lados
12 lados
Página 175 of
Capítulo 16: Trabajando con Strings
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.
Función
Descripción
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
2
3
4
5
6
7
# c16_string.kbs
# convierte un numero a string
a$ = string(10 + 13)
print a$
b$ = string(2 * pi)
print b$
Programa 104: La función String
23
6.283185
Salida 104: La función String
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 176 of
Capítulo 16: Trabajando con Strings
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
2
3
4
5
6
7
# c16_leftrightmid.kbs
# mostrar funcionamiento de funciones: right, left y mid
a$ = "abcdefghijklm"
print left(a$,4)
# imprime primeras 4 letras
print right(a$,2)
# imprime últimas 2 letras
print mid(a$,4,3)
# imprime letras 4ta. a 7ma.
print mid(a$,10,9)
# imprime letras 10ma. a 11va.
Programa 106: Las funciones Left, Right y Mid
abcd
kl
def
jklm
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 177 of
Capítulo 16: Trabajando con Strings
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 substring 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
2
3
4
5
6
# c16_upperlower.kbs
a$ = "Hola."
print lower(a$)
print upper(a$)
# imprima todo en minusculas
# 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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 178 of
Capítulo 16: Trabajando con Strings
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
2
3
4
5
6
7
8
# c16_instr.kbs
# un string dentro de otro
a$ = "abcdefghijklm"
print 'la ubicación de "hi" es ';
print instr(a$,"hi")
print 'la ubicación de "bye" es ';
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
2
3
4
# c16_radix.kbs
# convierte un numero de una base (2-36) a otra
# letras usadas para los dígitos 11 al 26
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 179 of
Capítulo 16: Trabajando con Strings
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
digits$ = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
frombase = getbase("desde base")
input "numero en base " + frombase + " >", number$
number$ = upper(number$)
# convierta numero a base 10 y guárdelo en n
n=0
for i = 1 to length(number$)
n = n * frombase
n = n + instr(digits$, mid(number$, i, 1)) - 1
next i
tobase = getbase("to base")
# ahora construya string en tobase
result$ = ""
while n <> 0
result$ = mid(digits$, n % tobase + 1, 1) + result$
n = n \ tobase
end while
print "en base " + tobase + " el numero es " + result$
end
function getbase(message$)
# obtenga la base desde 2 a 36
do
input message$+"> ", base
until base >= 2 and base <= 36
return base
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 180 of
Capítulo 16: Trabajando con Strings
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 181 of
Capítulo 16: Trabajando con Strings
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 182 of
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. BASIC256 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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# c17_readlfile.kbs
# leer un archivo de texto simple
input "Archivo> ", fn$
if not exists(fn$) then
print fn$ + " El archivo no existe."
end
end if
#
n=0
open fn$
while not eof
l$ = readline
n=n+1
print n + " " + l$
end while
#
print "El archivo " + fn$ + " tiene " + size + " bytes."
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 183 of
Capítulo 17: Files – Guardando Información para Después
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
open
open
open
expresión
(expresión)
unumero, expresión
(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 (“”).
Si no se especifica unumero, entonces el archivo que se usará será
la unidad cero (0).
size
size()
size(unumero)
Esta función devuelve la longitud de un archivo abierto, en Bytes.
Si no se especifica unumero, entonces el archivo que se usará será
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 184 of
Capítulo 17: Files – Guardando Información para Después
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# c17_resetwrite.kbs
# escriba texto a un archivo, vuelva al comienzo y
# muestre el texto
open "e2_c17_resetwrite.dat"
print "Ingrese una línea en blanco para cerrar el archivo."
# limpie el archivo (reset) y vuelva a empezar
reset
while true
input ">", l$
if l$ = "" then exit while
writeline l$
end while
# vaya al inicio y muestre contenido
seek 0
k=0
while not eof()
k=k+1
print k + " " + readline()
end while
close
end
Programa 111: Limpie el archivo y escriba líneas
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 185 of
Capítulo 17: Files – Guardando Información para Después
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.
Si no se especifica unumero, entonces el archivo que se usará será
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
Si no se especifica unumero, entonces el archivo que se usará será
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
2
3
# c17_appendwrite.kbs
# agregar nuevas líneas al final del archivo
# luego mostrarlas en pantalla
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 186 of
Capítulo 17: Files – Guardando Información para Después
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
open "e2_c17_appendwrite.dat"
print "Ingrese una línea en blanco para cerrar el archivo."
# mueva el puntero al final del archivo y agregue
seek size
while true
input ">", l$
if l$ = "" then exit while
writeline l$
end while
# mueva puntero al comienzo del archivo y muestre contenido
seek 0
k=0
while not eof()
k=k+1
print k + " " + readline()
end while
close
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 EndOf-Line). Múltiples delimitadores entre tokens serán tratados como
uno solo.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 187 of
Capítulo 17: Files – Guardando Información para Después
Si no se especifica unumero, el archivo que se usará será la unidad
cero (0).
write
write
write
write
expresión
(expresión)
unumero,expresión
(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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# c17_phonelist.kbs
# Agregue un nro. Telefónico a la lista y muéstrelo
filename$ = "c17_phonelist.txt"
print "phonelist.kbs - Maneje su directorio telefónico."
do
input "Agregar, Listar, Salir (a/l/s)? ",action$
if left(lower(action$),1) = "a" then call addrecord(filename$)
if left(lower(action$),1) = "l" then call listfile(filename$)
until left(lower(action$),1) = "s"
end
subroutine listfile(f$)
if exists(f$) then
# liste nombres y TE números en el archivo
open f$
print "el archivo tiene " + size + " bytes"
while not eof
# lea siguiente línea del archivo e imprimala
print readline
end while
close
else
print "No hay TEs en el archivo. Agregue primero."
end if
end subroutine
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 188 of
Capítulo 17: Files – Guardando Información para Después
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 189 of
Capítulo 17: Files – Guardando Información para Después
Ejercicios:
e
s
n
e
p
o
r
e
t
b
n
y
e
f
p
e
x
e
k
r
i
r
k
m
s
i
e
r
e
e
l
o
o
e
s
z
e
t
n
w
e
t
t
t
i
l
i
i
z
r
t
c
s
s
i
m
l
k
e
i
i
e
q
f
i
d
e
s
l
t
r
r
h
l
a
e
o
y
j
e
w
i
e
e
s
l
r
e
a
d
e
d
r
p
c
e
o
f
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 190 of
Capítulo 17: Files – Guardando Información para Después
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
…
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 191 of
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
2
3
4
5
6
7
# c18_stack.kbs
# implementando un stack usando un array
dim stack(1) # array para contener el stack con tamaño inicial
nstack = 0 # numero de elementos en el stack
global stack, nstack
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 192 of
Capítulo 18: Files – Stacks (Pilas), Queues (Colas)
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
call push(1)
call push(2)
call push(3)
call push(4)
call push(5)
while not vacio()
print pop()
end while
end
function vacio()
# devuelva true si el comienzo está vacío
return nstack=0
end function
function pop()
# tome el primer numero del stack y devuelvalo
# o imprima un mensaje y devuelva -1
if nstack = 0 then
print "stack vacio"
return -1
end if
nstack = nstack - 1
value = stack[nstack]
return value
end function
subroutine push(valor)
# ponga el numero en la variable “valor” sobre el stack
# agrande el stack si esta lleno
if nstack = stack[?] then redim stack(stack[?] + 5)
stack[nstack] = valor
nstack = nstack + 1
end subroutine
Programa 114: Stack
5
4
3
2
1
Salida 114: Stack
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 193 of
Capítulo 18: Files – Stacks (Pilas), Queues (Colas)
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
2
3
4
5
6
7
8
9
# c18_queue.kbs
# implementando un queue usando un array
global queuesize, queue, queuetail, queuehead, inqueue
call createqueue(5)
call enqueue(1)
call enqueue(2)
print dequeue()
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 194 of
Capítulo 18: Files – Stacks (Pilas), Queues (Colas)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
print
call enqueue(3)
call enqueue(4)
print dequeue()
print dequeue()
print
call enqueue(5)
call enqueue(6)
call enqueue(7)
# vacie el queue
while inqueue > 0
print dequeue()
end while
end
subroutine createqueue(z)
# máximo nro. de entradas en la queue a cualquier tiempo
queuesize = z
# array para contener la queue con valor inicial
dim queue(z)
# ubicación en la queue de la próxima entrada nueva
queuetail = 0
# ubicación en la queue de la próxima entrada a ser devuelta (servida)
queuehead = 0
# numero de entradas en la queue
inqueue = 0
end subroutine
function dequeue()
if inqueue = 0 then
print "queue is empty"
value = -1
else
value = queue[queuehead]
inqueue-queuehead++
if queuehead = queuesize then queuehead = 0
end if
return value
end function
subroutine enqueue(value)
if inqueue = queuesize then
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 195 of
Capítulo 18: Files – Stacks (Pilas), Queues (Colas)
58
59
60
61
62
63
64
65
print "queue is full"
else
queue[queuetail] = value
inqueue++
queuetail++
if queuetail = queuesize then queuetail = 0
end if
end subroutine
Programa 115: Queue
1
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 196 of
Capítulo 18: Files – Stacks (Pilas), Queues (Colas)
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# c18_linkedlist.kbs
# crer una “linked list” usando arrays
# data$ es array conteniendo los strings de datos en la lista
# nextitem es un array con punteros al próximo ítem de datos
# si nextitem es -2:esta libre o si -1:es el final
global head, data$, nextitem
call initialize(6)
# lista de 3 personas
call append("Bob")
call append("Sue")
call append("Guido")
call displaylist()
call displayarrays()
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 197 of
Capítulo 18: Files – Stacks (Pilas), Queues (Colas)
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
call wait()
print "eliminar persona 2"
call delete(2)
call displaylist()
call displayarrays()
call wait()
print "insertar Mary al frente de la lista (#1)"
call insert("Mary",1)
call displaylist()
call displayarrays()
call wait()
print "insertar John en posicion 2"
call insert("John",2)
call displaylist()
call displayarrays()
call wait()
print "eliminar persona 1"
call delete(1)
call displaylist()
call displayarrays()
call wait()
end
subroutine wait()
input "Intro para continuar> ",foo$
print
end subroutine
subroutine initialize(n)
head = -1 # comienzo de lista (-1 pointer a ningún lado)
dim data$(n)
dim nextitem(n)
# inicialice items como libres
for t = 0 to data$[?]-1
call freeitem(t)
next t
end subroutine
subroutine freeitem(i)
# elemento libre en el array, en posicion i
data$[i] = ""
nextitem[i] = -2
end subroutine
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 198 of
Capítulo 18: Files – Stacks (Pilas), Queues (Colas)
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
function findfree()
# encuentre un ítem libre (un item apuntando a -2)
for t = 0 to data$[?]-1
if nextitem[t] = -2 then return t
next t
print 'no hay elementos libres para alojar'
end
end function
function createitem(text$)
# crear un nuevo ítem en la lista
# y devolver índice a la nueva ubicacion
i = findfree()
data$[i] = text$
nextitem[i] = -1
return i
end function
subroutine displaylist()
# muestre la lista siguiendo la linked list
print "list..."
k=0
i = head
do
k=k+1
print k + " ";
print data$[i]
i = nextitem[i]
until i = -1
end subroutine
subroutine displayarrays()
# muestre datos realmente guardados y como
print "arrays..."
for i = 0 to data$[?]-1
print i + " " + data$[i] + " >" + nextitem[i] ;
if head = i then print " <<head";
print
next i
end subroutine
subroutine insert(text$, n)
# inserte text$ en la posición n
index = createitem(text$)
if n = 1 then
nextitem[index] = head
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 199 of
Capítulo 18: Files – Stacks (Pilas), Queues (Colas)
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
123
148
159
150
151
152
153
154
155
156
head = index
else
k=2
i = head
while i <> -1 and k <> n
k=k+1
i = nextitem[i]
end while
if i <> -1 then
nextitem[index] = nextitem[i]
nextitem[i] = index
else
print "No es posible insertar mas allá de la lista"
end if
end if
end subroutine
subroutine delete(n)
# elimine elemento n de la linked list
if n = 1 then
# elimine head – haga el segundo elemento la nueva head
index = head
head = nextitem[index]
call freeitem(index)
else
k=2
i = head
while i <> -1 and k <> n
k=k+1
i = nextitem[i]
end while
if i <> -1 then
index = nextitem[i]
nextitem[i] = nextitem[nextitem[i]]
call freeitem(index)
else
print "
print "No es posible borrar mas allá del final de la lista "
end if
end if
end subroutine
subroutine append(text$)
# apendice text$ al final de la linked list
index = createitem(text$)
if head = -1 then
# no hay cabeza aun – haga al ítem cabeza
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 200 of
Capítulo 18: Files – Stacks (Pilas), Queues (Colas)
157
158
159
160
161
162
163
164
165
166
head = index
else
# muévase al final de la lista y agregue un nuevo item
i = head
while nextitem[i] <> -1
i = nextitem[i]
end while
nextitem[i] = index
endif
end subroutine
Programa 116: Linked List
Re-escriba el Programa 116 para implementar un stack y un queue
usando una linked list.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 201 of
Capítulo 18: Files – Stacks (Pilas), Queues (Colas)
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 202 of
Capítulo 18: Files – Stacks (Pilas), Queues (Colas)
Ilustración 36: Ordenamiento Burbuja – Diagrama de Flujo
1
2
4
5
6
7
8
9
10
#
#
#
#
#
#
#
#
#
c18_bubblesortf.kbs
implementando un ordenamiento simple
El ordenamiento burbuja es uno de los algoritmos MAS
LENTOS para ordenar, pero el mas fácil de implementar
y entender
El algoritmo para el ordenamiento burbuja es:
1. Pase a través del array barriendo valores adyacentes
de modo que el menor valor quede primero.
2. Ejecute el paso 1 una y otra vez hasta que no haya
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 203 of
Capítulo 18: Files – Stacks (Pilas), Queues (Colas)
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
# reacomodamientos (el array está ordenado)
#
dim d(20)
# llene el array con números no ordenados
for i = 0 to d[?]-1
d[i] = int(rand * 1000)
next i
print "*** NO-Ordenados ***"
call displayarray(ref(d))
call bubblesort(ref(d))
print "*** Ordenados ***"
call displayarray(ref(d))
end
subroutine displayarray(ref(array))
# imprima los valores del array
for i = 0 to array[?]-1
print array[i] + " ";
next i
print
end subroutine
subroutine bubblesort(ref(array))
do
sorted = true
for i = 0 to array[?] - 2
if array[i] > array[i+1] then
sorted = false
temp = array[i+1]
array[i+1] = array[i]
array[i] = temp
end if
next i
until sorted
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 204 of
Capítulo 18: Files – Stacks (Pilas), Queues (Colas)
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-apaso, su funcionamiento.
Ilustración 37: Ordenamiento por Inserción – Paso-a-Paso.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 205 of
Capítulo 18: Files – Stacks (Pilas), Queues (Colas)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
# c18_insertionsort.kbs
# implementando un ordenamiento eficiente
# El Ordenamiento por Insercion hace un loop a través de
# los items comenzando en el segundo elemento.
# toma el elemento corriente y lo inserta en la posicion
# ordenada correcta en los elementos previamente ordenados
#
#
#
#
moviéndose desde atrás de la ubicación corriente y
corriendo los elementos con un valor mayor hacia
adelante para hacer lugar al corriente valor en el
lugar correcto (en un array parcialmente ordenado).
dim d(20)
# llene el array con números desordenados
for i = 0 to d[?]-1
d[i] = int(rand * 1000)
next i
print "*** Desordenado ***"
call displayarray(ref(d))
call insertionsort(ref(d))
print "*** Ordenado ***"
call displayarray(ref(d))
end
subroutine displayarray(ref(a))
# imprima los valores del array
for i = 0 to a[?]-1
print a[i] + " ";
next i
print
end subroutine
subroutine insertionsort(ref(a))
for i = 1 to a[?] - 1
currentvalue = a[i]
j=i-1
done = false
do
if a[j] > currentvalue then
a[j+1] = a[j]
j=j-1
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 206 of
Capítulo 18: Files – Stacks (Pilas), Queues (Colas)
48
49
50
51
52
53
54
55
if j < 0 then done = true
else
done = true
endif
until done
a[j+1] = currentvalue
next i
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 207 of
Capítulo 18: Files – Stacks (Pilas), Queues (Colas)
Ejercicios:
k
n
i
l
v
p
q
v
i
z
d
z
m
f
o
h
m
o
g
l
o
b
a
l
y
x
i
f
p
p
e
f
f
i
c
i
e
n
t
f
i
v
u
k
c
a
t
s
v
y
g
s
o
l
e
f
x
i
u
q
z
e
d
o
n
e
u
o
d
v
l
h
s
u
p
j
v
y
q
x
d
s
m
e
m
o
r
y
h
c
i
i
q
t
r
o
s
e
l
b
b
u
b
t
q
q
q
c
i
a
l
l
o
c
a
t
e
h
y
y
t
s
i
l
i
d
s
r
y
i
m
e
u
e
u
q
n
e
t
z
o
l
q
t
r
o
s
n
o
i
t
r
e
s
n
i
o
b
d
e
u
e
u
q
e
d
p
q
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?
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 208 of
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
2
3
4
5
6
7
8
9
10
# c19_divider.kbs
# división simple
print "Divida dos numeros"
while true
input "numerador? ", n
input "denominador? ", d
q = n/d
print "El cociente es " + q
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
2
# c19_trycatch.kbs
# simple try catch
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 209 of
Capítulo 19: Atrapando Errores durante Ejecución
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
El cociente es
0.8333333
numerador? 99
denominador? 0
No es posible dividir 99 por 0
numerador? 4
denominador? 3
El cociente es
1.3333333
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
2
3
# c19_trap.kbs
# atrapado de error con informe
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 210 of
Capítulo 19: Atrapando Errores durante Ejecución
4
5
6
7
8
9
10
11
12
try
print "z = " + z
catch
print "Error Atrapado"
print "
Error = " + lasterror
print "
En línea = " + lasterrorline
print "
Mensaje = " + lasterrormessage
end try
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.
lasterror
Devuelve el número del último error
atrapado. Si no han sido atrapados errores,
esta función devolverá cero. Ver Apéndice G:
Errores y Advertencias para una lista
completa de errores “atrapables”.
lasterrorline
Devuelve el número de línea del programa
en donde el último error fue atrapado
lasterrormessage
Devuelve un string describiendo el último
error.
lasterrorextra
Devuelve un string con información adicional
sobre el error. Para la mayoría de los errores
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 211 of
Capítulo 19: Atrapando Errores durante Ejecución
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 212 of
Capítulo 19: Atrapando Errores durante Ejecución
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
2
3
4
5
6
7
8
9
10
11
# c19_simpletrap.kbs
# atrapando error con subrutina
onerror atrap # se define subrutina a llamar
print "z = " + z
print "Aún corriendo después del error"
end
subroutine atrap()
print "Se atrapó un error."
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
2
3
4
5
# c19_trapoff.kbs
# Atrapado de errores con informe.
onerror errortrap
print "z = " + z
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 213 of
Capítulo 19: Atrapando Errores durante Ejecución
6
7
8
9
10
11
12
13
14
15
print "Aún corriendo después del primer error"
offerror
print "z = " + z
print " Aún corriendo después del segundo error"
end
subroutine errortrap()
print "Atrapado de Errores - Activado"
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 214 of
Capítulo 19: Atrapando Errores durante Ejecución
Ejercicios:
e
p
b
q
t
r
y
q
x
y
z
i
a
r
m
u
u
g
l
e
a
f
h
o
l
k
a
l
q
e
s
b
q
u
a
e
n
x
z
i
f
m
h
i
c
u
u
z
r
b
s
s
n
i
r
b
x
f
l
l
m
k
h
r
l
i
t
v
s
d
l
m
o
z
e
n
t
z
l
l
w
r
e
w
r
e
t
r
z
o
i
r
q
b
a
h
f
r
r
j
q
o
m
r
o
r
r
e
r
b
r
a
e
h
r
l
o
u
r
r
y
r
y
j
k
o
x
l
p
f
o
p
i
c
f
r
o
q
r
f
o
u
r
k
j
j
r
g
i
a
k
s
e
r
p
e
g
f
m
p
x
w
e
a
t
t
o
i
l
t
r
p
t
l
v
a
s
w
x
m
m
c
s
e
b
s
s
e
l
s
w
r
p
w
t
w
r
h
k
f
b
k
f
a
t
g
a
t
w
o
r
l
a
t
v
b
i
e
g
n
l
s
q
l
n
c
a
o
n
e
r
r
o
r
y
r
u
t
a
n
c
p
p
q
o
y
i
f
a
a
m
l
u
j
l
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
Entrada incorrecta. Intente nuevamente.
Ingrese un numero > 43fdgdf
Entrada incorrecta. Intente nuevamente.
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 215 of
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)
Tabla
Una Tabla consiste en un número predefinido de columnas y cualquier
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.
Relaciones
Una referencia de una clave de una tabla como una columna de otra
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 216 of
Capítulo 20: Programación de Bases de Datos
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# c20_createpetsdb.kbs
# crear la BD "mascotas.sqlite"
# borre BD vieja si existe
file$ = "mascotas.sqlite3"
if exists(file$) then kill(file$)
# abrir archivo de BD
# owner=dueño, pet=mascota, petname=nombre de la mascota
dbopen file$
stmt$ = "CREATE TABLE owner (owner_id INTEGER,
ownername TEXT, phonenumber TEXT, PRIMARY KEY
(owner_id));"
print stmt$
dbexecute stmt$
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));"
print stmt$
dbexecute stmt$
dbclose
print file$ + " creada OK."
end
Programa 125: Crear una DB
CREATE TABLE owner (owner_id INTEGER, ownername TEXT, phonenumber
TEXT, PRIMARY KEY
(owner_id));
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 217 of
Capítulo 20: Programación de Bases de Datos
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
2
3
4
5
6
7
8
9
10
11
12
13
14
# c20_addpetsdb.kbs
# agregue filas a la BD
file$ = "mascotas.sqlite3"
dbopen file$
call
call
call
call
addowner(1, "Jim", "555-3434")
addpet(1, 1, "Spot", "Cat")
addpet(2, 1, "Fred", "Cat")
addpet(3, 1, "Elvis", "Cat")
call addowner(2, "Sue", "555-8764")
call addpet(4, 2, "Alfred", "Dog")
call addpet(5, 2, "Fido", "Cat")
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 218 of
Capítulo 20: Programación de Bases de Datos
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");
INSERT INTO owner (owner_id, ownername, phonenumber) VALUES
(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");
INSERT INTO owner (owner_id, ownername, phonenumber) VALUES
(3,"Amy","555-4321");
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 219 of
Capítulo 20: Programación de Bases de Datos
INSERT INTO pet (pet_id, owner_id, petname, type) VALUES (6,3,"Bones","Dog");
INSERT INTO owner (owner_id, ownername, phonenumber) VALUES
(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
2
3
4
5
6
7
8
9
# c20_updatepetsdb.kbs
# actualice una fila de la BD
dbopen "mascotas.sqlite3"
# cree y cargue datos
s$ = "UPDATE owner SET phonenumber = " + chr(34) +
"555-5555" + chr(34) + " where owner_id = 1;"
print s$
dbexecute s$
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 220 of
Capítulo 20: Programación de Bases de Datos
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 221 of
Capítulo 20: Programación de Bases de Datos
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,
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 222 of
Capítulo 20: Programación de Bases de Datos
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# c20_rolofile.kbs
# un ejemplo de BD para mantener una lista de nros. de TE
dbopen "rolofile.sqlite3"
call createtables()
do
print
print "rolofile - phone numbers"
print "1-agregar una persona"
print "2-listado de personas"
print "3-agregar No. de telefono"
print "4-listado de Nos. de telefonos "
input "0-exit >", opcion
print
if opcion=1 then call addperson()
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 223 of
Capítulo 20: Programación de Bases de Datos
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
if opcion=2 then call listpeople()
if opcion=3 then call addphone()
if opcion=4 then call listphone()
until opcion = 0
dbclose
end
function quote$(a$)
# ponga srting entre comillas simples (para una sentencia sql)
# si contiene una comilla simple hágala doble
return "'" + replace(a$,"'","''") + "'"
end function
function inputphonetype$()
do
input "Tipo de TE (h-home, c-cell, f-fax, w-work) > ", type$
until type$ = "h" or type$ = "c" or type$ = "f" or type$ = "w"
return type$
end function
subroutine createtables()
# incluya la cláusula IF NOT EXISTS para evitar error si la
# tabla ya existe.
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 224 of
Capítulo 20: Programación de Bases de Datos
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
end subroutine
subroutine addphone()
print "Agregar un Número de Teléfono"
input "person id > ", person_id$
person_id$ = upper(person_id$)
if not ispersononfile(person_id$) then
print "La persona no existe el el archivo"
else
input "phone number > ", phone$
if phone$ = "" then
print "Por favor, ingrese un nro. de Teléfono"
else
type$ = inputphonetype$()
dbexecute "INSERT INTO phone (person_id,
phone, type) values (" + quote$(person_id$) + "," +
quote$(phone$) + "," + quote$(type$) + ");"
print phone$ + " agregado."
end if
end if
end subroutine
75
76
77
78
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$
99 person_id$ = upper(person_id$)
100 stmt$ = "SELECT person.person_id, person.name,
phone.phone, phone.type FROM person LEFT JOIN phone
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 225 of
Capítulo 20: Programación de Bases de Datos
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 226 of
Capítulo 20: Programación de Bases de Datos
Ejercicios:
y
e
t
a
e
r
c
i
d
b
r
o
w
p
l
q
s
e
q
n
u
q
d
m
x
c
z
i
x
t
a
t
p
e
b
u
o
h
g
t
b
h
p
e
d
u
s
p
d
e
c
h
c
a
o
s
a
s
t
c
b
o
o
r
t
e
m
o
t
n
r
e
o
e
l
b
e
y
l
l
e
l
i
o
p
s
u
x
s
d
j
e
n
t
n
f
e
i
m
o
o
e
t
c
s
a
g
e
n
b
n
t
l
l
p
b
r
o
x
n
s
t
m
d
c
a
z
c
o
d
x
x
e
t
t
a
b
l
e
l
w
b
s
x
t
d
f
s
d
m
u
y
f
e
y
d
d
b
i
n
t
r
e
s
n
i
m
r
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 227 of
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 bidireccional 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.
1
SERVER
CLIENT
2
3
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 228 of
Capítulo 21: Conectandose a la Red
Un Server y un Cliente Simples:
1
2
3
4
5
6
7
# c21_simpleserver.kbs
# envie un mensaje al cliente sobre port 999
print "Escuchando el port 9999 en " + netaddress()
NetListen 9999
NetWrite "El server simple envió este mensaje."
NetClose
Programa 130: Server de Red Simple
1
2
3
4
5
6
7
8
9
# c21_simpleclient.kbs
# conectar al server simple y obtener el mensaje
#
input "¿Cual es la dirección IP del server simple?", addr$
if addr$ = "" then addr$ = "127.0.0.1"
#
NetConnect addr$, 9999
print NetRead
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
netlisten
netlisten
netlisten
nro_puerto
(nro_puerto)
nro_socket, nro_puerto
(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).
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 229 of
Capítulo 21: Conectandose a la Red
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
netwrite
netwrite
netwrite
string
(string)
nro_socket, string
(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
netconnect
netconnect
netconnect
servername, nro_port
(servername, nro_port)
nro_socket, servername, nro_port
(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
2
# c21_chat.kbs
# use port 9999 para chat simple
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 230 of
Capítulo 21: Conectandose a la Red
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
input "Chat a la direccion (¿volver por server o host local?)", addr$
if addr$ = "" then addr$ = "127.0.0.1"
#
# trate de conectarse al server
# si no hay uno, vuélvase uno.
try
NetConnect addr$, 9999
catch
print "Arrancando server – Esperando por cliente chat"
NetListen 9999
end try
print "Conectado"
while true
# obtenga tecla apretada y envíela
k = key
if k <> 0 then
call show(k)
netwrite string(k)
end if
# obtenga tecla de la red y muéstrela
if NetData() then
k = int(NetRead())
call show(k)
end if
pause .01
end while
end
subroutine show(keyvalue)
if keyvalue=16777220 then
print
else
print chr(keyvalue);
end if
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 231 of
Capítulo 21: Conectandose a la Red
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# c21_battle.kbs
# usa port 9998 para server
spritedim 4
call tanksprite(0,white)
call tanksprite(1,black)
call projectilesprite(2,blue)
call projectilesprite(3,red) # tiro
# yo
# oponente
# mi tiro
del oponente
kspace = 32
kleft = 16777234
kright = 16777236
kup = 16777235
kdown = 16777237
dr = pi / 20
dxy = 2.5
shotdxy = 5
port = 9998
print
print
print
print
# cambio de direccion
# velocidad de movimiento
# velocidad del proyectil
# puerto para comunicarse
"Tank Battle – Ud es el tanque blanco."
"Su misión es disparar y matar al tanque negro. "
"Use flechas para moverse y la barra espaciadora"
"para disparar."
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 232 of
Capítulo 21: Conectandose a la Red
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
print
input "Es Ud. el server? (y or n)", mode$
if mode$ = "y" then
print "Ud. es el server. Esperando que un cliente se conecte."
NetListen port
else
input "Dirección del Server para conectarse (Intro para local host)?", addr$
if addr$ = "" then addr$ = "127.0.0.1"
NetConnect addr$, port
end if
# defina mi posición por defecto y envíesela a mi oponente
x = 100
y = 100
r=0
# projectil: posición dirección y visible
p = false
px = 0
py = 0
pr = 0
call writeposition(x,y,r,p,px,py,pr)
# actualice la pantalla
color green
rect 0, 0, graphwidth, graphheight
spriteshow 0
spriteshow 1
spriteplace 0, x, y, 1, r
while true
# adquiera tecla apretada y mueva el tanque en pantalla
k = key
if k <> 0 then
if k = kup then
x = ( graphwidth + x + sin(r) * dxy ) % graphwidth
y = ( graphheight + y - cos(r) * dxy ) % graphheight
end if
if k = kdown then
x = ( graphwidth + x - sin(r) * dxy ) % graphwidth
y = ( graphheight + y + cos(r) * dxy ) % graphheight
end if
if k = kleft then r = r - dr
if k = kright then r = r + dr
if k = kspace then
pr = r
px = x
py = y
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 233 of
Capítulo 21: Conectandose a la Red
73
74
75
76
77
78
79
80
81
82
83
87
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
p = true
spriteshow 2
end if
spriteplace 0, x, y, 1, r
call writeposition( x, y, r, p, px, py, pr )
if spritecollide( 0, 1 ) then
netwrite "F"
print "Ud. embistió al otro tanque y ambos murieron. Game Over."
end
end if
end if
# mueva mi proyectil (si hay uno)
if p then
px = px + sin( pr ) * shotdxy
py = py - cos( pr ) * shotdxy
spriteplace 2, px, py, 1, pr
if spritecollide( 1, 2 ) then
NetWrite "W"
print "Ud. mató a su oponente. Game over."
end
end if
if px<0 or px > graphwidth or py <0 or py> graphheight then
p = false
spritehide 2
end if
call writeposition( x, y, r, p, px, py, pr )
end if
#
# adquiera posición desde la red y
# defina las variables de ubicación para el oponente
# dé vuelta las coordenadas como las decodificamos
while NetData()
position$ = NetRead()
while position$ <> ""
if left(position$,1) = "W" then
print "Ud. está muerto - Game Over."
end
end if
if left(position$,1) = "F" then
print "Ud. fue impactado y ambos murieron-Game Over"
end
end if
op_x = graphwidth - unpad( ref( position$ ),3)
op_y = graphheight - unpad( ref( position$ ), 3)
op_r = pi + unpad( ref( position$ ), 5)
op_p = unpad( ref( position$ ), 1)
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 234 of
Capítulo 21: Conectandose a la Red
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,
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 235 of
Capítulo 21: Conectandose a la Red
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 236 of
Capítulo 21: Conectandose a la Red
Ejercicios:
m
j
v
p
k
t
t
n
n
n
r
r
v
h
e
n
e
e
e
e
d
f
r
k
e
t
t
t
x
t
t
d
c
i
w
l
r
r
p
i
n
o
l
o
i
e
e
c
o
r
s
c
r
s
a
v
t
x
r
w
i
k
t
d
r
v
t
g
t
t
p
e
g
e
k
c
n
o
m
e
n
e
s
o
l
c
t
e
n
n
n
e
t
c
o
n
n
e
c
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 237 of
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 238 of
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 239 of
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"
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 240 of
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”).
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 241 of
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 242 of
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
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
MUESTRA
clear
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 243 of
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
G - 196
A - 220
F# - 185
G# - 208
A# - 233
B – 247
Middle C - 262
D - 294
C# - 277
D# - 311
E - 330
F - 349
F# - 370
G - 392
A - 440
G# - 415
A# - 466
B - 494
C - 523
D - 587
C# - 554
D# - 622
E - 659
F - 698
F# - 740
G - 784
G# - 831
A - 880
A# - 932
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 244 of
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 245 of
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 246 of
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.
#
abs
acos
and
arc
asc
asin
atan
black
blue
call
catch
ceil
changedir
chord
chr
circle
clear
clg
clickb
clickclear
clickx
clicky
close
cls
color
colour
confirm
continue
continuedo
continuefor
continuewhile
cos
count
countx
currentdir
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
cyan
dark
darkblue
darkcyan
darkgeeen
darkgray
darkgrey
darkorange
darkpurple
darkred
darkyellow
day
dbclose
dbcloseset
dbexecute
dbfloat
dbint
dbnull
dbopen
dbopenset
dbrow
dbstring
debuginfo
degrees
dim
dir
do
editvisible
else
end
endfunction
endif
endsubroutine
endtry
endwhile
eof
Página 247 of
Apéndice F
error_arrayindex
error_arrayindexmissing
error_arraysizelarge
error_arraysizesmall
error_byref
error_byreftype
error_colornumber
error_dbcolno
error_dbconnnumber
error_dbnotopen
error_dbnotset
error_dbnotsetrow
error_dbopen
error_dbquery
error_dbsetnumber
error_divzero
error_filenotopen
error_filenumber
error_fileopen
error_filereset
error_filewrite
error_folder
error_fontsize
error_fontweight
error_for1
error_for2
error_freedb
error_freedbset
error_freefile
error_freenet
error_imagefile
error_imagesavetype
error_imagescale
error_infinity
error_logrange
error_netaccept
error_netbind
error_netconn
error_nethost
error_netnone
error_netread
error_netsock
error_netsocknumber
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
error_none
error_nonnumeric
error_nosuchvariable
error_notanumber
error_notimplemented
error_penwidth
error_permission
error_polyarray
error_polypoints
error_printernotoff
error_printernoton
error_printeropen
error_putbitformat
error_radix
error_radixstring
error_rgb
error_spritena
error_spritenumber
error_spriteslice
error_strend
error_stringmaxlen
error_strneglen
error_strstart
exists
exitdo
exitfor
exitwhile
exp
explode
explodex
false
fastgraphics
float
floor
font
for
freedb
freedbset
freefile
freenet
frombinary
fromhex
fromoctal
Página 248 of
Apéndice F
error_netsockopt
error_netwrite
getcolor
getpenwidth
getsetting
getslice
global
gosub
goto
graphheight
graphsize
graphwidth
gray
green
grey
hour
if
imgload
imgsave
implode
include
input
instr
instrx
int
key
kill
lasterror
lasterrorextra
lasterrorline
lasterrormessage
left
length
line
log
log10
lower
md5
mid
minute
month
mouseb
mousex
mousey
msec
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
fromradix
getbrushcolor
netconnect
netdata
netlisten
netread
netwritenext
next
not
offerror
onerror
open
openb
or
orange
ostype
outputvisible
pause
penwidth
pi
pie
pixel
plot
poly
portin
portout
print
printercancel
printeroff
printeron
printerpage
purple
putslice
radians
rand
read
readbyte
readline
rect
red
redim
ref
refresh
rem
replace
Página 249 of
Apéndice F
netaddress
netclose
return
rgb
right
say
second
seek
setsetting
sin
size
sound
spritecollide
spritedim
spriteh
spritehide
spriteload
spritemove
spriteplace
spritepoly
spriteshow
spriteslice
spritev
spritew
spritex
spritey
sqr
stamp
step
string
system
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
replacex
reset
tan
text
textheight
textwidth
then
throwerror
to
tobinary
tohex
tooctal
toradix
true
try
until
upper
version
volume
wavplay
wavstop
wavwait
while
white
write
writebyte
writeline
xor
year
yellow
Página 250 of
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"
18
ERROR_STREND
"El string no suficientemente largo para el carácter
inicial dado"
19
ERROR_NONNUMERIC
"Valor no-numérico en expresión numérica"
20
ERROR_RGB
"Valores RGB de Color deben estar en el rango 0 a
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."
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 251 of
Apéndice G
29
ERROR_INFINITY
"La operación retornó infinito."
30
ERROR_DBOPEN
"No es posible abrir la base de datos SQLITE"
31
ERROR_DBQUERY
"Error de query en la base de datos (seguido de
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."
42
ERROR_NETSOCKOPT
"No es posible definir las opciones del socket de
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"
46
ERROR_PERMISSION
"Ud. No tiene permiso para utilizar esta
declaración/función."
47
ERROR_IMAGESAVETYPE
"Tipo para guardar imagen inválido."
50
ERROR_DIVZERO
"División por cero"
51
ERROR_BYREF
"Función/Subrutina espera una referencia a una
variable en el llamado."
52
ERROR_BYREFTYPE
"Función/Subrutina: referencia a un tipo de
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"
55
ERROR_FREEDB
"No hay conexiones libres a la base de datos
para alocar"
56
ERROR_DBCONNNUMBER
"Número de conexión a la Base de Datos inválido
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 252 of
Apéndice G
57
ERROR_FREEDBSET
"No hay conjuntos de datos libre para alocar para
esa conexión a la base de datos "
58
ERROR_DBSETNUMBER
"Número de conjunto de datos inválido"
59
ERROR_DBNOTSETROW
"Ud. debe avanzar el conjunto de datos usando
DBROW antes de poder leer datos desde él "
60
ERROR_PENWIDTH
"El ancho de la punta de dibujo debe ser un
número no negativo "
61
ERROR_COLORNUMBER
"El valor de color debe estar en el rango -1 a
16,777,215"
62
ERROR_ARRAYINDEXMISSING
"La variable array %VARNAME% no tiene valor
sin un índice"
63
ERROR_IMAGESCALE
"Escala para la imagen debe ser mayor o igual
que cero "
64
ERROR_FONTSIZE
"El tamaño de fuente, en puntos, debe ser mayor
o igual que cero "
65
ERROR_FONTWEIGHT
"El peso de la fuente debe ser mayor o igual a
cero "
66
ERROR_RADIXSTRING
"No es posible convertir radix string de vuelta a
un número decimal "
67
ERROR_RADIX
"La base de la conversión Radix debe estar entre
2 y 36"
68
ERROR_LOGRANGE
"No es posible calcular el logaritmo o raíz de un
número negativo"
69
ERROR_STRINGMAXLEN
"El string excede la longitud máxima posible de
16,777,216 caracteres"
70
ERROR_NOTANUMBER
"La operación matemática devolvió un valor
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"
65535 ERROR_NOTIMPLEMENTED
WARNING #
65537
"Característica no implementada en este
ambiente."
Descripción del Error (ESP)
WARNING_TYPECONV
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
"No es posible convertir un string a número, se
usó cero"
Página 253 of
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 unidimensional, 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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 254 of
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 255 of
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.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 256 of
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).
(quotation marks) (""). Ver también string.
Se representa por dos apóstrofes
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
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 257 of
Apéndice H
entre dos procesos sobre una única o dos computadoras.
© 2014James M. Reneau (CC BY-NC-SA 3.0 US)
258
Traducción al castellano por Oswy (Mayo 2014)
Página 258 of
Fly UP