mlogjs 0.4.10 → 0.5.1

package/lib/commands.d.ts

@@ -45,6 +45,18 @@ declare global {
      */
     function color(r: number, g: number, b: number, a?: number): void;
 
+    /**
+     * Sets the color for the next drawing operations.
+     *
+     * Uses compressed rgba data from `packColor`.
+     *
+     * ```js
+     * draw.col(packColor(1, 1, 1, 1));
+     * ```
+     *
+     */
+    function col(rgbaData: number): void;
+
     /**
      * Sets the width of the next lines to be drawn.
      *
@@ -256,7 +268,7 @@ declare global {
    * Example:
    * ```js
    * if(index < Vars.links) {
-   *   let myBlock = getLink(index)
+   *   const myBlock = getLink(index)
    *   // ...
    * }
    * ```
@@ -344,20 +356,13 @@ declare global {
     /**
      * Sets the color of an illuminator.
      *
-     * The RGB values must be within the range: [0, 255].
-     *
      *  ```js
      *  const illuminator = getBuilding("illuminator1");
      *
-     *  control.color(illuminator, 10, 150, 210);
+     *  control.color(illuminator, packColor(0.2, 0.65, 1, 1));
      *  ```
      */
-    function color(
-      building: BasicBuilding,
-      r: number,
-      g: number,
-      b: number
-    ): void;
+    function color(building: BasicBuilding, rgbaData: number): void;
   }
 
   /**
@@ -400,12 +405,12 @@ declare global {
    *
    * Example:
    *  ```ts
-   *  let myBuilding = getBuilding("container1");
+   *  const myBuilding = getBuilding("container1");
    *
    *  // typescript annotation, you can use jsdoc comments on
    *  // regular javascript
-   *  let myCustomSymbol = getVar<symbol>("@custom-symbol"); // problably defined by a mod
-   *  let result = sensor(myCustomSymbol, myBuilding);
+   *  const myCustomSymbol = getVar<symbol>("@custom-symbol"); // problably defined by a mod
+   *  const result = sensor(myCustomSymbol, myBuilding);
    *  ```
    */
   function sensor<T>(property: symbol, target: BasicBuilding | BasicUnit): T;
@@ -432,7 +437,7 @@ declare global {
      * Example:
      * ```js
      * if(index < Vars.blockCount) {
-     *   let blockKind = lookup.block(index);
+     *   const blockKind = lookup.block(index);
      * }
      * ```
      */
@@ -446,11 +451,11 @@ declare global {
      * Example:
      * ```js
      * if(index < Vars.unitCount) {
-     *   let unitKind = lookup.unit(index);
+     *   const unitKind = lookup.unit(index);
      * }
      * ```
      */
-    function unit(index: number): UnitSymbol | null;
+    function unit(index: number): UnitSymbol | undefined;
 
     /**
      * Looks up an item symbol by it's index on the content registry.
@@ -460,11 +465,11 @@ declare global {
      * Example:
      * ```js
      * if(index < Vars.itemCount) {
-     *   let itemKind = lookup.item(index);
+     *   const itemKind = lookup.item(index);
      * }
      * ```
      */
-    function item(index: number): ItemSymbol | null;
+    function item(index: number): ItemSymbol | undefined;
 
     /**
      * Looks up a liquid symbol by it's index on the content registry.
@@ -474,11 +479,11 @@ declare global {
      * Example:
      * ```js
      * if(index < Vars.liquidCount) {
-     *   let liquidKind = lookup.liquid(index);
+     *   const liquidKind = lookup.liquid(index);
      * }
      * ```
      */
-    function liquid(index: number): LiquidSymbol | null;
+    function liquid(index: number): LiquidSymbol | undefined;
   }
 
   /**
@@ -491,7 +496,12 @@ declare global {
    *  const colorData = packColor(0.1, 0.6, 0.8, 0.1);
    *
    *  // world processor only
+   *  // sets the color of the ambient light
    *  setRule.ambientLight(colorData);
+   *
+   *  // set color of illuminator
+   *  const illuminator = getBuilding("illuminator1");
+   *  control.color(illuminator, packColor(0.2, 0.65, 1, 1));
    *  ```
    */
   function packColor(r: number, g: number, b: number, a: number): number;
@@ -499,6 +509,11 @@ declare global {
   /**
    * Binds an unit to the this processor. The unit is accessible at `Vars.unit`.
    *
+   * If an unit symbol is received, the processor will pick an
+   * unit of the given type.
+   *
+   * If an unit object is received, the processor will bind to the unit.
+   *
    *  ```js
    *  unitBind(Units.flare);
    *
@@ -508,7 +523,7 @@ declare global {
    *  printFlush();
    *  ```
    */
-  function unitBind(type: UnitSymbol): void;
+  function unitBind(unit: UnitSymbol | BasicUnit): void;
 
   namespace unitControl {
     /**
@@ -694,12 +709,24 @@ declare global {
     function getBlock<T extends BasicBuilding = AnyBuilding>(
       x: number,
       y: number
-    ): [type: BlockSymbol | null, building: T | null];
+    ): [
+      type: BlockSymbol | undefined,
+      building: T | undefined,
+      floor: EnvBlockSymbol | OreSymbol | undefined
+    ];
 
     /**
      * Checks if the unit bound to this processor is within a radius of a given position.
      */
     function within(options: { x: number; y: number; radius: number }): boolean;
+
+    /**
+     * Resets the AI of the unit.
+     *
+     * Calling `unbind` does not actually unbind the unit from the processor,
+     * it just makes the unit resume its natural behavior.
+     */
+    function unbind(): void;
   }
 
   /**
@@ -869,11 +896,11 @@ declare global {
     /** Gets the block type on the give location. `Blocks.air` if there is no block. */
     function block(x: number, y: number): BlockSymbol;
 
-    /** Gets the building on the given location. `null` if there is no building. */
+    /** Gets the building on the given location. `undefined` if there is no building. */
     function building<T extends BasicBuilding = AnyBuilding>(
       x: number,
       y: number
-    ): T | null;
+    ): T | undefined;
   }
 
   /**  Sets block data on a given location. World processor ONLY.  */
