So you have an idea that you think might be the next great hit in the game world. How you do you go about creating it? Finding the way forward on a project can be extremely confusing at first as there are many paths forward and making an informed decision requires speeding a large amount of time exploring and understanding the ins and outs of the options available as they are often complex and have high learning curves.
When you get down to it, there are really 2 broad categories you can choose from, and finding the answer to this is actually pretty straight forward once you know how to evaluate the options. Option 1 is to build some sort of native game, this may be done with either the platform SDK or native development tools, or a cross platform game engine or framework. Platforms are diverse and while we are primarily concerned with mobile devices here, it is worth mentioning that some cross platform approaches include the ability to compile native for game consoles and PC’s as well. Option 2 is to build a web based game that has the majority or the entirety of its code base served over the web. Hybrid options can be used as part of this option as well, usually to create a simple native wrapper that manages access and presentation of the core application and offers additional hardware control.
Defining the architecture and choosing how to create a mobile game complicated. The amount of time invested in game development is usually higher when compared to many other types of applications and the requirements on hardware are higher generally as well. This leads to scenarios that favor native, lower level development or use of proprietary game engines such as Unity or Unreal which effectively get you to the same place using a cross platform approach. This sometimes complicates use of more universal and platform inclusive development methods when using a native approach, or introduces higher costs to pay for use of or royalties to the frameworks used. There are some cross platform approaches that are a good middle ground, offering a low or no cost option, such as LibGDX and we will explore those as well.
If you require more hardware resources for graphics or AI cpu intensive work, your best option would be a cross platform native approach with an established game engine such as Unity or Unreal, or straight native development. We will look at both approaches here. While you will get the best results for CPU intensive work, this is going to be the most expensive option. Both in terms of developer time and / or royalties paid to the game engine vendor if you decide to go that route.
Option 1: Native Development (Really Native)
Unfortunately it getting harder to create native games cross platform using industry standard methods such as C++ and OpenGL. Android offers excellent support in this area, even offering the Android Native Developer Kit (NDK). The NDK lets you implement parts of your app in native code, bypassing the SDK and the Android Runtime completely. Apple however is moving in the other direction, having recently announced they are deprecating support for OpenGL and OpenCL as of OS X 10.14 and iOS 12. (ref: https://developer.apple.com/macos/whats-new/, https://developer.apple.com/ios/whats-new/). In combination with the difficulty of building native C++ code for iOS (although there is compatibility and the ability to use C++ libraries with Objective-C) using low a low level native approach is currently not the path of least resistance if you want to include iOS (which is usually the point).
That said, straight C++ Development is still an option even if difficult and risky for future support. It gives you the most control over your program and by far the fastest results when done correctly. Even if you are using a game engine written in C++ like unity or unreal, you are usually writing your game code in scripts that are interrupted and run by the game engine. C++ is directly compiled to machine instructions by the compiler which generates native object code after compilation and links to the native libraries. You also do not have to use garbage collection (although since C++ version 11 you can create and control your own garbage collection). Having control over garbage collection can be a huge advantage because as the programmer you know what objects you want to retain in memory and can make sure that they are there when needed. Garbage collectors may remove items from memory that are going to possibly return at a later time. The act of both reclaiming memory (collection) and creating the objects in memory is time intensive and is a common cause for performance issues in games.
A great option for managing and creating graphics in your C++ games is the Open Graphics Library (OpenGL). It is a cross-language, cross-platform application programming interface (API) for rendering 2D and 3D vector graphics . The API is typically used to interact with a graphics processing unit (GPU), to achieve hardware-accelerated rendering. There is also a newer similar initiative called Vulkan. Vulkan is a grounds-up redesign effort to unify OpenGL and OpenGL ES into one common API that will not be backwards compatible with existing OpenGL versions . These options have optimizations for specific graphics cards so that they run much more efficiently on specific hardware taking advantage of manufacture specific hardware. There is a board range of support for many specific specific pieces of hardware.
As mentioned earlier, Apple has signaled that they are not looking forward with OpenGL, opting instead to promote Metal, their proprietary option. Metal is a low-level, low-overhead hardware-accelerated 3D graphic and compute shader application programming interface (API) developed by Apple Inc., and which debuted in iOS 8 . Metal combines functions similar to OpenGL and OpenCL under one API (it acts in a similar fashion to openGL, enabling software running on Apple devices to take advantage of optimizations available in the hardware). Luckily, Unity and Unreal engine take advantage of Metal and OpenGL so they can provide a great experience on either platform. If you intend to develop your own native solution however and want to incorporate hardware-accelerated rendering on both platforms, you will either have to incorporate metal for iOS or risk incompatibility in future releases.
Option 1: Native Development (Game Engine / Cross Platform)
The 2 heavy hitters are Unity and Unreal Engine. Both require you to pay for use but use different payment models. Unity utilities a tiered pay by the month model, you can find additional information here: https://store.unity.com/. Unreal has a slightly different approach where the use of Unreal Engine is completely free but once you ship your game or application, you pay Epic 5% of gross revenue after the first $3,000 per product per calendar quarter. You can read more about licensing for these products: https://www.unrealengine.com/en-US/faq and https://www.unrealengine.com/en-US/blog/ue4-is-free.
Both Unity and Unreal support a large amount of platforms, Unity has 27 including: iOS, Android, Tizen, Windows, Universal Windows Platform, macOS, Linux, WebGL, PlayStation 4, PlayStation Vita, Xbox One, Wii U, 3DS, Oculus Rift, Google Cardboard, SteamVR, PlayStation VR, Gear VR, Windows Mixed Reality, Daydream, Android TV, Samsung Smart TV, tvOS, Nintendo Switch, Fire OS, Facebook Gameroom, Apple's ARKit, Google's ARCore, and Vuforia . Unreal currently supports: Microsoft Windows, macOS, Linux, SteamOS, HTML5, iOS, Android, Nintendo Switch, PlayStation 4, Xbox One, Magic Leap One and virtual reality (SteamVR/HTC Vive, Oculus Rift, PlayStation VR, Google Daydream, OSVR and Samsung Gear VR . Either of these platforms are a great choice if your game requires fast performance and immersive 3D graphics on many platforms. Both Unity and Unreal have large developer communities, but Unity is generally perceived to be the leader of the pack in the shear size of community and marketplace assets available. Unreal offers complete source access to the engine, unity has a limited approach for source access. Generally speaking Unity is considered slightly more approachable for beginners which is one of the reasons it has attracted a larger community. It also had a free version available before Unreal which lead to wider adoption. Unreal however is seen as offering the absolute best when it comes to visuals, either platform is very capable.
A 3rd major option is CryEngine which is a lesser known but very capable engine. It has lighting and graphics capabilities that are considered to be better than Unity and on par with Unreal. It has had some changes to licensing recently that make it more attractive, but it is still considered to have a generally more restrictive license. The documentation is also not as good and while source has been recently made available, it is not an “open source” framework.
If your game does not require a high level of graphics performance, there are alternative game engines that accomplish the job but give you more freedom and can be easier to learn. A good example is LibGDX. LibGDX is a free and open-source game-development application framework written in the Java programming language with some C and C++ components for performance dependent code . It allows for the development of desktop and mobile games by using the same code base. It is cross-platform, supporting Windows, Linux, Mac OS X, Android, iOS, BlackBerry and web browsers with WebGL support. You write your core application code in Java and then add any platform specific code needed in sub-projects for each platform. An additional benefit of this approach is that you can test the game easily using your development machine, then test on individual platforms for differences and platform specific bugs. Some frameworks such as LibGDX also have the added benefit of being royalty free. This is a good option to explore especially for 2D and smaller scale games.
A last option I want to discuss that is more basic in nature called GameMaker Studio. It is primarily a 2D game engine and supports building for Microsoft Windows, macOS, Ubuntu, HTML5, Android, iOS, Amazon Fire TV, Android TV, Microsoft UWP, PlayStation 4, and Xbox One; support for the Nintendo Switch was announced in March 2018 . GameMaker accommodates the creation of cross-platform and multi-genre video games using a custom drag-and-drop visual programming language or a scripting language known as Game Maker Language, which can be used to develop more advanced games that could not be created just by using the drag and drop features. GameMaker was originally designed to allow novice computer programmers to be able to make computer games without much programming knowledge by use of these actions. Recent versions of software also focus on appealing to advanced developers .
Option 2: Web Based
The major alternative approach is centered around having a web based game. You might have a purely web based game, a hybrid based one with a native wrapper that uses functionally delivered from the web, or even a Progressive Web Application (PWA) that maintains it’s purely web based approach but includes a client side element called a service worker that can manage a local cache, manage asynchronous communications with the web server (both classic and push), and also includes a more native feel, being able to be “installed” and having an icon that and a more native feel not requiring the user to open the devices browser to enter the URL.
So using the combination of HTML5 canvases and WebGL, it is possible to create a capable (albeit less capable than a natively compiled solution) game that can be built on the web which ensures that it is highly portable between platforms. With this freedom comes all the advantages of having a single code base. If your games requirements are less CPU and graphics intensive building for the web might be a great option for you.
Hopefully all of this information will prove useful getting you orientated when starting out developing a game in the modern mobile landscape. Once you realize that there are really only 2 major directions to move in, some form of native application vs web centric one, and the major advantages and drawbacks to each. Moving forward with the first decision is relatively easy. From there you can decide your specific approach, say choosing between Unity, Unreal or native C++ development based on your specific requirements, armed with initial research laid out here.
Links / Resources / Research
Links to information on major game engines:
-  https://en.wikipedia.org/wiki/Unreal_Engine
- Unreal Android Setup:
Phaser (An open source framework from HTML5 Canvas and WebGL games)
Other Links of interest:
- Google developers games home: https://developers.google.com/games/
- Why C++ for game development: https://www.youtube.com/watch?v=mVaf9v2Ya7M
- C++ on iOS: http://www.cplusplus.com/reference/ios/ios/
- Android NDK: https://developer.android.com/ndk/
- Cross platform Game Development: https://www.androidauthority.com/cross-platform-mobile-development-677913/
- OpenGL:  https://en.wikipedia.org/wiki/OpenGL#Vulkan
- Metal:  https://en.wikipedia.org/wiki/Metal_(API) : https://developer.apple.com/metal/
- Apple depreciation of OpenGL: https://developer.apple.com/ios/whats-new/
- Graphics in HTML5: https://www.html5rocks.com/en/features/graphics
- National Geographic (three.js example): https://www.nationalgeographic.com/magazine/2017/06/nodosaur-3d-interactive-dinosaur-fossil/
- Oat the Goat (three.js example): http://oatthegoat.co.nz/
- Invaders (phaser example): https://phaser.io/examples/v2/games/invaders
- What is WebGL:  https://www.youtube.com/watch?v=qkDg-Y9iHBA
- Three.js: 3D browser framework done right: https://www.youtube.com/watch?v=qFY3JosrS8M