Features At A Glance

Game Engine

JavaMon is built on LibGDX, a powerful framework offering cross-platform compatibility between Android, iOS, and desktops. Unlike higher-level editors (e.g. RPG Maker or GameMaker Studio), this engine is optimized for high performance on mobile devices. Additionally, because the source code is fully available, you can easily tweak and optimize your game where needed.

Game developers can (almost) completely ignore the source code and design most of their world through Lua scripting and the provided content editors. You don’t have to be a code wizard to use JavaMon!

The JavaMon engine has several convenient built-in features:

  • Adaptive animation rendering: whether you’re running JavaMon on a high-end desktop or an old mobile device, animations and special effects will always look the same.
  • Rich debugging tools: the Console class allows developers to log helpful information, “verbose” messages, warnings and errors. Optional timestamps and method signatures help pinpoint both where and when an error occurred, making it easy to track down bugs.
  • Stream-saving: inspired by games like Dark Souls, this mechanism allows most RPG games to be saved every few seconds with only a small impact on performance. This is preferable for mobile games and minimizes the progress lost if a crash does occur. JavaMon even offers built-in support for saving the game mid-battle.


JavaMon is fully resolution-independent, meaning you can run it on your phone, tablet, or computer with minimal visual differences. Each game screen can specify its own size, allowing you to mix high-resolution and low-resolution graphics where appropriate. If the device aspect ratio does not match the virtual resolution, developers can choose to stretch or extend the screen, or add “black bars” to preserve the original aspect ratio. JavaMon is optimized for crisp display of pixel-perfect and low-resolution graphics.

Several high-level UI widgets are at your disposal: keyboards, text boxes, a D-pad, and a variety of buttons. All widgets can be animated (faded, rotated, moved, etc.) and are organized into a 2D scene graph. Widgets can also be “themed”; the player can select from up to 21 built-in visual styles and more can be added. Finally, classes already exist for sprite animations like walking, running, biking, and fishing. All you need to do is provide the graphics!

Fonts are always rendered at device resolution, always ensuring a crisp appearance. Built-in UI elements allow you to color text and assign a configurable “drop-shadow” effect.

JavaMon supports the LibGDX particle system, which can be used to define weather patterns, battle animations, and more. This particle system was designed to run smoothly even on phones.


Music and sound effects can be provided in MP3, WAV, and OGG formats (although the latter isn’t supported by iOS). You can split music into a non-looping “introductory” section, followed by a looping main section. Audio and music are automatically mixed together; you can also create “stingers” or “jingles” that temporarily pause the main music until they have finished. Adjustments to pan and pitch are supported.

Because audio files can be prohibitively large for mobile applications, JavaMon supports an external system for storing files. Developers can provide a small-size, “core” audio set for people downloading their game, and later allow users to install high-quality “sound packs” on external storage (e.g. an SD card). JavaMon automatically falls back on the core audio if extra files are not available, ensuring your audience is never left in silence.

Map Engine

JavaMon supports multi-layer, tile-based maps. Maps are “chunked” into 32x32 segments and organized into a 9x9 “cell”, allowing you to create the illusion of a seamless world. Best of all, no loading screens are necessary, although it is relatively easy to implement them if desired.

Maps are created using the Tiled Map Editor. Support already exists for animated tiles (e.g. waterfalls), script triggers, collision detection, player creation, and “warp” tiles—just to name a few. A full day/night and season cycle is provided, allowing you to create different map variants for winter vs. summer. You can even run a script to change a map e.g. when a quest has been completed.

Unusual for a tile-based engine, JavaMon allows each map to access all tilesets. You should still organize your tiles into logical groupings—forests, buildings, and oceans, for example—but you don’t have to waste time maintaining a separate tileset for each map.

Scripting & Events

JavaMon employs a full-featured, event-driven system for creating cutscenes and dialogues. Game designers can script almost all of their world in Lua using high level primitives like:

  • Events.TURN:add(player, NORTH)
  • Cutscene:addDialogue(player, "dialogueFile")
  • Cutscene:addPlayer(player, playerToCreate, x, y, layer)

