Escalator / Moving Platform

Mechanic governing escalator / moving platform behavior, establishing rules for player interaction, feedback, and progression within this system.

High complexity

4 examples

2 patterns

grand-strategy open-world real-time-strategy

Overview

As a core game system, escalator / moving platform defines how players interact with this aspect of the game world. The mechanic interacts with multiple other game systems, creating emergent gameplay that extends beyond its individual components. Understanding the design principles behind this mechanic helps developers create more engaging and balanced game experiences.

Game Examples

Soulslike Games

Soulslike Games use this mechanic where players customize their experience to achieve mastery over the system. The learning curve is steep but rewarding, resulting in skill differentiation.

Cooperative Games

Cooperative Games use this mechanic where players respond to dynamic events to overcome specific obstacles. Edge cases create memorable moments, resulting in strategic variety.

Submarine Games

Submarine Games use this mechanic where players plan their approach to explore every possibility. Multiple valid strategies exist for different playstyles, resulting in narrative investment.

Flight Simulators

Flight Simulators use this mechanic where players respond to dynamic events to explore every possibility. Each decision has cascading consequences, resulting in strategic variety.

Pros & Cons

Advantages

Integrates naturally with meta systems
Reduces monotony while maintaining challenge
Rewards both creative problem-solving and strategic thinking
Encourages exploratory playstyles and experimentation
Creates meaningful strategic decisions for players

Disadvantages

May reduce pacing if implemented poorly
Increases CPU requirements significantly
Can lead to frustration if overused
Risk of power creep in competitive environments
Difficult to balance across a wide range of skill levels

Implementation Patterns

Physics Simulator

Event-driven pattern that reacts to escalator / moving platform changes and updates dependent systems.

class EscalatorMovingPlatformSystem {
  location = { x: 0, y: 0 };
  moveSpeed = 10.0;
  mode = "idle";

  update(input: Input, dt: number) {
    const speed = this.getSpeed();
    this.location.x += input.x * speed * dt;
    this.location.y += input.y * speed * dt;
  }

  getSpeed() {
    switch (this.mode) {
      case "sprinting": return this.moveSpeed * 1.8;
      case "crouching": return this.moveSpeed * 0.4;
      case "swimming": return this.moveSpeed * 0.7;
      default: return this.moveSpeed;
    }
  }
}

Terrain Analyzer

Core implementation pattern for handling escalator / moving platform logic with clean state management.

class EscalatorMovingPlatformSystem {
  position = { x: 0, y: 0 };
  speed = 8.0;
  phase = "idle";

  update(input: Input, dt: number) {
    const speed = this.getSpeed();
    this.position.x += input.x * speed * dt;
    this.position.y += input.y * speed * dt;
  }

  getSpeed() {
    switch (this.phase) {
      case "sprinting": return this.speed * 1.8;
      case "crouching": return this.speed * 0.4;
      case "swimming": return this.speed * 0.8;
      default: return this.speed;
    }
  }
}