El manual de KTurtle

# El manual de KTurtle

Cies Breijs `<cies AT kde DOT nl>`

Anne-Marie Mahfouf `<annma AT kde DOT org>`

Mauricio Piacentini `<piacentini AT kde DOT org>`

Traductor: Rafael Beccar
Traductor: Leticia Martín Hernández
revisión Aplicaciones 20.12 (2021-01-20)

Copyright © 2004, 2009 Cies Breijs

Copyright © 2004, 2007 Anne-Marie Mahfouf

Copyright © 2007 Mauricio Piacentini

Aviso Legal

KTurtle es un entorno educativo de programación cuyo objetivo es facilitar el aprendizaje de cómo se programa. Para conseguirlo, KTurtle permite acceder a todas las herramientas de programación desde la interfaz de usuario. El lenguaje de programación que se utiliza es TurtleScript, que admite la traducción de sus órdenes.

Lista de tablas

4.1. Tipos de preguntas
5.1. Los diferentes tipos de código y su color de resaltado
5.2. Combinaciones RGB frecuentes

Capítulo 1. Introducción
Introducción

# Capítulo 1. Introducción

KTurtle es un entorno educativo de programación que usa TurtleScript, un lenguaje de programación vagamente basado e inspirado en Logo. El objetivo de KTurtle es hacer que la programación sea fácil y accesible. Esto convierte a KTurtle en una herramienta apropiada para enseñar a los niños los fundamentos de las matemáticas, la geometría y, por supuesto, la programación. Una de las características principales de TurtleScript es que permite traducir las órdenes al idioma del programador.

KTurtle lleva este nombre en honor a la tortuga («turtle», en inglés) que juega un papel central en este entorno de programación. El estudiante, en general, dará instrucciones a la tortuga, usando comandos de TurtleScript, para que esta realice un dibujo en el lienzo.

## ¿Qué es TurtleScript?

TurtleScript, el lenguaje de programación usado en KTurtle, está inspirado en la familia de lenguajes de programación Logo. La primera versión del lenguaje Logo fue creada en 1967 por Seymour Papert, del Laboratorio de Inteligencia Artificial de MIT (Massachusetts Institute of Technology), como una evolución del lenguaje de programación LISP. A partir de este momento aparecieron muchas versiones de Logo. En torno a 1980, Logo fue ganando impulso, con versiones para los sistemas MSX, Commodore, Atari, Apple II e IBM PC. Estas versiones fueron desarrolladas principalmente con fines educativos. MIT sigue manteniendo un sitio web sobre Logo que contiene una lista con varias implementaciones populares del lenguaje.

TurtleScript comparte una característica con muchas otras implementaciones de Logo: la posibilidad de traducir las órdenes al idioma nativo del estudiante. Esta característica facilita las cosas a los estudiantes que no entienden inglés (o que lo entienden poco). KTurtle tiene otras muchas características que tienen como objetivo que la primera experiencia de los estudiantes con la programación sea lo más sencilla posible.

Características de KTurtle
Características de KTurtle

## Características de KTurtle

KTurtle tiene algunas características que hacen que comenzar a programar sea coser y cantar. Estas son algunas de las características más destacadas de KTurtle:

- Un entorno integrado con el intérprete de TurtleScript, el editor, el lienzo y otras herramientas, todo en una única aplicación (sin dependencias adicionales).

- La posibilidad de traducir las órdenes de TurtleScript usando el marco de traducción de KDE.

- TurtleScript admite funciones definidas por el usuario, algoritmos recursivos y el cambio de tipos dinámicos.

- En cualquier momento, la ejecución puede ralentizarse, detenerse brevemente o interrumpirse.

- Un poderoso editor que incluye resaltado intuitivo de sintaxis, numeración de líneas, marcadores de errores, ejecución visual y mucho más.

- El lienzo, donde la tortuga dibuja, puede ser imprimido o guardado como imagen (PNG) o como dibujo (SVG).

- Ayuda contextual: la ayuda cuando la necesita. Pulse F2 (o vaya a Ayuda → Ayuda sobre: …) para obtener ayuda sobre la porción de código que se encuentre bajo su cursor.

- Un diálogo de error que relaciona los mensajes de error con los errores en el programa, resaltándolos en rojo.

- Terminología simplificada de programación.

- Ejemplos integrados que le ayudan a empezar. Estos ejemplos han sido traducidos usando el marco de traducción de KDE.

Capítulo 2. Uso de KTurtle
Uso de KTurtle

# Capítulo 2. Uso de KTurtle

La ventana principal de KTurtle consta de las siguientes partes principales: el editor (1), a la izquierda, que es donde se escriben las órdenes de TurtleScript; el lienzo (2), a la derecha, que es donde la tortuga dibuja lo que se le ordena; y el inspector (3), que le proporciona información mientras se ejecuta el programa. Otras partes son la barra de menús (5), desde donde puede acceder a todas las funciones; la barra de herramientas (4), que le permite acceder rápidamente a las funciones más habituales; el campo de entrada Consola:, donde puede introducir una línea de código para su verificación; y la barra de estado, situada en la parte inferior de la ventana, donde puede comprobar el estado de KTurtle.

## El editor

En el editor se escriben las órdenes de TurtleScript. La mayoría de las funciones del editor pueden encontrarse en los menús Archivo y Editar. El editor puede estar acoplado a cada uno de los bordes de la ventana principal, o puede colocarse en cualquier lugar de su escritorio.

Dispone de varios métodos para introducir el código en el editor. Lo más sencillo es usar un ejemplo: vaya al submenú Archivo → Ejemplos y seleccione un ejemplo. El ejemplo que elija se abrirá en el editor y, a continuación, podrá seleccionar la opción del menú Ejecutar → Ejecutar (atajo de teclado Alt+F2) o pulsar el botón Ejecutar de la barra de herramientas para, si así lo desea, ejecutar el código.

Puede abrir archivos de TurtleScript usando la opción del menú Archivo → Abrir….

El tercer método es escribir directamente su propio código en el editor, o copiar y pegar código de otro lugar.

El lienzo
El lienzo

## El lienzo

El lienzo es el campo de acción de la tortuga; aquí, la tortuga dibuja siguiendo las instrucciones que se le den. Después de introducir un código en el editor y de ejecutarlo, pueden ocurrir dos cosas: que el código se ejecute correctamente (con lo que con toda probabilidad verá cómo algo cambia en el lienzo), o que haya un error en el código (con lo que se mostrará una pestaña donde se le explicará qué error ha cometido).

Puede ampliar o reducir el lienzo con la rueda de su ratón.

El inspector
El inspector

## El inspector

El inspector le informa acerca de las variables y las funciones aprendidas, y le muestra el árbol del código mientras se ejecuta el programa.

El inspector puede estar acoplado a cada uno de los bordes de la ventana principal, o puede separarse y colocarse en cualquier lugar del escritorio.

La barra de herramientas
La barra de herramientas

## La barra de herramientas

Puede acceder desde aquí a las funciones más habituales. En la barra de herramientas se encuentra también el campo de entrada Consola:, desde donde puede invocar órdenes. Esto le puede ser útil si lo que quiere es comprobar una orden sin tener que modificar el contenido del editor.

Puede configurar la barra de herramientas de acuerdo con sus preferencias en Preferencias → Configurar las barras de herramientas…

La barra de menús
La barra de menús

## La barra de menús

En la barra de menús encontrará todas las funciones de KTurtle. Estas están agrupadas de la siguiente forma: Archivo, Editar, Lienzo, Ejecutar, Herramientas, Preferencias y Ayuda. Todas las funciones están descritas a continuación:

