El Wren libro

0 - Fin del programa exitoso
1 - Error desconocido
2 - (grep) Uso incorrecto del comando | (bash) Error de entrada/salida
64 - Uso incorrecto del comando
65 - Error de formato de datos
66 - Sin acceso a la entrada
67 - Dirección desconocida
68 - Nombre de dominio (host name) desconocido
69 - Servicio no disponible
70 - Error interno del software
71 - Error de sistema
72 - Archivo crítico del sistema no encontrado
73 - Imposible de crear archivo de salida
74 - Error de entrada/salida
75 - Falla temporal
76 - Error remoto en protocolo
77 - Permiso denegado
78 - Error de configuración
126 - Comando encontrado, pero no es ejecutable
127 - Comando no encontrado
128 - Código de salida no válido
128   Error fatal terminado por kill -9
140 - Comando terminado por Ctrl-C
141 - Comando terminado por Ctrl-D
255 - Código de salida fuera de rango

// Exit codes used by the wren binaries, following the BSD standard
//
// The interpreter was used with an incorrect number of arguments
#define WREN_EX_USAGE 64

// Compilation error
#define WREN_EX_DATAERR 65

// Runtime error
#define WREN_EX_SOFTWARE 70

// Cannot open input file
#define WREN_EX_NOINPUT 66

// I/O Error
#define WREN_EX_IOERR 74

¡Hola Wren!

// muestra: ¡Hola Wren!

hola
camelCase
PascalCase
_under_score
abc123
TODAS_MAYUSCULAS

13hola
mi-variable
$miVariable
mi variable
ñandú
👨miMetodo
Mi👩clase

🏁 🍇
  😀 🔤Hello World!🔤❗️
🍉

// Asociamos la clase `Numero` como un substituto para llamar a la clase `Num`
var Numero = Num

// Dará error. No se puede heredar de las clases primitivas.
class Numero is Num {}

// Es posible nombrar con minúsculas, pero puede dar
// conflictos de contexto al momento de usarlo dentro
// de una clase. (Puede hacer colisión con nombres de variable)
class numero {}

var animales = [
  "perro",
  "gato",
  "condor",
  "huemul"
]

MiClase.metodo(
  parametro1,
  parametro2,
  parametro3
)

// Correcto
if (condiccion == true) { x = 0 }

// Correcto
if (condiccion == true)   {
  x = 0
}

// Correcto
if (condicion == true) x = 0

  // Si la condición es verdadera, x será 0. Si es falsa, x será 1
  var x = condicion ? 0 : 1

  // Si x es nulo se asignará 0. Caso contrario mantiene su valor anterior.
  x = x || 0

// Error
if (condiction == true)
{
  x = 0
}

Random.new().int(10)

Random
.new()
.int(10)

Random.
new().
int(10)

Random.new().int(10) Random.new().int(10)

// /*
  codigo()
// */

/*
  codigo()
// */

//*
  codigo()
// */

/*
  codigo()
// */

circulo(/* x */ 10, /* y */ 20, /* radio */ 10)

var x = 10
var y = 20
var radio = 10
circulo(x, y, radio)

var nombre = " arturo "

// Elimina solamente espacio final
System.print(nombre.trimEnd())

// Elimina solamente espacio inicial
System.print(nombre.trimStart())

// Elimina espacio inicial y final
System.print(nombre.trim())

var nombre = " arturo "

// Elimina solamente espacio final
System.print("-" + nombre.trimEnd() + "-")

// Elimina solamente espacio inicial
System.print("-" + nombre.trimStart() + "-")

// Elimina espacio inicial y final
System.print("-" + nombre.trim() + "-")

System.print(""" mi raw string """ + "\"\"\"")

System.print(""" mi raw string '''""".replace("'", "\""))

