Variables y Datos en Scratch

Variables y Datos en Scratch 📊

Las variables son como cajas mágicas que pueden guardar información en tus proyectos de Scratch. Son fundamentales para crear juegos interactivos, llevar puntuaciones, recordar preferencias del usuario y mucho más. En esta guía aprenderás todo sobre variables, listas y cómo manejar datos de manera efectiva.

¿Qué son las Variables? 📦

Una variable es un contenedor que puede almacenar diferentes tipos de información: números, texto, o valores verdadero/falso. Piensa en las variables como etiquetas que puedes pegar en cajas para recordar qué hay dentro.

¿Por qué son Importantes las Variables?

💾 Memoria del Programa

Permiten que tu programa “recuerde” información importante como puntuaciones, vidas, o configuraciones.

🔄 Cambios Dinámicos

Hacen que tu programa sea interactivo al cambiar comportamientos basados en la información almacenada.

🎮 Mecánicas de Juego

Esenciales para sistemas de puntuación, niveles, inventarios, y progreso del jugador.

🧮 Cálculos Complejos

Permiten realizar operaciones matemáticas y lógicas sofisticadas.

📈 Seguimiento de Estado

Mantienen registro del estado actual del juego, personajes, o elementos.

🔗 Comunicación

Facilitan el intercambio de información entre diferentes sprites y scripts.

Analogías del Mundo Real

Variables como Contenedores:

• Alcancía: Guarda la cantidad de monedas (puntos)
• Termómetro: Muestra la temperatura actual (nivel de dificultad)
• Contador: Lleva registro de elementos (vidas restantes)
• Etiqueta: Identifica el nombre o estado (nombre del jugador)

Creando y Usando Variables 🛠️

Cómo Crear una Variable

1. Accede a la Categoría Variables

   • Haz clic en la sección “Variables” (color naranja)
   • Verás las opciones para trabajar con variables

2. Crear Nueva Variable

   • Haz clic en “Crear una Variable”
   • Aparecerá un cuadro de diálogo

3. Configurar la Variable

   • Nombre: Elige un nombre descriptivo (ej: “puntos”, “vidas”, “velocidad”)
   • Alcance: Selecciona el tipo:
     • Para todos los objetos: Variable global (compartida)
     • Solo para este objeto: Variable local (privada del sprite)

4. Confirmar Creación

   • Haz clic en “Aceptar”
   • La variable aparecerá en la lista y en el escenario

Tipos de Variables por Alcance

Variables Globales

Para todos los objetos

Características:

• Compartidas entre todos los sprites
• Visibles desde cualquier sprite
• Perfectas para información del juego

Cuándo Usar:

• Puntuación del juego
• Nivel actual
• Tiempo restante
• Configuraciones globales
• Estado del juego (pausado, activo, terminado)

Ejemplo:

// Cualquier sprite puede modificar y leer estas variables
fijar [puntos] a (0)           // Puntuación global
fijar [nivel] a (1)            // Nivel actual
fijar [tiempo-restante] a (60) // Tiempo del juego

Variables Locales

Solo para este objeto

Características:

• Privadas de cada sprite
• No interfieren entre sprites
• Cada sprite tiene su propia copia

Cuándo Usar:

• Propiedades específicas del sprite
• Estados individuales
• Configuraciones particulares
• Datos que no necesitan compartirse

Ejemplo:

// Cada enemigo tiene sus propias variables
fijar [mi-vida] a (3)          // Vida individual
fijar [mi-velocidad] a (2)     // Velocidad propia
fijar [mi-estado] a [patrullando] // Estado personal

Operaciones Básicas con Variables

1. Asignar Valor (Fijar):

// Establecer un valor específico
fijar [puntos] a (0)              // Inicializar en cero
fijar [nombre-jugador] a [Ana]    // Asignar texto
fijar [juego-activo] a [verdadero] // Asignar estado
fijar [velocidad] a (número al azar entre (3) y (7)) // Valor aleatorio

2. Modificar Valor (Cambiar):