### El menú Archivo

Archivo → Nuevo (Ctrl+N)

  Crea un nuevo archivo TurtleScript.

Archivo → Abrir… (Ctrl+O)

  Abre un archivo TurtleScript.

Archivo → Abrir reciente

  Abre un archivo TurtleScript utilizado recientemente.

Archivo → Ejemplos

  Abre ejemplos de programas TurtleScript. El idioma de estos ejemplos es el que haya seleccionado en el submenú Preferencias → Idioma del código.

Archivo → Obtener más ejemplos…

  Abre el diálogo Obtener novedades para descargar de Internet archivos de TurtleScript adicionales.

Archivo → Guardar (Ctrl+S)

  Guarda el archivo TurtleScript que está abierto en ese momento.

Archivo → Guardar como… (Ctrl+Mayúsculas+S)

  Guarda el archivo TurtleScript que está abierto en ese momento en una ubicación específica.

Archivo → Exportar a HTML…

  Exporta el contenido del editor a un archivo HTML manteniendo los colores de resaltado.

Archivo → Imprimir… (Ctrl+P)

  Imprime el código que aparece en el editor.

Archivo → Salir (Ctrl+Q)

  Sale de KTurtle.

### El menú Editar

Editar → Deshacer (Ctrl+Z)

  Deshace el último cambio en el código. No hay límite en KTurtle para el número de veces que puede usarse esta función.

Editar → Rehacer (Ctrl+Mayúsculas+Z)

  Rehace un cambio en el código que anteriormente ha sido deshecho.

Editar → Cortar (Ctrl+X)

  Corta el texto seleccionado del editor al portapapeles.

Editar → Copiar (Ctrl+C)

  Copia el texto seleccionado del editor al portapapeles.

Editar → Pegar (Ctrl+V)

  Pega el texto del portapapeles al editor.

Editar → Seleccionar todo (Ctrl+A)

  Selecciona todo el texto del editor.

Editar → Buscar… (Ctrl+F)

  Con esta función, puede buscar frases en el código.

Editar → Buscar siguiente (F3)

  Use esto para encontrar la próxima aparición de la frase que está buscando.

Editar → Buscar anterior (Mayúsculas+F3)

  Use esto para encontrar la aparición anterior de la frase que está buscando.

Editar → Modo de sobrescritura (Ins)

  Cambia entre los modos «insertar» y «sobrescribir».

### El menú Lienzo

Lienzo → Exportar a imagen (PNG)…

  Exporta el contenido actual del lienzo a una imagen rasterizada de tipo PNG (Portable Network Graphics).

Lienzo → Exportar a dibujo (SVG)…

  Exporta el contenido actual del lienzo a una imagen vectorial de tipo SVG (Scalable Vector Graphics).

Lienzo → Imprimir lienzo…

  Imprime el contenido actual del lienzo.

### El menú Ejecutar

Ejecutar → Ejecutar (F5)

  Inicia la ejecución de las órdenes introducidas en el editor.

Ejecutar → Pausar (F6)

  Detiene momentáneamente la ejecución. Esta acción solo está disponible mientras se ejecutan las órdenes.

Ejecutar → Interrumpir (F7)

  Detiene la ejecución. Esta acción solo está disponible mientras se ejecutan las órdenes.

Ejecutar → Velocidad de ejecución

  Muestra una lista con las posibles velocidades de ejecución:Velocidad máxima (sin resaltado y sin inspector), Velocidad máxima, Moderada , Lenta, Muy lenta y Paso a paso. Cuando la velocidad de ejecución es Velocidad máxima (que es el valor predeterminado) apenas podremos ver lo que está ocurriendo. En ocasiones, esto es lo que se quiere, pero es posible que en otras se prefiera seguir con atención la ejecución. Es entonces cuando conviene cambiar la velocidad de ejecución a Moderada, Lenta o Muy lenta. Cuando se selecciona uno de estos modos, el punto actual de la ejecución se muestra en el editor. Con el modo Paso a paso las órdenes se ejecutan de una en una.

### El menú Herramientas

Herramientas → Selector de dirección…

  Esta acción abre el diálogo de selección de dirección.

Herramientas → Selector de color…

  Esta acción abre el diálogo de selección de color.

### El menú Preferencias

Preferencias → Idioma del código

  Permite elegir el idioma del código.

Preferencias → Mostrar editor (Ctrl+E)

  Muestra u oculta el editor.

Preferencias → Mostrar inspector (Ctrl+I)

  Muestra u oculta el inspector.

Preferencias → Mostrar errores

  Muestra u oculta la pestaña Errores con una lista de los errores que se han producido al ejecutar el código. Si esta opción está activada, pulse sobre la pestaña Lienzo para volver a ver la tortuga.

Preferencias → Mostrar números de línea (F11)

  Con esta acción se muestran los números de línea en el editor. Esta función es muy útil para encontrar errores.

Preferencias → Mostrar la barra de herramientas

  Conmuta la barra de herramientas principal.

Preferencias → Mostrar barra de estado

  Conmuta la barra de estado.

Preferencias → Configurar los atajos de teclado…

  Diálogo estándar de KDE para configurar los atajos de teclado.

Preferencias → Configurar las barras de herramientas…

  Diálogo estándar de KDE para configurar las barras de herramientas.

### El menú Ayuda

KTurtle tiene un menú de Ayuda predeterminado de KDE similar al descrito en los Fundamentos de KDE con una entrada adicional:

Ayuda → Ayuda sobre: … (F2)

  Esta es una función muy útil: proporciona ayuda acerca de la porción de código en el editor sobre el que se encuentra el cursor. Por ejemplo, ha usado la orden `escribir` en su código y quiere saber lo que el manual dice acerca de ella. Solo tiene que colocar el cursor sobre la orden `escribir` y pulsar F2. El manual mostrará toda la información acerca de la orden `escribir`.

  Esta función le puede ser de gran ayuda a la hora de aprender el lenguaje de programación TurtleScript.

La barra de estado
La barra de estado

## La barra de estado

En la barra de estado se muestra información sobre el estado de KTurtle. A la izquierda se muestra información sobre la última acción. A la derecha encontrará la ubicación actual del cursor (número de línea y de columna). En la parte intermedia de la barra de estado se indica el idioma que se está usando para las órdenes.

Capítulo 3. Cómo empezar
Cómo empezar

# Capítulo 3. Cómo empezar

La primera vez que inicie KTurtle podrá ver algo parecido a esto:

En esta guía para principiantes, supondremos que el idioma de las órdenes es el español. Puede cambiar el idioma en el submenú Preferencias → Idioma del código. Tenga en cuenta que el idioma que elija para KTurtle es el que usará para escribir las órdenes de TurtleScript, y no tiene por qué coincidir con el idioma que usa KDE en su equipo y con el que se muestran la interfaz y los menús de KTurtle.

## Primeros pasos con TurtleScript: ¡conozca la tortuga!

Debe haber visto que hay una tortuga en el centro del lienzo: va a aprender a controlarla mediante órdenes que introducirá en el editor.

### La tortuga se mueve

Empecemos a mover la tortuga. Nuestra tortuga puede realizar tres tipos de movimiento: 1) puede ir hacia atrás o hacia adelante; 2) puede girar a la derecha o a la izquierda; y 3) puede desplazarse directamente (saltar) a una posición de la pantalla. A modo de ejemplo, intente lo siguiente:

    avanzar 100
    izquierda 90

Escriba o copie y pegue este código en el editor y ejecútelo (usando Ejecutar → Ejecutar) para ver el resultado.