New events can easily be added to JavaMon with only a minimal knowledge of Java. A variety of pre-built events exist for movement, dialogue, player creation, battling, and saving the game.

Not familiar with Lua? No problem! A script template and readme exists in every JavaMon directory to help get you started.


Quests in JavaMon can be created via a combination of the Quest Editor and Lua scripts. Each quest can have one or more stages, accessible via easily-understood text flags:

if QuestIO:isStage("bigChallenge", "killedTheDragon") then
    Events.ITEM:add(player, rewardItem) -- quest complete; give a reward
elseif QuestIO:isGreaterThan("bigChallenge", "talkedToMan") then
    -- do something else
    -- ...

Each quest can have up to 255 stages (or even more if multiple “slots” are used). UI widgets allow players to make decisions about the events presented to them, making it easy to create branching dialogue and complex quests with far-reaching consequences. These widgets offer far more flexibility than the traditional “yes/no” options in other RPG games.


Scripts can tie themselves into the player’s footstep count. This can be useful for “regeneration” (e.g. healing a player’s monsters every 250 steps) or for time-activated quests. Up to 128 can be active at any given time.


“Tree patches” can easily be placed in any map, allowing players to harvest, plant, water, and even fertilize up to 250 trees at any time. When harvested, trees can give any number (and any type) of items.


Items can also be placed directly into a map, to be picked up by players. These items can be made visible or hidden to the player, allowing developers to reward exploration and careful observation of the game world.


A store interface is provided by JavaMon, allowing players to buy and sell various items. Stores can be given variable or quest-influenced prices and can even restrict their inventory based on the player’s reputation.

By default, players have a limited inventory managed through the bag screen. The player can store items in a computer, purchase additional storage space, and even buy/swap different kinds of bags. Items can be additionally given different stack sizes and “weights”, allowing for an immersive (and totally optional!) storage system.

Battle Engine

JavaMon includes a turn-based battle engine, by default used for battling various “monsters” between one or more players. The entire battle system is modular, allowing you to easily add or remove mechanics (damage, accuracy, etc.) to suit your specific game. Battles are saved at each turn to prevent “save-scumming” and add consequence to player decisions—but this system can be easily disabled if needed.

Up to 3 players/monsters can exist on each side of a battle at any time. However, for reasons of screen estate JavaMon only provides graphics support for 2 monsters on each side. Because all calculations are written to support an infinite size, expanding this graphical limit is relatively straightforward.

Dynamic Generation

Want a more immersive world? Just specify a few spawn points in your map and JavaMon can automatically generate random opponents and monster encounters. It’s really that simple!

Generated opponents will be given random names, rosters, and can even be made to automatically react to the main player’s reputation. Monster encounters instead have two levels of randomness: (1) the type of monster that appears and (2) that monster’s level.

Opponents and allies alike can be made to scale to the main player’s level and experience. You have full control over how this scaling is applied. By default, a high-level opponent will be made weaker, but might still easily outclass the main player. Dynamic scaling doesn’t have to mean “easy mode” as in some other games.


Players can battle each other or trade monsters, only needing a (free!) Dropbox account to do so. Battles and trades follow a “chess by mail” pattern. If players forget what happened previously within a battle, they can “replay” it in real time. While playing the regular game, players can elect to receive notifications whenever a trade has been approved, etc.

JavaMon also provides support for save backups and uploading crash reports to a user’s Dropbox account. All wireless operations can be accessed from in-game; various safeguards protect the player from duping or save corruption. The wireless function is completely optional and, from a code standpoint, does not in any way interfere with the rest of your game.

Utilities & Support

JavaMon supports/provides several user-friendly editors to make your game even easier to design:

  • Particle Editor
  • TexturePacker (for sprite sheets, etc.)
  • Tiled Map Editor
  • Item Editor
  • Map Joiner/Splitter
  • Monster Editor
  • Opponent Editor
  • Weather Editor
  • Time/Season Editor
  • Various monster-specific editors

In addition to this documentation, JavaMon provides template files and readmes in EVERY directory of the game assets folder. A full API of JavaMon code and scripter’s reference are also available.


source code & script reference link