main.ts

import { Clock } from './clock.js';
import {
  LIGHT_SECOND_IN_WORLD_UNITS, METER_IN_WORLD_UNITS, SECTOR_SIZE_IN_WORLD_UNITS,
} from './constants.js';
import { getNextContactId } from './contact_id.js';
import { GraphRenderer } from './graph_renderer.js';
import { Ship } from './model/ship.js';
import { World } from './model/world.js';
import { DebugView } from './debug_view.js';
import { Positions } from './operations/positions.js';
import { Physics } from './physics.js';
import { Renderer } from './renderer.js';
import { ShipComputer } from './ship_computer.js';
import { Snapshot } from './snapshot.js';
import { SnapshotManager } from './snapshot_manager.js';
import { Updater } from './updater.js';

const clock = new Clock();
const snapshots = new SnapshotManager();
const computer: ShipComputer = {};
const updater = new Updater();
const physics = new Physics();
const renderer = new Renderer();
const batteryGraphRenderer = new GraphRenderer(document.getElementById('batteryGraph'),
  'actualShips.:player-ship.systems.battery.charge',
  'actualShips.:player-ship.systems.battery.capacity', 200, 100);
const jumpDriveGraphRenderer = new GraphRenderer(document.getElementById('jumpDriveGraph'),
  'actualShips.:player-ship.systems.jumpDrive.charge',
  'actualShips.:player-ship.systems.jumpDrive.capacity', 200, 100);
const reactorGraphRenderer = new GraphRenderer(document.getElementById('reactorGraph'),
  'actualShips.:player-ship.systems.reactor.powerOutput',
  'actualShips.:player-ship.systems.reactor.maxPowerOutput', 200, 100);

const enterprise: Ship = {
  id: getNextContactId(),
  exists: true,
  isPlayerShip: true,
  name: 'UNS_ENT',
  position: {
    sector: {
      x: 0,
      y: 0,
    },
    x: 0,
    y: 0,
  },
  facing: 0,
  linearVelocity: {
    dx: 1 * METER_IN_WORLD_UNITS,
    dy: 0 * METER_IN_WORLD_UNITS,
  },
  linearAcceleration: {
    ax: 9.8 * METER_IN_WORLD_UNITS,
    ay: 0,
  },
  angularVelocity: {
    yaw: 0,
  },
  angularAcceleration: {
    dyaw: 0,
  },
  systems: {
    reactor: {
      enabled: true,
      maxPowerOutput: 500,
      powerOutput: 500,
      powerOutputDelta: -50,
      minPowerOutputDelta: -50,
      maxPowerOutputDelta: 50,
    },
    battery: {
      enabled: true,
      capacity: 20000,
      charge: 0,
      maxPowerInput: 200,
      maxPowerOutput: 500,
      powerInput: 0,
      powerOutput: 0,
    },
    powerRegulator: {
      enabled: true,
      targetBatteryChargePercent: 0.5,
      tolerance: 0.1,
    },
    jumpDrive: {
      enabled: true,
      charging: false,
      charge: 0,
      destination: undefined,
      requestedPowerInput: 0,
      powerInput: 0,

      powerPriority: 0,
      maxPowerInput: 240,
      efficiency: 0.05,
      maxAcceleration: 1.0,
      capacity: 7200,
      operatingPower: 1200,
      driftRatioMedial: 0.15,
      driftRatioLateral: 0.05,
    },
    navComputer: {
      enabled: true,
      requestedPowerInput: 80,
      powerInput: 80,
      maxPowerInput: 80,
      powerPriority: 2,
    },
    combatComputer: {
      enabled: true,
      requestedPowerInput: 40,
      powerInput: 40,
      maxPowerInput: 600,
      powerPriority: 1,
    },
    lifeSupport: {
      enabled: true,
      requestedPowerInput: 30,
      powerInput: 30,
      maxPowerInput: 30,
      powerPriority: 0,
    }
  },
};