Al introducir y ejecutar órdenes como las anteriores en el editor, es posible que haya notado alguna de las siguientes cosas:

1. Después de ejecutar las órdenes, la tortuga se desplazó hacia arriba y giró noventa grados hacia la izquierda. Este es el resultado de usar las órdenes `avanzar` e `izquierda`.

2. El color del código cambia a medida que vamos escribiendo. Esta característica se denomina resaltado intuitivo de sintaxis: los distintos tipos de órdenes se colorean de forma diferente. Esto permite leer con facilidad grandes bloques de código.

3. La tortuga dibujó una delgada linea negra.

4. Quizás obtuvo un mensaje de error. Esto puede significar dos cosas: puede haber cometido una equivocación al copiar las órdenes o todavía tiene que elegir el idioma correcto de las órdenes de TurtleScript (lo que puede hacer seleccionando el submenú Preferencias → Idioma del código).

Probablemente entienda que `avanzar 100` le ordena a la tortuga que se desplace hacia adelante dejando una línea, y que `izquierda 90` le ordena que rote noventa grados hacia la izquierda.

Si desea una explicación completa de estas órdenes, vea los siguientes enlaces al manual de referencia: `avanzar`, `retroceder`, `izquierda` y `derecha`.

### Otros ejemplos

El primer ejemplo es muy sencillo, así que comencemos.

    reiniciar

    tamañolienzo 200;200
    colorlienzo 0;0;0
    colorpincel 255;0;0
    grosorpincel 5

    ir 20;20
    dirección 135

    avanzar 200
    izquierda 135
    avanzar 100
    izquierda 135
    avanzar 141
    izquierda 135
    avanzar 100
    izquierda 45

    ir 40;100

De nuevo, puede escribir o copiar y pegar el código en el editor, o abrir el ejemplo `flecha` que se encuentra en el submenú Ejemplos y ejecutarlo (usando Ejecutar → Ejecutar) para ver el resultado. En los siguientes ejemplos se supondrá que ya sabe cómo funciona este mecanismo.

Habrá notado que este segundo ejemplo es mucho más complejo. También habrá visto que hay varias órdenes nuevas. Aquí tiene una breve explicación de todas las órdenes nuevas:

Después de una orden `reiniciar`, todo es como cuando inició KTurtle.

`tamañolienzo 200;200` define un lienzo con un ancho y un alto de 200 píxeles. El ancho y el alto son iguales, por lo que el lienzo será un cuadrado.

`colorlienzo 0;0;0` convierte el lienzo en negro. `0;0;0` es una combinación RGB con todos los valores igual a `0`, lo que da lugar al color negro.

`colorpincel 255;0;0` indica que el color del pincel debe ser rojo. `255;0;0` es una combinación RGB con el valor del rojo igual a `255` (el máximo valor posible) y el valor de los otros colores (el verde y el azul) igual a `0` (el mínimo valor posible). Esto da lugar a una tonalidad brillante de rojo.

Si no entiende los valores de los colores, lea la entrada del glosario correspondiente a combinación RGB.

`grosorpincel 5` establece un grosor para el trazo del pincel igual a `5` píxeles. A partir de ahora, cada línea que la tortuga dibuje tendrá un grosor de `5` píxeles, así hasta que cambiemos de nuevo el valor de `grosorpincel`.

`ir 20;20` le indica a la tortuga que vaya a una posición determinada del lienzo. Contando desde la esquina superior izquierda, esta posición es 20 píxeles hacia la derecha y 20 píxeles hacia abajo. Fíjese que con la orden `ir`, la tortuga no dibuja una línea.

`dirección 135` define el ángulo de dirección de la tortuga. Las órdenes `izquierda` y `derecha` cambian el ángulo de la tortuga con respecto a su dirección actual. En cambio, la orden `dirección` cambia el ángulo de la tortuga a partir de cero y no en relación con su dirección anterior.

Después de la orden `dirección`, hay unas cuantas órdenes del tipo `avanzar` e `izquierda`. Estas órdenes son las que verdaderamente realizan el dibujo.

Finalmente, una nueva orden `ir` hace que la tortuga se posicione a un lado.

Asegúrese de seguir los enlaces al manual de referencia, donde se explica con más detalle cada orden.

Capítulo 4. Guía del lenguaje de programación TurtleScript
Guía del lenguaje de programación TurtleScript

# Capítulo 4. Guía del lenguaje de programación TurtleScript

Esta es la guía del lenguaje de programación TurtleScript de KTurtle. La primera sección de este capítulo está dedicada a aspectos relacionados con la gramática de los programas de TurtleScript. La segunda sección trata exclusivamente los operadores aritméticos, los operadores lógicos (verdadero/falso) y los operadores de comparación. La tercera sección es, básicamente, una gran lista con todos las órdenes explicadas una a una. La cuarta sección explica cómo asignar valores a las variables. Finalmente, en la quinta sección se explica cómo organizar la ejecución de órdenes usando declaraciones de control de la ejecución y, en la sexta, cómo puedes crear tus propias órdenes con `aprender`.

## La gramática de TurtleScript

Como ocurre con todos los idiomas, TurtleScript consta de diferentes tipos de palabras y símbolos. En español distinguimos entre verbos (como «caminar» y «cantar») y sustantivos (como «hermana» o «casa») que se usan para distintos propósitos. TurtleScript es un lenguaje de programación que se usa para dar instrucciones a la tortuga sobre lo que tiene que hacer.

En esta sección, se explican brevemente los distintos tipos de palabras que usa TurtleScript. Se introduce lo que son comentarios, órdenes y los tres diferentes tipos de literales: números, cadenas y valores lógicos (verdadero/falso).

### Comentarios

Un programa consta de instrucciones (que es lo que se ejecuta) y de los denominados comentarios. Los comentarios no se ejecutan. Es decir, KTurtle los ignora por completo cuando se ejecuta un programa. Los comentarios están ahí para que otros programadores puedan comprender mejor el programa. Todo lo que aparece después de un símbolo `#` se considera como un comentario en TurtleScript. Un ejemplo es este programa que no hace nada:

    # este programa no hace nada, es solo un comentario

Es un programa inútil, pero permite explicar bien el asunto.

Los comentarios son especialmente útiles en el caso de programas más complejos, ya que permiten dar consejos a otros programadores. En el siguiente programa verás comentarios que se usan junto con la orden escribir.

    # este programa ha sido creado por Cies Breijs
    escribir "este texto aparecerá escrito en el lienzo"
    # la línea anterior no es un comentario, pero la siguiente sí que lo es:
    # escribir "¡este texto no aparecerá escrito!"

La primera línea describe el programa. La segunda línea es ejecutada por KTurtle, que escribe en el lienzo `este texto aparecerá escrito en el lienzo`. La tercera línea es un comentario. Y la cuarta es un comentario que contiene una orden de TurtleScript. Si de esta cuarta línea se eliminara el símbolo `#`, KTurtle ejecutaría la orden de escribir. Lo que los programadores suelen decir es que la orden de escribir se ha «comentado».

Las líneas comentadas aparecen resaltadas en gris claro en el editor de código.

### Órdenes

Con las órdenes puedes decirle a la tortuga o a KTurtle lo que tiene que hacer. Algunas órdenes necesitan un parámetro de entrada, mientras que otras devuelven un parámetro de salida.

    # avanzar es una orden que requiere de un parámetro de entrada, en este caso el número 100:
    avanzar 100

La primera línea es un comentario. La segunda línea contiene la orden `avanzar` y el número `100`. El número no es parte de la orden, es solo su parámetro de entrada.