// Aumentar o disminuir el valor actual
cambiar [puntos] por (10)         // Sumar 10 puntos
cambiar [vidas] por (-1)          // Restar 1 vida
cambiar [velocidad] por (0.5)     // Aumentar velocidad
cambiar [temperatura] por (número al azar entre (-2) y (2)) // Cambio aleatorio

3. Mostrar y Ocultar:

// Controlar visibilidad en el escenario
mostrar variable [puntos]         // Hacer visible
esconder variable [codigo-secreto] // Ocultar información

4. Leer Valor:

// Usar el valor de la variable
decir (puntos)                    // Mostrar valor
ir a x: (posicion-x) y: (posicion-y) // Usar en coordenadas
si <(vidas) > (0)> entonces       // Usar en condiciones
  // continuar juego
fin

Aplicaciones Prácticas de Variables 🎯

1. Sistema de Puntuación

Configuración Inicial:

// Al iniciar el juego
al presionar ⚑
fijar [puntos] a (0)
fijar [puntos-maximos] a (0)
mostrar variable [puntos]

Ganar Puntos:

// Cuando el jugador recoge un objeto
al tocar [Moneda]
cambiar [puntos] por (10)
tocar sonido [ding]

// Bonus por velocidad
si <(temporizador) < (tiempo-limite)> entonces
  cambiar [puntos] por (5)  // Bonus por rapidez
fin

// Actualizar récord
si <(puntos) > (puntos-maximos)> entonces
  fijar [puntos-maximos] a (puntos)
fin

Sistema de Multiplicadores:

// Multiplicador de puntos
fijar [multiplicador] a (1)

// Aumentar multiplicador con combos
si <(combo-actual) > (5)> entonces
  fijar [multiplicador] a (2)
si no
  si <(combo-actual) > (10)> entonces
    fijar [multiplicador] a (3)
  fin
fin

// Aplicar multiplicador
cambiar [puntos] por ((puntos-base) * (multiplicador))

2. Sistema de Vidas y Salud

Gestión de Vidas:

// Inicialización
al presionar ⚑
fijar [vidas] a (3)
fijar [salud-maxima] a (100)
fijar [salud-actual] a (salud-maxima)

Recibir Daño:

// Cuando el jugador es dañado
al recibir [jugador-dañado]
cambiar [salud-actual] por (-20)

// Verificar si la salud llegó a cero
si <(salud-actual) < (1)> entonces
  cambiar [vidas] por (-1)

  si <(vidas) > (0)> entonces
    // Reiniciar salud
    fijar [salud-actual] a (salud-maxima)
    enviar [respawn-jugador]
  si no
    // Game Over
    enviar [game-over]
  fin
fin

Regeneración de Salud:

// Regeneración gradual
por siempre
  si <<(salud-actual) < (salud-maxima)> y <(regeneracion-activa) = [verdadero]>> entonces
    esperar (2) segundos
    cambiar [salud-actual] por (5)

    // No exceder el máximo
    si <(salud-actual) > (salud-maxima)> entonces
      fijar [salud-actual] a (salud-maxima)
    fin
  fin
fin

3. Control de Propiedades del Jugador

Atributos del Personaje:

// Estadísticas del jugador
fijar [velocidad-base] a (5)
fijar [fuerza] a (10)
fijar [defensa] a (8)
fijar [experiencia] a (0)
fijar [nivel] a (1)

Sistema de Experiencia y Niveles:

// Ganar experiencia
al recibir [enemigo-derrotado]
cambiar [experiencia] por (25)

// Verificar subida de nivel
fijar [exp-necesaria] a ((nivel) * (100))
si <(experiencia) > (exp-necesaria)> entonces
  cambiar [nivel] por (1)
  cambiar [experiencia] por (0 - (exp-necesaria))

  // Mejorar estadísticas
  cambiar [velocidad-base] por (1)
  cambiar [fuerza] por (2)
  cambiar [defensa] por (1)

  decir (unir [¡Nivel ] (unir (nivel) [!])) por (3) segundos
  tocar sonido [level-up]
fin

Modificadores Temporales:

// Power-up de velocidad
al recibir [powerup-velocidad]
fijar [velocidad-actual] a ((velocidad-base) * (2))
fijar [tiempo-powerup] a (10)

// Countdown del power-up
por siempre
  si <(tiempo-powerup) > (0)> entonces
    cambiar [tiempo-powerup] por (-0.1)
    esperar (0.1) segundos
  si no
    fijar [velocidad-actual] a (velocidad-base)
  fin
fin

4. Interacción con el Usuario

Entrada de Datos:

// Obtener información del jugador
preguntar [¿Cuál es tu nombre?] y esperar
fijar [nombre-jugador] a (respuesta)

preguntar [¿Qué dificultad quieres? (1-3)] y esperar
fijar [dificultad] a (respuesta)

// Validar entrada
si <<(dificultad) < (1)> o <(dificultad) > (3)>> entonces
  fijar [dificultad] a (2)  // Dificultad por defecto
fin

decir (unir [¡Hola ] (unir (nombre-jugador) [! Empecemos...])) por (3) segundos

Personalización:

// Configuraciones del jugador
preguntar [¿Qué color prefieres? (rojo/azul/verde)] y esperar
fijar [color-preferido] a (respuesta)

si <(color-preferido) = [rojo]> entonces
  fijar efecto [color] a (0)
si no
  si <(color-preferido) = [azul]> entonces
    fijar efecto [color] a (200)
  si no
    si <(color-preferido) = [verde]> entonces
      fijar efecto [color] a (100)
    fin
  fin
fin

5. Comportamiento Dinámico

Dificultad Adaptativa:

// Ajustar dificultad según rendimiento
por siempre
  si <(puntos) > ((nivel-dificultad) * (500))> entonces
    cambiar [nivel-dificultad] por (1)
    cambiar [velocidad-enemigos] por (0.5)
    cambiar [frecuencia-spawn] por (-0.2)

    decir [¡Dificultad aumentada!] por (2) segundos
  fin

  esperar (5) segundos  // Verificar cada 5 segundos
fin

Comportamiento Basado en Estado:

// Estados del juego
fijar [estado-juego] a [menu]

por siempre
  si <(estado-juego) = [menu]> entonces
    // Lógica del menú
    si <tecla [espacio] presionada?> entonces
      fijar [estado-juego] a [jugando]
    fin

  si no
    si <(estado-juego) = [jugando]> entonces
      // Lógica del juego
      si <(vidas) < (1)> entonces
        fijar [estado-juego] a [game-over]
      fin

    si no
      si <(estado-juego) = [game-over]> entonces
        // Lógica de game over
        si <tecla [r] presionada?> entonces
          fijar [estado-juego] a [menu]
          // Reiniciar variables
          fijar [puntos] a (0)
          fijar [vidas] a (3)
        fin
      fin
    fin
  fin
fin

Trabajando con Listas 📋

¿Qué son las Listas?

Las listas son variables especiales que pueden almacenar múltiples valores en orden. Son como estantes con múltiples compartimentos numerados.

Creando y Usando Listas

Crear una Lista:

1. Ve a la categoría “Variables”
2. Haz clic en “Crear una Lista”
3. Dale un nombre descriptivo (ej: “inventario”, “enemigos”, “puntuaciones”)
4. Elige el alcance (global o local)

Operaciones Básicas con Listas:

Agregar Elementos

// Agregar al final de la lista
añadir [espada] a [inventario]
añadir [100] a [puntuaciones-altas]
añadir (nombre-jugador) a [jugadores]

// Insertar en posición específica
insertar [poción] en (1) de [inventario]  // Al principio
insertar [boss] en (longitud de [enemigos]) de [enemigos]  // Al final

Acceder a Elementos

// Obtener elemento por posición
fijar [item-actual] a (elemento (1) de [inventario])  // Primer elemento
fijar [ultimo-item] a (elemento (longitud de [inventario]) de [inventario])  // Último

// Usar en condiciones
si <(elemento (1) de [inventario]) = [llave]> entonces
  decir [¡Tienes la llave!]
fin

