About This Page

This page covers specialized game engines — CryEngine, O3DE, GameMaker Studio 2, Construct, and RPG Maker. For the big three see Godot, Unity, Unreal Engine. For engine-agnostic concepts see Game Development.

Engine Comparison at a Glance

CryEngine

History

2004 — Far Cry ships on CryEngine 1 (revolutionary outdoor rendering)
2007 — Crysis ships on CryEngine 2 (still a benchmark today)
2011 — CryEngine 3, Crysis 2 (console + PC)
2013 — CryEngine 3 SDK released free to developers
2016 — CryEngine V, pay-what-you-want model
2019 — Hunt: Showdown enters early access
2022 — CryEngine 5.7 with ray tracing support

Key Features

Scripting in CryEngine

Languages available:
  C++       — Core engine, full access, best performance
  Lua       — Legacy scripting, still used for game logic
  Schematyc — Visual node-based scripting (like Blueprints)

C++ Entity example:
  class CMyEntity : public IEntityComponent {
      void Initialize() override { /* setup */ }
      void ProcessEvent(const SEntityEvent& e) override { /* events */ }
  };

-- Lua scripting example
function OnInit(self, table)
    self.health = 100
end
 
function OnDamage(self, damage)
    self.health = self.health - damage
    if self.health <= 0 then
        self:Die()
    end
end

When to Use CryEngine

✅ AAA-quality FPS or open-world games
✅ Games requiring top-tier outdoor environments
✅ VR experiences needing high fidelity
✅ Teams with C++ experience

❌ Avoid for 2D games
❌ Avoid for mobile (not optimized)
❌ Steep learning curve vs Godot/Unity
❌ Smaller community than Unreal/Unity

O3DE (Open 3D Engine)

Lumberyard → O3DE History

2015 — Amazon acquires Lumberyard code from Crytek (CryEngine 3 fork)
2016 — Amazon Lumberyard announced (free, required AWS for multiplayer)
2021 — Amazon donates engine to Linux Foundation → becomes O3DE
2021 — O3DE 21.11 first public release (open source, Apache 2.0)
2022 — O3DE 22.x — improved rendering, gem system
2023 — O3DE 23.x — PhysX 5, multiplayer improvements

Key Features

Gem System (Modules)

O3DE uses a modular "Gem" system — every feature is a plugin

Core Gems:
  PhysX         — Physics simulation
  Multiplayer   — Networking and replication
  Atom          — Rendering pipeline
  White Box     — Rapid geometry prototyping
  Script Canvas — Visual scripting
  LyShine       — UI system
  Audio         — Wwise integration

Custom Gems:
  Create your own gem with C++ and register it in project.json

// O3DE Component example (C++)
class MyComponent
    : public AZ::Component
    , public AZ::TickBus::Handler
{
public:
    AZ_COMPONENT(MyComponent, "{GUID-HERE}");
 
    void Activate() override {
        AZ::TickBus::Handler::BusConnect();
    }
 
    void Deactivate() override {
        AZ::TickBus::Handler::BusDisconnect();
    }
 
    void OnTick(float dt, AZ::ScriptTimePoint) override {
        // runs every frame
    }
};

When to Use O3DE

✅ AAA 3D games, simulations, digital twins
✅ Need full source access (Apache 2.0, no royalties)
✅ Cloud/AWS integration projects
✅ Experienced C++ teams

❌ Not for beginners (complex C++ architecture)
❌ Small community vs Unreal/Unity
❌ Less marketplace content

GameMaker Studio 2

Key Features

GML Scripting

// Player movement — GML example
// In Step Event of Player object:
 
var spd = 4;
var hsp = (keyboard_check(vk_right) - keyboard_check(vk_left)) * spd;
var vsp = (keyboard_check(vk_down)  - keyboard_check(vk_up))   * spd;
 
// Move and stop at walls
if (place_meeting(x + hsp, y, obj_wall)) hsp = 0;
if (place_meeting(x, y + vsp, obj_wall)) vsp = 0;
 
x += hsp;
y += vsp;
 
// Animation
if (hsp != 0 || vsp != 0) {
    sprite_index = spr_player_walk;
    image_speed = 0.2;
} else {
    sprite_index = spr_player_idle;
    image_speed = 0;
}

// Shooting — create bullet instance
// In Step Event, on fire key:
if (keyboard_check_pressed(ord("Z"))) {
    var b = instance_create_layer(x, y, "Bullets", obj_bullet);
    b.direction = point_direction(x, y, mouse_x, mouse_y);
    b.speed = 10;
    audio_play_sound(snd_shoot, 1, false);
}

Object Events System

GameMaker uses an Event-driven architecture:

Create Event    — runs once when object is created (like Start())
Step Event      — runs every frame (like Update())
Draw Event      — handles all rendering
Collision Event — triggered on overlap with another object
Destroy Event   — runs when object is destroyed
Alarm Event     — timer-based callbacks (Alarm[0] to Alarm[11])
Key Press Event — specific key input

Example Alarm usage:
  // In Create Event:
  alarm[0] = 60; // fire after 60 steps (1 second at 60fps)
  
  // In Alarm[0] Event:
  instance_create_layer(x, y, "Enemies", obj_enemy_spawn);
  alarm[0] = 120; // reset timer

Rooms & Layers