Algunas órdenes, como por ejemplo `ir`, necesitan más de un valor de entrada. Si hay varios valores, hay que separarlos con el carácter `,` (coma).

Para una descripción detallada de todas las órdenes que reconoce KTurtle, vaya aquí. Las órdenes integradas en KTurtle aparecen resaltadas en azul oscuro.

### Números

Lo más probable es que ya sepa bastante de números. La forma en que KTurtle usa los números no es muy diferente a cómo se hace en el idioma hablado o en las matemáticas.

Tenemos los llamados números naturales («`0`», «`1`», «`2`», «`3`», «`4`», «`5`», etc.), los enteros negativos («`-1`», «`-2`», «`-3`», etc.) y los números con decimales («`0,1`», «`3,14`», «`33,3333`», «`-5,05`», «`-1,0`», etc.). El carácter `,` (coma) se utiliza como separador.

Los números pueden utilizarse en conjunción con operadores aritméticos y operadores de comparación. También pueden guardarse en variables. Los números aparecen resaltados en rojo oscuro.

### Cadenas

Primero un ejemplo:

    escribir "Hola, soy una cadena."

En este ejemplo, `escribir` es una orden y `"Hola, soy una cadena."` es una cadena. Las cadenas comienzan y terminan con dobles comillas (`"`); es esto lo que hace que KTurtle las identifique como tal.

Al igual que ocurre con los números, las cadenas también se pueden guardar en variables. Sin embargo, al contrario que los números, las cadenas no pueden usarse con operadores aritméticos o con operadores de comparación. Las cadenas aparecen resaltadas en rojo.

### Valores lógicos (verdadero/falso)

Solo hay dos valores lógicos: `verdadero` y `falso`, aunque en ocasiones se los denomina «`encendido`» y «`apagado`», «`sí`» y «`no`» o «`uno`» y «`cero`». Pero en TurtleScript siempre los llamaremos `verdadero` y `falso`. Observa este código de TurtleScript:

    $a = verdadero

Si miras en el inspector verás que a la variable `$a` le corresponde el valor `verdadero`, que es de tipo lógico.

Con frecuencia, los valores lógicos son el resultado de un operador de comparación, como ocurre en el siguiente ejemplo:

    $respuesta = 10 > 3

A la variable `$respuesta` le corresponde el valor `verdadero` porque `10` es mayor que `3`.

Los valores lógicos `verdadero` y `falso` aparecen resaltados en rojo oscuro.

Operadores aritméticos, lógicos y de comparación
Operadores aritméticos, lógicos y de comparación

## Operadores aritméticos, lógicos y de comparación

Aunque el título de esta sección parezca complejo, verás como el contenido no es tan difícil como parece.

### Operadores aritméticos

Estos son los símbolos aritméticos básicos: suma (`+`), resta (`-`), multiplicación (`*`), división (`/`) y potenciación (`^`).

Este es un ejemplo de cómo usar los operadores aritméticos en TurtleScript:

    $sumar = 1 + 1
    $restar = 20 - 5
    $multiplicar = 15 * 2
    $dividir = 30 / 30
    $potencia = 2 ^ 2

Los valores resultantes de estas operaciones aritméticos son asignados a variables. Puedes ver los valores resultantes en el inspector.

Si lo que quieres es realizar un cálculo simple, puedes hacer algo como esto:

    escribir 2010-12

Ahora veamos un ejemplo con paréntesis:

    escribir ( ( 20 - 5 ) * 2 / 30 ) + 1

Primero se calculan las operaciones que están dentro de los paréntesis. En este ejemplo, primero se calcula 20 - 5; el resultado se multiplica por 2, luego se divide por 30 y, por último, se le suma 1. El resultado final es 2. Los paréntesis pueden también usarse en otros casos.

KTurtle también tiene otras funciones aritméticas en forma de órdenes. Echa un vistazo a las siguientes órdenes, eso sí, teniendo en cuenta que se trata de operaciones avanzadas: redondear, aleatorio, raíz, pi, sen, cos, tan, arcsen, arccos, arctan.

### Operadores lógicos (verdadero/falso)

Mientras que los operadores aritméticos se usan principalmente con números, los operadores lógicos están pensados para usarse con valores lógicos (`verdadero` y `falso`). Hay solo tres operadores lógicos: `y`, `o` y `no`. El siguiente código de TurtleScript muestra cómo usarlos:

    $y_1_1 = verdadero y verdadero  # -> verdadero
    $y_1_0 = verdadero y falso  # -> falso
    $y_0_1 = falso y verdadero  # -> falso
    $y_0_0 = falso y falso  # -> falso

    $o_1_1 = verdadero o verdadero # -> verdadero
    $o_1_0 = verdadero o falso  # -> verdadero
    $o_0_1 = falso o verdadero  # -> verdadero
    $o_0_0 = falso o falso  # -> falso

    $no_1 = no verdadero  # -> falso
    $no_0 = no falso  # -> verdadero

Puedes ver los valores resultantes en el inspector, aunque también se proporcionan pequeños comentarios al final de las líneas. `Y` resulta en `verdadero` solo si ambas partes son `verdaderos`. `O` resulta en `verdadero` si alguna de las dos partes es `verdadero`. Y `no` transforma `verdadero` en `falso` y`falso` en `verdadero`.

Los operadores lógicos aparecen resaltados en rosa.

#### Unos ejemplos más complejos:

Considera el siguiente ejemplo con `and`:

    $a = 1
    $b = 5
    si (($a < 10) y ($b == 5)) y ($a < $b) {
      escribir "hola"
    }

En este código de TurtleScript, el resultado de los tres operadores de comparación están agrupados mediante los operadores `y`. Esto significa que los tres resultados tienen que ser iguales a «verdadero» para que se escriba la palabra «hola».

Un ejemplo con `o`:

    $n = 1
    si ($n < 10) o ($n == 2) {
      escribir "hola"
    }

En este código de TurtleScript, la parte izquierda del operador `o` es «verdadera», mientras que la derecha es «falsa». Ya que una de las dos partes del operador `o` es «verdadera», el resultado del operador `o` también lo es. Esto quiere decir que se escribe la palabra «hola».

Finalmente, un ejemplo con `no`, que transforma «verdadero» en «falso» y «falso» en verdadero». Fíjate:

    $n = 1
    si no ($n == 3) {
      escribir "hola"
    } sino {
      escribir "no hola ;-)"
    }

### Operadores de comparación

Considera esta comparación sencilla:

    $respuesta = 10 > 3

Aquí, `10` se compara con `3` usando el operador «más grande que». El resultado de esta operación, es decir, el valor lógico `verdadero`, se guarda en la variable `$respuesta`.

Todos los números y variables (que contengan números) pueden compararse entre sí usando operadores de comparación.

Estos son todos los posibles operadores de comparación:

Tabla 4.1. Tipos de preguntas

`$A == $B` | igual a | la respuesta es «verdadera» si `$A` es igual a `$B`
`$A != $B` | no igual a | la respuesta es «verdadera» si `$A` no es igual a `$B`
`$A > $B` | mayor que | la respuesta es «verdadera» si `$A` es mayor que `$B`
`$A < $B` | menor que | la respuesta es «verdadera» si `$A` es menor que `$B`
`$A >= $B` | mayor o igual que | la respuesta es «verdadera» si `$A` es mayor o igual que `$B`
`$A <= $B` | menor o igual que | la respuesta es «verdadera» si `$A` es menor o igual que `B`

Ten en cuenta que `$A` y `$B` tienen que ser números o variables que contengan números.

Órdenes
Órdenes

## Órdenes

