Trains, Phases & Market

This page covers the three constants that drive a game's economic arc: TRAINS, PHASES, and MARKET. All three are declared in game.rb. Together they control how fast the game progresses, when older trains become worthless, and how the stock price grid is structured.

For the entities that run on trains — corporations and companies — see Corporations & Companies.

How They Fit Together

Train purchase  →  Phase advances  →  Track colours unlock / Old trains rust / OR count changes
                                    →  Events fire (close_companies, etc.)

Every train purchase is checked against the on: field in PHASES. When the first copy of that train is bought, the phase advances and all consequences apply simultaneously.

The stock market is independent of phases — it moves on share buys and sells throughout the game.

TRAINS

TRAINS is an array of hashes defining every train type in the game. The Engine::Depot reads it to populate the train supply [lib/engine/depot.rb:7].

Required fields

Common optional fields

Complex distance arrays

When a train visits different node types with different counting rules, use an array of hashes:

distance: [
  { 'nodes' => %w[city offboard], 'pay' => 2, 'visit' => 2 },
  { 'nodes' => ['town'],          'pay' => 99, 'visit' => 99 },
]

Each element specifies which node types count toward pay (revenue stops) and visit (traversal limit). This pattern is used for titles where towns are free to pass through but cities are limited.

Train events

Events in events: are dispatched via @game.send("event_#{type}!") when the first copy is bought. Define a matching event_*! method in game.rb — or rely on a base class implementation.

Common event types defined in Game::Base:

Rusts vs Obsolete

• rusts_on — train is removed from the game entirely when the named train is first purchased. Corporations that only held rusted trains must buy a replacement (emergency buy).
• obsolete_on — train stays in play but is worth less when sold to another corporation. A corporation can still run it.

Example

TRAINS = [
  { name: '2', distance: 2, price: 80,  rusts_on: '4', num: 6 },
  { name: '3', distance: 3, price: 180, rusts_on: '6', num: 5 },
  { name: '4', distance: 4, price: 300, rusts_on: 'D', num: 4 },
  {
    name: '5',
    distance: 5,
    price: 450,
    num: 3,
    events: [{ 'type' => 'close_companies' }],
  },
  {
    name: 'D',
    distance: 999,
    price: 1_100,
    num: 20,
    available_on: '6',
    discount: { '4' => 300, '5' => 300, '6' => 300 },
  },
].freeze

PHASES

PHASES is an array of hashes defining game phases in order. The engine advances through phases as trains are purchased [lib/engine/phase.rb:19]. The first phase in the array is the starting phase; it has no on: field.

Required fields

Common optional fields

Status flags

Status strings are arbitrary — they appear in the phase indicator in the UI. The base engine recognises several:

Custom status strings can be added freely. Check them in Steps with @game.phase.status.include?('my_flag').

Common phase patterns

Standard 18xx escalation — one phase per train tier, each adding track colours and increasing OR count:

PHASES = [
  { name: '2', train_limit: 4, tiles: [:yellow],              operating_rounds: 1 },
  { name: '3', on: '3', train_limit: 4, tiles: %i[yellow green],         operating_rounds: 2, status: ['can_buy_companies'] },
  { name: '4', on: '4', train_limit: 3, tiles: %i[yellow green],         operating_rounds: 2, status: ['can_buy_companies'] },
  { name: '5', on: '5', train_limit: 2, tiles: %i[yellow green brown],   operating_rounds: 3, events: [{ 'type' => 'close_companies' }] },
  { name: '6', on: '6', train_limit: 2, tiles: %i[yellow green brown],   operating_rounds: 3 },
  { name: 'D', on: 'D', train_limit: 2, tiles: %i[yellow green brown gray], operating_rounds: 3 },
].freeze

Reducing train limit — important for late-game engine pressure. Check production titles for the exact numbers that create interesting decisions.

MARKET

MARKET is a two-dimensional array of strings representing the stock price grid [lib/engine/stock_market.rb:7]. Rows run top (high) to bottom (low); columns run left (low) to right (high).

Cell format

Each cell is a price string optionally followed by suffix characters:

Par prices

A corporation's par price must land on a p-marked cell. The engine reads these automatically from the MARKET definition — no separate list needed.

Example (1830 excerpt)

MARKET = [
  %w[60y 67 71 76 82 90 100p 112 126 142 160 180 200 225 250 275 300 325 350],
  %w[53y 60y 66 70 76 82  90p 100 112 126 142 160 180 200 220 240 260 280 300],
  %w[46y 55y 60y 65 70 76  82p  90 100 112 126 142 160 180 200 220 240 260 280],
  %w[39y 48y 55y 60 65 70   76   82  90 100 112 126 142 160 180 200 220 240],
  %w[32y 41y 48y 55 60 65   70   76  82  90 100 112 126 142 160 180],
  %w[25y 34y 41y 48 55 60   65   70  76   82  90 100 112 126],
  %w[18y 27y 34y 41 48 55   60   65   70   76  82  90 100],
  %w[10y 20y 27y 34 41 48   55   60   65   70  76  82],
].freeze

Market movement constants

These constants in game.rb control how the stock marker moves:

Financial Constants

These constants in game.rb control the economy.

GAME_END_CHECK keys and timing values

GAME_END_CHECK is a hash where each key is a trigger and the value is the timing of the end.

Trigger keys:

Timing values:

Multiple triggers can coexist. When two triggers fire simultaneously the one with earlier timing wins (:immediate beats :current_or beats :full_or, etc.).

18OE example (§13: bank-break ends at current OR; first L8 purchase gives one more full OR set):

GAME_END_CHECK = { bank: :current_or, final_phase: :one_more_full_or_set }.freeze

Looking up reference values

Before inventing your own numbers, check a production title that plays similarly:

What's Next

• Defining map hexes, tile supply, and location names: Map Configuration
• How Steps use phase status to gate actions: Rounds & Steps
• Ability types that interact with trains and phases: Abilities
• Testing the economic arc: Testing Your Game

Version: 2026-05-08 — derived from lib/engine/depot.rb, lib/engine/phase.rb, lib/engine/stock_market.rb, lib/engine/train.rb, lib/engine/game/base.rb, lib/engine/game/g_1830/game.rb.