@schedule1-tools/mixer 0.1.2 → 0.2.2

package/README.md

@@ -17,11 +17,29 @@ const result = mixSubstances('OG Kush', ['Cuke', 'Flu Medicine', 'Gasoline']);
 
 /*
 {
-  effects: [ 'Be', 'Eu', 'Se', 'To' ],
+  effects: [ 'Be', 'Se', 'Eu', 'To' ],
   cost: 12,
   sellPrice: 64,
-  profit: 17,
-  profitMargin: 0.27
+  profit: 52,
+  profitMargin: 0.81,
+  addiction: 0.44
+}
+*/
+```
+
+### Calculate a mix using a hash
+
+```typescript
+const result = mixFromHash('T0cgS3VzaDpBQkM');
+
+/*
+{
+  effects: [ 'Be', 'Se', 'Eu', 'To' ],
+  cost: 12,
+  sellPrice: 64,
+  profit: 52,
+  profitMargin: 0.81,
+  addiction: 0.44
 }
 */
 ```

package/dist/core/effectSet.d.ts

@@ -2,10 +2,37 @@ import type { EffectCode } from '../types';
 export declare class EffectSet {
     private effects;
     constructor(initialEffects?: EffectCode[]);
+    /**
+     * Add an effect to the set
+     * @param effect - The effect to add
+     * @returns True if the effect was added, false if it already exists
+     */
     add(effect: EffectCode): boolean;
+    /**
+     * Remove an effect from the set
+     * @param effect - The effect to remove
+     * @returns True if the effect was removed, false if it didn't exist
+     */
     remove(effect: EffectCode): boolean;
+    /**
+     * Check if the set contains an effect
+     * @param effect - The effect to check for
+     * @returns True if the effect is in the set, false otherwise
+     */
     has(effect: EffectCode): boolean;
+    /**
+     * Convert the set to an array
+     * @returns An array of effects
+     */
     toArray(): EffectCode[];
+    /**
+     * Get the size of the set
+     * @returns The number of effects in the set
+     */
     size(): number;
+    /**
+     * Clone the set
+     * @returns A new set with the same effects
+     */
     clone(): EffectSet;
 }

package/dist/core/effectSet.js

@@ -5,25 +5,52 @@ class EffectSet {
     constructor(initialEffects = []) {
         this.effects = new Set(initialEffects);
     }
+    /**
+     * Add an effect to the set
+     * @param effect - The effect to add
+     * @returns True if the effect was added, false if it already exists
+     */
     add(effect) {
         const alreadyExists = this.effects.has(effect);
         this.effects.add(effect);
         return !alreadyExists;
     }
+    /**
+     * Remove an effect from the set
+     * @param effect - The effect to remove
+     * @returns True if the effect was removed, false if it didn't exist
+     */
     remove(effect) {
         const existed = this.effects.has(effect);
         this.effects.delete(effect);
         return existed;
     }
+    /**
+     * Check if the set contains an effect
+     * @param effect - The effect to check for
+     * @returns True if the effect is in the set, false otherwise
+     */
     has(effect) {
         return this.effects.has(effect);
     }
+    /**
+     * Convert the set to an array
+     * @returns An array of effects
+     */
     toArray() {
         return Array.from(this.effects);
     }
+    /**
+     * Get the size of the set
+     * @returns The number of effects in the set
+     */
     size() {
         return this.effects.size;
     }
+    /**
+     * Clone the set
+     * @returns A new set with the same effects
+     */
     clone() {
         const clone = new EffectSet();
         clone.effects = new Set(this.effects);

package/dist/core/mixer.d.ts

@@ -1,5 +1,14 @@
-import type { MixResult, ProductType, SubstanceCode } from '../types';
+import type { MixResult, Product, Substance } from '../types';
 /**
  * Calculate the result of mixing substances with a product
+ * @param product - The product to mix
+ * @param substanceCodes - The substances to mix
+ * @returns The result of the mix
  */
-export declare function mixSubstances(product: ProductType, substanceCodes: SubstanceCode[]): MixResult;
+export declare function mixSubstances(product: Product, substanceCodes: Substance[]): MixResult;
+/**
+ * Mix substances from a hash
+ * @param hash - The hash to mix
+ * @returns The result of the mix
+ */
+export declare function mixFromHash(hash: string): MixResult;

package/dist/core/mixer.js

@@ -1,14 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mixSubstances = mixSubstances;
+exports.mixFromHash = mixFromHash;
 const effects_1 = require("../data/effects");
 const products_1 = require("../data/products");
 const rules_1 = require("../data/rules");
 const substances_1 = require("../data/substances");
+const encoding_1 = require("../utils/encoding");
 const effectSet_1 = require("./effectSet");
 const MAX_EFFECTS = 8;
 /**
  * Calculate the result of mixing substances with a product
+ * @param product - The product to mix
+ * @param substanceCodes - The substances to mix
+ * @returns The result of the mix
  */
 function mixSubstances(product, substanceCodes) {
     if (!products_1.products[product]) {
@@ -61,6 +66,8 @@ function mixSubstances(product, substanceCodes) {
     }
     const finalEffects = effectsSet.toArray().slice(0, MAX_EFFECTS);
     const effectValue = calculateEffectValue(finalEffects);
+    const addictionValue = calculateAddiction(finalEffects);
+    const addiction = Math.round(addictionValue * 100) / 100;
     const sellPrice = Math.round(productInfo.price * (1 + effectValue));
     const profit = sellPrice - totalCost;
     const profitMargin = Math.round((profit / sellPrice) * 100) / 100;
@@ -70,10 +77,26 @@ function mixSubstances(product, substanceCodes) {
         sellPrice,
         profit,
         profitMargin,
+        addiction,
     };
 }
+/**
+ * Mix substances from a hash
+ * @param hash - The hash to mix
+ * @returns The result of the mix
+ */
+function mixFromHash(hash) {
+    const state = (0, encoding_1.decodeMixState)(hash);
+    if (!state) {
+        throw new Error(`Invalid hash: ${hash}`);
+    }
+    return mixSubstances(state.product, state.substances);
+}
 /**
  * Check if a rule's preconditions are met
+ * @param rule - The rule to check
+ * @param initialEffects - The initial effects
+ * @returns True if the preconditions are met, false otherwise
  */
 function checkRulePreconditions(rule, initialEffects) {
     // Check if all required effects are present
@@ -95,6 +118,11 @@ function checkRulePreconditions(rule, initialEffects) {
 }
 /**
  * Check if a rule meets phase two conditions
+ * @param rule - The rule to check
+ * @param initialEffects - The initial effects
+ * @param currentEffects - The current effects
+ * @param removedEffects - The removed effects
+ * @returns True if the rule meets the conditions, false otherwise
  */
 function meetsPhaseTwo(rule, initialEffects, currentEffects, removedEffects) {
     // All required effects must have been initially present
@@ -121,6 +149,11 @@ function meetsPhaseTwo(rule, initialEffects, currentEffects, removedEffects) {
 }
 /**
  * Apply effect replacements
+ * @param replace - The replacements to apply
+ * @param initialEffects - The initial effects
+ * @param effectsSet - The effects set
+ * @param processedEffects - The processed effects
+ * @param removedEffects - The removed effects
  */
 function applyReplaceEffects(replace, initialEffects, effectsSet, processedEffects, removedEffects) {
     for (const [oldEffect, newEffect] of Object.entries(replace)) {
@@ -134,6 +167,9 @@ function applyReplaceEffects(replace, initialEffects, effectsSet, processedEffec
 }
 /**
  * Check if a transformation can be applied
+ * @param replace - The replacements to apply
+ * @param effectsSet - The effects set
+ * @returns True if the transformation can be applied, false otherwise
  */
 function canApplyTransformation(replace, effectsSet) {
     for (const oldEffect of Object.keys(replace)) {
@@ -144,6 +180,9 @@ function canApplyTransformation(replace, effectsSet) {
 }
 /**
  * Apply transformations to effects
+ * @param replace - The replacements to apply
+ * @param effectsSet - The effects set
+ * @param processedEffects - The processed effects
  */
 function applyTransformations(replace, effectsSet, processedEffects) {
     for (const [oldEffect, newEffect] of Object.entries(replace)) {
@@ -156,6 +195,8 @@ function applyTransformations(replace, effectsSet, processedEffects) {
 }
 /**
  * Calculate the total value multiplier from effects
+ * @param effectCodes - The effects to calculate the value for
+ * @returns The total value multiplier
  */
 function calculateEffectValue(effectCodes) {
     var _a;
@@ -165,3 +206,16 @@ function calculateEffectValue(effectCodes) {
     }
     return value;
 }
+/**
+ * Calculate the total addiction value from effects
+ * @param effectCodes - The effects to calculate the value for
+ * @returns The total addiction value
+ */
+function calculateAddiction(effectCodes) {
+    var _a;
+    let value = 0;
+    for (const code of effectCodes) {
+        value += ((_a = effects_1.effects[code]) === null || _a === void 0 ? void 0 : _a.addiction) || 0;
+    }
+    return value;
+}

package/dist/data/effects.js

@@ -4,172 +4,274 @@ exports.effects = void 0;
 exports.effects = {
     Ca: {
         name: 'Calming',
+        description: 'Induces a slight calmness in the user.',
+        tier: 1,
         price: 0.1,
         color: '#fdba74',
+        addiction: 0,
     },
     Re: {
         name: 'Refreshing',
+        description: 'Slightly energizes the user.',
+        tier: 1,
         price: 0.14,
         color: '#bef264',
+        addiction: 0.104,
     },
     En: {
         name: 'Energizing',
+        description: 'Increases the users energy.',
+        tier: 2,
         price: 0.22,
         color: '#a3e635',
+        addiction: 0.34,
     },
     Se: {
         name: 'Sedating',
+        description: 'Induces heavy sleepiness in the user.',
+        tier: 2,
         price: 0.26,
         color: '#818cf8',
+        addiction: 0,
     },
     Be: {
         name: 'Bright-Eyed',
+        description: "Causes the user's eyes to emit light.",
+        tier: 4,
         price: 0.4,
         color: '#67e8f9',
+        addiction: 0.2,
     },
     Cd: {
         name: 'Calorie-Dense',
+        description: 'Results in immediate weight gain.',
+        tier: 2,
         price: 0.28,
         color: '#e879f9',
+        addiction: 0.1,
     },
     Eu: {
         name: 'Euphoric',
+        description: 'Induces mild euphoria in the user.',
+        tier: 1,
         price: 0.18,
         color: '#fde68a',
+        addiction: 0.235,
     },
     To: {
         name: 'Toxic',
+        description: "Damages the user's liver and induces vomiting.",
+        tier: 2,
         price: 0,
         color: '#a3e635',
+        addiction: 0,
     },
     At: {
         name: 'Athletic',
+        description: 'After consumption, the user is only able to run.',
+        tier: 3,
         price: 0.32,
         color: '#7dd3fc',
+        addiction: 0.607,
     },
     Ba: {
         name: 'Balding',
+        description: 'Causes balding in the user.',
+        tier: 3,
         price: 0.3,
         color: '#c79232',
+        addiction: 0,
     },
     Ag: {
         name: 'Anti-Gravity',
+        description: 'Weakens the effects of gravity on the user.',
+        tier: 5,
         price: 0.54,
         color: '#3b82f6',
+        addiction: 0.611,
     },
     Mu: {
         name: 'Munchies',
+        description: 'Makes the user hungry.',
+        tier: 1,
         price: 0.12,
         color: '#C96E57',
+        addiction: 0.096,
     },
     Sl: {
         name: 'Slippery',
+        description: "Reduces the user's ability to maintain traction on the ground.",
+        tier: 3,
         price: 0.34,
         color: '#7dd3fc',
+        addiction: 0.309,
     },
     Gi: {
         name: 'Gingeritis',
+        description: 'After consumption, the user will become a ginger.',
+        tier: 2,
         price: 0.2,
         color: '#fb923c',
+        addiction: 0,
     },
     Sn: {
         name: 'Sneaky',
+        description: 'Silences the users foot steps.',
+        tier: 2,
         price: 0.24,
         color: '#a8a29e',
+        addiction: 0.327,
     },
     Tp: {
         name: 'Thought-Provoking',
+        description: "Increases the size of the user's head.",
+        tier: 4,
         price: 0.44,
         color: '#f9a8d4',
+        addiction: 0.37,
     },
     Sp: {
         name: 'Spicy',
+        description: "Consumption results in the user's eyes turning blue.",
+        tier: 3,
         price: 0.38,
         color: '#f87171',
+        addiction: 0.665,
     },
     Pa: {
         name: 'Paranoia',
+        description: 'Induces paranoia in the user.',
+        tier: 1,
         price: 0,
         color: '#f87171',
+        addiction: 0,
     },
     Tt: {
         name: 'Tropic Thunder',
+        description: "Inverts the user's skin color.",
+        tier: 4,
         price: 0.46,
         color: '#fdba74',
+        addiction: 0.803,
     },
     Gl: {
         name: 'Glowing',
+        description: 'Imbues a bioluminescence on the user.',
+        tier: 4,
         price: 0.48,
         color: '#85E459',
+        addiction: 0.472,
     },
     Cy: {
         name: 'Cyclopean',
+        description: 'Causes the user to see with a single eye in the center of their forehead.',
+        tier: 5,
         price: 0.56,
         color: '#FEC174',
+        addiction: 0.1,
     },
     Fo: {
         name: 'Foggy',
+        description: 'Causes a cloud of fog to form around the user.',
+        tier: 3,
         price: 0.36,
         color: '#94a3b8',
+        addiction: 0.1,
     },
     Ex: {
         name: 'Explosive',
+        description: 'Causes the user to explode shortly after consumption.',
+        tier: 5,
         price: 0,
         color: '#ef4444',
+        addiction: 0,
     },
     La: {
         name: 'Laxative',
+        description: 'Causes the user to fart and shit uncontrollably.',
+        tier: 3,
         price: 0,
         color: '#a16207',
+        addiction: 0.1,
     },
     Lf: {
         name: 'Long Faced',
+        description: "Considerably increases the size of the user's head and neck.",
+        tier: 5,
         price: 0.52,
         color: '#fde047',
+        addiction: 0.607,
     },
     Je: {
         name: 'Jennerising',
+        description: "Inverts the user's gender.",
+        tier: 4,
         price: 0.42,
         color: '#e879f9',
+        addiction: 0.343,
     },
     El: {
         name: 'Electrifying',
+        description: 'Electrifies the user, causing arcs of electricity to be emitted, zapping anyone nearby.',
+        tier: 5,
         price: 0.5,
         color: '#22d3ee',
+        addiction: 0.235,
     },
     Di: {
         name: 'Disorienting',
+        description: 'Causes unpredictable movement and slight visual impairment in the user.',
+        tier: 2,
         price: 0,
         color: '#FE7551',
+        addiction: 0,
     },
     Sc: {
         name: 'Schizophrenia',
+        description: 'Induces hallucinations and unpredictable behaviour in the user.',
+        tier: 4,
         price: 0,
         color: '#645AFD',
+        addiction: 0,
     },
     Si: {
         name: 'Seizure-Inducing',
+        description: 'Consumption results in an instant seizure.',
+        tier: 3,
         price: 0,
         color: '#FEE900',
+        addiction: 0,
     },
     Zo: {
         name: 'Zombifying',
+        description: 'Transforms the user into a zombie, causing them to walk with a limp and seek brains.',
+        tier: 5,
         price: 0.58,
         color: '#71AB5D',
+        addiction: 0.598,
     },
     Fc: {
         name: 'Focused',
+        description: "Focuses the user's mind.",
+        tier: 1,
         price: 0.16,
         color: '#75F1FD',
+        addiction: 0.104,
     },
     Sm: {
         name: 'Smelly',
+        description: 'Makes the user unbearably smelly.',
+        tier: 1,
         price: 0,
         color: '#84cc16',
+        addiction: 0,
     },
     Sh: {
         name: 'Shrinking',
+        description: 'Shrinks the user.',
+        tier: 5,
         price: 0.6,
         color: '#B6FEDA',
+        addiction: 0.336,
     },
 };

package/dist/data/products.d.ts

@@ -1,3 +1,3 @@
-import type { ProductData, ProductType } from '../types';
-export declare const products: Record<ProductType, ProductData>;
-export declare const productAbbreviations: Record<string, ProductType>;
+import type { Product, ProductData } from '../types';
+export declare const products: Record<Product, ProductData>;
+export declare const productAbbreviations: Record<string, Product>;

package/dist/data/rules.d.ts

@@ -1,2 +1,2 @@
-import type { EffectRule, SubstanceCode } from '../types';
-export declare const effectRulesBySubstance: Record<SubstanceCode, EffectRule[]>;
+import type { EffectRule, Substance } from '../types';
+export declare const effectRulesBySubstance: Record<Substance, EffectRule[]>;

package/dist/data/substances.d.ts

@@ -1,3 +1,3 @@
-import type { SubstanceCode, SubstanceData } from '../types';
-export declare const substances: Record<SubstanceCode, SubstanceData>;
-export declare const substanceAbbreviations: Record<string, SubstanceCode>;
+import type { Substance, SubstanceData } from '../types';
+export declare const substances: Record<Substance, SubstanceData>;
+export declare const substanceAbbreviations: Record<string, Substance>;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export { mixSubstances } from './core/mixer';
+export { mixSubstances, mixFromHash } from './core/mixer';
 export { encodeMixState, decodeMixState } from './utils/encoding';
 export { effects } from './data/effects';
 export { products, productAbbreviations } from './data/products';
 export { substances } from './data/substances';
 export { effectRulesBySubstance } from './data/rules';
-export type { EffectCode, SubstanceCode, ProductType, RankCode, EffectData, SubstanceData, ProductData, EffectRule, MixResult, MixState, } from './types';
+export type { EffectCode, Substance, Product, RankCode, EffectData, SubstanceData, ProductData, EffectRule, MixResult, MixState, } from './types';

package/dist/index.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.effectRulesBySubstance = exports.substances = exports.productAbbreviations = exports.products = exports.effects = exports.decodeMixState = exports.encodeMixState = exports.mixSubstances = void 0;
+exports.effectRulesBySubstance = exports.substances = exports.productAbbreviations = exports.products = exports.effects = exports.decodeMixState = exports.encodeMixState = exports.mixFromHash = exports.mixSubstances = void 0;
 // Main exports
 var mixer_1 = require("./core/mixer");
 Object.defineProperty(exports, "mixSubstances", { enumerable: true, get: function () { return mixer_1.mixSubstances; } });
+Object.defineProperty(exports, "mixFromHash", { enumerable: true, get: function () { return mixer_1.mixFromHash; } });
 var encoding_1 = require("./utils/encoding");
 Object.defineProperty(exports, "encodeMixState", { enumerable: true, get: function () { return encoding_1.encodeMixState; } });
 Object.defineProperty(exports, "decodeMixState", { enumerable: true, get: function () { return encoding_1.decodeMixState; } });

package/dist/types.d.ts

@@ -1,11 +1,14 @@
 export type EffectCode = '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';
-export type SubstanceCode = 'Cuke' | 'Flu Medicine' | 'Gasoline' | 'Donut' | 'Energy Drink' | 'Mouth Wash' | 'Motor Oil' | 'Banana' | 'Chili' | 'Iodine' | 'Paracetamol' | 'Viagra' | 'Horse Semen' | 'Mega Bean' | 'Addy' | 'Battery';
-export type ProductType = 'OG Kush' | 'Sour Diesel' | 'Green Crack' | 'Grandaddy Purple' | 'Meth' | 'Cocaine';
+export type Substance = 'Cuke' | 'Flu Medicine' | 'Gasoline' | 'Donut' | 'Energy Drink' | 'Mouth Wash' | 'Motor Oil' | 'Banana' | 'Chili' | 'Iodine' | 'Paracetamol' | 'Viagra' | 'Horse Semen' | 'Mega Bean' | 'Addy' | 'Battery';
+export type Product = 'OG Kush' | 'Sour Diesel' | 'Green Crack' | 'Grandaddy Purple' | 'Meth' | 'Cocaine';
 export type RankCode = '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12' | '13';
 export interface EffectData {
     name: string;
+    description: string;
+    tier: number;
     price: number;
     color: string;
+    addiction: number;
 }
 export interface SubstanceData {
     abbreviation: string;
@@ -29,8 +32,9 @@ export interface MixResult {
     sellPrice: number;
     profit: number;
     profitMargin: number;
+    addiction: number;
 }
 export interface MixState {
-    product: ProductType;
-    substances: SubstanceCode[];
+    product: Product;
+    substances: Substance[];
 }

package/dist/utils/encoding.d.ts

@@ -1,11 +1,14 @@
 import type { MixState } from '../types';
 /**
  * Encode a mix state into a URL-safe string
+ * @param state - The mix state to encode
+ * @returns The URL-safe string
  * @throws Error if the product type or any substance code is invalid
  */
 export declare function encodeMixState(state: MixState): string;
 /**
  * Decode a mix state from a URL-safe string
+ * @param hash - The URL-safe string to decode
  * @returns The decoded MixState or null if invalid
  */
 export declare function decodeMixState(hash: string): MixState | null;

package/dist/utils/encoding.js

@@ -6,6 +6,8 @@ const products_1 = require("../data/products");
 const substances_1 = require("../data/substances");
 /**
  * Encode a mix state into a URL-safe string
+ * @param state - The mix state to encode
+ * @returns The URL-safe string
  * @throws Error if the product type or any substance code is invalid
  */
 function encodeMixState(state) {
@@ -29,6 +31,7 @@ function encodeMixState(state) {
 }
 /**
  * Decode a mix state from a URL-safe string
+ * @param hash - The URL-safe string to decode
  * @returns The decoded MixState or null if invalid
  */
 function decodeMixState(hash) {
@@ -45,7 +48,7 @@ function decodeMixState(hash) {
         if (!product || !products_1.products[product]) {
             return null;
         }
-        const substanceCodes = [];
+        const subs = [];
         if (substancesStr) {
             for (let i = 0; i < substancesStr.length; i++) {
                 const abbr = substancesStr[i];
@@ -53,12 +56,12 @@ function decodeMixState(hash) {
                 if (!fullName || !substances_1.substances[fullName]) {
                     return null;
                 }
-                substanceCodes.push(fullName);
+                subs.push(fullName);
             }
         }
         return {
             product: product,
-            substances: substanceCodes,
+            substances: subs,
         };
     }
     catch (error) {
@@ -67,6 +70,8 @@ function decodeMixState(hash) {
 }
 /**
  * Convert a string to a URL-safe base64 string
+ * @param str - The string to convert
+ * @returns The URL-safe base64 string
  */
 function toBase64Url(str) {
     return Buffer.from(str, 'utf-8')
@@ -77,6 +82,8 @@ function toBase64Url(str) {
 }
 /**
  * Convert a URL-safe base64 string back to a regular string
+ * @param str - The URL-safe base64 string to convert
+ * @returns The regular string
  */
 function fromBase64Url(str) {
     if (typeof str !== 'string') {

package/package.json

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