Con las órdenes podemos decirle a la tortuga o a KTurtle lo que tiene que hacer. Algunas órdenes requieren de parámetros de entrada, mientras que otras devuelven parámetros de salida. En esta sección se explican todas las órdenes integradas en KTurtle. Alternativamente, puedes usar `aprender` para crear tus propias órdenes. Las órdenes que van a detallarse aquí aparecen resaltadas en azul oscuro.

### Cómo mover la tortuga

Hay varias órdenes que permiten mover la tortuga por la pantalla.

avanzar (avz)

      avanzar X

  `avanzar` desplaza la tortuga hacia delante X píxeles. Cuando el pincel está bajado, la tortuga deja a su paso un trazo. `avanzar` puede abreviarse como `avz`.

retroceder (ret)

      retroceder X

  `retroceder` hace retroceder la tortuga X píxeles. Cuando el pincel está bajado, la tortuga deja a su paso un trazo. `retroceder` puede abreviarse como `ret`.

izquierda (izq)

      izquierda X

  `izquierda` le ordena a la tortuga que rote X grados hacia la izquierda. `izquierda` puede abreviarse como `izq`.

derecha (der)

      derecha X

  `derecha` le ordena a la tortuga que rote X grados hacia la derecha. `derecha` puede abreviarse como `der`.

dirección (dir)

      dirección X

  `dirección` determina el ángulo de dirección de la tortuga, que será X grados contando a partir de cero. No se tiene en cuenta la dirección anterior de la tortuga. `dirección` puede abreviarse como `dir`.

obtenerdirección

      obtenerdirección

  `obtenerdirección` determina el ángulo de dirección de la tortuga, que será X grados contando a partir de cero.

centrar

      centrar

  `centrar` mueve la tortuga al centro del lienzo.

ir

      ir X; Y

  `ir` le ordena a la tortuga que se desplace a una posición concreta del lienzo. Esta posición está a X píxeles del margen izquierdo del lienzo y a Y píxeles del margen superior del lienzo.

irx

      irx X

  `irx` le ordena a la tortuga que vaya a una posición que está a X píxeles del margen izquierdo del lienzo, sin modificar su altura. `irx` se puede abreviar con `ix`.

iry

      iry Y

  `iry` le ordena a la tortuga que vaya a una posición que está a Y píxeles del margen superior del lienzo, sin modificar la distancia a la que se encuentre del margen izquierdo. `iry` se puede abreviar con `iy`.

### Nota

Con las órdenes `ir`, `irx`, `iry` y `centrar`, la tortuga no dibuja ningún trazo, independientemente de que el pincel esté bajado o no.

### ¿Dónde está la tortuga?

Hay dos órdenes que devuelven la posición de la tortuga en la pantalla.

obtenerx

  `obtenerx` devuelve el número de píxeles desde el margen izquierdo del lienzo de la posición actual de la tortuga.

obtenery

  `obtenery` devuelve el número de píxeles desde el margen superior del lienzo de la posición actual del la tortuga.

### La tortuga tiene un pincel

La tortuga tiene un pincel que dibuja una línea cuando esta se desplaza. Hay varia órdenes que controlan el pincel. En esta sección se explican estas órdenes.

levantarpincel (lpl)

      levantarpincel

  `levantarpincel` alza el pincel del lienzo. Cuando el pincel está «levantado», la tortuga no deja ningún trazo cuando se desplaza. Consulta también `bajarpincel`. `levantarpincel` puede abreviarse como `lpl`.

bajarpincel (bpl)

      bajarpincel

  `bajarpincel` presiona el pincel sobre el lienzo. Cuando el pincel está «bajado», la tortuga deja un trazo a su paso. Vea también `levantarpincel`. `bajarpincel` puede abreviarse como `bpl`.

grosorpincel (gpl)

      grosorpincel X

  `grosorpincel` fija el grosor de la línea trazada por la tortuga en X píxeles. `grosorpincel` puede abreviarse como `gpl`.

colorpincel (cpl)

      colorpincel R;G;B

  `colorpincel` fija el color del pincel. El parámetro de entrada de `colorpincel` es una combinación RGB. `colorpincel` puede abreviarse como `cpl`.

### Órdenes que controlan el lienzo

Existen varias órdenes que controlan el lienzo.

tamañolienzo (tl)

      tamañolienzo X;Y

  Con la orden `tamañolienzo` puede modificar las dimensiones del lienzo. Requiere de X e Y como parámetros de entrada, donde X es el ancho en píxeles del nuevo lienzo, e Y es la altura del nuevo lienzo también en píxeles. `tamañolienzo` puede abreviarse como `tl`.

colorlienzo (cl)

      colorlienzo R;G;B

  `colorlienzo` define el color del lienzo. El parámetro de entrada de `colorlienzo` es una combinación RGB. `colorlienzo` puede abreviarse como `cl`.

### Comandos para limpiar

Existen dos comandos que permiten limpiar el lienzo después de un embrollo.

limpiar (lmp)

      limpiar

  Con `limpiar` puede borrar todos los dibujos del lienzo. Todo lo demás permanece: la posición y ángulo de la tortuga, el color del lienzo, la visibilidad de la tortuga y el tamaño del lienzo.

reiniciar

      reiniciar

  `reiniciar` borra todo de una forma más concienzuda que la orden `limpiar`. Después de una orden `reiniciar`, todo vuelve a como estaba cuando inició KTurtle. La tortuga regresará a su posición en el centro del lienzo, el color del lienzo volverá a ser blanco, la tortuga dibujará de nuevo una línea negra en el lienzo y el tamaño del lienzo será 400x400 píxeles.

### La tortuga es un duendecillo

Antes de nada conviene explicar qué son los sprites: los duendecillos son pequeñas figuras que pueden desplazarse por la pantalla, como vemos con frecuencia en los videojuegos. Nuestra tortuga también es un duendecillo. Para obtener más información, consulta la entrada en el glosario correspondiente a los duendecillos.

A continuación, encontrarás una descripción detallada de todas las órdenes relacionadas con duendecillos.

### Nota

La versión actual de KTurtle no admite otro duendecillo aparte de la tortuga. En las versiones futuras sí que podrá cambiar la tortuga por algo diseñado por usted mismo.

mostrartortuga (mt)

      mostrartortuga

  `mostrartortuga` vuelve visible de nuevo a la tortuga después de haberla ocultado. `mostrartortuga` puede abreviarse como `mt`.

ocultartortuga (ot)

      ocultartortuga

  `ocultartortuga` oculta la tortuga. Puede usarse cuando la tortuga no quede bien en su dibujo. `ocultartortuga` puede abreviarse como `ot`.

### ¿La tortuga puede escribir?

La respuesta es «sí». La tortuga puede escribir: escribirá todo lo que le ordenes.

escribir

      escribir X

  La orden `escribir` le indica a la tortuga que escriba algo en el lienzo. El parámetro de entrada de `escribir` puede ser un número o una cadena. Puedes concatenar varios números y cadenas usando el símbolo «+». Aquí tienes un ejemplo sencillo:

      $año = 2003
      $autor = "Cies"
      escribir $autor + " comenzó a trabajar en el proyecto KTurtle en " + $año + " y todavía disfruta haciéndolo"

tamañoletra

      tamañoletra X

  `tamañoletra` fija el tamaño del tipo de letra que usa la orden `escribir`. El parámetro de entrada de `tamañoletra` tiene que ser un número. El tamaño viene determinado en píxeles.

### Órdenes aritméticas

Las siguientes son algunas de las órdenes aritméticas más avanzadas de KTurtle.

redondear

      redondear(X)

  Permite `redondear` el número dado a su entero más cercano.

      escribir redondear(10,8)
      avanzar 20
      escribir redondear(10,3)

  Este código hace que la tortuga escriba los números 11 y 10.

