@schedule1-tools/mixer 0.0.1 → 0.1.2

package/README.md

@@ -10,12 +10,11 @@ npm install @schedule1-tools/mixer
 
 ## Usage
 
-```typescript
-import { decodeMixState, encodeMixState, mixSubstances } from '@schedule1-tools/mixer';
+### Calculate a mix
 
-// Calculate a mix
+```typescript
 const result = mixSubstances('OG Kush', ['Cuke', 'Flu Medicine', 'Gasoline']);
-console.log(result);
+
 /*
 {
   effects: [ 'Be', 'Eu', 'Se', 'To' ],
@@ -25,17 +24,24 @@ console.log(result);
   profitMargin: 0.27
 }
 */
+```
 
-// Encode a mix state for sharing
+### Encode a mix state for sharing
+
+```typescript
 const encoded = encodeMixState({
   product: 'OG Kush',
   substances: ['Cuke', 'Flu Medicine', 'Gasoline'],
 });
-console.log(encoded); // "T0cgS3VzaDpBQkM"
 
-// Decode a mix state
+// "T0cgS3VzaDpBQkM"
+```
+
+### Decode a mix state
+
+```typescript
 const decoded = decodeMixState('T0cgS3VzaDpBQkM');
-console.log(decoded);
+
 /*
 {
   product: 'OG Kush',
@@ -52,3 +58,7 @@ The package also exports the following data objects:
 - `products`: Information about all products
 - `substances`: Information about all substances
 - `effectRulesBySubstance`: Rules for how substances transform effects
+
+## Notice
+
+This is a fan-made project and is not affiliated with, authorized, maintained, sponsored, or endorsed by the developers of Schedule I the game. All game-related content, including but not limited to names, trademarks, and copyrights, belong to their respective owners.

package/dist/core/effectSet.d.ts

@@ -1,38 +1,11 @@
 import type { EffectCode } from '../types';
 export declare class EffectSet {
-    private static readonly effectToIndex;
-    private static readonly indexToEffect;
-    private static initialized;
-    private bits;
-    /**
-     * Initialize the static mapping between effect codes and bit positions
-     */
-    private static initialize;
+    private effects;
     constructor(initialEffects?: EffectCode[]);
-    /**
-     * Add an effect to the set
-     * @returns true if the effect was added, false if it was already present
-     */
     add(effect: EffectCode): boolean;
-    /**
-     * Remove an effect from the set
-     * @returns true if the effect was removed, false if it wasn't present
-     */
     remove(effect: EffectCode): boolean;
-    /**
-     * Check if an effect is in the set
-     */
     has(effect: EffectCode): boolean;
-    /**
-     * Convert the set to an array of effect codes
-     */
     toArray(): EffectCode[];
-    /**
-     * Get the number of effects in the set
-     */
     size(): number;
-    /**
-     * Create a copy of this effect set
-     */
     clone(): EffectSet;
 }

package/dist/core/effectSet.js

