URE - the unRogueEngine

UnRogue Engine is a Java library for making roguelike games.

URE is a class library of smart classes which work together to create a typical roguelike game environment based on 2D cell grids, turn-based action, and procedural content. It can emulate all the conventions of a normal single player roguelike such as Nethack, but is not limited to these conventions. Users can use URE simply as a display layer, as a full world abstraction manager, or take full advantage of its object library and use a conventional roguelike as an immediate jumping-off point to create from.

Features

URE is built for flexibility -- you should be able to use as few or as many of its features as you need. Its base classes are extendable and configurable to achieve almost any roguelike game you can imagine.

• Realtime lighting and visibility with full color blending and illumination for hundreds of lightsources in a scene
• OpenGL rendering layer with no AWT/swing elements, for cross platform high performance
• Visual particle system
• 60fps animation of lights, terrain, and entities
• Included truetype and pixel CP437-capable monospace fonts, or use any truetype font
• Complete game loop with action-time system and NPC turn management
• Full input handling, key buffering, mappable keybindings, mouse support
• Persist game areas to disk and restore them seamlessly for a persistent world
• JSON support for defining all types of game entities
• Many level generator algorithms included as generic methods to mix and match for your own custom level generators
• A* pathfinding available to actor entities or for general problem solving
• Simplex and Perlin noise
• A complete gameworld model incorporating things, actor NPCs, terrain, and more
• Cartographer system for centrally defining a world structure, regions, and area links
• UI elements such as a scroll panel, status panels, input widgets, lens panel, and more
• Built for flexibility -- mix and match URE classes, extend and replace with your own

Planned features

• Drop-in replacement renderer modules to allow graphical tile rendering, isometric views, or other visualizations without changing the underlying game
• Complex NPC AI, conversation trees, shops, quest-givers, and other rich NPC features
• Status effects
• Object materials and composition
• Environmental effects such as liquid flow, smoke/vapors, and their interactions

(see the Roadmap for more details on planned features.)

Why Java?

The decision to implement URE into Java was not made lightly. We recognize that there are more popular languages for roguelike and indie game development, such as Python, Lua, Unity/C#, etc. However we feel that Java provides several advantages for roguelike development in particular.

• Robust object model. The data model of a simulation-style game maps well to a robust inheritance/interface model such as Java's. Java capabilities such as reflection allow us to dynamically support user-created classes.
• Cross platform. Although a Java app requires a JVM, this can be bundled easily into platform-specific distros to support all major targets.
• Performance. Roguelikes often use CPU-intensive algorithms. Java implementations can be significantly faster than their Python or other interpreted-language equivalent.
• Type-safety. More accessible languages like Python tend to be weakly typed. While this allows more rapid prototyping and a looser style, it can make maintenance of a large interacting system (such as a roguelike world state) problematic and brittle. Java's strong typing helps to keep things on the rails.
• Tools support. Working in Java gives us access to professional strength IDEs such as IntelliJ and their plugins and build systems.
• A path to Scala. We wanted the option, for ourselves and for users, to incorporate Scala in addition to vanilla Java code in order to leverage modern functional programming techniques. This allowed us to mainly support a well-known language (Java) while still providing a path to a functional language (since Scala is a superset of Java), rather than writing natively in a newer less-known functional language.
• Future non-Java support. Not only Scala, but Kotlin (or any other JVM-based language) should also be able to import and use URE unmodified. We have hopes of building an API frontend for Python and possibly Lua as well.

Getting Started

See the HOWTO to get started on a URE project.

If you're excited about URE and would like to start trying it out in its early state, we would welcome your feedback and be happy to work with you to get features implemented to help you achieve your roguelike dream.

API Documentation

see JavaDoc

Contributing to URE

URE is an open source community project and the maintainers welcome contributions from the community. We aim to provide a comprehensive library of useful game objects and functionality covering as wide a variety of use cases as possible. If you've made a generally useful Thing, Behavior, Action, Terrain, or other entity type, ping us with your branch and we'd be happy to consider merging it back.

Projects made with URE

Hopefully someday there will be links here to actual games.

Built With

• IntelliJ A mighty nice IDE.
• Gradle Build automation and dependency management.
• Jackson JSON serializing for object persistence.
• Reflections Dynamic class detection.
• LWJGL Low level OpenGL access.
• JOML Low level OpenGL math.
• Dagger Dependency injection. Pretty handy for game projects and lazy devs!
• Guava Provides a lightweight global event bus.
• RexPaint URE imports and renders Rexpaint .xp files for splash screens, sprites, terrain decorations, etc.