aleatorio (alt)

      aleatorio X;Y

  `aleatorio` es una orden que requiere de parámetros de entrada y que devuelve un parámetro de salida. Como parámetros de entrada, necesita dos números, el primero (X) fija el valor mínimo del parámetro de salida, y el segundo (Y) fija su valor máximo. El parámetro de salida es un número elegido al azar que es igual o más grande que el valor mínimo, e igual o más pequeño que el valor máximo. Aquí tiene un ejemplo sencillo:

      repetir 500 {
        $x = aleatorio 1;20
        avanzar $x
        izquierda 10 - $x
      }

  Con la orden `aleatorio` puedes incorporar algo de caos a tu programa.

mod

      mod X,Y

  La orden `mod` devuelve el resto de la división del primer número entre el segundo número.

raíz

      raíz X

  La orden `raíz` sirve para calcular la raíz cuadrada de un número X.

pi

      pi

  Esta orden devuelve el valor del número Pi, `3,14159`.

sen, cos, tan

      sen X
      cos X
      tan X

  Estas tres órdenes representan las famosas funciones trigonométricas `sen`, `cos` y `tan`. El parámetro de entrada de estas tres órdenes, X, es un número.

arcsen, arccos, arctan

      arcsen X
      arccos X
      arctan X

  Estas tres órdenes son las funciones inversas de sen, cos y tan. El parámetro de entrada de estas órdenes, X, es un número.

### Entrada e información mediante diálogos

Un diálogo es una pequeña ventana emergente que proporciona información o que solicita un parámetro de entrada. KTurtle tiene dos órdenes relacionadas con diálogos: `mensaje` y `preguntar`.

mensaje

      mensaje X

  La orden `mensaje` necesita una cadena como parámetro de entrada. Muestra una ventana emergente con el texto de la cadena.

      mensaje "Cies comenzó a trabajar en el proyecto KTurtle en 2003 y todavía disfruta haciéndolo"

preguntar

      preguntar X

  `preguntar` necesita una cadena como parámetro de entrada. Muestra el texto de la cadena en una ventana emergente (igual que hace mensaje) junto a un campo de entrada. Una vez que el usuario ha introducido un número o una cadena, el resultado puede guardarse en una variable o pasarse como un argumento a otra orden. Por ejemplo:

      $entrada = preguntar "¿En qué año naciste?"
      $salida = 2003 - $entrada
      escribir "En 2003 tenías " + salida + " años."

  Si el usuario cancela el diálogo de entrada o no introduce ningún valor, la variable queda vacía.

Asignar valores a las variables
Asignar valores a las variables

## Asignar valores a las variables

Antes de nada, echemos un vistazo a las variables, después veremos cómo asignarles valores.

Las variables son palabras que comienzan con un “$”; en el editor, aparecen resaltadas en color morado.

Las variables pueden contener un número, una cadena o un valor lógico (verdadero/falso). Con el signo de asignación (`=`) se da un valor a la variable, que mantendrá hasta que el programa termine de ejecutarse o hasta que se le asigne un nuevo valor.

Puedes usar las variables, una vez asignadas, de la misma forma que usarías su contenido. Por ejemplo, vea el siguiente código de TurtleScript:

    $x = 10
    $x = $x / 3
    escribir $x

Primero, a la variable `$x` se le asigna el valor `10`. A continuación, a esta misma variable `$x` se le asigna su propio valor dividido por `3`, es decir, a la variable `$x` se da el valor `10 / 3`. Finalmente, se escribe `$x`. En las líneas dos y tres, comprobará que se usa la variable `$x` como si fuera un número.

A las variables hay que asignarles un valor para que puedan ser usadas. Por ejemplo:

    escribir $n

Este código da lugar a un mensaje de error.

Considera el siguiente código de TurtleScript:

    $a = 2004
    $b = 25

    # la siguiente orden escribe "2029"
    escribir $a + $b
    retroceder 30
    # la siguiente orden escribe  "2004 más 25 igual a 2029"
    escribir $a + " más " + $b + " es igual a " + ($a + $b)

En las primeras dos líneas, a las variables `$a` y `$b` se les asigna los valores 2004 y 25. A continuación hay dos órdenes `escribir` con una orden `retroceder 30` en medio. Los comentarios que hay antes de las órdenes `escribir` explican lo que hacen. Como ves, puedes usar las variables de la misma forma que usarías sus contenidos. Es decir, puedes usarlas con cualquier operador o convertirlas en el parámetro de entrada de una orden.

Un nuevo ejemplo:

    $nombre = preguntar "¿Cuál es tu nombre?"
    escribir "¡Hola " + $nombre + "! Buena suerte con el aprendizaje del arte del programar…"

Este ejemplo es muy claro. De nuevo, aquí tiene como la variable `$name` se trata como si fuera una cadena.

Cuando estés usando variables, el inspector te puede ser de gran ayuda. Muestra el contenido de todas las variables que están en uso en un momento dado.

Cómo controlar la ejecución
Cómo controlar la ejecución

## Cómo controlar la ejecución

Los controladores de la ejecución permiten, tal como su nombre indica, controlar la ejecución.

Las órdenes de control de la ejecución aparecen resaltadas en negro y con un tipo de letra negrita. Las llaves, que se usan generalmente junto con los controladores de ejecución, aparecen resaltadas en negro.

### Cómo hacer que la tortuga espere

Si ya has programado algo en KTurtle, te habrás dado cuenta de que la tortuga es muy rápida dibujando. Con esta orden puede hacer que la tortuga se detenga durante un tiempo determinado.

esperar

      esperar X

  `esperar` hace que la tortuga se detenga durante X segundos.

      repetir 36 {
        avanzar 5
        derecha 10
        esperar 0,5
      }

  Este código dibuja un circulo, pero la tortuga espera durante medio segundo antes de realizar el siguiente paso. Esto da la impresión de que la tortuga se está moviendo a cámara lenta.

### Ejecutar “si”

si

      si valor lógico { … }

  El código que está entre llaves solo se ejecutará `si` el valor lógico es «verdadero».

      $x = 6
      si $x > 5 {
        escribir $x + " es mayor que cinco"
      }

  En la primer línea, a `$x` se le asigna el valor 6. En la segunda, se usa un operador de comparación para evaluar la condición `$x > 5`. Al cumplirse esta condición, es decir, al ser 6 mayor que 5, el controlador `si` permite que el código entre llaves se ejecute.

### Si no es así: «sino»

sino

      si valor lógico { … } sino { … }

  `sino` puede usarse en conjunción con el controlador `si`. El código que aparece entre llaves después de `sino` solo se ejecute si el valor lógico es «falso».

      reiniciar
      $x = 4
      si $x > 5 {
        escribir $x + " es mayor que cinco"
      }
      sino {
        escribir $x + " es menor que seis"
      }

  El operador de comparación evalúa la expresión `$x > 5`. Ya que en este caso 4 no es mayor que 5, el resultado es «falso». Esto quiere decir que se ejecuta el código que aparece entre llaves después de `sino`.

### El bucle «mientras»

mientras

      mientras valor lógico { … }

  El controlador `mientras` actúa de forma similar a `si`. La diferencia es que `mientras` continúa ejecutando (en un bucle) el código que se encuentra entre llaves hasta que el valor lógico sea «falso».

      $x = 1
      mientras $x < 5 {
        avanzar 10
        esperar 1
        $x = $x + 1
      }

  En la primer línea, a `$x` se le asigna el valor 1. En la segunda, se evalúa la condición `$x < 5`. Mientras el resultado de esta condición sea «verdadero», el controlador `while` continúa ejecutando el código que se encuentra entre llaves, así hasta que la condición `$x < 5` sea «falsa». En este ejemplo, el código entre llaves se ejecuta 4 veces, porque cada vez que la quinta línea se ejecuta, al valor de `$x` se le suma 1.