@@ -2,132 +2,32 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EffectSet = void 0;
 class EffectSet {
-    /**
-     * Initialize the static mapping between effect codes and bit positions
-     */
-    static initialize() {
-        if (this.initialized)
-            return;
-        const effects = [
-            'Ag',
-            'At',
-            'Ba',
-            'Be',
-            'Ca',
-            'Cd',
-            'Cy',
-            'Di',
-            'El',
-            'En',
-            'Eu',
-            'Ex',
-            'Fc',
-            'Fo',
-            'Gi',
-            'Gl',
-            'Je',
-            'La',
-            'Lf',
-            'Mu',
-            'Pa',
-            'Re',
-            'Sc',
-            'Se',
-            'Sh',
-            'Si',
-            'Sl',
-            'Sm',
-            'Sn',
-            'Sp',
-            'To',
-            'Tp',
-            'Tt',
-            'Zo',
-        ];
-        effects.forEach((effect, index) => {
-            this.effectToIndex.set(effect, index);
-            this.indexToEffect.set(index, effect);
-        });
-        this.initialized = true;
-    }
     constructor(initialEffects = []) {
-        this.bits = 0;
-        EffectSet.initialize();
-        for (const effect of initialEffects) {
-            this.add(effect);
-        }
+        this.effects = new Set(initialEffects);
     }
-    /**
-     * Add an effect to the set
-     * @returns true if the effect was added, false if it was already present
-     */
     add(effect) {
-        const index = EffectSet.effectToIndex.get(effect);
-        if (index === undefined)
-            return false;
-        const mask = 1 << index;
-        const alreadyExists = (this.bits & mask) !== 0;
-        this.bits |= mask;
+        const alreadyExists = this.effects.has(effect);
+        this.effects.add(effect);
         return !alreadyExists;
     }
-    /**
-     * Remove an effect from the set
-     * @returns true if the effect was removed, false if it wasn't present
-     */
     remove(effect) {
-        const index = EffectSet.effectToIndex.get(effect);
-        if (index === undefined)
-            return false;
-        const mask = 1 << index;
-        const existed = (this.bits & mask) !== 0;
-        this.bits &= ~mask;
+        const existed = this.effects.has(effect);
+        this.effects.delete(effect);
         return existed;
     }
-    /**
-     * Check if an effect is in the set
-     */
     has(effect) {
-        const index = EffectSet.effectToIndex.get(effect);
-        if (index === undefined)
-            return false;
-        return (this.bits & (1 << index)) !== 0;
+        return this.effects.has(effect);
     }
-    /**
-     * Convert the set to an array of effect codes
-     */
     toArray() {
-        const result = [];
-        for (let i = 0; i < 34; i++) {
-            if ((this.bits & (1 << i)) !== 0) {
-                const effect = EffectSet.indexToEffect.get(i);
-                if (effect)
-                    result.push(effect);
-            }
-        }
-        return result;
+        return Array.from(this.effects);
     }
-    /**
-     * Get the number of effects in the set
-     */
     size() {
-        let count = 0;
-        let n = this.bits;
-        while (n) {
-            n &= n - 1;
-            count++;
-        }
-        return count;
+        return this.effects.size;
     }
-    /**
-     * Create a copy of this effect set
-     */
     clone() {
         const clone = new EffectSet();
-        clone.bits = this.bits;
+        clone.effects = new Set(this.effects);
         return clone;
     }
 }
 exports.EffectSet = EffectSet;
-EffectSet.effectToIndex = new Map();
-EffectSet.indexToEffect = new Map();
-EffectSet.initialized = false;

package/dist/core/mixer.js

@@ -16,16 +16,40 @@ function mixSubstances(product, substanceCodes) {
     }
     const productInfo = products_1.products[product];
     const effectsSet = new effectSet_1.EffectSet(productInfo.effects);
