mlogjs 0.1.9 → 0.2.0

package/lib/eslib/lib.es5.d.ts

@@ -0,0 +1,295 @@
+/// <reference no-default-lib="true"/>
+
+interface Symbol {}
+
+interface SymbolConstructor {}
+
+declare var Symbol: SymbolConstructor;
+interface Object {}
+
+/**
+ * Creates a new function.
+ */
+interface Function {}
+
+/**
+ * Extracts the type of the 'this' parameter of a function type, or 'unknown' if the function type has no 'this' parameter.
+ */
+type ThisParameterType<T> = T extends (this: infer U, ...args: any[]) => any
+  ? U
+  : unknown;
+
+/**
+ * Removes the 'this' parameter from a function type.
+ */
+type OmitThisParameter<T> = unknown extends ThisParameterType<T>
+  ? T
+  : T extends (...args: infer A) => infer R
+  ? (...args: A) => R
+  : T;
+
+interface CallableFunction extends Function {}
+
+interface NewableFunction extends Function {}
+
+interface IArguments {}
+
+interface String {
+  /** Returns the length of a String object. */
+  readonly length: number;
+}
+
+interface Boolean {}
+
+interface Number {}
+
+interface TemplateStringsArray extends ReadonlyArray<string> {
+  readonly raw: readonly string[];
+}
+
+/**
+ * The type of `import.meta`.
+ *
+ * If you need to declare that a given property exists on `import.meta`,
+ * this type may be augmented via interface merging.
+ */
+interface ImportMeta {}
+
+interface Math {
+  /**
+   * Returns the larger of two of supplied numeric expressions.
+   * @param a
+   * @param b
+   */
+  max(a: number, b: number): number;
+
+  /**
+   * Returns the smaller of two of supplied numeric expressions.
+   * @param a
+   * @param b
+   */
+  min(a: number, b: number): number;
+
+  /**
+   * Returns the angle of a vector in degrees
+   * @param a
+   * @param b
+   */
+  angle(a: number, b: number): number;
+
+  /**
+   * Returns the length of a vector
+   * @param a
+   * @param b
+   */
+  len(a: number, b: number): number;
+
+  /**
+   * Returns 2D simplex noise
+   * @param x
+   * @param y
+   */
+  noise(x: number, y: number): number;
+
+  /**
+   * Returns the absolute value of a number.
+   * @example
+   *    Math.abs(-5) // 5
+   *    Math.abs(5) // 5
+   * @param x
+   */
+  abs(x: number): number;
+
+  /**
+   * Returns the natural logarithm (base e) of a number
+   * @param x
+   */
+  log(x: number): number;
+
+  /**
+   * Returns the logarithm (base 10) of a number
+   * @param x
+   */
+  log10(x: number): number;
+
+  sin(x: number): number;
+  cos(x: number): number;
+  tan(x: number): number;
+  floor(x: number): number;
+  ceil(x: number): number;
+  sqrt(x: number): number;
+
+  /**
+   * Returns a random floating point number from 0 to `range` (excluding `range` istself)
+   * @param range
+   */
+  rand(range: number): number;
+}
+declare const Math: Math;
+
+interface Error {}
+
+interface EvalError extends Error {}
+
+interface RangeError extends Error {}
+
+interface ReferenceError extends Error {}
+
+interface SyntaxError extends Error {}
+
+interface TypeError extends Error {}
+
+interface URIError extends Error {}
+
+/////////////////////////////
+/// ECMAScript Array API (specially handled by compiler)
+/////////////////////////////
+
+interface ReadonlyArray<T> {
+  /**
+   * Gets the length of the array. This is a number one higher than the highest element defined in an array.
+   */
+  readonly length: number;
+
+  readonly [n: number]: T;
+}
+
+interface ConcatArray<T> {
+  readonly length: number;
+  readonly [n: number]: T;
+}
+
+interface Array<T> {
+  /**
+   * Gets or sets the length of the array. This is a number one higher than the highest index in the array.
+   */
+  length: number;
+
+  [n: number]: T;
+}
+
+interface ArrayLike<T> {
+  readonly length: number;
+  readonly [n: number]: T;
+}
+
+/**
+ * Make all properties in T optional
+ */
+type Partial<T> = {
+  [P in keyof T]?: T[P];
+};
+
+/**
+ * Make all properties in T required
+ */
+type Required<T> = {
+  [P in keyof T]-?: T[P];
+};
+
+/**
+ * Make all properties in T readonly
+ */
+type Readonly<T> = {
+  readonly [P in keyof T]: T[P];
+};
+
+/**
+ * From T, pick a set of properties whose keys are in the union K
+ */
+type Pick<T, K extends keyof T> = {
+  [P in K]: T[P];
+};
+
+/**
+ * Construct a type with a set of properties K of type T
+ */
+type Record<K extends keyof any, T> = {
+  [P in K]: T;
+};
+
+/**
+ * Exclude from T those types that are assignable to U
+ */
+type Exclude<T, U> = T extends U ? never : T;
+
+/**
+ * Extract from T those types that are assignable to U
+ */
+type Extract<T, U> = T extends U ? T : never;
+
+/**
+ * Construct a type with the properties of T except for those in type K.
+ */
+type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
+
+/**
+ * Exclude null and undefined from T
+ */
+type NonNullable<T> = T extends null | undefined ? never : T;
+
+/**
+ * Obtain the parameters of a function type in a tuple
+ */
+type Parameters<T extends (...args: any) => any> = T extends (
+  ...args: infer P
+) => any
+  ? P
+  : never;
+
+/**
+ * Obtain the parameters of a constructor function type in a tuple
+ */
+type ConstructorParameters<T extends new (...args: any) => any> =
+  T extends new (...args: infer P) => any ? P : never;
+
+/**
+ * Obtain the return type of a function type
+ */
+type ReturnType<T extends (...args: any) => any> = T extends (
+  ...args: any
+) => infer R
+  ? R
+  : any;
+
+/**
+ * Obtain the return type of a constructor function type
+ */
+type InstanceType<T extends new (...args: any) => any> = T extends new (
+  ...args: any
+) => infer R
+  ? R
+  : any;
+
+/**
+ * Convert string literal type to uppercase
+ */
+type Uppercase<S extends string> = intrinsic;
+
+/**
+ * Convert string literal type to lowercase
+ */
+type Lowercase<S extends string> = intrinsic;
+
+/**
+ * Convert first character of string literal type to uppercase
+ */
+type Capitalize<S extends string> = intrinsic;
+
+/**
+ * Convert first character of string literal type to lowercase
+ */
+type Uncapitalize<S extends string> = intrinsic;
+
+/**
+ * Marker for contextual 'this' type
+ */
+interface ThisType<T> {}
+
+/////////////////////////////
+/// ECMAScript Internationalization API
+/////////////////////////////
+
+interface String {}
+
+interface Number {}

package/lib/eslib/lib.es6.d.ts

@@ -0,0 +1,18 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2015" />

package/lib/globals.d.ts

@@ -0,0 +1,328 @@
+/// <reference path="./kinds.d.ts" />
+
+declare enum ControlKind {
+  ctrlPlayer,
+  ctrlProcessor,
+  ctrlFormation,
+}
+
+interface Vars {
+  /** The processor currently executing this code */
+  readonly this: BasicBuilding &
+    Typed<
+      | typeof Blocks.microProcessor
+      | typeof Blocks.logicProcessor
+      | typeof Blocks.hyperProcessor
+    >;
+  /** The position on the x axis of this processor */
+  readonly thisx: number;
+  /** The position on the y axis of this processor */
+  readonly thisy: number;
+  /** The width of the map */
+  readonly mapw: number;
+  /** The height of the map */
+  readonly maph: number;
+  /** The number of blocks linked to this processor */
+  readonly links: number;
+  /** The amount of instructions run per second */
+  readonly ipt: number;
+  /** The unit bound to this processor */
+  readonly unit: AnyUnit;
+}
+
+declare const Vars: Vars;
+
+declare namespace Items {
+  const copper: unique symbol;
+  const lead: unique symbol;
+  const metaglass: unique symbol;
+  const graphite: unique symbol;
+  const sand: unique symbol;
+  const coal: unique symbol;
+  const titanium: unique symbol;
+  const thorium: unique symbol;
+  const scrap: unique symbol;
+  const silicon: unique symbol;
+  const plastanium: unique symbol;
+  const phaseFabric: unique symbol;
+  const surgeAlloy: unique symbol;
+  const sporePod: unique symbol;
+  const blastCompound: unique symbol;
+  const pyratite: unique symbol;
+}
+
+type ItemSymbol = typeof Items[keyof typeof Items];
+
+declare namespace Liquids {
+  const water: unique symbol;
+  const slag: unique symbol;
+  const oil: unique symbol;
+  const cryofluid: unique symbol;
+}
+
+type LiquidSymbol = typeof Liquids[keyof typeof Liquids];
+
+declare namespace Units {
+  const dagger: unique symbol;
+  const mace: unique symbol;
+  const fortress: unique symbol;
+  const scepter: unique symbol;
+  const reign: unique symbol;
+  const nova: unique symbol;
+  const pulsar: unique symbol;
+  const quasar: unique symbol;
+  const vela: unique symbol;
+  const corvus: unique symbol;
+  const crawler: unique symbol;
+  const atrax: unique symbol;
+  const spiroct: unique symbol;
+  const arkyid: unique symbol;
+  const toxopid: unique symbol;
+  const flare: unique symbol;
+  const horizon: unique symbol;
+  const zenith: unique symbol;
+  const antumbra: unique symbol;
+  const eclipse: unique symbol;
+  const mono: unique symbol;
+  const poly: unique symbol;
+  const mega: unique symbol;
+  const quad: unique symbol;
+  const oct: unique symbol;
+  const risso: unique symbol;
+  const minke: unique symbol;
+  const bryde: unique symbol;
+  const sei: unique symbol;
+  const omura: unique symbol;
+  const retusa: unique symbol;
+  const oxynoe: unique symbol;
+  const cyerce: unique symbol;
+  const aegires: unique symbol;
+  const navanax: unique symbol;
+  const alpha: unique symbol;
+  const beta: unique symbol;
+  const gamma: unique symbol;
+}
+
+type UnitSymbol = typeof Units[keyof typeof Units];
+
+declare namespace LAccess {
+  const totalItems: unique symbol;
+  const firstItem: unique symbol;
+  const totalLiquids: unique symbol;
+  const totalPower: unique symbol;
+  const itemCapacity: unique symbol;
+  const liquidCapacity: unique symbol;
+  const powerCapacity: unique symbol;
+  const powerNetStored: unique symbol;
+  const powerNetCapacity: unique symbol;
+  const powerNetIn: unique symbol;
+  const powerNetOut: unique symbol;
+  const ammo: unique symbol;
+  const ammoCapacity: unique symbol;
+  const health: unique symbol;
+  const maxHealth: unique symbol;
+  const heat: unique symbol;
+  const efficiency: unique symbol;
+  const progress: unique symbol;
+  const timescale: unique symbol;
+  const rotation: unique symbol;
+  const x: unique symbol;
+  const y: unique symbol;
+  const shootX: unique symbol;
+  const shootY: unique symbol;
+  const size: unique symbol;
+  const dead: unique symbol;
+  const range: unique symbol;
+  const shooting: unique symbol;
+  const boosting: unique symbol;
+  const mineX: unique symbol;
+  const mineY: unique symbol;
+  const mining: unique symbol;
+  const team: unique symbol;
+  const type: unique symbol;
+  const flag: unique symbol;
+  const controlled: unique symbol;
+  const controller: unique symbol;
+  const commanded: unique symbol;
+  const name: unique symbol;
+  const payloadCount: unique symbol;
+  const payloadType: unique symbol;
+  const enabled: unique symbol;
+  const shoot: unique symbol;
+  const shootp: unique symbol;
+  const config: unique symbol;
+  const color: unique symbol;
+}
+
+declare namespace UnitCommands {
+  const attack: unique symbol;
+  const rally: unique symbol;
+  const idle: unique symbol;
+}
+
+type UnitCommandSymbol = typeof UnitCommands[keyof typeof UnitCommands];
+
+declare namespace Blocks {
+  // special "blocks" to reference stuff from the environment
+  const air: unique symbol;
+  const solid: unique symbol;
+
+  const siliconSmelter: unique symbol;
+  const siliconCrucible: unique symbol;
+  const kiln: unique symbol;
+  const graphitePress: unique symbol;
+  const plastaniumCompressor: unique symbol;
+  const multiPress: unique symbol;
+  const phaseWeaver: unique symbol;
+  const surgeSmelter: unique symbol;
+  const pyratiteMixer: unique symbol;
+  const blastMixer: unique symbol;
+  const cryofluidMixer: unique symbol;
+  const melter: unique symbol;
+  const separator: unique symbol;
+  const disassembler: unique symbol;
+  const sporePress: unique symbol;
+  const pulverizer: unique symbol;
+  const incinerator: unique symbol;
+  const coalCentrifuge: unique symbol;
+  const powerSource: unique symbol;
+  const powerVoid: unique symbol;
+  const itemSource: unique symbol;
+  const itemVoid: unique symbol;
+  const liquidSource: unique symbol;
+  const liquidVoid: unique symbol;
+  const payloadSource: unique symbol;
+  const payloadVoid: unique symbol;
+  const illuminator: unique symbol;
+  const copperWall: unique symbol;
+  const copperWallLarge: unique symbol;
+  const titaniumWall: unique symbol;
+  const titaniumWallLarge: unique symbol;
+  const plastaniumWall: unique symbol;
+  const plastaniumWallLarge: unique symbol;
+  const thoriumWall: unique symbol;
+  const thoriumWallLarge: unique symbol;
+  const door: unique symbol;
+  const doorLarge: unique symbol;
+  const phaseWall: unique symbol;
+  const phaseWallLarge: unique symbol;
+  const surgeWall: unique symbol;
+  const surgeWallLarge: unique symbol;
+  const mender: unique symbol;
+  const mendProjector: unique symbol;
+  const overdriveProjector: unique symbol;
+  const overdriveDome: unique symbol;
+  const forceProjector: unique symbol;
+  const shockMine: unique symbol;
+  const scrapWall: unique symbol;
+  const scrapWallLarge: unique symbol;
+  const scrapWallHuge: unique symbol;
+  const scrapWallGigantic: unique symbol;
+  const thruster: unique symbol;
+  const conveyor: unique symbol;
+  const titaniumConveyor: unique symbol;
+  const plastaniumConveyor: unique symbol;
+  const armoredConveyor: unique symbol;
+  const distributor: unique symbol;
+  const junction: unique symbol;
+  const itemBridge: unique symbol;
+  const phaseConveyor: unique symbol;
+  const sorter: unique symbol;
+  const invertedSorter: unique symbol;
+  const router: unique symbol;
+  const overflowGate: unique symbol;
+  const underflowGate: unique symbol;
+  const massDriver: unique symbol;
+  const duct: unique symbol;
+  const ductRouter: unique symbol;
+  const ductBridge: unique symbol;
+  const mechanicalPump: unique symbol;
+  const rotaryPump: unique symbol;
+  const thermalPump: unique symbol;
+  const conduit: unique symbol;
+  const pulseConduit: unique symbol;
+  const platedConduit: unique symbol;
+  const liquidRouter: unique symbol;
+  const liquidContainer: unique symbol;
+  const liquidTank: unique symbol;
+  const liquidJunction: unique symbol;
+  const bridgeConduit: unique symbol;
+  const phaseConduit: unique symbol;
+  const combustionGenerator: unique symbol;
+  const thermalGenerator: unique symbol;
+  const steamGenerator: unique symbol;
+  const differentialGenerator: unique symbol;
+  const rtgGenerator: unique symbol;
+  const solarPanel: unique symbol;
+  const largeSolarPanel: unique symbol;
+  const thoriumReactor: unique symbol;
+  const impactReactor: unique symbol;
+  const battery: unique symbol;
+  const batteryLarge: unique symbol;
+  const powerNode: unique symbol;
+  const powerNodeLarge: unique symbol;
+  const surgeTower: unique symbol;
+  const diode: unique symbol;
+  const mechanicalDrill: unique symbol;
+  const pneumaticDrill: unique symbol;
+  const laserDrill: unique symbol;
+  const blastDrill: unique symbol;
+  const waterExtractor: unique symbol;
+  const oilExtractor: unique symbol;
+  const cultivator: unique symbol;
+  const coreShard: unique symbol;
+  const coreFoundation: unique symbol;
+  const coreNucleus: unique symbol;
+  const vault: unique symbol;
+  const container: unique symbol;
+  const unloader: unique symbol;
+  const duo: unique symbol;
+  const scatter: unique symbol;
+  const scorch: unique symbol;
+  const hail: unique symbol;
+  const arc: unique symbol;
+  const wave: unique symbol;
+  const lancer: unique symbol;
+  const swarmer: unique symbol;
+  const salvo: unique symbol;
+  const fuse: unique symbol;
+  const ripple: unique symbol;
+  const cyclone: unique symbol;
+  const foreshadow: unique symbol;
+  const spectre: unique symbol;
+  const meltdown: unique symbol;
+  const segment: unique symbol;
+  const parallax: unique symbol;
+  const tsunami: unique symbol;
+  const commandCenter: unique symbol;
+  const groundFactory: unique symbol;
+  const airFactory: unique symbol;
+  const navalFactory: unique symbol;
+  const additiveReconstructor: unique symbol;
+  const multiplicativeReconstructor: unique symbol;
+  const exponentialReconstructor: unique symbol;
+  const tetrativeReconstructor: unique symbol;
+  const repairPoint: unique symbol;
+  const repairTurret: unique symbol;
+  const payloadConveyor: unique symbol;
+  const payloadRouter: unique symbol;
+  const payloadPropulsionTower: unique symbol;
+  const deconstructor: unique symbol;
+  const constructor: unique symbol;
+  const largeConstructor: unique symbol;
+  const payloadLoader: unique symbol;
+  const payloadUnloader: unique symbol;
+  const message: unique symbol;
+  const switchBlock: unique symbol;
+  const microProcessor: unique symbol;
+  const logicProcessor: unique symbol;
+  const hyperProcessor: unique symbol;
+  const largeLogicDisplay: unique symbol;
+  const logicDisplay: unique symbol;
+  const memoryCell: unique symbol;
+  const memoryBank: unique symbol;
+  const launchPad: unique symbol;
+  const interplanetaryAccelerator: unique symbol;
+}
+
+type BlockSymbol = typeof Blocks[keyof typeof Blocks];