### El bucle «repetir»

repetir

      repetir número { … }

  El controlador `repetir` actúa de forma similar a `mientras`. La diferencia es que `repetir` continúa ejecutando (en un bucle) el código que se encuentra entre llaves tantas veces como le indica el número dado.

### El bucle «para», un bucle que cuenta

para

      para variable = número hasta número { … }

  El bucle `para` es un «bucle que cuenta», es decir, que lleva la cuenta por ti. El primer número asigna a la variable el valor del primer bucle. Con cada bucle, este número se incrementa hasta alcanzar el segundo número.

      para $x = 1 hasta 10 {
        escribir $x * 7
        avanzar 15
      }

  Cada vez que se ejecute el código entre llaves, la variable `$x` se incrementa en 1, así hasta que sea igual a 10. El código entre llaves escribe el valor de `$x` multiplicado por 7. Cuando el código termine de ejecutarse, verás en el lienzo la tabla de multiplicar del 7.

  El incremento predeterminado del bucle es 1, pero puedes usar otro valor con:

      para variable = número hasta número paso número { … }

### Interrumpir un bucle

parar

      parar

  Interrumpe inmediatamente el bucle que se está ejecutando y transfiere el control a la primera línea de código después del bucle.

### Interrumpir la ejecución de tu programa

salir

      salir

  Detiene la ejecución de tu programa.

### Comprobación de afirmaciones en tiempo de ejecución

afirmar

      afirmarvalor lógico { … }

  Se puede utilizar para razonar sobre la corrección del programa o de los datos de entrada

      $in = ask "What is your year of birth?"
      # el año debe ser positivo
      assert $in
      > 0

Crea tus propias órdenes con «aprender»
Crea tus propias órdenes con «aprender»

## Crea tus propias órdenes con «aprender»

`aprender` es especial ya que lo puedes usar para crear tus propias órdenes. La orden que crees puede admitir parámetros de entrada y devolver parámetros de salida. Veamos cómo se crea una nueva orden:

    aprender círculo $x {
      repetir 36 {
        avanzar $x
        izquierda 10
      }
    }

La nueva orden se denomina `círculo`. `círculo` necesita un parámetro de entrada para fijar el tamaño del círculo y no devuelve ningún parámetro de salida. A partir de ahora la orden `círculo` puede usarse como una orden normal en cualquier lugar del código. Mira este ejemplo:

    aprender círculo $x {
      repetir 36 {
        avanzar $x
        izquierda 10
      }
    }

    ir 200;200
    círculo 20

    ir 300;200
    círculo 40

En el próximo ejemplo, se crea una orden que devuelve un parámetro de salida:

    aprender facultad $x {
      $r = 1
      para $i = 1 hasta $x {
        $r = $r * $i
      }
      devolver $r
    }

    escribir facultad 5

En este ejemplo, se crea una nueva orden llamada `facultad`. Si el parámetro de entrada es `5`, entonces el parámetro de salida es `5*4*3*2*1`. Con `devolver` se define un parámetro de salida que se devuelve durante la ejecución.

Las órdenes pueden tener más de un parámetro de entrada. En el siguiente ejemplo se crea una orden que dibuja un rectángulo:

    aprender caja $x;$y {
      avanzar $y
      derecha 90
      avanzar $x
      derecha 90
      avanzar $y
      derecha 90
      avanzar $x
      derecha 90
    }

Ahora, si ejecuta `caja 50;100`, la tortuga dibujará una rectángulo en el lienzo.

Capítulo 5. Glosario
Glosario

# Capítulo 5. Glosario

En este capitulo encontrará una explicación de muchas de las palabras «inusuales» que se utilizan a lo largo del manual.

grados

  Grados son unidades para medir ángulos y giros. Una vuelta completa es 360 grados, media vuelta 180 grados y una cuarto de vuelto 90 grados. Las órdenes `izquierda`, `derecha` y `dirección` necesitan un parámetro de entrada en grados.

parámetros de entrada y parámetros de salida de las órdenes

  Hay órdenes que necesitan un parámetro de entrada, órdenes que devuelven un parámetro de salida, órdenes que necesitan un parámetro entrada y devuelven un parámetro salida, y órdenes que ni necesitan un parámetro de entrada ni devuelven un parámetro de salida.

  Ejemplos de órdenes que solo necesitan parámetros de entrada son:

      avanzar 50
      colorpincel 255;0;0
      escribir "¡Hola!"

  La orden `avanzar` toma el valor `50` como parámetro de entrada. La orden `avanzar` necesita este parámetro de entrada para saber cuántos píxeles deberá avanzar hacia delante. La orden `colorpincel` necesita un color como parámetro de entrada, y la orden `escribir`, una cadena de texto. Tenga en cuenta que el parámetro de entrada puede ser también una variable. El siguiente ejemplo es una muestra de esto:

      $x = 50
      escribir $x
      avanzar 50
      $str = "¡Hola!"
      escribir $str

  Aquí hay ejemplos de órdenes que devuelven un parámetro de salida:

      $x = preguntar "Escriba cualquier cosa y pulse Aceptar. ¡Gracias!"
      $r = aleatorio 1;100

  La orden `preguntar` necesita una cadena como parámetro de entrada, y devuelve el número o cadena que se le proporciona. Como puede ver, el parámetro de salida de la orden `preguntar` se guarda en la variable `$x`. La orden `aleatorio` también devuelve un parámetro de salida. En este caso, se trata de un número entre 1 y 100. El parámetro de salida de la orden `aleatorio` también se guarda en una variable, denominada en este caso `$r`. Fíjese que las variables `$x` y `$r` no tienen ningún uso en este ejemplo.

  También hay órdenes que no requieren de parámetros de entrada y que no devuelven ningún parámetro de salida. Estos son algunos ejemplos:

      limpiar
      levantarpincel