@@ -1104,7 +1131,7 @@ declare global {
      * The index starts at 0.
      *
      * ```js
-     *  const count = fetch.unitCount();
+     *  const count = fetch.unitCount(Teams.sharded);
      *  for(let i = 0; i < count; i++) {
      *    const unit = fetch.unit(Teams.sharded, i);
      *    print`x: ${unit.x}, y: ${unit.y}\n`;
@@ -1120,7 +1147,7 @@ declare global {
      *  Gets the amount of units existing on a given team.
      *
      * ```js
-     *  const count = fetch.unitCount();
+     *  const count = fetch.unitCount(Teams.sharded);
      *  for(let i = 0; i < count; i++) {
      *    const unit = fetch.unit(Teams.sharded, i);
      *    print`x: ${unit.x}, y: ${unit.y}\n`;
@@ -1135,7 +1162,7 @@ declare global {
      * The index starts at 0.
      *
      * ```js
-     *  const count = fetch.playerCount();
+     *  const count = fetch.playerCount(Teams.sharded);
      *  for(let i = 0; i < count; i++) {
      *    const player = fetch.player(Teams.sharded, i);
      *    print`x: ${player.x}, y: ${player.y}\n`;
@@ -1151,7 +1178,7 @@ declare global {
      * Gets the amount of players existing on a given team.
      *
      * ```js
-     *  const count = fetch.playerCount();
+     *  const count = fetch.playerCount(Teams.sharded);
      *  for(let i = 0; i < count; i++) {
      *    const player = fetch.player(Teams.sharded, i);
      *    print`x: ${player.x}, y: ${player.y}\n`;
@@ -1166,7 +1193,7 @@ declare global {
      * The index of the starts at 0.
      *
      * ```js
-     *  const count = fetch.coreCount();
+     *  const count = fetch.coreCount(Teams.sharded);
      *  for(let i = 0; i < count; i++) {
      *    const core = fetch.core(Teams.sharded, i);
      *    print`x: ${core.x}, y: ${core.y}\n`;
@@ -1178,7 +1205,7 @@ declare global {
     /**
      * Gets the amount of cores existing on a given team.
      * ```js
-     *  const count = fetch.coreCount();
+     *  const count = fetch.coreCount(Teams.sharded);
      *  for(let i = 0; i < count; i++) {
      *    const core = fetch.core(Teams.sharded, i);
      *    print`x: ${core.x}, y: ${core.y}\n`;
@@ -1193,7 +1220,7 @@ declare global {
      * The index starts at 0.
      *
      * ```js
-     *  const count = fetch.buildCount();
+     *  const count = fetch.buildCount(Teams.sharded, Blocks.router);
      *  for(let i = 0; i < count; i++) {
      *    const router = fetch.build(Teams.sharded, i, Blocks.router);
      *    print`x: ${router.x}, y: ${router.y}\n`;
@@ -1210,7 +1237,7 @@ declare global {
      * Gets the amount of buildings existing on a given team.
      *
      * ```js
-     *  const count = fetch.buildCount();
+     *  const count = fetch.buildCount(Teams.sharded, Blocks.router);
      *  for(let i = 0; i < count; i++) {
      *    const router = fetch.build(Teams.sharded, i, Blocks.router)
      *    print`x: ${router.x}, y: ${router.y}\n`

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

@@ -135,11 +135,22 @@ interface Math {
    */
   log10(x: number): number;
 
+  /** Returns the sine of an angle in degrees.*/
   sin(x: number): number;
+
+  /** Returns the cosine of an angle in degrees */
   cos(x: number): number;
+
+  /** Returns the tangent of an angle in degrees */
   tan(x: number): number;
+
+  /**Returns the greatest integer less than or equal to `x` */
   floor(x: number): number;
+
+  /**Returns the smallest integer greater than or equal to `x` */
   ceil(x: number): number;
+
+  /** Returns the positive square root of a number */
   sqrt(x: number): number;
 
   /**
@@ -147,6 +158,31 @@ interface Math {
    * @param range
    */
   rand(range: number): number;
+
+  /** Returns the arc sine of a number, in degrees */
+  asin(x: number): number;
+
+  /** Returns the arc cosine of a number, in degrees */
+  acos(x: number): number;
+
+  /** Returns the arc tangent of a number, in degrees */
+  atan(x: number): number;
+
+  /**
+   * Returns the integer result of the division: `x / y`.
+   *
+   * @param x
+   * @param y
+   */
+  idiv(x: number, y: number): number;
+
+  /**
+   * Returns the value of a base expression taken to a specified power.
+   *
+   * @param x The base value of the expression.
+   * @param y The exponent value of the expression.
+   */
+  pow(x: number, y: number): number;
 }
 declare const Math: Math;
 

package/lib/globals.d.ts

@@ -70,7 +70,7 @@ declare const Vars: Vars;
 /** Contains the base game teams. */
 declare namespace Teams {
   /** The gray team. */
-  const delerict: unique symbol;
+  const derelict: unique symbol;
   /** The yellow team. */
   const sharded: unique symbol;
   /** The red team. */
@@ -91,7 +91,7 @@ declare namespace Teams {
   const blue: unique symbol;
 }
 
-type TeamSymbol = typeof Teams[keyof typeof Teams];
+type TeamSymbol = (typeof Teams)[keyof typeof Teams];
 
 declare namespace Items {
   const copper: unique symbol;
@@ -118,7 +118,7 @@ declare namespace Items {
   const dormantCyst: unique symbol;
 }
 
-type ItemSymbol = typeof Items[keyof typeof Items];
+type ItemSymbol = (typeof Items)[keyof typeof Items];
 
 declare namespace Liquids {
   const water: unique symbol;
@@ -134,7 +134,7 @@ declare namespace Liquids {
   const cyanogen: unique symbol;
 }
 
-type LiquidSymbol = typeof Liquids[keyof typeof Liquids];
+type LiquidSymbol = (typeof Liquids)[keyof typeof Liquids];
 
 declare namespace Units {
   const dagger: unique symbol;
@@ -200,7 +200,7 @@ declare namespace Units {
   const assemblyDrone: unique symbol;
 }
 
-type UnitSymbol = typeof Units[keyof typeof Units];
+type UnitSymbol = (typeof Units)[keyof typeof Units];
 
 declare namespace LAccess {
   const totalItems: unique symbol;

package/lib/helpers.d.ts

@@ -20,8 +20,24 @@ declare function getBuilding<T extends BasicBuilding = AnyBuilding>(
   name: string
 ): T;
 
-/** Concatenates a list of constant strings */
-declare function concat(...strings: string[]): string;
+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.

package/lib/index.d.ts

@@ -3,5 +3,5 @@
 /// <reference path="./globals.d.ts" />
 /// <reference path="./helpers.d.ts" />
 /// <reference path="./kinds.d.ts" />
-/// <reference path="./memory.d.ts" />
+/// <reference path="./macros.d.ts" />
 /// <reference path="./traits.d.ts" />

package/lib/macros.d.ts

@@ -0,0 +1,150 @@
+/// <reference path="./kinds.d.ts" />
+
+type MemoryCapacity = 64 | 128 | 512;
+/**
+ * Allows you to view and modify the data of memory cells and memory banks.
+ */
+declare class Memory<S extends MemoryCapacity = 64> {
+  constructor(cell: BasicBuilding, size?: S);
+
+  [Symbol.iterator](): IterableIterator<number>;
+  [index: number]: number;
+
+  /**
+   * The practical length of the memory view.
+   */
+  readonly length: S;
+}
+
+/**
+ * Creates a mutable, dynamic access array, the length is constant.
+ *
+ * The instructions for dynamic accesses
+ */
+declare class MutableArray<T> {
+  /**
+   * Creates an array with fixed size that supports dynamic index accesses.
+   *
+   * The array can contain any value assignable to a store.
+   */
+  constructor(init: readonly T[]);
+  constructor(length: number);
+
+  [index: number]: T;
+
+  /** Fills the array with a given value */
+  fill(value: T): void;
+
+  /**
+   * Returns the item at the given index. Negative indexes are relative to `this.size`.
+   *
+   * ```js
+   * print(array.at(-1)); // equal to array[array.size - 1]
+   * ```
+   */
+  at(index: number): T;
+
+  /** The number of items preallocated for this array */
+  readonly size: number;
+
+  [Symbol.iterator](): IterableIterator<T>;
+}
+
+declare class DynamicArray<T> extends MutableArray<T> {
+  /**
+   * Creates an array with a predefined capacity that supports dynamic index accesses.
+   *
+   * The array can contain any value assignable to a store.
+   */
+  constructor(init: readonly T[]);
+  constructor(length: number);
+
+  /**
+   * Sets the last item of the array to `undefined` and decreases its length by 1.
+   *
+   * This method only generates the instructions for getting the value when needed.
+   *
+   * You can use `unchecked` to skip the bound check.
+   *
+   * ```js
+   * array.pop(); // doesn't generate getter instructions
+   * print(array.pop()); // generates getter instructions
+   * unchecked(array.pop()); // doesn't check the array length
+   * ```
+   */
+  pop(): T;
+  /**
+   * Adds the given item to the end of the array.
+   *
+   * If the array is full, the proccess is skipped.
+   *
+   * You can use `unchecked` to skip the length check.
+   *
+   * ```js
+   * // only do this if you know the array isn't full
+   * unchecked(array.push(Items.copper));
+   *
+   * array.push(Items.beryllium);
+   * ```
+   */
+  push(item: T): void;
+
+  /**
+   * Removes the item at the given index.
+   *
+   * This method only generates the instructions for getting the value when needed.
+   *
+   * The index must be within the range: [`0`, `this.length - 1`]
+   *
+   * You can use `unchecked` to skip the bound check.
+   *
+   * ```js
+   *
+   * let a = array.removeAt(i); // generates getter instructions
+   * array.removeAt(i); // doesn't generate getter instructions
+   *
+   * // only do this if you know the index is valid
+   * unchecked(array.removeAt(i));
+   * ```
+   */
+  removeAt(index: number): T;
+
+  /**
+   * Returns the item at the given index. Negative indexes are relative to `this.length`.
+   *
+   * ```js
+   * print(array.at(-1)); // equal to array[array.length - 1]
+   * ```
+   */
+  at(index: number): T;
+
+  /** The current length of the array, it can't be directly modified by the user. */
+  get length(): number;
+}
+
+/**
+ * A function that tells the compiler not to add
+ * bound checking in the array accesses in the given expression.
+ *
+ * Only access that are computed inside the call are unchecked:
+ *
+ * ```js
+ * // checked
+ * const a = array[i]
+ * // unckecked
+ * const b = unchecked(array[i])
+ *
+ * // the array accesses inside `doSomething`
+ * // are NOT unchecked
+ * unchecked(doSomething(i))
+ *
+ * // only `array[i * 2]` is unchecked
+ * const c = unchecked(doSomething(i) * array[i * 2])
+ *
+ * function doSomething(i) {
+ *     // will always be checked
+ *     return (array[i - 1] + array[i + 1]) / 2
+ * }
+ * ```
+ */
+declare function unchecked<T>(expression: T): T;

package/lib/traits.d.ts

@@ -23,7 +23,7 @@ declare global {
         readonly [I in keyof typeof Items]: number;
       } & {
         readonly totalItems: number;
-        readonly firstItem: ItemSymbol | null;
+        readonly firstItem?: ItemSymbol;
         readonly itemCapacity: number;
       }
     > {}
@@ -93,7 +93,7 @@ declare global {
 
   interface Boosted
     extends WithSymbols<{
-      readonly boosting: number;
+      readonly boosting: boolean;
     }> {}
 
   interface Mining
@@ -120,13 +120,13 @@ declare global {
 
   interface Nameable
     extends WithSymbols<{
-      readonly name: string | null;
+      readonly name?: string;
     }> {}
 
   interface PayloadHolder
     extends WithSymbols<{
       readonly payloadCount: number;
-      readonly payloadType: symbol | null;
+      readonly payloadType?: symbol;
     }> {}
 
   interface WithEnable
@@ -134,7 +134,7 @@ declare global {
       enabled: boolean;
     }> {}
   interface WithConfig<
-    T extends symbol | number | null = symbol | null
+    T extends symbol | number | undefined = symbol | undefined
   > extends WithSymbols<{
       readonly config: T;
     }> {}

package/package.json

@@ -1,11 +1,22 @@
 {
   "name": "mlogjs",
-  "version": "0.4.10",
+  "version": "0.5.1",
   "description": "Compiler that compiles Javascript to Mindustry Logic Code.",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
   "bin": "./dist/bin.cjs",
   "types": "./dist/index.d.ts",
+  "scripts": {
+    "clean": "rm -rf ../docs dist build",
+    "build": "rollup -c",
+    "build:dev": "rollup -c --environment DEV",
+    "dev": "ts-node src/bin",
+    "test": "jest",
+    "lint": "eslint src/**/*.ts",
+    "coverage": "jest --coverage",
+    "start": "pnpm run build && pnpm i -g . && mlogjs",
+    "prepublishOnly": "pnpm run build"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/weisrc/mlogjs.git"
@@ -17,28 +28,31 @@
     "url": "https://github.com/weisrc/mlogjs/issues"
   },
   "homepage": "https://github.com/weisrc/mlogjs#readme",
+  "engines": {
+    "node": ">=16"
+  },
   "dependencies": {
-    "@babel/parser": "^7.20.0",
-    "@babel/types": "^7.20.0",
+    "@babel/parser": "^7.20.7",
+    "@babel/types": "^7.20.7",
     "chalk": "^4.1.2",
     "cli-highlight": "^2.1.11",
-    "yargs": "^17.0.1"
+    "yargs": "^17.6.2"
   },
   "devDependencies": {
     "@rollup/plugin-alias": "^4.0.2",
-    "@rollup/plugin-typescript": "^9.0.2",
-    "@types/jest": "^29.0.3",
-    "@types/node": "^15.14.9",
-    "@types/yargs": "^17.0.13",
-    "@typescript-eslint/eslint-plugin": "^5.38.0",
-    "@typescript-eslint/parser": "^5.38.0",
-    "eslint": "^8.24.0",
-    "jest": "^29.0.3",
+    "@rollup/plugin-typescript": "^11.0.0",
+    "@types/jest": "^29.2.5",
+    "@types/node": "^16.18.10",
+    "@types/yargs": "^17.0.19",
+    "@typescript-eslint/eslint-plugin": "^5.48.2",
+    "@typescript-eslint/parser": "^5.48.2",
+    "eslint": "^8.32.0",
+    "jest": "^29.3.1",
     "npm-run-all": "^4.1.5",
-    "rollup": "^3.2.3",
-    "ts-jest": "^29.0.2",
+    "rollup": "^3.10.0",
+    "ts-jest": "^29.0.5",
     "ts-node": "^10.9.1",
-    "tslib": "^2.3.1",
+    "tslib": "^2.4.1",
     "typescript": "*"
   },
   "files": [
@@ -47,15 +61,5 @@
     "lib",
     "LICENSE",
     "README.md"
-  ],
-  "scripts": {
-    "clean": "rm -rf ../docs dist build",
-    "build": "rollup -c",
-    "build:dev": "rollup -c --environment DEV",
-    "dev": "ts-node src/bin",
-    "test": "jest",
-    "lint": "eslint src/**/*.ts",
-    "coverage": "jest --coverage",
-    "start": "pnpm run build && pnpm i -g . && mlogjs"
-  }
-}
+  ]
+}