-    const processedEffects = new effectSet_1.EffectSet();
-    const removedEffects = new effectSet_1.EffectSet();
     let totalCost = 0;
     for (const code of substanceCodes) {
         const substance = substances_1.substances[code];
         if (!substance)
             continue;
         totalCost += substance.price;
-        applySubstanceRules(code, effectsSet, processedEffects, removedEffects);
-        if (effectsSet.size() < MAX_EFFECTS) {
+        const rules = rules_1.effectRulesBySubstance[code];
+        if (rules && rules.length > 0) {
+            const initialEffects = effectsSet.clone();
+            const processedEffects = new effectSet_1.EffectSet();
+            const removedEffects = new effectSet_1.EffectSet();
+            const appliedRules = new Set();
+            // Phase 1: Apply rules where conditions are met in the initial state
+            for (let i = 0; i < rules.length; i++) {
+                const rule = rules[i];
+                if (checkRulePreconditions(rule, initialEffects)) {
+                    applyReplaceEffects(rule.replace, initialEffects, effectsSet, processedEffects, removedEffects);
+                    appliedRules.add(i);
+                }
+            }
+            // Phase 2: Apply rules where conditions are met after phase 1
+            for (let i = 0; i < rules.length; i++) {
+                if (appliedRules.has(i))
+                    continue;
+                const rule = rules[i];
+                if (meetsPhaseTwo(rule, initialEffects, effectsSet, removedEffects)) {
+                    if (canApplyTransformation(rule.replace, effectsSet)) {
+                        applyTransformations(rule.replace, effectsSet, processedEffects);
+                    }
+                }
+            }
+        }
+        // Add substance effects AFTER applying rules
+        if (effectsSet.size() < MAX_EFFECTS && substance.effect) {
             for (const effect of substance.effect) {
                 if (!effectsSet.has(effect)) {
                     effectsSet.add(effect);
@@ -37,9 +61,8 @@ function mixSubstances(product, substanceCodes) {
     }
     const finalEffects = effectsSet.toArray().slice(0, MAX_EFFECTS);
     const effectValue = calculateEffectValue(finalEffects);
-    const productPrice = productInfo.price;
-    const sellPrice = Math.round(productPrice * (1 + effectValue));
-    const profit = sellPrice - totalCost - productPrice;
+    const sellPrice = Math.round(productInfo.price * (1 + effectValue));
+    const profit = sellPrice - totalCost;
     const profitMargin = Math.round((profit / sellPrice) * 100) / 100;
     return {
         effects: finalEffects,
@@ -49,35 +72,6 @@ function mixSubstances(product, substanceCodes) {
         profitMargin,
     };
 }
-/**
- * Apply the rules for a substance to the current effect set
- */
-function applySubstanceRules(substanceCode, effectsSet, processedEffects, removedEffects) {
-    const rules = rules_1.effectRulesBySubstance[substanceCode];
-    if (!rules || rules.length === 0)
-        return;
-    const initialEffects = effectsSet.clone();
-    const appliedRules = new Set();
-    // Phase 1: Apply rules where conditions are met in the initial state
-    for (let i = 0; i < rules.length; i++) {
-        const rule = rules[i];
-        if (checkRulePreconditions(rule, initialEffects)) {
-            applyReplaceEffects(rule.replace, initialEffects, effectsSet, processedEffects, removedEffects);
-            appliedRules.add(i);
-        }
-    }
-    // Phase 2: Apply rules where conditions are met after phase 1
-    for (let i = 0; i < rules.length; i++) {
-        if (appliedRules.has(i))
-            continue;
-        const rule = rules[i];
-        if (meetsPhaseTwo(rule, initialEffects, effectsSet, removedEffects)) {
-            if (canApplyTransformation(rule.replace, effectsSet)) {
-                applyTransformations(rule.replace, effectsSet, processedEffects);
-            }
-        }
-    }
-}
 /**
  * Check if a rule's preconditions are met
  */
@@ -125,16 +119,6 @@ function meetsPhaseTwo(rule, initialEffects, currentEffects, removedEffects) {
     }
     return true;
 }
-/**
- * Check if a transformation can be applied
- */
-function canApplyTransformation(replace, effectsSet) {
-    for (const oldEffect of Object.keys(replace)) {
-        if (effectsSet.has(oldEffect))
-            return true;
-    }
-    return false;
-}
 /**
  * Apply effect replacements
  */
@@ -148,6 +132,16 @@ function applyReplaceEffects(replace, initialEffects, effectsSet, processedEffec
         }
     }
 }
+/**
+ * Check if a transformation can be applied
+ */
+function canApplyTransformation(replace, effectsSet) {
+    for (const oldEffect of Object.keys(replace)) {
+        if (effectsSet.has(oldEffect))
+            return true;
+    }
+    return false;
+}
 /**
  * Apply transformations to effects
  */

package/dist/data/products.js

@@ -22,16 +22,16 @@ exports.products = {
         effects: ['Se'],
         abbreviation: 'GE',
     },
-    Cocaine: {
-        price: 150,
-        effects: [],
-        abbreviation: 'CE',
-    },
     Meth: {
         price: 70,
         effects: [],
         abbreviation: 'MH',
     },
+    Cocaine: {
+        price: 150,
+        effects: [],
+        abbreviation: 'CE',
+    },
 };
 exports.productAbbreviations = Object.entries(exports.products).reduce((acc, [product, data]) => {
     acc[data.abbreviation] = product;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schedule1-tools/mixer",
-  "version": "0.0.1",
+  "version": "0.1.2",
   "description": "A package for calculating substance mixes in Schedule 1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",