resaltado intuitivo

  Esta es una característica de KTurtle que hace que programar sea mucho más fácil. Con el resaltado intuitivo, el código que escribe se muestra en uno u otro color en función de qué tipo de código sea. En la siguiente lista encontrará los diferentes tipos de código y el color en que se muestran en el editor.

  Tabla 5.1. Los diferentes tipos de código y su color de resaltado

  órdenes habituales | azul oscuro | Las órdenes habituales se describen aquí.
  órdenes de control de la ejecución | negro (negrita) | Estas órdenes especiales controlan la ejecución; lea más sobre estas órdenes aquí.
  comentarios | gris | Cuando una línea de código comienza con el carácter #, se interpreta como un comentario. Estas líneas se ignoran durante la ejecución del código. Los comentarios permiten a los programadores explicar un poco su código. Pueden usarse también para evitar que una parte concreta del código se ejecute.
  llaves {, } | verde oscuro (negrita) | Las llaves se usan para agrupar porciones de código. Las llaves se utilizan con frecuencia en combinación con los controladores de ejecución.
  la orden aprender | verde claro (negrita) | La orden aprender se usa para crear nuevas instrucciones.
  cadenas | rojo | No hay mucho que decir acerca de estas cadenas (de texto), excepto que siempre comienzan y terminan con dobles comillas (").
  números | rojo oscuro | Son números, no es necesario añadir más.
  valores lógicos | rojo oscuro | Existen dos valores lógicos, verdadero y falso.
  variables | púrpura | Comienzan con el símbolo «$» y pueden ser números, cadenas o valores lógicos.
  operadores aritméticos | gris | Estos son los operadores aritméticos: `+`, `-`, `*`, `/` y `^`.
  operadores de comparación | azul claro (negrita) | Estos son los operadores de comparación: `==`, `!=`, `<`, `>`, `<=` y `>=`.
  operadores lógicos | rosado (negrita) | Estos son los operadores lógicos: `y`, `o` y `no`.
  texto normal | negro |

píxeles

  Un píxel es un punto sobre la pantalla. Si observa con atención, verá que la pantalla de su monitor usa píxeles. Todas las imágenes que aparecen en la pantalla se construyen a base de píxeles. Un píxel es lo más pequeño que puede dibujarse en una pantalla.

  Muchas órdenes necesitan un número de píxeles como parámetro de entrada. Estas órdenes son: `avanzar`, `retroceder`, `ir`, `irx`, `iry`, `tamañolienzo` y `grosorpincel`.

  En versiones anteriores de KTurtle, el lienzo era básicamente una imagen rasterizada; sin embargo, en las versiones más recientes, el lienzo es una imagen vectorial. Esto quiere decir que la escala del lienzo puede ampliarse o reducirse y que, por lo tanto, un píxel no se corresponde necesariamente con un punto sobre la pantalla.

Combinaciones RGB (código de colores)

  Las combinaciones RGB se utilizan para describir colores. La «R» (que viene de la palabra inglesa «red») representa el «rojo», la «G» (de la palabra inglesa «green») representa el «verde», y la «B» (de la palabra inglesa «blue») representa el «azul». Un ejemplo de una combinación RGB es `255;0;0`. El primer valor (es decir, el rojo) es 255 y los otros dos son 0, lo que da lugar a una tonalidad brillante de rojo. Cada valor de una combinación RGB debe estar entre 0 y 255. Aquí hay una lista con algunos de los colores más utilizados:

  Tabla 5.2. Combinaciones RGB frecuentes

  `0;0;0` | negro
  `255;255;255` | blanco
  `255;0;0` | rojo
  `150;0;0` | rojo oscuro
  `0;255;0` | verde
  `0;0;255` | azul
  `0;255;255` | azul claro
  `255;0;255` | rosado
  `255;255;0` | amarillo

  Existen dos órdenes que necesitan combinaciones RGB como parámetro de entrada: `colorlienzo` y `colorpincel`.

sprite

  Un sprite (en inglés «duendecillo») es una pequeña imagen que puede moverse por la pantalla. Nuestra querida tortuga, por ejemplo, es un sprite.

  ### Nota

  En esta versión de KTurtle, el sprite no puede cambiarse de una tortuga a otra imagen. Sin embargo, en futuras versiones de KTurtle sí que está previsto que se pueda hacer esto.

Capítulo 6. Guía para la traducción de KTurtle
Guía para la traducción de KTurtle

# Capítulo 6. Guía para la traducción de KTurtle

Como probablemente ya sepa, el lenguaje de programación de KTurtle, TurtleScript, puede ser traducido. Se elimina así una de las barreras que algunas personas, especialmente los estudiantes más jóvenes, encuentran a la hora de comprender los fundamentos de la programación.

Cuando traduzca KTurtle a un nuevo idioma encontrará, junto a las cadenas de la interfaz gráfica de usuario, que las órdenes de programación, los ejemplos y los mensajes de error están incluidos en los archivos `.pot` estándares que se usan para la traducción en KDE. Todo se traduce siguiendo el método de traducción habitual de KDE. No obstante, se le recomienda que aprenda cómo traducir esta aplicación en particular (como también leerá en los comentarios del traductor).

Consulte https://edu.kde.org/kturtle/translation.php si desea obtener más información sobre el proceso de traducción. Le agradecemos su colaboración. KTurtle depende en gran medida de sus traducciones.

Capítulo 7. Créditos y licencia
Créditos y licencia

# Capítulo 7. Créditos y licencia

KTurtle

Copyright del programa 2003-2005 Cies Breijs `(cies AT kde DOT nl)`

Copyright de la documentación 2004, 2007, 2009

- Cies Briej `(cies AT kde DOT nl)`

- Anne-Marie Mahfouf `(annma AT kde.org)`

- Correcciones hechas por Philip Rodrigues `(phil AT kde.org)`

- Actualización de la guía de traducción y correcciones: Andrew Coles `(andrew_coles AT yahoo DOT co DOT uk)`

Traducido por Rafael Beccar`(rafael.beccar AT kdemail.net)` y Leticia Martín Hernández `(leticia.martin AT gmail.com)`

Esta documentación está sujeta a los términos de la Licencia de Documentación Libre GNU.

Este programa está sujeto a los términos de la Licencia Pública General GNU.

Índice de órdenes
Índice de órdenes

# Índice de órdenes

### A

afirmar, Comprobación de afirmaciones en tiempo de ejecución
aleatorio (alt), Órdenes aritméticas
aprender, Crea tus propias órdenes con «aprender»
arccos, Órdenes aritméticas
arcsen, Órdenes aritméticas
arctan, Órdenes aritméticas
avanzar (avz), Cómo mover la tortuga

### B

bajarpincel (bpl), La tortuga tiene un pincel

### C

centrar, Cómo mover la tortuga
colorlienzo (cl), Órdenes que controlan el lienzo
colorpincel (cpl), La tortuga tiene un pincel
cos, Órdenes aritméticas

### D

derecha (der), Cómo mover la tortuga
dirección (dir), Cómo mover la tortuga

### E

escribir, ¿La tortuga puede escribir?
esperar, Cómo hacer que la tortuga espere

### F

falso, Valores lógicos (verdadero/falso)

### G

grosorpincel (gpl), La tortuga tiene un pincel

### H

hasta, El bucle «para», un bucle que cuenta

### I

ir, Cómo mover la tortuga
irx (ix), Cómo mover la tortuga
iry (iy), Cómo mover la tortuga
izquierda (izq), Cómo mover la tortuga

### L

levantarpincel (lpl), La tortuga tiene un pincel
limpiar (lmp), Comandos para limpiar

### M

mensaje, Entrada e información mediante diálogos
mientras, El bucle «mientras»
mod, Órdenes aritméticas
mostrartortuga (mt), La tortuga es un duendecillo

### N

no, Operadores lógicos (verdadero/falso)

### O

o, Operadores lógicos (verdadero/falso)
obtenerdirección, Cómo mover la tortuga
obtenerx, ¿Dónde está la tortuga?
obtenery, ¿Dónde está la tortuga?
ocultartortuga (ot), La tortuga es un duendecillo

### P

para, El bucle «para», un bucle que cuenta
parámetro de salida, Crea tus propias órdenes con «aprender»
parar, Interrumpir un bucle
paso, El bucle «para», un bucle que cuenta
pi, Órdenes aritméticas
preguntar, Entrada e información mediante diálogos

### R

raíz, Órdenes aritméticas
redondear, Órdenes aritméticas
reiniciar, Comandos para limpiar
repetir, El bucle «repetir»
retroceder (ret), Cómo mover la tortuga

### S

salir, Interrumpir la ejecución de tu programa
sen, Órdenes aritméticas
si, Ejecutar “si”
sino, Si no es así: «sino»

### T

tamañoletra, ¿La tortuga puede escribir?
tamañolienzo (tl), Órdenes que controlan el lienzo
tan, Órdenes aritméticas

### V

verdadero, Valores lógicos (verdadero/falso)

### Y

y, Operadores lógicos (verdadero/falso)