landlord-ts 1.0.2

package/dist/simulation-worker.cjs

@@ -0,0 +1,208 @@
+"use strict";
+
+// src/simulation-worker.ts
+var import_node_fs = require("fs");
+var import_node_worker_threads = require("worker_threads");
+
+// src/card/types.ts
+function isLandKind(kind) {
+  return kind === "BasicLand" /* BasicLand */ || kind === "ShockLand" /* ShockLand */ || kind === "CheckLand" /* CheckLand */ || kind === "TapLand" /* TapLand */ || kind === "FastLand" /* FastLand */ || kind === "SlowLand" /* SlowLand */ || kind === "BattleLand" /* BattleLand */ || kind === "TurnLand" /* TurnLand */ || kind === "SurveilLand" /* SurveilLand */ || kind === "BounceLand" /* BounceLand */ || kind === "TriomeLand" /* TriomeLand */ || kind === "CyclingLand" /* CyclingLand */ || kind === "PainLand" /* PainLand */ || kind === "FetchLand" /* FetchLand */ || kind === "CanopyLand" /* CanopyLand */ || kind === "PathwayLand" /* PathwayLand */ || kind === "OtherLand" /* OtherLand */ || kind === "ForcedLand" /* ForcedLand */;
+}
+function isLand(card) {
+  return isLandKind(card.kind);
+}
+
+// src/card/land-types.ts
+var BasicLandType = {
+  Plains: 1 << 0,
+  Island: 1 << 1,
+  Swamp: 1 << 2,
+  Mountain: 1 << 3,
+  Forest: 1 << 4
+};
+var TYPE_NAME_TO_BIT = [
+  ["plains", BasicLandType.Plains],
+  ["island", BasicLandType.Island],
+  ["swamp", BasicLandType.Swamp],
+  ["mountain", BasicLandType.Mountain],
+  ["forest", BasicLandType.Forest]
+];
+
+// src/hand.ts
+function simCardFromCard(card) {
+  return {
+    hash: card.hash,
+    kind: card.kind,
+    manaCost: { ...card.manaCost },
+    basicLandTypes: card.basicLandTypes ?? 0,
+    checkTypes: card.checkTypes ?? 0,
+    manaPerTap: card.manaPerTap ?? 1
+  };
+}
+function handFromOpeningAndDraws(opening, draws, startingHandSize = 7) {
+  const cards = [];
+  for (const card of opening) cards.push(simCardFromCard(card));
+  for (const card of draws) cards.push(simCardFromCard(card));
+  const openingHandSize = opening.length;
+  return {
+    cards,
+    startingHandSize,
+    openingHandSize,
+    mulliganCount: startingHandSize - openingHandSize
+  };
+}
+function handFromMulligan(mulligan, rng, deck, draws) {
+  return mulligan.simulateHand(rng, deck, draws);
+}
+
+// src/mulligan/types.ts
+function createMulberry32(seed) {
+  let t = seed >>> 0;
+  return {
+    genRange(min, max) {
+      t = t + 1831565813 >>> 0;
+      let r = Math.imul(t ^ t >>> 15, 1 | t);
+      r ^= r + Math.imul(r ^ r >>> 7, 61 | r);
+      const u = ((r ^ r >>> 14) >>> 0) / 4294967296;
+      return min + Math.floor(u * (max - min));
+    }
+  };
+}
+function partialShuffle(slice, rng, amount) {
+  const n = Math.min(amount, slice.length);
+  for (let i = 0; i < n; i++) {
+    const j = rng.genRange(i, slice.length);
+    const tmp = slice[i];
+    slice[i] = slice[j];
+    slice[j] = tmp;
+  }
+  return slice.slice(0, n);
+}
+
+// src/mulligan/london.ts
+var STARTING_HAND_SIZE = 7;
+function londonNever() {
+  return {
+    startingHandSize: STARTING_HAND_SIZE,
+    mulliganDownTo: STARTING_HAND_SIZE,
+    mulliganOnLands: /* @__PURE__ */ new Set(),
+    acceptableHandList: []
+  };
+}
+function londonSimulateHand(self, rng, deck, draws) {
+  const deckSize = deck.length;
+  const startingHandSize = Math.min(self.startingHandSize, deckSize);
+  const mulliganDownTo = Math.min(self.mulliganDownTo, startingHandSize);
+  const maxMulliganRounds = startingHandSize - mulliganDownTo + 1;
+  const cardsToDraw = Math.min(startingHandSize + draws + maxMulliganRounds, deckSize);
+  const indexRange = Array.from({ length: deckSize }, (_, i) => i);
+  const mustKeepCardIndices = [];
+  const seenCardHashes = /* @__PURE__ */ new Set();
+  for (let round = 0; round < maxMulliganRounds; round++) {
+    const shuffledIndices2 = partialShuffle(indexRange.slice(), rng, cardsToDraw);
+    const shuffledDeck2 = shuffledIndices2.map((i) => deck[i]);
+    const startingHand = shuffledDeck2.slice(0, startingHandSize);
+    const isLastRound = round === maxMulliganRounds - 1;
+    let landCount = 0;
+    for (const c of startingHand) {
+      if (isLand(c)) landCount += 1;
+    }
+    const sufficientLandCount = !self.mulliganOnLands.has(landCount);
+    if (!isLastRound && !sufficientLandCount) continue;
+    let foundAcceptableHand = false;
+    for (const acceptableHand of self.acceptableHandList) {
+      mustKeepCardIndices.length = 0;
+      seenCardHashes.clear();
+      for (let i = 0; i < startingHand.length; i++) {
+        const card = startingHand[i];
+        if (seenCardHashes.has(card.hash)) continue;
+        if (acceptableHand.has(card.hash)) mustKeepCardIndices.push(i);
+        seenCardHashes.add(card.hash);
+      }
+      foundAcceptableHand = mustKeepCardIndices.length === acceptableHand.size;
+      if (foundAcceptableHand) break;
+    }
+    const disregardFoundAcceptableHand = self.acceptableHandList.length === 0;
+    const keep = isLastRound || sufficientLandCount && (disregardFoundAcceptableHand || foundAcceptableHand);
+    if (!keep) continue;
+    const openingHandSize = startingHandSize - round;
+    let landsSaved = 0;
+    for (let i = 0; i < startingHand.length; i++) {
+      const card = startingHand[i];
+      if (!isLandKind(card.kind)) continue;
+      const needMoreLands = self.mulliganOnLands.has(landsSaved) && landsSaved < openingHandSize;
+      if (needMoreLands) {
+        mustKeepCardIndices.push(i);
+        landsSaved += 1;
+      } else {
+        break;
+      }
+    }
+    mustKeepCardIndices.sort((a, b) => a - b);
+    {
+      let w = 0;
+      for (let r = 0; r < mustKeepCardIndices.length; r++) {
+        if (r === 0 || mustKeepCardIndices[r] !== mustKeepCardIndices[r - 1]) {
+          mustKeepCardIndices[w++] = mustKeepCardIndices[r];
+        }
+      }
+      mustKeepCardIndices.length = w;
+    }
+    for (let i = 0; i < mustKeepCardIndices.length; i++) {
+      const mustKeepI = mustKeepCardIndices[i];
+      const tmp = shuffledDeck2[i];
+      shuffledDeck2[i] = shuffledDeck2[mustKeepI];
+      shuffledDeck2[mustKeepI] = tmp;
+    }
+    let discardCount = 0;
+    for (let i = openingHandSize; i < startingHandSize; i++) {
+      const j = cardsToDraw - 1 - discardCount;
+      const tmp = shuffledDeck2[i];
+      shuffledDeck2[i] = shuffledDeck2[j];
+      shuffledDeck2[j] = tmp;
+      discardCount += 1;
+    }
+    return handFromOpeningAndDraws(
+      shuffledDeck2.slice(0, openingHandSize),
+      shuffledDeck2.slice(openingHandSize),
+      startingHandSize
+    );
+  }
+  const shuffledIndices = partialShuffle(indexRange.slice(), rng, cardsToDraw);
+  const shuffledDeck = shuffledIndices.map((i) => deck[i]);
+  return handFromOpeningAndDraws(
+    shuffledDeck.slice(0, startingHandSize),
+    shuffledDeck.slice(startingHandSize),
+    startingHandSize
+  );
+}
+function asLondonMulligan(london) {
+  return {
+    simulateHand: (rng, deck, draws) => londonSimulateHand(london, rng, deck, draws)
+  };
+}
+
+// src/simulation-worker.ts
+var payload = import_node_worker_threads.workerData;
+try {
+  const london = londonNever();
+  london.startingHandSize = payload.startingHandSize;
+  london.mulliganDownTo = payload.mulliganDownTo;
+  london.mulliganOnLands = new Set(payload.mulliganOnLands);
+  london.acceptableHandList = payload.acceptableHandList.map((row) => new Set(row));
+  const mulligan = asLondonMulligan(london);
+  const rng = createMulberry32(payload.seed);
+  const deck = payload.deck;
+  const hands = [];
+  for (let i = 0; i < payload.runCount; i++) {
+    hands.push(handFromMulligan(mulligan, rng, deck, payload.drawCount));
+  }
+  (0, import_node_fs.writeFileSync)(payload.outFile, JSON.stringify(hands));
+  const statuses = new Int32Array(payload.sab);
+  Atomics.store(statuses, payload.statusIndex, 1);
+  Atomics.notify(statuses, payload.statusIndex);
+} catch {
+  const statuses = new Int32Array(payload.sab);
+  Atomics.store(statuses, payload.statusIndex, -1);
+  Atomics.notify(statuses, payload.statusIndex);
+}

