¿Cómo programar un bot de Discord en Python?
En los últimos años, Discord se ha convertido en una de las plataformas de comunicación más populares, especialmente en el mundo de los videojuegos y comunidades online. Y, con millones de usuarios activos diariamente, no es de extrañar que la demanda de bots de Discord haya crecido significativamente.
Los bots de Discord pueden realizar una amplia variedad de tareas, desde moderar servidores hasta ofrecer información en tiempo real, mejorar la experiencia del usuario y automatizar procesos repetitivos.
Si te interesa aprender cómo crear un bot en Discord, estás en el lugar correcto. A continuación, te guiaremos paso a paso en la programación de un bot de Discord con Python, uno de los lenguajes de programación más accesibles y versátiles que existen hoy en día.
Qué es un bot de Discord
Este tipo de tecnología no es más que una aplicación automatizada que interactúa con los usuarios y realiza tareas en un servidor de Discord. Estos bots pueden ejecutar comandos específicos, responder a mensajes, y realizar acciones administrativas, como silenciar usuarios o asignar roles. Además, son herramientas valiosas para mantener la organización y mejorar la funcionalidad de los servidores.
Por qué usar Python para crearlos
Python es una opción excelente para quien se pregunte cómo crear un bot en Discord por varias razones:
- Simplicidad: Python es conocido por su sintaxis clara y fácil de leer, lo que lo hace ideal para principiantes y desarrolladores experimentados.
- Documentación y comunidad: Existe una amplia cantidad de recursos y una comunidad activa dispuesta a ayudar. La documentación de las bibliotecas de Python para Discord es extensa y detallada.
- Bibliotecas especializadas: Hay bibliotecas como `discord.py` que están específicamente diseñadas para interactuar con la API Oficial de Discord, facilitando enormemente el proceso de desarrollo.
Configuración inicial
Antes de comenzar a desarrollar un bot de Discord en Python, es crucial configurar adecuadamente tu entorno de trabajo. Este proceso incluye asegurarte de que tienes todas las herramientas necesarias instaladas, crear un entorno de desarrollo limpio y registrar tu bot en el Portal de Desarrolladores de Discord. Una configuración inicial bien realizada no solo facilita el desarrollo, sino que también previene posibles problemas a medida que avances en el proyecto.
Configuración del entorno de desarrollo
Como decíamos, antes de empezar a programar tu bot de Discord con Python, es esencial preparar adecuadamente tu entorno de desarrollo. Veamos los pasos necesarios para configurar tu entorno:
- Instalación de Python: Asegúrate de tener Python instalado en tu sistema. Puedes descargar la última versión desde python.org. Sigue las instrucciones de instalación según tu sistema operativo (Windows, macOS o Linux).
- Configuración del entorno virtual: Es recomendable usar un entorno virtual para aislar las dependencias de tu proyecto y evitar conflictos con otros proyectos. Para crear un entorno virtual, abre tu terminal o línea de comandos y ejecuta los siguientes comandos:
```bash
python -m venv nombre_del_entorno
```
Luego, activa el entorno virtual:
- En Windows:
```bash
nombre_del_entorno\Scripts\activate
```
- En macOS/Linux:
```bash
source nombre_del_entorno/bin/activate
```
- Instalación de las dependencias: Con el entorno virtual activado, instala la biblioteca `discord.py` utilizando pip:
```bash
pip install discord.py
```
- Editor de código: Elige un editor de código con el que te sientas cómodo. Visual Studio Code, PyCharm y Sublime Text son opciones populares. Instala las extensiones necesarias para facilitar el desarrollo, como linters y debuggers para Python.
Registrar el bot en Discord y obtener las claves API necesarias
Ahora bien, para que tu bot de Discord con Python pueda interactuar con los servidores de esta herramienta, necesitas registrarlo y obtener las claves API necesarias. Te explicamos cómo hacerlo:
- Acceder al Portal de Desarrolladores de Discord: Ve a Discord Developer Portal e inicia sesión con tu cuenta de Discord.
- Crear una nueva aplicación: Haz clic en "New Application" en la esquina superior derecha. Dale un nombre a tu aplicación y haz clic en "Create".
- Configurar el bot: En el menú de la izquierda, selecciona "Bot". Haz clic en "Add Bot" y confirma la acción cuando se te solicite. Tu bot de Discord con Python será creado y aparecerá en la lista de bots.
- Obtener el token del bot: Bajo la sección "TOKEN", haz clic en "Copy" para copiar el token del bot. Guarda este token en un lugar seguro. Es crucial para autenticar tu bot y permitirle interactuar con Discord.
- Asignar permisos al bot de Discord en Python: En la sección "OAuth2", selecciona "URL Generator". Bajo "OAuth2 URL Generator", selecciona "bot" en el ámbito de "Scopes". En la sección "Bot Permissions", selecciona los permisos que necesite tu bot. Por ejemplo, puedes seleccionar "Send Messages", "Manage Roles", y "Read Message History". Copia la URL generada y pégala en tu navegador. Selecciona el servidor donde quieres añadir el bot y autoriza la aplicación.
- Configurar intenciones del bot: En la sección "Bot", asegúrate de habilitar las "Privileged Gateway Intents" si planeas usar funciones que las requieran, como detectar cuándo los miembros se unen o salen del servidor. Activa las intenciones necesarias, como "PRESENCE INTENT" y "SERVER MEMBERS INTENT".
Instalación de bibliotecas necesarias
Para crear bot de Discord con Python, es esencial contar con las bibliotecas adecuadas que faciliten la interacción con la API de Discord y amplíen las capacidades de tu bot. La biblioteca principal que utilizaremos es `discord.py`, una herramienta poderosa y fácil de usar que permite manejar eventos, comandos y muchas otras funciones de Discord. Además, hay otras bibliotecas que pueden ser útiles para tareas específicas, como realizar solicitudes HTTP, manipular imágenes o gestionar bases de datos. Veamos cómo instalar y configurar `discord.py`, así como otras herramientas que te ayudarán a crear un bot más funcional.
Instalar y configurar Discord.py
Para crear bot de Discord con Python, utilizaremos `discord.py`, una potente biblioteca que facilita la interacción con la API de Discord. Aquí tienes el paso a paso para instalar y configurar `discord.py`:
- Instalación de discord.py: Con tu entorno virtual activado, instala `discord.py` utilizando pip. Abre tu terminal y ejecuta el siguiente comando:
```bash
pip install discord.py
```
- Configuración básica: Crea un archivo nuevo para tu bot, por ejemplo, `bot.py`. Abre este archivo en tu editor de código favorito. Importa las bibliotecas necesarias y configura la instancia de tu bot:
```python
import discord
from discord.ext import commands
intents = discord.Intents.default()
intents.message_content = True # Esto es necesario para recibir el contenido de los mensajes
bot = commands.Bot(command_prefix='!', intents=intents)
@bot.event
async def on_ready():
print(f'{bot.user.name} ha iniciado sesión.')
@bot.command()
async def hola(ctx):
await ctx.send('¡Hola! ¿Cómo estás?')
bot.run('TU_TOKEN_AQUÍ')
```
- Ejecutar el bot: Reemplaza `'TU_TOKEN_AQUÍ'` con el token de tu bot que obtuviste del Portal de Desarrolladores de Discord. Guarda el archivo y ejecuta el bot con el siguiente comando:
```bash
python bot.py
```
Si todo está configurado correctamente, verás un mensaje en la consola indicando que tu bot ha iniciado sesión. Ahora puedes probar el comando `!hola` en tu servidor de Discord para asegurarte de que el bot responde correctamente.
Otras herramientas para ampliar la funcionalidad del bot
Además de `discord.py`, existen varias otras bibliotecas y herramientas que pueden ayudarte a ampliar la funcionalidad de tu bot de Discord con Python. Estas son algunas de las más útiles:
- Requests: La biblioteca `requests` facilita la realización de solicitudes HTTP. Esto es útil si tu bot necesita interactuar con APIs externas. Instálala con pip:
```bash
pip install requests
```
- Ejemplo de uso:
```python
import requests
@bot.command()
async def gato(ctx):
response = requests.get('https://api.thecatapi.com/v1/images/search')
data = response.json()
await ctx.send(data[0]['url'])
```
- BeautifulSoup: `BeautifulSoup` es excelente para el scraping de datos web, permitiendo a tu bot extraer información de páginas web. Instálala con pip:
```bash
pip install beautifulsoup4
```
- Ejemplo de uso:
```python
from bs4 import BeautifulSoup
@bot.command()
async def noticias(ctx):
response = requests.get('https://example.com/news')
soup = BeautifulSoup(response.text, 'html.parser')
headline = soup.find('h1').text
await ctx.send(f'Última noticia: {headline}')
```
- SQLAlchemy: Si necesitas que tu bot maneje datos persistentes, `SQLAlchemy` es una excelente opción para interactuar con bases de datos SQL. Instálala con pip:
```bash
pip install sqlalchemy
```
- Ejemplo de uso:
```python
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
engine = create_engine('sqlite:///bot.db')
Base = declarative_base()
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
name = Column(String)
points = Column(Integer, default=0)
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()
@bot.command()
async def puntos(ctx, puntos: int):
user = session.query(User).filter_by(name=ctx.author.name).first()
if not user:
user = User(name=ctx.author.name, points=puntos)
else:
user.points += puntos
session.add(user)
session.commit()
await ctx.send(f'{ctx.author.name} ahora tiene {user.points} puntos.')
```
- Pillow: `Pillow` es una biblioteca de manipulación de imágenes que puede ser útil si tu bot de Discord con Python necesita generar o editar imágenes. Instálala con pip:
```bash
pip install pillow
```
- Ejemplo de uso:
```python
from PIL import Image, ImageDraw, ImageFont
@bot.command()
async def imagen(ctx, texto: str):
img = Image.new('RGB', (200, 100), color = (73, 109, 137))
d = ImageDraw.Draw(img)
font = ImageFont.load_default()
d.text((10,10), texto, font=font, fill=(255, 255, 0))
img.save('imagen.png')
await ctx.send(file=discord.File('imagen.png'))
```
Escritura del código del bot
Con tu entorno de desarrollo configurado y las bibliotecas necesarias instaladas, es hora de abordar la escritura del código para responder a la pregunta cómo crear un bot en Discord con Python.
Este es el corazón del desarrollo del bot, donde definirás su comportamiento, los comandos que responderá y cómo interactuará con los usuarios en tu servidor de Discord.
Empezaremos con la estructura básica del código, asegurándonos de que el bot pueda conectarse y responder a comandos simples.
Luego, profundizaremos en el manejo de eventos y comandos más complejos para hacer que tu bot sea verdaderamente interactivo y útil.
¿Estás listo para empezar a programar?
Estructura básica del código
Para comenzar a escribir el código de tu bot de Discord en Python, es importante entender la estructura básica. A continuación, se detalla cómo configurar el esqueleto de tu bot:
- Importaciones y configuración inicial: Importa las bibliotecas necesarias y configura la instancia de tu bot.
```python
import discord
from discord.ext import commands
intents = discord.Intents.default()
intents.message_content = True # Para recibir el contenido de los mensajes
bot = commands.Bot(command_prefix='!', intents=intents)
```
- Evento `on_ready`: Este evento se ejecuta cuando el bot se conecta exitosamente a Discord.
```python
@bot.event
async def on_ready():
print(f'{bot.user.name} ha iniciado sesión.')
```
- Comandos básicos: Define algunos comandos básicos para asegurarte de que el bot funciona correctamente.
```python
@bot.command()
async def hola(ctx):
await ctx.send('¡Hola! ¿Cómo estás?')
@bot.command()
async def adios(ctx):
await ctx.send('¡Adiós! ¡Que tengas un buen día!')
```
- Ejecución del bot: Finalmente, ejecuta el bot utilizando el token que obtuviste del Portal de Desarrolladores de Discord.
```python
bot.run('TU_TOKEN_AQUÍ')
```
Aquí tienes el código completo de la estructura básica de tu bot:
```python
import discord
from discord.ext import commands
intents = discord.Intents.default()
intents.message_content = True
bot = commands.Bot(command_prefix='!', intents=intents)
@bot.event
async def on_ready():
print(f'{bot.user.name} ha iniciado sesión.')
@bot.command()
async def hola(ctx):
await ctx.send('¡Hola! ¿Cómo estás?')
@bot.command()
async def adios(ctx):
await ctx.send('¡Adiós! ¡Que tengas un buen día!')
bot.run('TU_TOKEN_AQUÍ')
```
Manejo de eventos y comandos
Ahora que tenemos la estructura básica, es hora de profundizar en el manejo de eventos y comandos para hacer que nuestro bot sea más interactivo y útil.
Eventos
Los eventos permiten que el bot responda a diversas acciones en Discord, como mensajes enviados, usuarios que se unen o salen, etc. Aquí hay algunos ejemplos de eventos comunes:
- on_message: Se activa cuando se envía un mensaje en un canal al que el bot tiene acceso.
```python
@bot.event
async def on_message(message):
if message.author == bot.user:
return
if 'hola' in message.content.lower():
await message.channel.send('¡Hola!')
await bot.process_commands(message)
```
- on_member_join: Se activa cuando un nuevo miembro se une a un servidor.
```python
@bot.event
async def on_member_join(member):
channel = discord.utils.get(member.guild.text_channels, name='general')
if channel:
await channel.send(f'¡Bienvenido al servidor, {member.mention}!')
```
- on_member_remove: Se activa cuando un miembro deja el servidor.
```python
@bot.event
async def on_member_remove(member):
channel = discord.utils.get(member.guild.text_channels, name='general')
if channel:
await channel.send(f'{member.mention} ha dejado el servidor.')
```
Comandos
Los comandos permiten a los usuarios interactuar directamente con el bot a través de mensajes de texto en Discord. Aquí hay algunos ejemplos de cómo definir y manejar comandos:
- Comandos con argumentos: Un comando que acepta argumentos del usuario.
```python
@bot.command()
async def sumar(ctx, a: int, b: int):
await ctx.send(f'La suma de {a} y {b} es {a + b}')
```
- Comandos con permisos: Un comando que verifica si el usuario tiene ciertos permisos antes de ejecutarse.
```python
@bot.command()
@commands.has_permissions(manage_messages=True)
async def limpiar(ctx, cantidad: int):
await ctx.channel.purge(limit=cantidad + 1)
await ctx.send(f'{cantidad} mensajes eliminados.', delete_after=5)
```
- Comandos personalizados: Un comando que responde con un mensaje personalizado.
```python
@bot.command()
async def info(ctx):
embed = discord.Embed(title="Información del Servidor", description="Detalles del servidor", color=0x00ff00)
embed.add_field(name="Servidor", value=ctx.guild.name, inline=False)
embed.add_field(name="Miembros", value=ctx.guild.member_count, inline=False)
await ctx.send(embed=embed)
```
Con el fin de dejarlo lo más claro posible, aquí tienes un ejemplo completo que incluye eventos y comandos:
```python
import discord
from discord.ext import commands
intents = discord.Intents.default()
intents.message_content = True
bot = commands.Bot(command_prefix='!', intents=intents)
@bot.event
async def on_ready():
print(f'{bot.user.name} ha iniciado sesión.')
@bot.event
async def on_message(message):
if message.author == bot.user:
return
if 'hola' in message.content.lower():
await message.channel.send('¡Hola!')
await bot.process_commands(message)
@bot.event
async def on_member_join(member):
channel = discord.utils.get(member.guild.text_channels, name='general')
if channel:
await channel.send(f'¡Bienvenido al servidor, {member.mention}!')
@bot.event
async def on_member_remove(member):
channel = discord.utils.get(member.guild.text_channels, name='general')
if channel:
await channel.send(f'{member.mention} ha dejado el servidor.')
@bot.command()
async def hola(ctx):
await ctx.send('¡Hola! ¿Cómo estás?')
@bot.command()
async def adios(ctx):
await ctx.send('¡Adiós! ¡Que tengas un buen día!')
@bot.command()
async def sumar(ctx, a: int, b: int):
await ctx.send(f'La suma de {a} y {b} es {a + b}')
@bot.command()
@commands.has_permissions(manage_messages=True)
async def limpiar(ctx, cantidad: int):
await ctx.channel.purge(limit=cantidad + 1)
await ctx.send(f'{cantidad} mensajes eliminados.', delete_after=5)
@bot.command()
async def info(ctx):
embed = discord.Embed(title="Información del Servidor", description="Detalles del servidor", color=0x00ff00)
embed.add_field(name="Servidor", value=ctx.guild.name, inline=False)
embed.add_field(name="Miembros", value=ctx.guild.member_count, inline=False)
await ctx.send(embed=embed)
bot.run('TU_TOKEN_AQUÍ')
```
Despliegue y pruebas del bot
Una vez que hayas escrito el código de tu bot de Discord con Python y hayas implementado sus funciones principales, es crucial asegurarte de que todo funcione correctamente antes de lanzarlo. El despliegue y las pruebas del bot son pasos esenciales para garantizar su rendimiento y fiabilidad.
En esta fase, conectarás tu bot a un servidor de Discord real, probarás sus comandos y funcionalidades, y depurarás cualquier problema que pueda surgir. Realizar pruebas exhaustivas y depuración efectiva ayudará a identificar y solucionar errores, mejorando así la experiencia del usuario final.
Conexión a un servidor de Discord
Uno de los últimos pasos que te llevarán a conocer cómo crear un bot en Discord con Python es la conexión con el servidor. Y es que para que tu bot esté disponible en tu servidor de Discord, debes invitarlo al mismo y asegurarte de que esté en línea. Para ello, deberás seguir estos pasos:
- Generar una URL de invitación:
- Ve al [Portal de Desarrolladores de Discord](https://discord.com/developers/applications) y selecciona tu aplicación de bot.
- En la sección "OAuth2", selecciona "URL Generator".
- Bajo "OAuth2 URL Generator", marca la opción "bot" en el ámbito "Scopes".
- En "Bot Permissions", selecciona los permisos que tu bot necesitará. Por ejemplo, "Send Messages", "Manage Messages", y "Read Message History".
- Copia la URL generada.
- Invitar el bot al servidor:
- Pega la URL en tu navegador y selecciona el servidor al que deseas añadir el bot.
- Autoriza la aplicación para añadir el bot a tu servidor.
- Verificar la conexión:
- Una vez que el bot esté añadido al servidor, deberías verlo en la lista de miembros del servidor.
- Ejecuta el bot localmente (si no está ejecutándose ya) con el siguiente comando en tu terminal:
```bash
python bot.py
```
Si el bot se ha conectado correctamente, deberías ver un mensaje en la consola indicando que el bot ha iniciado sesión. Prueba algunos de los comandos que has configurado, como `!hola` o `!info`, para asegurarte de que el bot responde correctamente.
Pruebas y depuración
Probar y depurar tu bot de Discord con Python es crucial para garantizar que funcione correctamente y proporcione una experiencia de usuario positiva. Veamos algunas de las prácticas más recomendadas para realizar pruebas y depuración de tu bot:
- Pruebas de comandos básicos: Asegúrate de que todos los comandos definidos respondan correctamente. Por ejemplo, envía `!hola` en tu servidor de Discord y verifica que el bot responda con "¡Hola! ¿Cómo estás?".
- Pruebas de permisos: Si tienes comandos que requieren permisos específicos, prueba estos comandos con cuentas que tienen y no tienen los permisos necesarios. Por ejemplo, el comando `!limpiar` debería funcionar solo para usuarios con permisos de gestión de mensajes.
- Manejo de errores: Implementa manejadores de errores para capturar y responder a errores comunes. Por ejemplo, si un usuario intenta usar el comando `!sumar` sin proporcionar números, el bot debería manejar el error adecuadamente:
```python
@sumar.error
async def sumar_error(ctx, error):
if isinstance(error, commands.MissingRequiredArgument):
await ctx.send('Por favor, proporciona dos números para sumar.')
```
- Registro de errores y eventos: Utiliza el módulo `logging` de Python para registrar errores y eventos importantes. Esto te ayudará a diagnosticar problemas y entender mejor cómo interactúa tu bot con los usuarios.
```python
import logging
logging.basicConfig(level=logging.INFO)
@bot.event
async def on_ready():
logging.info(f'{bot.user.name} ha iniciado sesión.')
@bot.event
async def on_command_error(ctx, error):
logging.error(f'Error en el comando {ctx.command}: {error}')
await ctx.send('Ha ocurrido un error. Inténtalo de nuevo más tarde.')
```
- Pruebas de carga y rendimiento: Simula el uso del bot en condiciones de carga pesada para asegurarte de que puede manejar múltiples solicitudes sin problemas. Puedes hacer esto manualmente o utilizar herramientas automatizadas para enviar múltiples comandos al mismo tiempo.
- Pruebas de integración: Si tu bot interactúa con APIs externas, asegúrate de que todas las integraciones funcionen correctamente. Prueba diferentes escenarios, como respuestas exitosas y errores de la API externa.
Aquí tienes un ejemplo completo que incluye manejo de errores y registro para mejorar la depuración:
```python
import discord
from discord.ext import commands
import logging
intents = discord.Intents.default()
intents.message_content = True
logging.basicConfig(level=logging.INFO)
bot = commands.Bot(command_prefix='!', intents=intents)
@bot.event
async def on_ready():
logging.info(f'{bot.user.name} ha iniciado sesión.')
@bot.event
async def on_message(message):
if message.author == bot.user:
return
if 'hola' in message.content.lower():
await message.channel.send('¡Hola!')
await bot.process_commands(message)
@bot.event
async def on_member_join(member):
channel = discord.utils.get(member.guild.text_channels, name='general')
if channel:
await channel.send(f'¡Bienvenido al servidor, {member.mention}!')
@bot.event
async def on_member_remove(member):
channel = discord.utils.get(member.guild.text_channels, name='general')
if channel:
await channel.send(f'{member.mention} ha dejado el servidor.')
@bot.command()
async def hola(ctx):
await ctx.send('¡Hola! ¿Cómo estás?')
@bot.command()
async def adios(ctx):
await ctx.send('¡Adiós! ¡Que tengas un buen día!')
@bot.command()
async def sumar(ctx, a: int, b: int):
await ctx.send(f'La suma de {a} y {b} es {a + b}')
@sumar.error
async def sumar_error(ctx, error):
if isinstance(error, commands.MissingRequiredArgument):
await ctx.send('Por favor, proporciona dos números para sumar.')
else:
logging.error(f'Error en el comando sumar: {error}')
@bot.command()
@commands.has_permissions(manage_messages=True)
async def limpiar(ctx, cantidad: int):
await ctx.channel.purge(limit=cantidad + 1)
await ctx.send(f'{cantidad} mensajes eliminados.', delete_after=5)
@bot.command()
async def info(ctx):
embed = discord.Embed(title="Información del Servidor", description="Detalles del servidor", color=0x00ff00)
embed.add_field(name="Servidor", value=ctx.guild.name, inline=False)
embed.add_field(name="Miembros", value=ctx.guild.member_count, inline=False)
await ctx.send(embed=embed)
@bot.event
async def on_command_error(ctx, error):
logging.error(f'Error en el comando {ctx.command}: {error}')
await ctx.send('Ha ocurrido un error. Inténtalo de nuevo más tarde.')
bot.run('TU_TOKEN_AQUÍ')
```
Conclusiones
Como hemos visto, con el crecimiento constante de Discord como plataforma de comunicación, los bots juegan un papel crucial en la automatización de tareas, moderación, y mejora de la experiencia del usuario. Python, con su sintaxis sencilla y su amplia biblioteca `discord.py`, se presenta como una excelente elección para este propósito.
En este sentido, siguiendo los pasos que hemos descrito deberías estar bien preparado para crear y desplegar tu propio bot de Discord en Python. No dudes en experimentar con nuevas funcionalidades y bibliotecas adicionales para expandir las capacidades de tu bot. Y recuerda siempre probar y depurar exhaustivamente para garantizar que tu bot funcione de manera eficiente y sin problemas en un entorno real.
Saber cómo crear un bot en Discord con Python es una habilidad valiosa que puede abrirte muchas oportunidades en el campo de la tecnología y la gestión de comunidades. ¡Buena suerte con tu proyecto de bot y disfruta del proceso de desarrollo!
Artículos relacionados
Cómo crear infinite scroll en React.js
El infinite scroll es una técnica muy popular en el desarrollo web moderno.
Minitutorial con vídeos para usar la IA de Photoshop
Descubre cómo la inteligencia artificial está revolucionando Adobe Photoshop.
¿Cómo configurar un servidor NAS?
¿Estás buscando una solución eficiente y segura para almacenar y gestionar grandes cantidades de datos? Descubre cómo configurar un servidor NAS (Network Attached Storage).