This is a difficult question, as it is not related to game development directly: we are currently evaluating, if an existing game implementation (game engine or part of it) may fulfill the needs for a new concept we like to integrate in our existing commercial application.

The idea: Implementation of a comprehensive resource management system.

A resource should have the following attributes (current draft state):

  1. State
    • Functional state (technical)
    • Organisational state
  2. Location/Assignment
    • Location of resource
    • Parent resource to which this resource is attached to
  3. Ability to move on its own
  4. Type
  5. Property List [0-n]
    • Compatibility constraints
    • Capacity constraints
    • important: each property in this list is organised in a hierarchical tree of its category and may only be assigned to resource while obeying the compatibility constraints of other existing properties, and the type, of course
  6. Dependencies [0-n]
    • to other resources
    • to other contexts ??
  7. Services/Skills [1-n]
    • List of requests this resource is able to fulfill (to a specific degree)
  8. Charge State [0-n]
    • depending on type, optional charge/load state

My researches brought up three different types of things:

  1. Receipts of how to build a resource management system/inventory
  2. Descriptions of existing game implementations (from user perspective)
  3. Game engines

These three things aren't exactly what we are trying to find. The closest match are game engines. But I doubt, that the integration of a whole game engine may be the best approach as (1) we have an existing application and (2) we don't need many of the game specific functionality. Using an external library that brings resource management would be a more precise approach.

On the other hand, what we do have is a 2d map view on which the resources (that can move on their own) are being displayed. On this map, the resources are being assigned to an event that opens one to many requests that need to be fulfilled. An important aspect is the time, resources need to move to the location of the event. So there indeed are some common mechanics to a (e. g. strategy) game.

Any ideas for a starting point from where we can proceed doing further research?

  • \$\begingroup\$ FWIW I've used Unity in the past for standalone visualisations (it made scaffolding a cross-platform visualisation trivially simple and allowed me to use compute shaders to render at a scale I couldn't replicate in the browser). For all that, it's way outside the usual ecosystem, continuous integration required a lot of scripting (unity doesn't play nicely with jenkins) and ended up being very fiddly. There's also licensing considerations... You'll most likely need to pay for the "free" engines if your turnover is above a threshold. \$\endgroup\$
    – Basic
    Mar 7, 2023 at 9:37

1 Answer 1


The resource (or "unit") properties and behaviours you describe are not things usually provided by game engines.

A game engine provides the core foundation to build a game on top of, things like...

  • importing texture, 3D model, sound assets and converting them to suitable real-time formats

  • providing an editor interface where creators can configure and arrange game content

  • gathering keyboard/mouse/controller input

  • tracking time and ticking update loops or event functions in user scripts to move the game state forward

  • providing a render loop with an API that makes it easy to draw 3D meshes or 2D sprites with a variety of shader materials

...and more, often all in a cross-platform.way.

You'll notice no game mechanics appear in that list, just the raw parts that a game developer would craft game mechanics out of (ways to react to input, ways to play a sound or spawn particles, etc...)

The game state and game mechanics like unit/resource management that you describe would be written in user code that then interfaces with the engine for things like spatial queries in the scene, path-finding, drawing, etc.

If you have a 2D map in your application, then it sounds like you already have modules providing most of that functionality, and you don't need a game engine to provide it.

The other thing you might be leading you toward game engines is that many come with libraries of sample user code, asset stores with pre-made scripts for download/purchase, or tutorials showing how to achieve common game features using that engine. But you don't need to integrate the engine itself into your app to benefit from these. It's unlikely you'll find a pre-made RTS unit or resource management game system that's configurable enough to do exactly what you need anyway, so you were always going to have to write some custom code. What you can do is study some of these pre-made assets and learn the kinds of techniques game developers use to implement these features, and what kind of engine APIs they're built on. Then you can use that knowledge to provide game-like facilities in your app's internal API, and build your custom resource mechanics against that.

To get you started in that direction, Game Programming Patterns is a great guide to common software development patterns through a game lens, which can help you get into the headspace of a game developer, and it's free to read online. You may also want to search this StackExchange for past answers talking about "composition over inheritance", component-based approaches, and entity-component-system architecture, which form a related family of ideas that's proven very powerful and flexible for building game content. These are better explained elsewhere, so I won't try to rehash it all here.


You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .