mlogjs 0.5.2 → 0.6.0

package/lib/globals.d.ts

@@ -3,6 +3,8 @@
 declare enum ControlKind {
   ctrlPlayer,
   ctrlProcessor,
+  ctrlCommand,
+  /** @deprecated Replaced by ctrlCommand in Mindustry v7 */
   ctrlFormation,
 }
 
@@ -28,22 +30,22 @@ interface Vars {
   readonly ipt: number;
   /** The unit bound to this processor */
   readonly unit: AnyUnit;
-  /** The amount of ticks that happened since the map started*/
+  /** The amount of ticks that happened since the map started */
   readonly tick: number;
-  /** The current UNIX timestamp in milliseconds */
+  /** The amount of milliseconds that passed since the map started */
   readonly time: number;
   /**
    * The amount of seconds that passed since the map started.
    *
-   * This number is NOT an integer, use `Math.floor` to get the number
-   * of whole seconds that already passed.
+   * This number is NOT an integer, use `Math.floor` to get the number of whole
+   * seconds that already passed.
    */
   readonly second: number;
   /**
    * The amount of minutes that passed since the map started.
    *
-   * This number is NOT an integer, use `Math.floor` to get the number
-   * of whole minutes that already passed.
+   * This number is NOT an integer, use `Math.floor` to get the number of whole
+   * minutes that already passed.
    */
   readonly minute: number;
   /** The number of the current wave. Starts at 1. */
@@ -51,22 +53,34 @@ interface Vars {
   /**
    * The amount of seconds left before the next wave.
    *
-   * This number is NOT an integer, use `Math.floor` to get the number
-   * of whole seconds left.
+   * This number is NOT an integer, use `Math.floor` to get the number of whole
+   * seconds left.
    */
   readonly waveTime: number;
-  /** Total amount of items existent, can be used to check if an ID is valid*/
+  /** Total amount of items existent, can be used to check if an ID is valid */
   readonly itemCount: number;
-  /** Total amount of liquids existent, can be used to check if an ID is valid*/
+  /** Total amount of liquids existent, can be used to check if an ID is valid */
   readonly liquidCount: number;
-  /** Total amount of units existent, can be used to check if an ID is valid*/
+  /** Total amount of units existent, can be used to check if an ID is valid */
   readonly unitCount: number;
-  /** Total amount of blocks existent, can be used to check if an ID is valid*/
+  /** Total amount of blocks existent, can be used to check if an ID is valid */
   readonly blockCount: number;
 }
 
 declare const Vars: Vars;
 
+declare enum Align {
+  left,
+  center,
+  right,
+  topLeft,
+  top,
+  topRight,
+  bottomLeft,
+  bottom,
+  bottomRight,
+}
+
 /** Contains the base game teams. */
 declare namespace Teams {
   /** The gray team. */
@@ -92,6 +106,7 @@ declare namespace Teams {
 }
 
 type TeamSymbol = (typeof Teams)[keyof typeof Teams];
+type TeamIdentifier = TeamSymbol | number;
 
 declare namespace Items {
   const copper: unique symbol;
@@ -198,6 +213,8 @@ declare namespace Units {
   const block: unique symbol;
   const manifold: unique symbol;
   const assemblyDrone: unique symbol;
+  const dummy: unique symbol;
+  const missile: unique symbol;
 }
 
 type UnitSymbol = (typeof Units)[keyof typeof Units];
@@ -216,18 +233,49 @@ declare namespace LAccess {
   const powerNetOut: unique symbol;
   const ammo: unique symbol;
   const ammoCapacity: unique symbol;
+  const currentAmmoType: unique symbol;
+  const memoryCapacity: unique symbol;
   const health: unique symbol;
   const maxHealth: unique symbol;
   const heat: unique symbol;
+  const shield: unique symbol;
+  const armor: 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 velocityX: unique symbol;
+  const velocityY: unique symbol;
   const shootX: unique symbol;
   const shootY: unique symbol;
+  /**
+   * Senses the X coordinate of the player camera. Privileged (world) processors
+   * only; evaluates to null on standard processors.
+   */
+  const cameraX: unique symbol;
+  /**
+   * Senses the Y coordinate of the player camera. Privileged (world) processors
+   * only; evaluates to null on standard processors.
+   */
+  const cameraY: unique symbol;
+  /**
+   * Senses the viewport width of the player camera. Privileged (world)
+   * processors only; evaluates to null on standard processors.
+   */
+  const cameraWidth: unique symbol;
+  /**
+   * Senses the viewport height of the player camera. Privileged (world)
+   * processors only; evaluates to null on standard processors.
+   */
+  const cameraHeight: unique symbol;
+  const displayWidth: unique symbol;
+  const displayHeight: unique symbol;
+  const bufferSize: unique symbol;
+  const operations: unique symbol;
   const size: unique symbol;
+  const solid: unique symbol;
   const dead: unique symbol;
   const range: unique symbol;
   const shooting: unique symbol;
@@ -235,20 +283,207 @@ declare namespace LAccess {
   const mineX: unique symbol;
   const mineY: unique symbol;
   const mining: unique symbol;
+  const buildX: unique symbol;
+  const buildY: unique symbol;
+  const building: unique symbol;
+  const breaking: unique symbol;
   const speed: unique symbol;
   const team: unique symbol;
   const type: unique symbol;
   const flag: unique symbol;
+  const flying: unique symbol;
   const controlled: unique symbol;
   const controller: unique symbol;
   const name: unique symbol;
   const payloadCount: unique symbol;
   const payloadType: unique symbol;
+  const totalPayload: unique symbol;
+  const payloadCapacity: unique symbol;
+  const maxUnits: unique symbol;
+  const id: unique symbol;
+  const pingX: unique symbol;
+  const pingY: unique symbol;
+  const pingText: unique symbol;
+  const selectedBlock: unique symbol;
+  const selectedRotation: unique symbol;
+  const bulletLifetime: unique symbol;
+  const bulletTime: unique symbol;
   const enabled: unique symbol;
   const config: unique symbol;
+  /**
+   * Senses, in:
+   *
+   * - Illuminators: the illuminator's light color.
+   * - Buildings: the buildings's team's color.
+   * - Units: the unit's team's color.
+   * - Block symbols: the block's map color.
+   * - Item symbols: the item's color.
+   * - Liquid symbols: the liquid's color.
+   */
   const color: unique symbol;
 }
 
+/** Contains the built-in game colors. */
+declare namespace Colors {
+  const tan: number;
+  const sky: number;
+  const pink: number;
+  const lightgrey: number;
+  const white: number;
+  const lightgray: number;
+  const magenta: number;
+  const salmon: number;
+  const coral: number;
+  const grey: number;
+  const darkgrey: number;
+  const lime: number;
+  const brown: number;
+  const blue: number;
+  const green: number;
+  const teal: number;
+  const forest: number;
+  const black: number;
+  const gold: number;
+  const brick: number;
+  const gray: number;
+  const cyan: number;
+  const royal: number;
+  const violet: number;
+  const yellow: number;
+  const clear: number;
+  const orange: number;
+  const maroon: number;
+  const red: number;
+  const darkgray: number;
+  const navy: number;
+  const scarlet: number;
+  const slate: number;
+  const olive: number;
+  const purple: number;
+  const acid: number;
+  const goldenrod: number;
+  const crimson: number;
+  const accent: number;
+  const unlaunched: number;
+  const highlight: number;
+  const stat: number;
+  const negstat: number;
+}
+
+declare namespace Weathers {
+  const snowing: unique symbol;
+  const rain: unique symbol;
+  const sandstorm: unique symbol;
+  const sporestorm: unique symbol;
+  const fog: unique symbol;
+  const suspendParticles: unique symbol;
+}
+
+interface Sounds {
+  readonly artillery: number;
+  readonly back: number;
+  readonly bang: number;
+  readonly beam: number;
+  readonly bigshot: number;
+  readonly bioLoop: number;
+  readonly blaster: number;
+  readonly bolt: number;
+  readonly boom: number;
+  readonly break: number;
+  readonly build: number;
+  readonly buttonClick: number;
+  readonly cannon: number;
+  readonly chatMessage: number;
+  readonly click: number;
+  readonly combustion: number;
+  readonly conveyor: number;
+  readonly corexplode: number;
+  readonly cutter: number;
+  readonly door: number;
+  readonly drill: number;
+  readonly drillCharge: number;
+  readonly drillImpact: number;
+  readonly dullExplosion: number;
+  readonly electricHum: number;
+  readonly explosion: number;
+  readonly explosionbig: number;
+  readonly extractLoop: number;
+  readonly fire: number;
+  readonly flame: number;
+  readonly flame2: number;
+  readonly flux: number;
+  readonly glow: number;
+  readonly grinding: number;
+  readonly hum: number;
+  readonly largeCannon: number;
+  readonly largeExplosion: number;
+  readonly laser: number;
+  readonly laserbeam: number;
+  readonly laserbig: number;
+  readonly laserblast: number;
+  readonly lasercharge: number;
+  readonly lasercharge2: number;
+  readonly lasershoot: number;
+  readonly machine: number;
+  readonly malignShoot: number;
+  readonly mediumCannon: number;
+  readonly message: number;
+  readonly mineDeploy: number;
+  readonly minebeam: number;
+  readonly missile: number;
+  readonly missileLarge: number;
+  readonly missileLaunch: number;
+  readonly missileSmall: number;
+  readonly missileTrail: number;
+  readonly mud: number;
+  readonly noammo: number;
+  readonly pew: number;
+  readonly place: number;
+  readonly plantBreak: number;
+  readonly plasmaboom: number;
+  readonly plasmadrop: number;
+  readonly press: number;
+  readonly pulse: number;
+  readonly pulseBlast: number;
+  readonly railgun: number;
+  readonly rain: number;
+  readonly release: number;
+  readonly respawn: number;
+  readonly respawning: number;
+  readonly rockBreak: number;
+  readonly sap: number;
+  readonly shield: number;
+  readonly shockBlast: number;
+  readonly shoot: number;
+  readonly shootAlt: number;
+  readonly shootAltLong: number;
+  readonly shootBig: number;
+  readonly shootSmite: number;
+  readonly shootSnap: number;
+  readonly shotgun: number;
+  readonly smelter: number;
+  readonly spark: number;
+  readonly spellLoop: number;
+  readonly splash: number;
+  readonly spray: number;
+  readonly steam: number;
+  readonly techloop: number;
+  readonly thruster: number;
+  readonly titanExplosion: number;
+  readonly torch: number;
+  readonly tractorbeam: number;
+  readonly unlock: number;
+  readonly wave: number;
+  readonly wind: number;
+  readonly wind2: number;
+  readonly wind3: number;
+  readonly windhowl: number;
+}
+
+declare const Sounds: Sounds;
+
+type WeatherSymbol = (typeof Weathers)[keyof typeof Weathers];
+
 interface BuildingSymbolTable {
   readonly graphitePress: unique symbol;
   readonly multiPress: unique symbol;
@@ -454,12 +689,24 @@ interface BuildingSymbolTable {
   readonly tetrativeReconstructor: unique symbol;
   readonly repairPoint: unique symbol;
   readonly repairTurret: unique symbol;
+  readonly tankFabricator: unique symbol;
+  readonly shipFabricator: unique symbol;
+  readonly mechFabricator: unique symbol;
+  readonly tankRefabricator: unique symbol;
+  readonly mechRefabricator: unique symbol;
+  readonly shipRefabricator: unique symbol;
+  readonly primeRefabricator: unique symbol;
+  readonly tankAssembler: unique symbol;
+  readonly shipAssembler: unique symbol;
+  readonly mechAssembler: unique symbol;
+  readonly basicAssemblerModule: unique symbol;
+  readonly unitRepairTower: unique symbol;
   readonly payloadConveyor: unique symbol;
   readonly payloadRouter: unique symbol;
   readonly reinforcedPayloadConveyor: unique symbol;
   readonly reinforcedPayloadRouter: unique symbol;
   readonly payloadMassDriver: unique symbol;
-  readonly payloadPropulsionTower: unique symbol;
+  readonly largePayloadMassDriver: unique symbol;
   readonly smallDeconstructor: unique symbol;
   readonly deconstructor: unique symbol;
   readonly constructor: unique symbol;
@@ -488,15 +735,16 @@ interface BuildingSymbolTable {
   readonly logicDisplay: unique symbol;
   readonly largeLogicDisplay: unique symbol;
   readonly canvas: unique symbol;
+  readonly reinforcedMessage: unique symbol;
   readonly worldProcessor: unique symbol;
   readonly worldCell: unique symbol;
+  readonly worldMessage: unique symbol;
+  readonly worldSwitch: unique symbol;
 }
 
 type BuildingSymbol = Blocks[keyof BuildingSymbolTable];
 
 interface EnvBlockSymbolTable {
-  // used by some instructions to represent any env block
-  readonly solid: EnvBlockSymbolTable["stoneWall"];
   readonly air: unique symbol;
   readonly spawn: unique symbol;
   readonly cliff: unique symbol;
@@ -645,9 +893,52 @@ interface OreSymbolTable {
 type OreSymbol = Blocks[keyof OreSymbolTable];
 
 interface Blocks
-  extends BuildingSymbolTable,
-    EnvBlockSymbolTable,
-    OreSymbolTable {}
+  extends BuildingSymbolTable, EnvBlockSymbolTable, OreSymbolTable {
+  readonly build1: unique symbol;
+  readonly build2: unique symbol;
+  readonly build3: unique symbol;
+  readonly build4: unique symbol;
+  readonly build5: unique symbol;
+  readonly build6: unique symbol;
+  readonly build7: unique symbol;
+  readonly build8: unique symbol;
+  readonly build9: unique symbol;
+  readonly build10: unique symbol;
+  readonly build11: unique symbol;
+  readonly build12: unique symbol;
+  readonly build13: unique symbol;
+  readonly build14: unique symbol;
+  readonly build15: unique symbol;
+  readonly build16: unique symbol;
+}
 
 type BlockSymbol = Blocks[keyof Blocks];
 declare const Blocks: Blocks;
+
+declare namespace StatusEffects {
+  const none: StatusEffectSymbol;
+  const burning: StatusEffectSymbol;
+  const freezing: StatusEffectSymbol;
+  const unmoving: StatusEffectSymbol;
+  const slow: StatusEffectSymbol;
+  const fast: StatusEffectSymbol;
+  const wet: StatusEffectSymbol;
+  const muddy: StatusEffectSymbol;
+  const melting: StatusEffectSymbol;
+  const sapped: StatusEffectSymbol;
+  const tarred: StatusEffectSymbol;
+  const overdrive: StatusEffectSymbol;
+  const overclock: StatusEffectSymbol;
+  const shielded: StatusEffectSymbol;
+  const shocked: StatusEffectSymbol;
+  const blasted: StatusEffectSymbol;
+  const corroded: StatusEffectSymbol;
+  const boss: StatusEffectSymbol;
+  const sporeSlowed: StatusEffectSymbol;
+  const disarmed: StatusEffectSymbol;
+  const electrified: StatusEffectSymbol;
+  const invincible: StatusEffectSymbol;
+  const dynamic: StatusEffectSymbol;
+}
+
+type StatusEffectSymbol = symbol & { readonly __statusEffect: unique symbol };

package/lib/helpers.d.ts

@@ -1,54 +1,88 @@
 /// <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` and `Vars`.
- *
- * @param name The identifier of the value
- */
-declare function getVar<T>(name: string): T;
-
-/**
- * Gets a building linked to the processor by its name.
- *
- * @param name
- */
-declare function getBuilding<T extends BasicBuilding = AnyBuilding>(
-  name: string
-): T;
-
-type ConcatLiteral = string | number | boolean | undefined;
-
-/**
- * Concatenates a list of constant literal values.
- *
- * ```js
- * const name = "example";
- *
- * // works with normal arguments
- * const before = concat("before_", name);
- *
- * // works with tagged template strings
- * const after = concat`after_${name}`;
- * ```
- */
-declare function concat(
-  ...args: ConcatLiteral[] | [TemplateStringsArray, ...ConcatLiteral[]]
-): string;
-
-/**
- * Inlines raw mlog code. Variables and expressions can be placed inside.
- *
- * Although possible, using this function is heavily not recommended since
- * you lose the benefits of getting type cheking and validation for some
- * commands.
- *
- * ```js
- *  let x = 10
- *  asm`ucontrol build ${x} ${x * 2} @router 0 0`
- * ```
- */
-declare function asm(strings: TemplateStringsArray, ...values: unknown[]): void;
+import { TLogicLinkNames } from "mlogjs:types";
+
+declare global {
+  /**
+   * 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`
+   * and `Vars`.
+   *
+   * @param name The identifier of the value
+   */
+  function getVar<T>(name: string): T;
+
+  /**
+   * Gets a building linked to the processor by its name.
+   *
+   * @param name
+   */
+
+  function getBuilding<T extends BasicBuilding = AnyBuilding>(
+    name: TLogicLinkNames<keyof BuildingSymbolTable> | (string & {}),
+  ): T;
+
+  /**
+   * Returns a record of all the buildings linked to this processor.
+   *
+   * The use of this function is preferred if you are assigning buildings to
+   * multiple variables at once.
+   *
+   * ```js
+   * const { switch1: toggle, cell1 } = getBuildings();
+   * ```
+   */
+  function getBuildings<T extends BasicBuilding = AnyBuilding>(): Record<
+    TLogicLinkNames<keyof BuildingSymbolTable> | (string & {}),
+    T
+  >;
+
+  /**
+   * Gets a color literal from a hex code.
+   *
+   * ```js
+   * const color = getColor("0e7eba");
+   *
+   * draw.col(color);
+   * draw.rect({ x: 0, y: 0, width: 500, height: 500 });
+   *
+   * drawFlush();
+   * ```
+   */
+  function getColor(hexCode: string): number;
+
+  type ConcatLiteral = string | number | boolean | undefined;
+
+  /**
+   * Concatenates a list of constant literal values.
+   *
+   * ```js
+   * const name = "example";
+   *
+   * // works with normal arguments
+   * const before = concat("before_", name);
+   *
+   * // works with tagged template strings
+   * const after = concat`after_${name}`;
+   * ```
+   */
+  function concat(
+    ...args: ConcatLiteral[] | [TemplateStringsArray, ...ConcatLiteral[]]
+  ): string;
+
+  /**
+   * Inlines raw mlog code. Variables and expressions can be placed inside.
+   *
+   * Although possible, using this function is heavily not recommended since you
+   * lose the benefits of getting type cheking and validation for some
+   * commands.
+   *
+   * ```js
+   * let x = 10;
+   * asm`ucontrol build ${x} ${x * 2} @router 0 0`;
+   * ```
+   */
+  function asm(strings: TemplateStringsArray, ...values: unknown[]): void;
+}

package/lib/kinds.d.ts

@@ -1,24 +1,34 @@
 /// <reference path="./traits.d.ts" />
 
 interface BasicUnit
-  extends ItemHolder,
+  extends
+    ItemHolder,
     Shooting,
     WithHealth,
+    WithShield,
     Rotatable,
     Spaced,
     Ranged,
+    Mining,
+    WithBuild,
+    Flying,
     Typed<UnitSymbol>,
     Flagged,
-    Controllable,
+    Controlled,
+    WithController,
     Nameable,
+    PayloadHolder,
     WithSpeed,
     WithColor,
-    WithTeam {}
+    WithTeam,
+    WithArmor,
+    WithVelocity {}
 
-interface AnyUnit extends BasicUnit, Boosted {}
+interface AnyUnit extends BasicUnit, Boosted, WithCamera {}
 
 interface BasicBuilding
-  extends LiquidHolder,
+  extends
+    LiquidHolder,
     ItemHolder,
     PowerHolder,
     WithHealth,
@@ -28,14 +38,39 @@ interface BasicBuilding
     Spaced,
     Ranged,
     Typed<BuildingSymbol>,
+    Controlled,
+    PayloadHolder,
     WithEnable,
     WithConfig,
     WithColor,
-    WithTeam {}
+    WithTeam,
+    WithSolid,
+    WithMaxUnits {}
 
 interface BasicTurret extends BasicBuilding, Shooting, WithProgress {}
 
 // just to make this future proof
 interface AnyTurret extends BasicTurret {}
 
-interface AnyBuilding extends AnyTurret, Heatable {}
+interface AnyBuilding
+  extends
+    AnyTurret,
+    Heatable,
+    WithShield,
+    WithMemory,
+    WithBufferSize,
+    WithDisplay,
+    WithOperations {}
+
+interface Bullet
+  extends
+    Rotatable,
+    WithHealth,
+    Spaced,
+    WithVelocity,
+    WithTeam,
+    Ranged,
+    WithAim,
+    WithSpeed,
+    WithColor,
+    WithBulletTime {}