Rooms = Scenes/Levels in GameMaker

Layer types:
  Background — tiling background images
  Tilemap    — grid-based tile placement
  Instance   — placed object instances
  Asset      — sprites without object logic
  Effect     — built-in particle effects

Room transitions:
  room_goto(rm_level2);           // switch room
  room_goto_next();               // next room in list
  room_transition_enable(true);   // enable transition

Pricing

Construct 4

Key Features

Event Sheet System

Construct uses Conditions → Actions logic:

[Condition]              → [Action]
Player overlaps Enemy   → Subtract 10 from Health
Keyboard A is pressed   → Player: Set X velocity to -200
Health <= 0             → Go to layout "GameOver"

This compiles to JavaScript under the hood.

Example event:
┌─────────────────────────────────────────┐
│ + Platform behavior: On floor            │
│ + Keyboard: Space is just pressed        │
├─────────────────────────────────────────┤
│ → Player: Platform: Set vector Y to -600 │
│ → Audio: Play Jump sound                 │
└─────────────────────────────────────────┘

JavaScript in Construct

// Construct 4 JavaScript scripting
// In a Script file or inline script event:
 
runOnStartup(async runtime => {
    runtime.addEventListener("beforeprojectstart", () => onBeforeProjectStart(runtime));
});
 
async function onBeforeProjectStart(runtime) {
    // Runs before the first layout starts
    console.log("Game starting!");
}
 
// Access instances
function onPlayerJump(runtime) {
    const player = runtime.objects.Player.getFirstInstance();
    if (player) {
        player.behaviors.Platform.vectorY = -600;
    }
}

When to Use Construct

✅ Teaching game development to beginners
✅ Rapid 2D prototyping
✅ Browser-based games (HTML5)
✅ No programming experience required

❌ Not for 3D games
❌ Not for complex AAA projects
❌ Limited compared to GameMaker for advanced devs

RPG Maker

RPG Maker Versions

Key Features

Event System

RPG Maker uses a Map Event system for all game logic:

Event Commands include:
  Show Text          — dialogue boxes
  Show Choices       — branching dialogue
  Control Variables  — game math and tracking
  Control Switches   — on/off flags for game state
  Transfer Player    — move to another map/location
  Battle Processing  — trigger a battle
  Play BGM           — change background music
  Change Gold        — economy management
  Change Items       — add/remove from inventory
  Conditional Branch — if/else logic

Trigger types:
  Action Button — player presses confirm key
  Player Touch  — fires when player walks on event
  Event Touch   — fires when event walks into player
  Autorun       — runs automatically, blocks input
  Parallel       — runs every frame, non-blocking

JavaScript Plugin (MZ)

/*:
 * @plugindesc Custom Plugin Example
 * @author YourName
 *
 * @param PlayerSpeed
 * @type number
 * @default 4
 * @desc Player walk speed
 */
 
(() => {
    const params = PluginManager.parameters("MyPlugin");
    const playerSpeed = Number(params["PlayerSpeed"]) || 4;
 
    // Override player movement speed
    const _Game_Player_realMoveSpeed = Game_Player.prototype.realMoveSpeed;
    Game_Player.prototype.realMoveSpeed = function() {
        return playerSpeed;
    };
})();

When to Use RPG Maker

✅ Making 2D top-down RPGs quickly
✅ Story-driven games with dialogue trees
✅ No-code approach to game creation
✅ Pixel art RPG aesthetic

❌ Limited to 2D top-down style
❌ Default look is very recognizable (generic)
❌ Performance issues with large maps/plugins
❌ Not for action, platformer, or 3D games

Engine Selection Guide

Decision Flowchart

flowchart TD
    Start([What kind of game?]) --> Q1{2D or 3D?}
    Q1 -->|2D| Q2{Skill level?}
    Q1 -->|3D| Q3{Scale?}

    Q2 -->|Beginner / No code| Construct[Construct 4]
    Q2 -->|Want to make an RPG| RPG[RPG Maker MZ]
    Q2 -->|Intermediate dev| GM[GameMaker Studio 2]
    Q2 -->|Advanced, open source| Godot2[Godot Engine]

    Q3 -->|Indie / Small team| Godot3[Godot Engine]
    Q3 -->|Mid-size, mobile, VR| Unity[Unity]
    Q3 -->|AAA, cinematic quality| Unreal[Unreal Engine]
    Q3 -->|AAA open source, AWS| O3DE[O3DE]
    Q3 -->|AAA FPS, top fidelity| Cry[CryEngine]

Feature Matrix

• *CryEngine: free until $5,000 revenue/quarter then 5% royalty

Learning Resources

CryEngine

• CryEngine Documentation
• CryEngine GitHub
• CryEngine Marketplace

O3DE

• O3DE Official Site
• O3DE GitHub
• O3DE Documentation
• O3DE Discord Community

GameMaker Studio 2

• GameMaker Manual
• GameMaker Marketplace
• Shaun Spalding YouTube — Best GMS2 tutorials
• GMLscripts.com — Community GML snippets

Construct 4

• Construct.net
• Construct Manual
• Scirra Arcade — Play community games

RPG Maker

• RPG Maker Web
• RPG Maker Forums
• Yanfly Plugins — Essential MV/MZ plugins
• itch.io RPG Maker Games — Inspiration