package/lib/helpers.d.ts

@@ -0,0 +1,23 @@
+/// <reference path="./kinds.d.ts" />
+
+/**
+ * Allows getting unlisted processor variables or symbols.
+ *
+ * Using this method is discouraged because most values are
+ * already accessible under the namespaces `Units`, `Blocks`,
+ * `Items`, `Liquids`, `ControlKind`, `Vars` and `UnitCommands`.
+ *
+ * @param key The identifier of the value
+ */
+declare function getVar<T>(key: string): T;
+
+/**
+ * Gets a building linked to the processor by its name.
+ *
+ * @param name
+ */
+declare function getBuilding<T extends BasicBuilding = AnyBuilding>(
+  name: string
+): T;
+
+declare function concat(...strings: string[]): string;

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference path="./eslib/index.d.ts" />
+/// <reference path="./commands.d.ts" />
+/// <reference path="./globals.d.ts" />
+/// <reference path="./helpers.d.ts" />
+/// <reference path="./kinds.d.ts" />
+/// <reference path="./memory.d.ts" />
+/// <reference path="./traits.d.ts" />

package/lib/kinds.d.ts

@@ -0,0 +1,36 @@
+/// <reference path="./traits.d.ts" />
+
+interface BasicUnit
+  extends ItemHolder,
+    Shooting,
+    WithHealth,
+    Rotatable,
+    Spaced,
+    Ranged,
+    Typed<UnitSymbol>,
+    Flagged,
+    Controllable,
+    Nameable {}
+
+interface AnyUnit extends BasicUnit, Boosted {}
+
+interface BasicBuilding
+  extends LiquidHolder,
+    ItemHolder,
+    PowerHolder,
+    WithHealth,
+    WithEffiency,
+    WithTimescale,
+    Rotatable,
+    Spaced,
+    Ranged,
+    Typed<BlockSymbol>,
+    WithEnable,
+    WithConfig {}
+
+interface BasicTurret extends BasicBuilding, Shooting, WithProgress {}
+
+// just to make this future proof
+interface AnyTurret extends BasicTurret {}
+
+interface AnyBuilding extends AnyTurret, Heatable {}