// Mostrar elemento
decir (elemento (número al azar entre (1) y (longitud de [frases])) de [frases])

Modificar Elementos

// Reemplazar elemento
reemplazar elemento (2) de [inventario] por [escudo-mejorado]

// Eliminar elemento
borrar (1) de [inventario]  // Eliminar primero
borrar (longitud de [inventario]) de [inventario]  // Eliminar último

// Eliminar todos
borrar todo de [inventario]

Información de la Lista

// Obtener longitud
fijar [total-items] a (longitud de [inventario])

// Verificar si contiene elemento
si <[inventario] contiene [llave]> entonces
  decir [¡Tienes la llave!]
fin

// Encontrar posición de elemento
fijar [posicion-llave] a (# de [llave] en [inventario])

Aplicaciones Prácticas de Listas

1. Sistema de Inventario:

// Inicializar inventario
al presionar ⚑
borrar todo de [inventario]
añadir [espada-básica] a [inventario]
añadir [poción-salud] a [inventario]

// Recoger objeto
al tocar [Objeto]
si <(longitud de [inventario]) < (capacidad-maxima)> entonces
  añadir (nombre-objeto) a [inventario]
  decir (unir [Recogiste: ] (nombre-objeto)) por (2) segundos
si no
  decir [¡Inventario lleno!] por (2) segundos
fin

// Usar objeto
al presionar tecla [i]
si <(longitud de [inventario]) > (0)> entonces
  fijar [objeto-usado] a (elemento (1) de [inventario])
  borrar (1) de [inventario]

  si <(objeto-usado) = [poción-salud]> entonces
    cambiar [salud] por (50)
    decir [¡Salud restaurada!] por (2) segundos
  fin
fin

2. Tabla de Puntuaciones Altas:

// Agregar nueva puntuación
al recibir [game-over]
// Insertar puntuación en orden
fijar [posicion] a (1)
repetir hasta que <<(posicion) > (longitud de [puntuaciones-altas])> o <(puntos) > (elemento (posicion) de [puntuaciones-altas])>>
  cambiar [posicion] por (1)
fin

insertar (puntos) en (posicion) de [puntuaciones-altas]
insertar (nombre-jugador) en (posicion) de [nombres-jugadores]

// Mantener solo top 10
si <(longitud de [puntuaciones-altas]) > (10)> entonces
  borrar (11) de [puntuaciones-altas]
  borrar (11) de [nombres-jugadores]
fin

3. Generación de Contenido Aleatorio:

// Listas de contenido
borrar todo de [nombres-enemigos]
añadir [Goblin] a [nombres-enemigos]
añadir [Orc] a [nombres-enemigos]
añadir [Troll] a [nombres-enemigos]
añadir [Dragón] a [nombres-enemigos]

borrar todo de [frases-npc]
añadir [¡Hola, aventurero!] a [frases-npc]
añadir [¿Necesitas ayuda?] a [frases-npc]
añadir [Ten cuidado ahí fuera.] a [frases-npc]

// Usar contenido aleatorio
fijar [enemigo-aleatorio] a (elemento (número al azar entre (1) y (longitud de [nombres-enemigos])) de [nombres-enemigos])
fijar [frase-aleatoria] a (elemento (número al azar entre (1) y (longitud de [frases-npc])) de [frases-npc])

4. Sistema de Diálogos:

// Configurar diálogo
borrar todo de [dialogo-actual]
añadir [Hola, soy el guardián de este lugar.] a [dialogo-actual]
añadir [He estado esperando a alguien como tú.] a [dialogo-actual]
añadir [¿Estás listo para la aventura?] a [dialogo-actual]

// Mostrar diálogo
fijar [linea-actual] a (1)
repetir (longitud de [dialogo-actual]) veces
  decir (elemento (linea-actual) de [dialogo-actual]) por (3) segundos
  cambiar [linea-actual] por (1)
fin

Técnicas Avanzadas con Variables 🚀

1. Variables como Comunicación Entre Sprites

Sistema de Mensajería:

// Sprite A: Envía información
fijar [mensaje-para-b] a [ataque-especial]
fijar [datos-mensaje] a (poder-ataque)
enviar [mensaje-enviado]

// Sprite B: Recibe y procesa
al recibir [mensaje-enviado]
si <(mensaje-para-b) = [ataque-especial]> entonces
  cambiar [mi-salud] por (0 - (datos-mensaje))
  decir [¡Auch!] por (1) segundos
fin
fijar [mensaje-para-b] a []  // Limpiar mensaje

Estado Compartido:

// Variables globales para coordinar sprites
fijar [fase-juego] a [preparacion]
fijar [enemigos-restantes] a (10)
fijar [boss-activo] a [falso]

// Sprite Enemigo: Actualiza estado
al recibir [enemigo-derrotado]
cambiar [enemigos-restantes] por (-1)
si <(enemigos-restantes) < (1)> entonces
  fijar [boss-activo] a [verdadero]
  enviar [spawn-boss]
fin

// Sprite Boss: Responde al estado
al recibir [spawn-boss]
si <(boss-activo) = [verdadero]> entonces
  ir a x: (0) y: (100)
  mostrar
  fijar [boss-salud] a (200)
fin

2. Optimización de Rendimiento

Evitar Cálculos Repetitivos:

// MALO: Calcular cada vez
por siempre
  ir a x: ((sen de (temporizador * 90)) * 100) y: ((cos de (temporizador * 90)) * 100)
fin

// BUENO: Calcular una vez, usar múltiples veces
por siempre
  fijar [angulo] a (temporizador * 90)
  fijar [x-calculada] a ((sen de (angulo)) * 100)
  fijar [y-calculada] a ((cos de (angulo)) * 100)
  ir a x: (x-calculada) y: (y-calculada)
fin

Cache de Valores Costosos:

// Calcular solo cuando sea necesario
fijar [distancia-calculada] a (-1)  // Valor inválido
fijar [ultima-posicion-x] a (posición x)
fijar [ultima-posicion-y] a (posición y)

// Función para obtener distancia
si <<no <(posición x) = (ultima-posicion-x)>> o <no <(posición y) = (ultima-posicion-y)>>> entonces
  // Recalcular solo si la posición cambió
  fijar [distancia-calculada] a (([((posición x) - (objetivo-x)) * ((posición x) - (objetivo-x))] + [((posición y) - (objetivo-y)) * ((posición y) - (objetivo-y))]) ^ (0.5))
  fijar [ultima-posicion-x] a (posición x)
  fijar [ultima-posicion-y] a (posición y)
fin

// Usar valor cacheado
si <(distancia-calculada) < (50)> entonces
  // hacer algo
fin

3. Patrones de Diseño con Variables

Patrón de Estado:

// Estados del personaje
fijar [estado-jugador] a [idle]

por siempre
  si <(estado-jugador) = [idle]> entonces
    cambiar a disfraz [parado]
    si <tecla [flecha derecha] presionada?> entonces
      fijar [estado-jugador] a [caminando]
    fin
    si <tecla [espacio] presionada?> entonces
      fijar [estado-jugador] a [saltando]
    fin

  si no
    si <(estado-jugador) = [caminando]> entonces
      cambiar a disfraz [caminando]
      cambiar x por (velocidad)
      si <no <tecla [flecha derecha] presionada?>> entonces
        fijar [estado-jugador] a [idle]
      fin

    si no
      si <(estado-jugador) = [saltando]> entonces
        cambiar a disfraz [saltando]
        cambiar y por (velocidad-salto)
        cambiar [velocidad-salto] por (-1)  // Gravedad
        si <tocando color [#00FF00]?> entonces  // Suelo
          fijar [estado-jugador] a [idle]
          fijar [velocidad-salto] a (15)
        fin
      fin
    fin
  fin
fin

Patrón de Configuración:

// Configuraciones centralizadas
fijar [config-velocidad-jugador] a (5)
fijar [config-salud-maxima] a (100)
fijar [config-dificultad] a (2)
fijar [config-volumen-musica] a (80)
fijar [config-efectos-visuales] a [verdadero]

// Aplicar configuraciones
fijar [velocidad] a (config-velocidad-jugador)
fijar [salud-maxima] a (config-salud-maxima)
fijar [salud-actual] a (salud-maxima)
fijar volumen a (config-volumen-musica) %

si <(config-efectos-visuales) = [verdadero]> entonces
  mostrar variable [puntos]
  mostrar variable [vidas]
si no
  esconder variable [puntos]
  esconder variable [vidas]
fin

Resolución de Problemas Comunes 🔧

Problemas Frecuentes y Soluciones

Variables No Se Actualizan

Problema: La variable no cambia su valor

Causas Posibles:

• Usando variable local en sprite incorrecto
• Script no se está ejecutando
• Condición nunca se cumple

Soluciones:

// Verificar que el script se ejecuta
decir [Script ejecutándose] por (1) segundos

// Verificar valor actual
decir (unir [Valor actual: ] (mi-variable)) por (2) segundos

// Usar variable global si necesitas compartir
// Crear como "Para todos los objetos"

// Simplificar condiciones para testing
si <verdadero> entonces  // Siempre se ejecuta
  cambiar [mi-variable] por (1)
fin

Variables Se Reinician

Problema: Las variables vuelven a valores anteriores

Causas Posibles:

• Múltiples scripts inicializando
• Reinicialización accidental
• Conflicto entre sprites

Soluciones:

// Inicializar solo una vez
nal presionar ⚑
si <(inicializado) = []> entonces  // Solo si no está inicializado
  fijar [puntos] a (0)
  fijar [vidas] a (3)
  fijar [inicializado] a [verdadero]
fin

// Usar bandera de control
fijar [permitir-reinicio] a [falso]

// Solo reiniciar cuando sea apropiado
si <(permitir-reinicio) = [verdadero]> entonces
  fijar [puntos] a (0)
  fijar [permitir-reinicio] a [falso]
fin

Listas No Funcionan

Problema: Errores al trabajar con listas

Causas Posibles:

• Acceder a posición que no existe
• Lista vacía
• Índice incorrecto

Soluciones:

// Verificar que la lista no esté vacía
si <(longitud de [mi-lista]) > (0)> entonces
  fijar [elemento] a (elemento (1) de [mi-lista])
si no
  decir [¡Lista vacía!] por (2) segundos
fin

// Verificar índice válido
fijar [indice] a (número al azar entre (1) y (10))
si <(indice) < ((longitud de [mi-lista]) + 1)> entonces
  fijar [elemento] a (elemento (indice) de [mi-lista])
fin

// Usar índices seguros
fijar [indice-seguro] a (((indice - 1) mod (longitud de [mi-lista])) + 1)

Rendimiento Lento

Problema: El programa se vuelve lento con muchas variables

Causas Posibles:

• Demasiadas variables mostradas
• Cálculos repetitivos
• Listas muy grandes

Soluciones:

// Ocultar variables no esenciales
esconder variable [variable-debug]
esconder variable [calculo-temporal]

// Limitar tamaño de listas
si <(longitud de [historial]) > (100)> entonces
  borrar (1) de [historial]  // Eliminar el más antiguo
fin

// Calcular solo cuando sea necesario
si <(frame-actual mod 10) = (0)> entonces  // Cada 10 frames
  // cálculo costoso
fin

// Usar variables locales cuando sea posible
// Son más rápidas que las globales

Debugging de Variables

Técnicas de Depuración:

// 1. Mostrar valores en tiempo real
decir (unir [Puntos: ] (unir (puntos) (unir [ Vidas: ] (vidas)))) por (0.1) segundos

// 2. Log de cambios
si <no <(puntos) = (puntos-anterior)>> entonces
  decir (unir [Puntos cambiaron de ] (unir (puntos-anterior) (unir [ a ] (puntos)))) por (2) segundos
  fijar [puntos-anterior] a (puntos)
fin

// 3. Verificar rangos
si <<(velocidad) < (0)> o <(velocidad) > (20)>> entonces
  decir [¡Velocidad fuera de rango!] por (2) segundos
  fijar [velocidad] a (5)  // Valor seguro
fin

// 4. Historial de valores
añadir (unir (temporizador) (unir [: ] (puntos))) a [historial-puntos]
si <(longitud de [historial-puntos]) > (50)> entonces
  borrar (1) de [historial-puntos]
fin

Mejores Prácticas 📋

Nomenclatura de Variables

Nombres Descriptivos:

// MALO: Nombres confusos
fijar [x] a (10)
fijar [temp] a (5)
fijar [var1] a [activo]

// BUENO: Nombres claros
fijar [velocidad-jugador] a (10)
fijar [tiempo-powerup] a (5)
fijar [estado-juego] a [activo]

Convenciones de Nombres:

• Usa guiones para separar palabras: puntos-maximos
• Sé específico: salud-jugador vs salud-enemigo
• Incluye unidades cuando sea relevante: tiempo-segundos
• Usa prefijos para agrupar: config-volumen, config-dificultad

Organización de Variables

Agrupación Lógica:

// Variables del jugador
fijar [jugador-x] a (0)
fijar [jugador-y] a (0)
fijar [jugador-salud] a (100)
fijar [jugador-velocidad] a (5)

// Variables del juego
fijar [juego-puntos] a (0)
fijar [juego-nivel] a (1)
fijar [juego-tiempo] a (60)
fijar [juego-estado] a [menu]

// Variables de configuración
fijar [config-dificultad] a (2)
fijar [config-volumen] a (80)
fijar [config-efectos] a [verdadero]

Inicialización Centralizada:

// Crear un script de inicialización
al presionar ⚑
// Llamar función de inicialización
inicializar-variables

// Definir función personalizada
definir inicializar-variables
// Jugador
fijar [jugador-salud] a (100)
fijar [jugador-velocidad] a (5)
fijar [jugador-puntos] a (0)

// Juego
fijar [nivel-actual] a (1)
fijar [enemigos-restantes] a (10)
fijar [tiempo-restante] a (60)

// UI
mostrar variable [jugador-puntos]
mostrar variable [jugador-salud]
esconder variable [debug-info]

Validación de Datos

Verificar Rangos:

// Asegurar que los valores estén en rangos válidos
si <(salud) > (salud-maxima)> entonces
  fijar [salud] a (salud-maxima)
fin

si <(salud) < (0)> entonces
  fijar [salud] a (0)
fin

// Función de validación
definir validar-salud
si <(salud) > (salud-maxima)> entonces
  fijar [salud] a (salud-maxima)
fin
si <(salud) < (0)> entonces
  fijar [salud] a (0)
fin

Valores por Defecto:

// Asegurar valores válidos
si <(velocidad) = []> entonces  // Si está vacía
  fijar [velocidad] a (5)  // Valor por defecto
fin

si <(dificultad) = []> entonces
  fijar [dificultad] a (2)  // Dificultad media
fin

Conclusión 🎉

¡Felicitaciones! Ahora dominas el uso de variables y datos en Scratch. Has aprendido:

✅ Qué son las variables y por qué son importantes
✅ Cómo crear y usar variables globales y locales
✅ Operaciones básicas con variables
✅ Aplicaciones prácticas en juegos y proyectos
✅ Trabajo con listas para datos complejos
✅ Técnicas avanzadas de optimización
✅ Resolución de problemas comunes
✅ Mejores prácticas para código limpio

Próximos Pasos

1. Practica creando un sistema de puntuación simple
2. Experimenta con listas para inventarios o diálogos
3. Crea un proyecto que use variables para controlar dificultad
4. Explora patrones avanzados de comunicación entre sprites
5. Comparte tus proyectos y aprende de otros

Consejo

Consejo de Vibelf: Las variables son como la memoria de tu programa - úsalas sabiamente para crear experiencias ricas e interactivas. Recuerda que un buen nombre de variable vale más que mil comentarios. ¡Empieza simple y ve construyendo complejidad gradualmente! 🧠✨

¿Listo para explorar más conceptos avanzados de Scratch? ¡Tu viaje de programación continúa! 🚀