package/dist/simulation-worker.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/simulation-worker.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/simulation-worker.js

@@ -0,0 +1,33 @@
+import {
+  asLondonMulligan,
+  createMulberry32,
+  handFromMulligan,
+  londonNever
+} from "./chunk-I6ETCO5F.js";
+
+// src/simulation-worker.ts
+import { writeFileSync } from "fs";
+import { workerData } from "worker_threads";
+var payload = workerData;
+try {
+  const london = londonNever();
+  london.startingHandSize = payload.startingHandSize;
+  london.mulliganDownTo = payload.mulliganDownTo;
+  london.mulliganOnLands = new Set(payload.mulliganOnLands);
+  london.acceptableHandList = payload.acceptableHandList.map((row) => new Set(row));
+  const mulligan = asLondonMulligan(london);
+  const rng = createMulberry32(payload.seed);
+  const deck = payload.deck;
+  const hands = [];
+  for (let i = 0; i < payload.runCount; i++) {
+    hands.push(handFromMulligan(mulligan, rng, deck, payload.drawCount));
+  }
+  writeFileSync(payload.outFile, JSON.stringify(hands));
+  const statuses = new Int32Array(payload.sab);
+  Atomics.store(statuses, payload.statusIndex, 1);
+  Atomics.notify(statuses, payload.statusIndex);
+} catch {
+  const statuses = new Int32Array(payload.sab);
+  Atomics.store(statuses, payload.statusIndex, -1);
+  Atomics.notify(statuses, payload.statusIndex);
+}

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "landlord-ts",
+  "version": "1.0.2",
+  "description": "Monte Carlo MTG on-curve simulator (TypeScript port of landlord)",
+  "license": "MIT",
+  "type": "module",
+  "author": "Lacy Garrison",
+  "keywords": [
+    "mtg",
+    "magic-the-gathering",
+    "mana",
+    "mulligan",
+    "simulation",
+    "landlord-ts"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lggarrison/landlord-ts.git"
+  },
+  "homepage": "https://github.com/lggarrison/landlord-ts#readme",
+  "bugs": {
+    "url": "https://github.com/lggarrison/landlord-ts/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "data",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "card-update": "tsx scripts/card-update.ts",
+    "mine-etb": "tsx scripts/mine-etb.ts",
+    "release:check": "npm-run-all format:check lint test build wiki:lint wiki:check",
+    "prepare": "node .husky/install.mjs",
+    "prepublishOnly": "npm run release:check",
+    "wiki:help": "llm-wiki-manager help",
+    "wiki:lint": "llm-wiki-manager lint",
+    "wiki:build": "llm-wiki-manager build",
+    "wiki:check": "llm-wiki-manager check",
+    "wiki:sync": "llm-wiki-manager sync",
+    "wiki:log": "llm-wiki-manager log",
+    "wiki:doctor": "llm-wiki-manager doctor",
+    "wiki:setup:husky": "llm-wiki-manager setup-husky"
+  },
+  "lint-staged": {
+    "*.{ts,js,mjs,cjs}": [
+      "eslint --fix --no-warn-ignored",
+      "prettier --write"
+    ],
+    "wiki/**/*.md": [
+      "npm run wiki:build",
+      "npm run wiki:lint",
+      "prettier --write"
+    ],
+    "*.{json,md,yml,yaml}": [
+      "prettier --write"
+    ]
+  },
+  "dependencies": {
+    "fflate": "^0.8.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.28.0",
+    "@types/node": "^22.15.0",
+    "eslint": "^10.7.0",
+    "eslint-config-prettier": "^10.1.5",
+    "globals": "^17.7.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.0.8",
+    "llm-wiki-manager": "^1.0.3",
+    "npm-run-all2": "^9.0.2",
+    "prettier": "^3.5.3",
+    "tsup": "^8.5.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.8.0",
+    "typescript-eslint": "^8.33.0",
+    "vitest": "^4.1.10"
+  }
+}