mi raw string """

// muestra: h
System.print("hola wren"[0])

// muestra: n
System.print("hola wren"[-1])

// muestra: la
System.print("hola wren"[2..3])

// muestra: nerw aloh
System.print("hola wren"[-1..0])

var contar_sangria = Fn.new {|string|
    var indice = 0
    var bytes = string.bytes
    while(indice < bytes.count) {
        var caracter = bytes[indice]
        if(caracter == 0x20 || caracter == 0x09) {
          indice = indice + 1
          continue
        }
        return indice
    }
    return 0
}

var borrar_sangrado = Fn.new {|string|
    var inicio = contar_sangria.call(string)
    if(inicio == 0) return string
    var lineas = string.split("\n")

    lineas = lineas.map {|linea|
        var izquierda = contar_sangria.call(linea)
        if(izquierda >= inicio) return linea[inicio..-1]
        return linea
    }
    return lineas.join("\n")
}

// Ejemplo
var frase = """        Mucha Sangría"""

// Elimina la sangría de la frase
System.print(borrar_sangrado.call(frase))

var donas = Fn.new {|cantidad|
  // Tu código aquí
}


// Pruebas para evaluar que el ejercicio
// se ha completado exitosamente.
// no modificar.

var probar = Fn.new {|tengo, quiero|
  var prefijo = " X "
  if (tengo == quiero) {
    prefijo = " OK "
  }
  System.print("%(prefijo) tengo: %(tengo) quiero: %(quiero)")
}

System.print("Probando donas")
probar.call(donas.call(4), "Número de donas: 4")
probar.call(donas.call(9), "Número de donas: 9")
probar.call(donas.call(10), "Número de donas: muchas")
probar.call(donas.call(99), "Número de donas: muchas")
System.print()

var a = 0.15 + 0.15
var b = 0.1 + 0.2

// puede ser falso
if (a == b) {}

// también puede ser falso
if (a >= b) {}

var equivalentes = Fn.new { |a, b, epsilon|

  var absA = a.abs
  var absB = b.abs
  var diff = (a - b).abs

  // Atajo, maneja los infinitos
  if (a == b) {
      return true
  }

  // a o b o ambos son cero
  if (a * b == 0) {
      // El error relativo no es importante aquí.
      // Se tiene que utilizar una definición totalmente distinta
      // del margen de error cuando a o b son cero, porque la definición
      // clásica del error relativo es inútil en esos casos.
      return diff < (epsilon * epsilon)
  }

  // Usar el error relativo
  return diff / (absA + absB) < epsilon
}

// Prueba de la función
var a = 0.15 + 0.15
var b = 0.1 + 0.2

// Epsilon siempre debe ser entregado según el contexto de comparación
// no utilizar epsilon fijos.
var epsilon = 0.001

var eq = equivalentes.call(a, b, epsilon)

// Debería ser verdadero
System.print(eq)

// Solamente muestra 3
System.print(Num.pi.truncate)

var formateado = (Num.pi * 1e2).truncate / 1e2

// Muestra 3.14
System.print(formateado)

var formatear = Fn.new {|numero, decimales| (numero * 10.pow(decimales)).truncate / 10.pow(decimales)}

// Muestra 3.14
System.print(formatear.call(Num.pi, 2))

// Convertimos el número a String
var string = Num.pi.toString

// Queremos mostrar 3.14
var posiciones = 2

// Buscamos donde comienzan los decimales
var index = string.indexOf(".")

// Separamos el número entre entero y decimal
var entero = string[0...index]
var decimal = string[index + 1..-1]

// Obtenemos los decimales a mostrar
var decimales = decimal.take(posiciones).join()

// Reunimos la parte entera y decimal
var formateado = entero + "." + decimales

System.print(formateado)

var numeros = [1, 2, 3]
numeros.each {|num|
  System.print(num)
}

var numeros = [1, 2, 3]

// .toList es necesario para que System.print() muestre la lista apropiadamente.
// Esto es debido a que una secuencia puede no tener fin. Necesitamos pasarlo a una estructura de datos finita.
// También estamos utilizando el "retorno implícito".
numeros = numeros.map{|num| num + 1}.toList

// Muestra [2, 3, 4]
System.print(numeros)

var numeros = [1, 2, 3, 4]

var pares = numeros.where{|num| num % 2 == 0}.toList

// Muestra [2, 4]
System.print(pares)

var numeros = [1, 2, 3]

// Si no se pasa un acumulador, se considera el primer elemento como valor inicial
var resultado = numeros.reduce {|acumulador, num| acumulador + num}

// Muestra 6
System.print(resultado)

// Iniciamos el acumulador con valor -1
resultado = numeros.reduce(-1) {|acumulador, num| acumulador + num}

// Muestra 5
System.print(resultado)

var numeros = [1, 2, 3, 4]
var primeros = numeros.take(2).toList

// Muestra [1, 2]
System.print(primeros)

var numeros = [1, 2, 3, 4]
var ultimos = numeros.skip(2).toList

// Muestra [3, 4]
System.print(ultimos)

var numeros = [1, 2, 3]

// Muestra "false" debido a que no contiene el número 4
System.print(numeros.contains(4))

var numeros = [1, 2, 3, 4]

// 4
System.print(numeros.count)

// Contamos solamente los números múltiplos de 2
var pares = numeros.count {|num| num % 2 == 0}

// 2
System.print(pares)

var numeros = [1, 2, 3]

// Muestra "123"
System.print(numeros.join())

// Muestra "1$2$3"
System.print(numeros.join("$"))

// Muestra "1 num 2 num 3"
System.print(numeros.join(" num "))

var numeros = [1, 2, 3]
var resultado = numeros.all {|num| num > 2}

// Falso. No todos los números en la secuencia son mayores a 2
System.print(resultado)

resultado = numeros.all{|num| num < 4}

// Verdadero. Todos los números en la secuencia son menores a 4
System.print(resultado)

var numeros = [1, 2, 3]
var resultado = numeros.any {|num| num % 2 == 0}

// Verdadero. Existe un número múltiplo de 2.
System.print(resultado)

resultado = numeros.any {|num| num % 5 == 0}

// Falso. Ningún número es múltiplo de 5.
System.print(resultado)

  // Creamos una nueva función para nuestra lógica
  var primerElemento = Fn.new {|elementos, predicado|

    // Si existe un elemento que cumpla la condición, obtenemos el primero de la secuencia.
    var resultado = elementos.any(predicado) ? elementos.where(predicado).take(1) : false
    if (resultado && resultado.count > 0) {
      return resultado.toList[0]
    }

    // Caso contrario devolvemos nulo
    return null
  }

  var numeros = [1, 2, 3]
  var resultado = primerElemento.call(numeros) {|item| item > 1}

  // Muestra 2
  System.print(resultado)

  resultado = primerElemento.call(numeros) {|item| item > 3}

  // Muestra null
  System.print(resultado)

// Declaramos la variable
var buscar

// Le asignamos el contenido
buscar = Fn.new {|elementos, objetivo, minimo, maximo|
    if (maximo < minimo) {
      return -1
    }

    var posicion = ((maximo + minimo) / 2).round
    var candidato = elementos[posicion]

    if (candidato == objetivo) {
      return posicion
    }

    if (candidato > objetivo) {
      // Ahora podemos hacer una llamada recursiva
      return buscar.call(elementos, objetivo, minimo, posicion - 1)
    }

    return buscar.call(elementos, objetivo, posicion + 1, maximo)
}

var elementos = (0..30).toList
var minimo = 0
var maximo = elementos.count - 1

System.print(buscar.call(elementos, 30, minimo, maximo)) // 30
System.print(buscar.call(elementos, 31, minimo, maximo)) // -1
System.print(buscar.call(elementos, 20, minimo, maximo)) // 20

var fibra = Fiber.new {
  123.noExiste
}

var error = fibra.try()
System.print("Hubo un Error: " + error)

Fiber.abort("Hubo un error")

class MiError {
  construct nuevo() {}
  mensaje {"Este es un objeto error personalizado"}
}

var fibra = Fiber.new {
  Fiber.abort(MiError.nuevo())
}

fibra.try()

if (fibra.error is MiError) {
  System.print(fibra.error.mensaje)
}

// Piedra, Papel o Tijeras
// Usando el Patron de Double Dispatch
class Elemento {
  pierdeCon(elemento) {}
  leGanaAPiedra(){}
  leGanaAPapel(){}
  leGanaATijera(){}
}

class Piedra is Elemento {
  construct crear() {}

  pierdeCon(elemento) {
    return elemento.leGanaAPiedra()
  }

  leGanaAPiedra() {
    return false
  }

  leGanaAPapel() {
    return false
  }

  leGanaATijera() {
    return true
  }
}

class Papel is Elemento {
  construct crear() {}

  pierdeCon(elemento) {
    return elemento.leGanaAPapel()
  }

  leGanaAPiedra() {
    return true
  }

  leGanaAPapel() {
    return false
  }

  leGanaATijera() {
    return false
  }
}

class Tijera is Elemento {
  construct crear() {}

  pierdeCon(elemento) {
    return elemento.leGanaATijera()
  }

  leGanaAPiedra() {
    return false
  }

  leGanaAPapel() {
    return true
  }

  leGanaATijera() {
    return false
  }
}

var piedra = Piedra.crear()
var papel = Papel.crear()
var tijera = Tijera.crear()

System.print(piedra.pierdeCon(papel))  // true (verdadero)
System.print(tijera.pierdeCon(piedra)) // true (verdadero)
System.print(piedra.pierdeCon(tijera)) // false (falso)
System.print(papel.pierdeCon(tijera))  // true (verdadero)
System.print(papel.pierdeCon(piedra))  // false (falso)

var piedra = Piedra.crear()

System.print(piedra is Piedra) // true (verdadero)
System.print(piedra == Piedra) // false (falso)

System.print(piedra is Tijera) // false (falso)
System.print(piedra == Tijera) // false (falso)

System.print(piedra is Elemento) // true (verdadero)
System.print(piedra == Elemento) // false (falso)

System.print(Piedra is Elemento) // false (falso)
System.print(Piedra == Elemento) // false (falso)

System.print(Piedra.supertype is Elemento) // false (falso)
System.print(Piedra.supertype == Elemento) // true (verdadero)

class Original {}

class Extendida {
  construct nueva() {}

  is(otra) {otra == Original}

  type {Original}
  static supertype {Original}
}

var instancia = Extendida.nueva()

System.print(instancia is Original) // true (verdadero)
System.print(instancia is Extendida) // false (falso)
System.print(instancia.type) // Original
System.print(Extendida.supertype) // Original

Estás en una tierra llena de dragones. Frente a tí
hay dos cuevas. En una de ellas, el dragón es generoso y amigable y compartirá su tesoro contigo. El otro dragón
es codicioso y está hambriento, y te devorará inmediatamente.

¿A qué cueva quieres entrar? (1 ó 2)
1

Te aproximas a la cueva...
Es oscura y espeluznante...
¡Un gran dragon aparece súbitamente frente a tí! Abre sus fauces y...

¡Te engulle de un bocado!

¿Quieres jugar de nuevo? (sí or no)

no

// nombre: dragon.wren
// autor: Camilo Castro <camilo@ninjas.cl>
// original: https://github.com/asweigart/inventwithpython3rded/blob/master/translations/es/src/drag%C3%B3n.py
// ejecutar: wren dragon/dragon.wren

import "random" for Random
import "timer" for Timer
import "io" for Stdin

var random = Random.new()

var mostrarIntroduccion = Fn.new {
  System.print("Estás en una tierra llena de dragones. Frente a tí")
  System.print("hay dos cuevas. En una de ellas, el dragón es generoso y")
  System.print("amigable y compartirá su tesoro contigo. El otro dragón")
  System.print("es codicioso y está hambriento, y te devorará inmediatamente.")
  System.print()
  }

  var elegirCueva = Fn.new {
  var cueva = null
  var primerDragon = "1"
  var segundoDragon = "2"

  while (cueva != primerDragon && cueva != segundoDragon) {
    System.print("¿A qué cueva quieres entrar? (1 ó 2)")
    cueva = Stdin.readLine()
  }
  return cueva
}

var explorarCueva = Fn.new { |cueva|
    // existen 1000 millisegundos en un segundo
    // por lo que para obtener 2 segundos
    // debemos multiplicar 2 * 1000
    var dosSegundos = 2 * 1000

    System.print("Te aproximas a la cueva...")
    Timer.sleep(dosSegundos)
    
    System.print("Es oscura y espeluznante...")
    Timer.sleep(dosSegundos)
    
    System.print("¡Un gran dragon aparece súbitamente frente a tí! Abre sus fauces y...")
    System.print()
    Timer.sleep(dosSegundos)

    // Un número aleatorio entre 1 y 2.
    // se necesita usar 3 debido a que el generador
    // no incluye el último número
    var cuevaAmigable = random.int(1, 3).toString

    if (cueva == cuevaAmigable) {
      System.print("¡Te regala su tesoro!")
    } else {
      System.print("¡Te engulle de un bocado!")
    }

    System.print()
}

var jugarDeNuevo = "sí"
while (jugarDeNuevo == "sí" || jugarDeNuevo == "si" || jugarDeNuevo == "s") {
  mostrarIntroduccion.call()
  var cueva = elegirCueva.call()
  explorarCueva.call(cueva)

  System.print("¿Quieres jugar de nuevo? (sí o no)")
  jugarDeNuevo = Stdin.readLine()
}

System.print("¡Eso fue divertido, nos vemos luego!")

/\
\/

/\
\/

 /\
/  \
\  /
 \/
...

/*
Diamantes, por Al Sweigart <al@inventwithpython.com>
https://github.com/asweigart/PythonStdioGames/blob/main/src/gamesbyexample/diamonds.py
Dibuja diamantes de varios tamaños.
Adaptado a Wren por Camilo Castro <camilo@ninjas.cl>
https://github.com/NinjasCL/wren-libro/blob/main/juegos/diamantes/diamantes.wren
- Tags: tiny, beginner, artistic, pequeño, novato, artistico
- Version: 1.0.0
*/

var mostrarDiamanteLineal = Fn.new { |dimension|
  // Mostrar la parte superior del diamante
  for (i in 0...dimension) {
    // Espacio izquierdo
    System.write(" " * (dimension - i - 1))
    // Parte izquierda del diamante
    System.write("/")
    // Espacio interior del diamante
    System.write(" " * (i * 2))
    // Parte derecha del diamante
    System.print("\\")
  }

  // Mostrar la parte inferior del diamante
  for (i in 0...dimension) {
    // Espacio izquierdo
    System.write(" " * i)
    // Lado izquierdo
    System.write("\\")
    // Espacio interior
    System.write(" " * ((dimension - i - 1) * 2))
    // Lado derecho
    System.print("/")
  }
}

var mostrarDiamanteRelleno = Fn.new { |dimension|
  // Mostrar la cara superior del diamante
  for (i in 0...dimension) {
    // Espaciado izquierdo
    System.write(" " * (dimension - i - 1))
    // Lado izquierdo
    System.write("/" * (i + 1))
    // Lado derecho
    System.print("\\" * (i + 1))
  }

  // Mostrar la cara inferior del diamante
  for (i in 0...dimension) {
    // Espaciado izquierdo
    System.write(" " * i)
    // Lado izquierdo
    System.write("\\" * (dimension - i))
    // Lado derecho
    System.print("/" * (dimension - i))
  }
}

// Muestra 5 diamantes de tamaño 0 al 5:
for(dimension in 0..5) {
  mostrarDiamanteLineal.call(dimension)
  System.print()
  mostrarDiamanteRelleno.call(dimension)
  System.print()
}

La gran carrera de caracoles

    @v <-- caracol


¿Cuántos caracoles correrán? Min:2 Max:8
2
Ingresa el nombre del caracol #1:
Ana
Ingresa el nombre del caracol #2:
Berto

INICIO                                  META
|                                       |
                                     Ana
.....................................@v
                                       Berto
.......................................@v
¡Ha ganado Berto!

/*
Snail Race, por Al Sweigart <al@inventwithpython.com>
https://github.com/asweigart/PythonStdioGames/blob/main/src/gamesbyexample/snailrace.py
Una carrera de caracoles, ¡alucinante!.
Adaptado a Wren por Camilo Castro <camilo@ninjas.cl>
https://github.com/NinjasCL/wren-libro/blob/main/juegos/caracoles/caracoles.wren
- Tags: short, beginner, artistic, corto, novato, artistico
- Version: 1.0.0
*/
import "random" for Random
import "timer" for Timer
import "io" for Stdin

var random = Random.new()

class Constantes {
  static minCaracoles { 2 }
  static maxCaracoles { 8 }
  static maxLargoNombre { 20 }
  static meta { 40 }
}


System.print("
La gran carrera de caracoles

    @v <-- caracol

")

var cantidad = null

while (true) {
  System.print("¿Cuántos caracoles correrán? Min:%(Constantes.minCaracoles) Max:%(Constantes.maxCaracoles)")
  cantidad = Num.fromString(Stdin.readLine())
  if (cantidad && cantidad >= Constantes.minCaracoles && cantidad <= Constantes.maxCaracoles) {
    break
  }
  System.print("Ingresar un número entre %(Constantes.minCaracoles) y %(Constantes.maxCaracoles)")
}

var nombres = []

for (i in 1..cantidad) {
  var nombre = ""
  while (true) {
    
    System.print("Ingresa el nombre del caracol #%(i):")
    nombre = Stdin.readLine()

    // Reducimos el nombre a su largo máximo
    nombre = nombre.take(Constantes.maxLargoNombre).join()
    
    if (nombre.count == 0) {
      System.print("Por favor ingresa un nombre.")
    } else if (nombres.contains(nombre)) {
      System.print("Nombre ya existe")
    } else {
      break
    }
  }
  nombres.add(nombre)
}

System.print("\n" * 40)
System.print("INICIO" + " " * (Constantes.meta - "INICIO".count) + "META")
System.print("|" + " " * (Constantes.meta - "|".count) + "|")

var caracoles = {}

for (nombre in nombres) {
  System.print(nombre)
  System.print("@v")
  caracoles[nombre] = 0
}

// 1.5 segundos
Timer.sleep(15 * 100)

while (true) {

  for (i in 0..(random.int(1, cantidad + 1))) {
    var nombre = random.sample(nombres)
    caracoles[nombre] = caracoles[nombre] + 1

    if (caracoles[nombre] >= Constantes.meta) {
      System.print("¡Ha ganado %(nombre)!")
      // Terminar el proceso del juego
      Fiber.yield()
    }
  }

  // 0.5 segundos
  Timer.sleep(500)

  System.print("\n" * 40)
  System.print("INICIO" + " " * (Constantes.meta - "INICIO".count) + "META")
  System.print("|" + " " * (Constantes.meta - "|".count) + "|")

  for (nombre in nombres) {
    var espacios = caracoles[nombre]
    System.print(" " * espacios + nombre)
    System.print("." * espacios + "@v")
  }
}

Quedan 1 objetivos
El cañón puede disparar hasta 34595 metros
El objetivo está a 6788 metros
La fórmula de la distancia es: alcance * sin(2 * ángulo * π / 180)

Ingrese el ángulo para disparar
5
Distancia Alcanzada: 10690 Distancia Objetivo: 6788

El tiro se pasó en 3902 metros.
¡Prueba otra vez!, quedan 4 tiros

Ingrese el ángulo para disparar
3.1
Distancia Alcanzada: 6695 Distancia Objetivo: 6788

!!BooOOOM!!
¡Felicidades!, haz destruido al objetivo en 2 intentos.

/**
Juego que simula el disparo de un cañón hacia un objetivo.
El jugador debe ingresar el ángulo para cada tiro del cañón.
Código levemente basado en la obra "Cómo construir juegos de aventura"
de Manuel Afonseca. ISBN 84-7688-019-7
- Author: Camilo Castro <camilo@ninjas.cl>
- Version: 1.0.0
*/

import "random" for Random
import "io" for Stdin

var random = Random.new()

var alcance = 0

var objetivos = 3
var oportunidades = 5

// Ángulos deben estar en grados
// mínimo 0.5, máximo 89.5
var anguloElevacion = 0.5
var anguloMinimo = 0.5
var anguloMaximo = 89.5

// Sentinela para saber si el objetivo fue destruido
var destruido = false

// Para saber cuantos tiros fueron
// necesarios para destruir al objetivo
var tiros = 0

// Distancia mínima requerida para considerar
// al objetivo como destruido
// Si el proyectil llega a los 100 metros del objetivo
// se considera destruido
// (en metros).
var distanciaMinima = 100

// Distancia alcanzada por el tiro (en metros)
var distanciaAlcanzada = 0

// Distancia final
// distanciaAlcanzada - distanciaObjetivo
var distanciaFinal = 0

// Distancia al azar del objetivo
// Debe ser igual o menor al alcance del cañón
// entre 100 hasta el alcance del cañón.
var distanciaObjetivo = 0

var jugar = true
while (jugar) {

  System.print("Quedan %(objetivos) objetivos")

  // Valores iniciales por cada objetivo
  oportunidades = 5
  destruido = false
  anguloElevacion = 0
  distanciaFinal = 0
  tiros = 1
  
  // Un número aleatorio entre 10K y 50K
  // Usamos notación científica para simplificar el número
  alcance = random.int(10e3, 50e3 + 1)

  distanciaObjetivo = random.int(distanciaMinima, alcance + 1)

  System.print("El cañón puede disparar hasta %(alcance) metros")
  System.print("El objetivo está a %(distanciaObjetivo) metros")
  System.print("La fórmula de la distancia es: alcance * sin(ángulo * 2 * π / 180)")

  while (oportunidades > 0) {

    while (anguloElevacion < anguloMinimo || anguloElevacion > anguloMaximo) {
      System.print()
      System.print("Ingrese el ángulo para disparar")
      anguloElevacion = Num.fromString(Stdin.readLine())

      if (!anguloElevacion) {
        System.print("Debe ingresar un ángulo.")
        anguloElevacion = 0
      } else if (anguloElevacion > anguloMaximo) {
        System.print("El ángulo debe ser menor a %(anguloMaximo)")
      } else if (anguloElevacion < anguloMinimo) {
        System.print("El ángulo debe ser mayor a %(anguloMinimo)")
      }
    }

    // Calculamos la distancia que el tiro llega con el ángulo ingresado.
    // La fórmula matemática (ángulo * 2π/180) convierte los grados del ángulo de
    // a radianes. Considerando 360º.
    // Luego se multiplica el alcance por el seno de los radianes obtenidos
    // para obtener la distancia alcanzada.
    // Finalmente se redondea el resultado para obtener un número entero.
    // Ver: http://math2.org/math/trig/es-tables.htm
    // Ver: https://es.khanacademy.org/science/physics/two-dimensional-motion/two-dimensional-projectile-mot/v/projectile-at-an-angle

    distanciaAlcanzada = (alcance * (anguloElevacion * ( 2 * Num.pi / 180)).sin).round
    distanciaFinal = (distanciaAlcanzada - distanciaObjetivo).abs
    System.print("Distancia Alcanzada: %(distanciaAlcanzada.abs) Distancia Objetivo: %(distanciaObjetivo) Diferencia: %(distanciaFinal)")

    destruido = (distanciaMinima >= distanciaFinal)

    if (destruido) {
      objetivos = objetivos - 1
      jugar = (objetivos > 0)
      System.print()
      System.print("!!BooOOOM!!")
      System.print("¡Felicidades!, haz destruido al objetivo en %(tiros) intentos.")
      System.print()
      break
    }

    // Aumentamos el contador de tiros
    tiros = tiros + 1

    // Y reiniciamos el angulo de elevación
    // para volver a solicitarlo
    anguloElevacion = 0
    oportunidades = oportunidades - 1
    System.print()

    if (distanciaAlcanzada > distanciaObjetivo) {
      System.print("El tiro se pasó en %(distanciaFinal) metros.")
    } else {
      System.print("El tiro quedó corto por %(distanciaFinal) metros.")
    }
    
    jugar = (oportunidades > 0)
    if (jugar) {
      System.print("¡Prueba otra vez!, quedan %(oportunidades) tiros")
    } else {
      System.print("Juego terminado. ¡Haz perdido todas tus balas!")
    }
  }
}

¡Hola Wren!

// muestra: ¡Hola Wren!
System.print("¡Hola Wren!")

var donas = Fn.new {|cantidad|
  // Tu código aquí
  var mensaje = "Número de donas:"
  if (cantidad >= 10) {
    return "%(mensaje) muchas"
  }
  return "%(mensaje) %(cantidad)"
}


// Pruebas para evaluar que el ejercicio
// se ha completado exitosamente.
// no modificar.

var probar = Fn.new {|tengo, quiero|
  var prefijo = " X "
  if (tengo == quiero) {
    prefijo = " OK "
  }
  System.print("%(prefijo) tengo: %(tengo) quiero: %(quiero)")
}

System.print("Probando donas")
probar.call(donas.call(4), "Número de donas: 4")
probar.call(donas.call(9), "Número de donas: 9")
probar.call(donas.call(10), "Número de donas: muchas")
probar.call(donas.call(99), "Número de donas: muchas")
System.print()