Game Mechanics Module: MAX Flight Physics

# =====================================================================================
# MODULE: MAX_FLIGHT_PHYSICS
# Purpose: Implement impossible, non-Newtonian flight mechanics for the Trimaxion Ship
# =====================================================================================

import math

# -----------------------------------------------------------------------------
# GLOBALS: (modifiable for difficulty modes)
# -----------------------------------------------------------------------------
rho_air = 1.2         # atmospheric density
g = 9.81              # baseline gravity
m = 3200.0            # effective ship mass (for collisions only)
S = 40.0              # size proxy for air interaction (rarely used)

# Field manipulation parameters:
EPS_G = 0.03          # % gravity suppression
EPS_RHO = 0.98        # % air-density suppression
BOB_AMPLITUDE = 1.0   # max vertical bob motion
SHIP_SPEED = 520.0    # m/s baseline (can scale by difficulty)

# -----------------------------------------------------------------------------
# 1. MAX’s "Gravity Field Rewrite"
# -----------------------------------------------------------------------------
def max_local_gravity():
    """
    MAX reduces local gravity. Used for:
    - hovering
    - smooth gliding
    - soft landing
    - cinematic passes
    """
    return g * (1 - EPS_G)


# -----------------------------------------------------------------------------
# 2. Air Density Corridor (removes drag)
# -----------------------------------------------------------------------------
def max_effective_air_density():
    """
    MAX creates a tunnel of low-density air, eliminating drag.
    """
    return rho_air * (1 - EPS_RHO)


def drag_force(v):
    """
    Drag normally depends on velocity, area, and coefficient.
    In MAX mode: drag becomes almost zero.
    """
    C_D = 0.2
    rho_eff = max_effective_air_density()
    return 0.5 * rho_eff * v * v * S * C_D


# -----------------------------------------------------------------------------
# 3. MAX Flight Controller (core loop)
# -----------------------------------------------------------------------------
def max_flight_update(t, t0, t1, x0, x1, y0, z0):
    """
    Produces a MAX-style flight trajectory.

    x = linear (constant speed)
    y = tiny bobbing motion (alive, organic)
    z = fixed unless player steers or AI evades obstacles

    This feeds directly into: 
    - Unity update()
    - Unreal tick()
    - Godot _process()
    - JS requestAnimationFrame loop
    """
    # normalized time 0–1
    u = (t - t0) / (t1 - t0)
    u = max(0.0, min(u, 1.0))

    # linear forward translation
    x = x0 + u * (x1 - x0)

    # slight hover fluctuation
    y = y0 + BOB_AMPLITUDE * math.sin(math.pi * u)

    # fixed z (unless steering)
    z = z0

    return (x, y, z)


# -----------------------------------------------------------------------------
# 4. MAX Steering (No banking, no tilt)
# -----------------------------------------------------------------------------
def max_steer(input_left_right, input_up_down):
    """
    Player or AI steering.
    Unlike aircraft, MAX:
      - does not roll
      - does not pitch
      - translates directly along axes
    """
    STRAFE_SPEED = 40.0
    VERT_SPEED = 25.0

    dz = input_left_right * STRAFE_SPEED
    dy = input_up_down * VERT_SPEED

    return (dy, dz)


# -----------------------------------------------------------------------------
# 5. MAX Shadow Displacement
# -----------------------------------------------------------------------------
def max_shadow_offset():
    """
    Shadow appears shifted due to field lensing.
    Cosmetic effect for rendering.
    """
    hull_radius = 8.0
    return EPS_G * hull_radius * 0.6    # ~1.8 m typically


# -----------------------------------------------------------------------------
# 6. Energy Model (MAX never overheats)
# -----------------------------------------------------------------------------
def max_energy_cost(v):
    """
    Game-friendly energy cost:
    - MAX doesn't consume thrust fuel
    - Instead use 'field charge' to limit boost or special maneuvers
    """
    base = 0.1
    boost = (v / SHIP_SPEED)
    return base * boost


# -----------------------------------------------------------------------------
# 7. MAX Special Ability: Air Stop
# -----------------------------------------------------------------------------
def max_air_stop(current_velocity):
    """
    MAX can stop mid-air instantly.
    Used for quick turnarounds or cinematic moments.
    """
    return (0,0,0)  # kills velocity vector


# -----------------------------------------------------------------------------
# 8. MAX Special Ability: Light Warp (Micro-jump)
# -----------------------------------------------------------------------------
def max_lightwarp(position, direction_vector, distance=60.0):
    """
    Teleports MAX forward along direction vector.
    Does not break continuity; appears as shimmering displacement.
    """
    x,y,z = position
    dx,dy,dz = direction_vector
    return (x + dx * distance, y + dy * distance, z + dz * distance)


# -----------------------------------------------------------------------------
# 9. MAX Physics Override (Master Switch)
# -----------------------------------------------------------------------------
def max_physics_override(delta_time, controls, position):
    """
    FULL GAME LOOP INTEGRATION.

    This replaces Newtonian physics entirely.
    """
    x,y,z = position

    # Steering
    dy, dz = max_steer(controls["left_right"], controls["up_down"])

    # Forward velocity (constant)
    vx = SHIP_SPEED

    # Global update
    x += vx * delta_time
    y += dy * delta_time
    z += dz * delta_time

    # Apply hover/organic motion
    y += BOB_AMPLITUDE * math.sin(x * 0.01)

    # Return updated position
    return (x,y,z)

// Pseudo-code: mirror Python max_physics_override in C#

Vector3 MaxPhysicsOverride(float deltaTime, Vector2 controls, Vector3 position) {
    float SHIP_SPEED = 520f;
    float BOB_AMPLITUDE = 1f;

    float x = position.x;
    float y = position.y;
    float z = position.z;

    // Steering (left/right = x, up/down = y for your control scheme)
    float STRAFE_SPEED = 40f;
    float VERT_SPEED = 25f;

    float dz = controls.x * STRAFE_SPEED;
    float dy = controls.y * VERT_SPEED;

    float vx = SHIP_SPEED;

    x += vx * deltaTime;
    y += dy * deltaTime;
    z += dz * deltaTime;

    y += BOB_AMPLITUDE * Mathf.Sin(x * 0.01f);

    return new Vector3(x, y, z);
}

func max_physics_override(delta: float, controls: Dictionary, position: Vector3) -> Vector3:
    var SHIP_SPEED := 520.0
    var BOB_AMPLITUDE := 1.0
    var STRAFE_SPEED := 40.0
    var VERT_SPEED := 25.0

    var x := position.x
    var y := position.y
    var z := position.z

    var dy := controls["up_down"] * VERT_SPEED
    var dz := controls["left_right"] * STRAFE_SPEED

    var vx := SHIP_SPEED

    x += vx * delta
    y += dy * delta
    z += dz * delta

    y += BOB_AMPLITUDE * sin(x * 0.01)

    return Vector3(x, y, z)

function maxPhysicsOverride(dt, controls, position) {
  const SHIP_SPEED = 520;
  const BOB_AMPLITUDE = 1.0;
  const STRAFE_SPEED = 40.0;
  const VERT_SPEED = 25.0;

  let { x, y, z } = position;
  const { left_right, up_down } = controls;

  const dy = up_down * VERT_SPEED;
  const dz = left_right * STRAFE_SPEED;
  const vx = SHIP_SPEED;

  x += vx * dt;
  y += dy * dt;
  z += dz * dt;

  y += BOB_AMPLITUDE * Math.sin(x * 0.01);

  return { x, y, z };
}