const reliant: Ship = {
  id: getNextContactId(),
  exists: true,
  isPlayerShip: false,
  name: 'UNS_REL',
  position: {
    sector: {
      x: 0,
      y: 0,
    },
    x: LIGHT_SECOND_IN_WORLD_UNITS,
    y: 42 * METER_IN_WORLD_UNITS,
  },
  facing: 0,
  linearVelocity: {
    dx: -LIGHT_SECOND_IN_WORLD_UNITS * 0.5,
    dy: 0,
  },
  linearAcceleration: {
    ax: 0,
    ay: 0,
  },
  angularVelocity: {
    yaw: 3,
  },
  angularAcceleration: {
    dyaw: 0,
  },
  systems: {
    reactor: {
      enabled: true,
      maxPowerOutput: 100,
      powerOutput: 100,
      powerOutputDelta: 0,
      minPowerOutputDelta: -10,
      maxPowerOutputDelta: 10,
    },
    battery: {
      enabled: true,
      capacity: 5000,
      charge: 2500,
      maxPowerInput: 200,
      maxPowerOutput: 500,
      powerInput: 0,
      powerOutput: 0,
    },
    powerRegulator: {
      enabled: true,
      targetBatteryChargePercent: 0.5,
      tolerance: 0.1,
    },
    jumpDrive: {
      enabled: true,
      charging: false,
      charge: 0,
      destination: undefined,
      requestedPowerInput: 0,
      powerInput: 0,

      powerPriority: 0,
      maxPowerInput: 240,
      efficiency: 0.05,
      maxAcceleration: 1.0,
      capacity: 7200,
      operatingPower: 1200,
      driftRatioMedial: 0.15,
      driftRatioLateral: 0.05,
    },
    navComputer: {
      enabled: true,
      requestedPowerInput: 80,
      powerInput: 80,
      maxPowerInput: 80,
      powerPriority: 2,
    },
    combatComputer: {
      enabled: true,
      requestedPowerInput: 40,
      powerInput: 40,
      maxPowerInput: 600,
      powerPriority: 1,
    },
    lifeSupport: {
      enabled: true,
      requestedPowerInput: 30,
      powerInput: 30,
      maxPowerInput: 30,
      powerPriority: 0,
    }
  },
};

const world: World = {
  staticObjects: [
    {
      name: 'Sun',
      radius: 695508000 * METER_IN_WORLD_UNITS,
      mass: 1.989e30,
      position: Positions.normalized({
        sector: {
          x: 0,
          y: 0,
        },
        x: SECTOR_SIZE_IN_WORLD_UNITS / 360 - (1.496e+11 * METER_IN_WORLD_UNITS),
        y: SECTOR_SIZE_IN_WORLD_UNITS / 360,
      }),
    },
    {
      name: 'Earth',
      radius: 6371000 * METER_IN_WORLD_UNITS,
      mass: 5.9722e24,
      position: {
        sector: {
          x: 0,
          y: 0,
        },
        x: SECTOR_SIZE_IN_WORLD_UNITS / 360,
        y: SECTOR_SIZE_IN_WORLD_UNITS / 360,
      },
    },
    {
      name: 'Moon',
      radius: 1737000 * METER_IN_WORLD_UNITS,
      mass: 7.34767309e22,
      position: {
        sector: {
          x: 0,
          y: 0,
        },
        x: SECTOR_SIZE_IN_WORLD_UNITS / 360 + 384401000 * METER_IN_WORLD_UNITS,
        y: SECTOR_SIZE_IN_WORLD_UNITS / 360,
      },
    },
    {
      name: 'Mars',
      radius: 3389000 * METER_IN_WORLD_UNITS,
      mass: 6.4169e23,
      position: Positions.normalized({
        sector: {
          x: 0,
          y: 0,
        },
        x: SECTOR_SIZE_IN_WORLD_UNITS / 360 + 225000000000 * METER_IN_WORLD_UNITS,
        y: SECTOR_SIZE_IN_WORLD_UNITS / 360,
      }),
    },
    {
      name: 'Jupiter',
      radius: 71492000 * METER_IN_WORLD_UNITS,
      mass: 1.898e27,
      position: Positions.normalized({
        sector: {
          x: 0,
          y: 0,
        },
        x: SECTOR_SIZE_IN_WORLD_UNITS / 360 + 628730000000 * METER_IN_WORLD_UNITS,
        y: SECTOR_SIZE_IN_WORLD_UNITS / 360,
      }),
    },
  ],
  apparentShips: [],
  actualShips: [],
};

snapshots.addSnapshot(enterprise.id, new Snapshot(clock.get(), enterprise));
// snapshots.addSnapshot(reliant.id, new Snapshot(clock.get(), reliant));

function runGameLoop() {
  clock.update();
  updater.update(world, clock, snapshots, computer);
  physics.simulate(world, clock, snapshots);
  renderer.render(world, computer);
  batteryGraphRenderer.render(world, computer, clock);
  reactorGraphRenderer.render(world, computer, clock);
  jumpDriveGraphRenderer.render(world, computer, clock);
  window.requestAnimationFrame(runGameLoop);

  // (document.getElementById('debug') as HTMLElement).textContent =
  //    JSON.stringify(world.actualShips[0].systems, undefined, 2);
}

function togglePaused() {
  if (clock.isPaused()) {
    clock.unpause();
  } else {
    console.log('Pausing');
    clock.pause();
  }
}

window.addEventListener('load', () => {
  console.log('Initializing game...');
  runGameLoop();
});

window.addEventListener('keydown', (event) => {
  if (event.key === ' ') {
    togglePaused();
    event.preventDefault();
  }
});

const plotJumpButton = document.getElementById('plotJumpButton') as HTMLElement;
plotJumpButton.addEventListener('activate', (event) => {
  computer.selectingJumpTarget = true;
});