Arrows Game (Android)

Arrows Game is a modular Android puzzle game inspired by Arrows – Puzzle Escape.

Google Play: https://play.google.com/store/apps/details?id=com.batodev.arrows

This project is an experiment in board generation: the main goal is to create a robust board generator for puzzle games, focusing on solvability and variety. The generator logic attempts to fill the board with "snakes" (arrow paths) while ensuring each level is solvable and interesting.

• Procedural board generation with customizable shapes and sizes
• Solvability checker to ensure every generated board can be completed
• Multiple board shapes via BoardShapeProvider
• Dynamic level progression and difficulty scaling
• Touch-based gameplay with animated feedback
• Lives system with game-over recovery via rewarded ads
• Hint system (free when ad-free, otherwise rewarded-ad-gated)
• Pinch-to-zoom and pan on the game board
• Toggleable guidance lines overlay to help aim

• Full-screen celebration with fade-in/out video playback (26 videos)
• 10 randomized congratulatory messages
• Confetti particle animation

• Unlocked at level 20
• Adjustable board width and height
• Shape selection (rectangular or custom shapes)
• Fill-the-board mode for denser puzzles

• 6 color themes: Dark, Green, Red, Yellow, Orange, Black and White
• 3 animation speed levels: High, Medium, Low
• Vibration and sound toggles

• Banner, rewarded, and interstitial ads
• Ad-free unlock by watching 30 rewarded ads (with progress bar)

• 15 languages: English, Arabic, Bengali, German, Spanish, French, Hindi, Indonesian, Italian, Japanese, Polish, Portuguese, Russian, Urdu, Chinese

• In-app review (Rate Us), email support (Write Us), developer store link (More Games)
• Privacy policy link and third-party licenses dialog

• Debug menu to force board dimensions, lives, and shapes

The project follows Clean Architecture with feature-based modularization — 11 Gradle modules split across four layers.

┌─────────────────────────────────────────────────────┐
│                      :app                           │  Entry point
├─────────────────────────────────────────────────────┤
│                  :navigation                        │  Navigation layer (Appyx)
├──────────────┬──────────────┬──────────────┬────────┤
│ :feature:home│ :feature:game│:feature:gen..│:feat.. │  Feature layer
├──────────────┴──────────────┴──────────────┴────────┤
│          :core:ui              :ads                 │  Presentation / shared
├─────────────────────────────────────────────────────┤
│                    :domain                          │  Business logic (pure Kotlin)
├──────────────────────────┬──────────────────────────┤
│           :data          │      :core:models        │  Data / models
├──────────────────────────┴──────────────────────────┤
│                  :core:resources                    │  Android resources
└─────────────────────────────────────────────────────┘

Dependency rule: inner layers know nothing about outer layers. :domain and :core:models have zero Android dependencies.

The project uses Koin for dependency injection, allowing for a decoupled and testable architecture across its modular structure.

1. Centralized Initialization: Koin is started in ArrowsApplication using startKoin, where the Android context is provided and all modules are loaded.
2. Modular Definitions: Each layer/feature defines its own Koin module (e.g., dataModule, adsModule, viewModelModule), keeping dependencies close to where they are used.
3. Injection:
   • Appyx Nodes: Implement KoinComponent to use by inject() for retrieving dependencies that aren't passed via constructors.
   • ViewModels: Defined using Koin's viewModel DSL and injected into Composables or Activities.
   • Singletons: Used for repositories, database instances, and ad managers.

Entry point. Single Activity + Application class.

Navigation layer built on Appyx 1.7.1.

Navigation state is a typed Kotlin object — fully testable without a UI (BackStackNavigationTest).

RootNode                    ← ParentNode, owns BackStack<NavTarget>
 ├── HomeNode               ← renders HomeScreen
 ├── GameNode               ← renders GameScreen
 ├── GenerateNode           ← renders GenerateScreen
 └── SettingsNode           ← renders SettingsScreen

Landing screen. Displays the current level, lives, and the Play button.

AppViewModel is managed by Koin and acts as the single source of truth for user preferences.

Core gameplay. The largest and most complex module.

Test coverage: GameEngineTapTest, GameEngineShapeLogicTest, CustomGameShapeTest, and more.

Custom level builder. Unlocked at level 20. Lets players configure and play their own boards.

Settings screen. User preferences, monetization controls, debug tools.

Shared UI. Theme, components, and styling consumed by all feature modules.

Pure Kotlin models. No Android dependencies — can run on the JVM alone.

Android resources only. No Kotlin/Java code — just strings, colors, drawables, and dimensions shared across all modules.

Business logic. Pure Kotlin, no Android dependencies — fully unit-testable.

Data layer. Room database, repositories, and persistence utilities.

Monetization. Google Mobile Ads integration and GDPR consent.

Android SDK: minSdk 29 (Android 10) · compileSdk 36 (Android 15) App version: 1.7 (version code 8) Application ID: com.batodev.arrows

This repo's Gradle build pulls shared build logic and the version catalog from release-tools via includeBuild. Clone it as a sibling directory before building:

git clone https://github.com/robmat/release-tools.git ../release-tools

# Run tests, lint, and static analysis
./gradlew test lint detekt

# Generate Jacoco coverage report
./gradlew testDebugUnitTestCoverage

This project is a playground for board generation algorithms. Feedback and contributions are welcome!

YourKit supports open source projects with innovative and intelligent tools for monitoring and profiling Java and .NET applications. YourKit is the creator of YourKit Java Profiler, YourKit .NET Profiler, and YourKit YouMonitor.