Centro de bachillerato tecnológico industrial y de
servicios No.271
“Ricardo Flores Magón”
MANUAL
TÉCNICO
ALUMNOS:
- RIGOBERTO CALDERÓN REYES
-RICARDO MAXIMILIANO TREJO TOBIAS
-DIEGO ALEJANDRO TREVIÑO GANDARILLA
-DIEGO ALEJANDRO MENDOZA REYES
-DIEGO EDUARDO ZAPATA AGUILAR
ÍNDICE
OBJETIVOS DEL SISTEMA ..................................................................................................................... 3
OBJETIVOS DEL MANUAL..................................................................................................................... 3
Términos y definiciones ........................................................................................................................ 3
Requerimientos ........................................................................................................................................ 4
Instalación y configuración .................................................................................................................. 5
Funcionamiento ....................................................................................................................................... 5
Arquitectura de la aplicación ............................................................................................................... 6
ALGORTIMOS ........................................................................................................................................... 8
Depuración y mantenimiento ............................................................................................................ 13
OBJETIVOS DEL SISTEMA
El objetivo principal del sistema es proporcionar una herramienta interactiva y entretenida tipo "clicker"
que permita a los usuarios obtener puntos a través de interacciones repetitivas. Este sistema está
diseñado para ser utilizado como una herramienta de "farming", es decir, para acumular puntos de manera
continua y sistemática. El propósito del sistema es ofrecer una experiencia lúdica y adictiva que permita
a los usuarios obtener recompensas virtuales a través de clics. Este tipo de juego se basa en la simplicidad
y la satisfacción inmediata que proporcionan los incrementos de puntos visibles en tiempo real.
OBJETIVOS DEL MANUAL
El objetivo de este manual es proporcionar una guía clara y comprensible sobre la definición, diseño,
organización y estructura de un juego tipo "clicker" desarrollado en Android Studio. Este manual está
dirigido al personal encargado del mantenimiento y mejora del sistema, incluyendo desarrolladores,
arquitectos, ingenieros de pruebas, y otros profesionales técnicos.
Términos y definiciones
• Java/Kotlin: Lenguajes de programación soportados por Android Studio para el desarrollo de
aplicaciones Android. Kotlin es recomendado por Google debido a su concisión y seguridad.
• XML (Extensible Markup Language): Lenguaje de marcado utilizado para definir los diseños de la
interfaz de usuario en Android, así como otros recursos estructurados como strings y estilos.
• API (Interfaz de Programación de Aplicaciones): Conjunto de definiciones y protocolos para
construir e integrar software, permitiendo la comunicación entre diferentes sistemas y
aplicaciones.
• MediaPlayer: Clase de Android utilizada para la reproducción de archivos multimedia como audio
y video. Permite la integración de efectos sonoros y música de fondo en la aplicación, mejorando
la experiencia del usuario.
• Animator: Clase base para crear animaciones en Android. Permite la animación de propiedades de
objetos, como cambios en el tamaño, posición y transparencia.
• Actividad (Activity): Componente fundamental de una aplicación de Android que representa una
pantalla con la que un usuario puede interactuar.
• Ciclo de Vida (Lifecycle): Conjunto de estados que experimenta una actividad o fragmento
durante su vida útil, desde su creación hasta su destrucción.
• Layout: Especificación de la estructura visual de la interfaz de usuario de una actividad o
fragmento, definida en archivos XML utilizando elementos como LinearLayout, RelativeLayout,
ConstraintLayout, etc.
Requerimientos
Requerimientos de Software:
• Sistema Operativo: Android 7.0 (Nougat) o superior.
• IDE: Android Studio 3.0 o superior para el desarrollo de la aplicación.
• Java Development Kit (JDK): JDK 8 o superior.
• Bibliotecas y Dependencias: Se requieren las bibliotecas y dependencias estándar de Android
para el desarrollo de aplicaciones, incluyendo las SDK Tools y las SDK Platform para Android 7.0
(Nougat) o superior.
Requerimientos de Hardware:
• Procesador: No se especifica un procesador mínimo, pero se recomienda un procesador
compatible con arquitectura ARM o x86.
• Memoria RAM: Se recomienda un mínimo de 2 GB de RAM para un rendimiento óptimo.
• Almacenamiento: Se recomienda un mínimo de 50 MB de espacio libre en disco para la
instalación de la aplicación.
Instalación y configuración
Paso 1: Compilación de la Aplicación en Android Studio
1. Abre tu proyecto de Android Studio donde has desarrollado la aplicación.
2. Asegúrate de que el proyecto esté configurado correctamente y sin errores.
3. En Android Studio, haz clic en el botón "Run" (Ejecutar) o presiona Shift + F10 para compilar y
ejecutar la aplicación.
Paso 2: Conexión del Dispositivo Móvil a la Computadora
1. Conecta tu dispositivo móvil a la computadora mediante un cable USB.
Paso 3: Configuración del Dispositivo para la Depuración USB
1. En tu dispositivo móvil, ve a "Configuración" > "Opciones de desarrollo" (puede variar según el
dispositivo).
2. Habilita la opción "Depuración USB".
Paso 4: Selección del Dispositivo de Destino en Android Studio
1. Una vez que la aplicación se haya compilado en Android Studio, se abrirá una ventana emergente
que te permitirá seleccionar el dispositivo de destino.
2. Selecciona tu dispositivo móvil conectado en la lista de dispositivos disponibles y haz clic en "OK"
para instalar la aplicación en él.
Paso 5: Ejecución y Prueba de la Aplicación en el Dispositivo Móvil
1. Android Studio instalará la aplicación en tu dispositivo móvil y la ejecutará automáticamente.
Funcionamiento
El sistema cuenta con una interfaz de usuario intuitiva y fácil de usar, diseñada para brindar una
experiencia fluida y agradable a los usuarios. Los elementos de la interfaz están organizados de manera
clara y accesible, lo que facilita la navegación y la interacción.
El sistema funciona mediante la interacción del usuario con la interfaz de la aplicación. Los usuarios
pueden tocar la pantalla de su dispositivo móvil para realizar acciones dentro del juego, la premisa
principal es realizar clicks en la pantalla para obtener puntos que se reflejan en un contador, y a partir de
esos puntos poder adquirir mejoras que ayudarán a que el proceso de obtención de esos puntos sea más
sencillo y rápido.
El propósito del sistema es ofrecer una plataforma divertida y estimulante donde los usuarios puedan
disfrutar de un juego interactivo y adictivo. A través de la mecánica de clics, los usuarios pueden acumular
puntos y progresar en el juego, desbloqueando nuevos niveles, características y recompensas a medida
que avanzan.
El sistema se mantiene actualizado con nuevas características, contenido y mejoras a través de
actualizaciones periódicas. Estas actualizaciones garantizan una experiencia fresca y emocionante para
los jugadores, fomentando su lealtad y compromiso a largo plazo con el juego.
Arquitectura de la aplicación
1. Interfaz de Usuario (UI):
La interfaz de usuario es la parte visible y accesible de la aplicación con la que interactúa el usuario. En
este caso, se compone principalmente de un botón para incrementar un contador y visualizaciones de
texto que muestran el contador actual y los precios de las mejoras.
Elementos de la Interfaz de Usuario (UI):
Layouts XML: Definen la estructura y apariencia de las pantallas de la aplicación.
Actividades y Fragmentos: Controladores que gestionan la lógica de presentación y la interacción con la
interfaz de usuario.
Recursos Visuales (drawables): Imágenes y otros recursos visuales utilizados en la interfaz de usuario.
2. Lógica de Aplicación:
La lógica de aplicación se encarga de procesar la entrada del usuario, realizar cálculos, tomar decisiones
y coordinar la interacción entre los diferentes componentes del sistema.
Componentes de Lógica de Aplicación:
Controladores de Eventos: Manejan las interacciones del usuario, como hacer clic en un botón para
incrementar el contador.
Actualización de Contador: Incrementa el contador cuando se realiza una acción específica.
Compra de Mejoras: Gestiona la lógica para comprar mejoras y actualizar los precios.
3. Gestión de Sonido:
La gestión de sonido se encarga de reproducir sonidos en respuesta a ciertas acciones del usuario, como
hacer clic en el botón o comprar una mejora.
Componentes de Gestión de Sonido:
MediaPlayer: Se utiliza para reproducir sonidos de clic y sonidos de actualización de mejora.
Recursos de Sonido: Archivos de sonido almacenados en el directorio res/raw.
Diagrama de Estructura de Código:
Interfaz de Usuario (UI) Lógica de Aplicación
- Layouts XML - Controladores de Eventos Gestión de Sonido
- Actividades y - Actualización de - MediaPlayer
Fragmentos Contador
- Recursos de Sonido
- Recursos Visuales - Compra de Mejoras
(drawables)
01 02 03
ALGORTIMOS
Clase Principal: MainActivity es la clase principal que controla la actividad principal de la aplicación.
Variables:
mediaPlayer: Reproduce la música de fondo.
cantidadMejora1, cantidadMejora2, cantidadMejora3: Contadores de las mejoras compradas.
contador: Contador principal de puntos (galletas).
precioMejora1, precioMejora2, precioMejora3: Precios de las mejoras.
mejora1Cps, mejora2Cps, mejora3Cps: Galletas por segundo (CPS) que cada mejora proporciona.
cpsTotal: Total de CPS acumuladas de todas las mejoras.
intervaloGeneracionCps: Intervalo de tiempo en milisegundos para la generación de CPS.
clickSound, upgradeSound: Sonidos de clic y de compra de mejora.
Métodos:
onCreate:
override fun onCreate(savedInstanceState: Bundle?) {
[Link](savedInstanceState)
setContentView([Link].activity_main)
// Referencias a los elementos de la interfaz de usuario
textViewContador = findViewById([Link])
textViewPrecioMejora1 = findViewById([Link].CVvarPrecio1)
textViewPrecioMejora2 = findViewById([Link].CVvarPrecio2)
textViewPrecioMejora3 = findViewById([Link].CVvarPrecio3)
textViewCantidadMejora1 = findViewById([Link].CVvarCantidad1)
textViewCantidadMejora2 = findViewById([Link].CVvarCantidad2)
textViewCantidadMejora3 = findViewById([Link].CVvarCantidad3)
textViewCps = findViewById([Link])
// Inicialización del MediaPlayer para los sonidos
mediaPlayer = [Link](this, [Link].background_music).apply
{
isLooping = true // Repetir la canción en un bucle
start() // Iniciar la reproducción
}
// Configuración del botón para incrementar el contador
findViewById<ImageButton>([Link]).setOnClickListener {
incrementarContador() }
// Inicialización del handler para la generación de CPS
handler = Handler()
iniciarGeneracionCps()
setupMejoras()
Se llama cuando la actividad se está creando.
• Configura la interfaz de usuario utilizando setContentView([Link].activity_main).
• Inicializa referencias a los elementos de la interfaz de usuario.
• Configura el MediaPlayer para reproducir música de fondo.
• Configura el botón de incremento del contador.
• Inicializa el Handler para la generación automática de CPS.
• Configura los botones de mejoras.
incrementarContador:
private fun incrementarContador() {
contador++
[Link] = [Link]()
[Link]()
animateClickButton()
}
• Incrementa el contador en 1.
• Actualiza el texto del contador en la interfaz de usuario.
• Reproduce el sonido de clic.
• Llama a animateClickButton para animar el botón de clic.
animateClickButton:
private fun animateClickButton() {
val imageButton = findViewById<ImageButton>([Link])
[Link]().scaleX(1.1f).scaleY(1.1f).setDuration(100).withEndA
ction {
[Link]().scaleX(1f).scaleY(1f).setDuration(100)
}
[Link]([Link]([Link].holo_red
_light))
Handler().postDelayed({
[Link]([Link]([Link]))
}, 200)
}
• Anima el botón de clic, haciéndolo crecer y luego volver a su tamaño original.
• Cambia temporalmente el color del texto del contador a rojo, luego lo vuelve a negro.
actualizarPrecioMejoras:
private fun actualizarPrecioMejoras() {
[Link] = [Link]()
[Link] = [Link]()
[Link] = [Link]()
[Link] = [Link]()
[Link] = [Link]()
[Link] = [Link]()
[Link] = [Link]()
}
• Actualiza los precios de las mejoras y las cantidades compradas en la interfaz de usuario.
• Actualiza el total de CPS en la interfaz de usuario.
iniciarGeneracionCps:
private fun iniciarGeneracionCps() {
[Link]({
contador += cpsTotal
[Link] = [Link]()
[Link](
{ iniciarGeneracionCps() },
[Link]()
)
}, [Link]())
}
• Incrementa el contador por la cantidad de cpsTotal cada segundo.
• Actualiza el texto del contador en la interfaz de usuario.
• Utiliza un Handler para repetir esta acción cada segundo.
setupMejoras:
findViewById<View>([Link].CVM1).setOnClickListener { comprarMejora(1) }
findViewById<View>([Link].CVM2).setOnClickListener { comprarMejora(2) }
findViewById<View>([Link].CVM3).setOnClickListener { comprarMejora(3) }
}
• Configura los botones de mejoras para que llamen a comprarMejora con el número de mejora
correspondiente.
comprarMejora:
private fun comprarMejora(numeroMejora: Int) {
val precio: Int
val cps: Int
val cantidad: Int
when (numeroMejora) {
1 -> {
precio = precioMejora1
cps = mejora1Cps
cantidad = ++cantidadMejora1
}
2 -> {
precio = precioMejora2
cps = mejora2Cps
cantidad = ++cantidadMejora2
}
else -> {
precio = precioMejora3
cps = mejora3Cps
cantidad = ++cantidadMejora3
}
}
if (contador >= precio) {
contador -= precio
cpsTotal += cps
when (numeroMejora) {
1 -> precioMejora1 *= 2
2 -> precioMejora2 *= 2
else -> precioMejora3 *= 2
}
actualizarPrecioMejoras()
[Link]()
[Link](this, "¡Mejora $numeroMejora comprada!",
Toast.LENGTH_SHORT).show()
}
}
• Verifica si el contador tiene suficientes puntos para comprar la mejora.
• Si es así, incrementa el contador de la mejora y el total de CPS.
• Duplica el precio de la mejora.
• Actualiza los textos en la interfaz de usuario.
• Reproduce el sonido de compra de mejora.
• Muestra un Toast notificando al usuario de la compra.
onDestroy:
override fun onDestroy() {
mediaPlayer?.stop()
mediaPlayer?.release()
[Link]()
[Link]()
[Link]()
}
• Se llama cuando la actividad está a punto de ser destruida.
• Libera los recursos del MediaPlayer y los sonidos.
Depuración y mantenimiento
Posibles errores y soluciones
Errores de Visualización:
Problema: Elementos que no se muestran correctamente o están mal alineados.
Solución: Verificar las restricciones y las propiedades de los elementos en ConstraintLayout. Asegurarse
de que todas las restricciones necesarias están definidas y ajustar los márgenes y tamaños según sea
necesario.
Fallo en el Incremento del Contador:
Problema: El ImageButton no incrementa el contador cuando se pulsa.
Solución: Revisar el método onClick asociado al ImageButton en el archivo Java/Kotlin correspondiente.
Asegurarse de que la lógica de incremento del contador está correctamente implementada y que el ID del
botón en el XML coincide con el ID referenciado en el código.
Desbordamiento de ScrollView:
Problema: El contenido se sale de los límites del ScrollView, causando problemas de visualización.
Solución: Asegurarse de que todos los elementos dentro del ScrollView tienen el atributo layout_height
establecido en "wrap_content" para permitir que el contenido se ajuste dinámicamente. Además, revisar
las restricciones de los elementos para que se alineen correctamente dentro del contenedor.
Recomendaciones de Mantenimiento
Actualizaciones Regulares:
Mantener las bibliotecas y dependencias del proyecto actualizadas a sus versiones más recientes. Esto
incluye las bibliotecas de soporte de Android, herramientas de terceros, y cualquier otro recurso que
utilice la aplicación. Las actualizaciones suelen incluir mejoras de rendimiento, correcciones de errores y
nuevas características que pueden ser beneficiosas para la aplicación.
Pruebas Continuas:
Realizar pruebas frecuentes y exhaustivas para identificar y resolver errores de forma temprana.
Implementar pruebas unitarias y de integración para asegurar que las diferentes partes de la aplicación
funcionen correctamente tanto de forma individual como en conjunto. Además, considerar la
automatización de pruebas para detectar posibles regresiones en futuras actualizaciones.
Optimización de Recursos:
Usar imágenes y recursos gráficos optimizados para reducir el tamaño de la aplicación y mejorar el
rendimiento. Herramientas como Android Asset Studio pueden ser útiles para generar recursos
optimizados. Además, considerar la utilización de técnicas como el lazy loading para cargar recursos solo
cuando sean necesarios, mejorando así la eficiencia general de la aplicación.
Monitoreo y Feedback:
Implementar herramientas de monitoreo para recoger información sobre el rendimiento de la aplicación
y el comportamiento de los usuarios en tiempo real.
Conclusión:
Este manual técnico ha proporcionado una visión detallada de la estructura y funcionalidad del juego,
abordando aspectos esenciales como la instalación, configuración, uso y mantenimiento del sistema.
Hemos cubierto el diseño de la interfaz, la arquitectura del software, y los componentes clave, incluyendo
los scripts de control de escenas y de pausa. Además, hemos detallado el proceso de depuración y las
mejores prácticas para asegurar un funcionamiento óptimo y continuo del sistema.
Es fundamental seguir las recomendaciones y procedimientos establecidos en este manual para mantener
la integridad y el rendimiento del juego.