@robsonbittencourt/calc 0.10.0

package/src/test/helper.ts

@@ -0,0 +1,185 @@
+/* eslint-env jest */
+
+import type * as I from '../data/interface';
+import {type Result, calculate, Pokemon, Move} from '../index';
+import type {State} from '../state';
+import {Field, Side} from '../field';
+
+const calc = (gen: I.GenerationNum) => (
+  attacker: Pokemon,
+  defender: Pokemon,
+  move: Move,
+  field?: Field
+) => calculate(gen, attacker, defender, move, field);
+
+const move = (gen: I.GenerationNum) => (
+  name: string,
+  options: Partial<Omit<State.Move, 'ability' | 'item' | 'species'>> & {
+    ability?: string;
+    item?: string;
+    species?: string;
+  } = {}
+) => new Move(gen, name, options as any);
+
+const pokemon = (gen: I.GenerationNum) => (
+  name: string,
+  options: Partial<Omit<State.Pokemon, 'ability' | 'item' | 'nature' | 'moves'>> & {
+    ability?: string;
+    item?: string;
+    nature?: string;
+    moves?: string[];
+    curHP?: number;
+    ivs?: Partial<I.StatsTable> & {spc?: number};
+    evs?: Partial<I.StatsTable> & {spc?: number};
+    boosts?: Partial<I.StatsTable> & {spc?: number};
+  } = {}
+) => new Pokemon(gen, name, options as any);
+
+const field = (field: Partial<State.Field> = {}) => new Field(field);
+
+const side = (side: State.Side = {}) => new Side(side);
+
+interface Gen {
+  gen: I.GenerationNum;
+  calculate: ReturnType<typeof calc>;
+  Pokemon: ReturnType<typeof pokemon>;
+  Move: ReturnType<typeof move>;
+  Field: typeof field;
+  Side: typeof side;
+}
+
+export function inGen(gen: I.GenerationNum, fn: (gen: Gen) => void) {
+  fn({
+    gen,
+    calculate: calc(gen),
+    Move: move(gen),
+    Pokemon: pokemon(gen),
+    Field: field,
+    Side: side,
+  });
+}
+
+export function inGens(from: I.GenerationNum, to: I.GenerationNum, fn: (gen: Gen) => void) {
+  for (let gen = from; gen <= to; gen++) {
+    inGen(gen, fn);
+  }
+}
+
+export function tests(name: string, fn: (gen: Gen) => void, type?: 'skip' | 'only'): void;
+export function tests(
+  name: string,
+  from: I.GenerationNum,
+  fn: (gen: Gen) => void,
+  type?: 'skip' | 'only'
+): void;
+export function tests(
+  name: string,
+  from: I.GenerationNum,
+  to: I.GenerationNum,
+  fn: (gen: Gen) => void,
+  type?: 'skip' | 'only'
+): void;
+export function tests(...args: any[]) {
+  const name = args[0];
+  let from: I.GenerationNum;
+  let to: I.GenerationNum;
+  let fn: (gen: Gen) => void;
+  let type: 'skip' | 'only' | undefined = undefined;
+  if (typeof args[1] !== 'number') {
+    from = 1;
+    to = 9;
+    fn = args[1];
+    type = args[2];
+  } else if (typeof args[2] !== 'number') {
+    from = args[1] as I.GenerationNum ?? 1;
+    to = 9;
+    fn = args[2];
+    type = args[3];
+  } else {
+    from = args[1] as I.GenerationNum ?? 1;
+    to = args[2] as I.GenerationNum ?? 8;
+    fn = args[3];
+    type = args[4];
+  }
+
+  inGens(from, to, gen => {
+    const n = `${name} (gen ${gen.gen})`;
+    if (type === 'skip') {
+      test.skip(n, () => fn!(gen));
+    } else if (type === 'only') {
+      test.only(n, () => fn!(gen));
+    } else {
+      test(n, () => fn!(gen));
+    }
+  });
+}
+
+declare global {
+  namespace jest {
+    interface Matchers<R, T> {
+      toMatch(gen: I.GenerationNum, notation?: '%' | 'px' | ResultDiff, diff?: ResultDiff): R;
+    }
+  }
+}
+
+type ResultDiff = Partial<Record<I.GenerationNum, Partial<ResultBreakdown>>>;
+interface ResultBreakdown {
+  range: [number, number];
+  desc: string;
+  result: string;
+}
+
+expect.extend({
+  toMatch(
+    received: Result,
+    gen: I.GenerationNum,
+    notation?: '%' | 'px' | ResultDiff,
+    diff?: ResultDiff
+  ) {
+    if (typeof notation !== 'string') {
+      diff = notation;
+      notation = '%';
+    }
+    if (!diff) throw new Error('toMatch called with no diff!');
+
+    const breakdowns = Object.entries(diff).sort() as [string, ResultBreakdown][];
+    const expected = {range: undefined! as [number, number], desc: '', result: ''};
+    for (const [g, {range, desc, result}] of breakdowns) {
+      if (Number(g) > gen) break;
+      if (range) expected.range = range;
+      if (desc) expected.desc = desc;
+      if (result) expected.result = result;
+    }
+
+    if (!(expected.range || expected.desc || expected.result)) {
+      throw new Error(`toMatch called with empty diff: ${diff}`);
+    }
+
+    if (expected.range) {
+      if (this.isNot) {
+        expect(received.range()).not.toEqual(expected.range);
+      } else {
+        expect(received.range()).toEqual(expected.range);
+      }
+    }
+    if (expected.desc) {
+      const r = received.fullDesc(notation).split(': ')[0];
+      if (this.isNot) {
+        expect(r).not.toEqual(expected.desc);
+      } else {
+        expect(r).toEqual(expected.desc);
+      }
+    }
+    if (expected.result) {
+      const post = received.fullDesc(notation).split(': ')[1];
+      const r = `(${post.split('(')[1]}`;
+      if (this.isNot) {
+        expect(r).not.toEqual(expected.result);
+      } else {
+        expect(r).toEqual(expected.result);
+      }
+    }
+
+    return {pass: !this.isNot, message: () => ''};
+  },
+});

package/src/test/move.test.ts

@@ -0,0 +1,13 @@
+import {Move} from '../index';
+
+describe('Move', () => {
+  test('clone', () => {
+    const m = new Move(7, 'Blizzard', {useZ: true});
+    expect(m.name).toBe('Subzero Slammer');
+    expect(m.bp).toBe(185);
+
+    const clone = m.clone();
+    expect(clone.name).toBe('Subzero Slammer');
+    expect(clone.bp).toBe(185);
+  });
+});

package/src/test/pokemon.test.ts

@@ -0,0 +1,121 @@
+import {Pokemon} from '../index';
+import type {StatID, MoveName} from '../data/interface';
+
+describe('Pokemon', () => {
+  test('defaults', () => {
+    const p = new Pokemon(7, 'Gengar');
+
+    expect(p.name).toBe('Gengar');
+    expect(p.types).toEqual(['Ghost', 'Poison']);
+    expect(p.weightkg).toBe(40.5);
+    expect(p.level).toBe(100);
+    expect(p.gender).toBe('M');
+    expect(p.item).toBeUndefined();
+    expect(p.ability).toBe('Cursed Body');
+    expect(p.nature).toBe('Serious');
+    expect(p.status).toBe('');
+    expect(p.hasStatus()).toBe(false);
+    expect(p.toxicCounter).toBe(0);
+    expect(p.curHP()).toBe(p.stats.hp);
+
+    let stat: StatID;
+    // tslint:disable-next-line:forin
+    for (stat in p.ivs) {
+      expect(p.ivs[stat]).toBe(31);
+      expect(p.evs[stat]).toBe(0);
+      expect(p.boosts[stat]).toBe(0);
+    }
+
+    expect(p.stats).toEqual({hp: 261, atk: 166, def: 156, spa: 296, spd: 186, spe: 256});
+  });
+
+  test('Pokemon full', () => {
+    const p = new Pokemon(7, 'Suicune', {
+      level: 50,
+      ability: 'Inner Focus',
+      item: 'Leftovers',
+      nature: 'Bold',
+      ivs: {spa: 30},
+      evs: {spd: 4, def: 252, hp: 252},
+      boosts: {atk: -1, spa: 2, spd: 1},
+      curHP: 60,
+      status: 'tox',
+      toxicCounter: 2,
+      moves: ['Surf', 'Rest', 'Curse', 'Sleep Talk'],
+    });
+
+    expect(p.name).toBe('Suicune');
+    expect(p.types).toEqual(['Water']);
+    expect(p.weightkg).toBe(187.0);
+    expect(p.level).toBe(50);
+    expect(p.gender).toBe('N');
+    expect(p.item).toBe('Leftovers');
+    expect(p.ability).toBe('Inner Focus');
+    expect(p.nature).toBe('Bold');
+    expect(p.status).toBe('tox');
+    expect(p.toxicCounter).toBe(2);
+    expect(p.curHP()).toBe(60);
+
+    expect(p.ivs).toEqual({hp: 31, atk: 31, def: 31, spa: 30, spd: 31, spe: 31});
+    expect(p.evs).toEqual({hp: 252, atk: 0, def: 252, spa: 0, spd: 4, spe: 0});
+    expect(p.boosts).toEqual({hp: 0, atk: -1, def: 0, spa: 2, spd: 1, spe: 0});
+    expect(p.stats).toEqual({hp: 207, atk: 85, def: 183, spa: 110, spd: 136, spe: 105});
+
+    expect(p.moves).toEqual(['Surf', 'Rest', 'Curse', 'Sleep Talk'] as MoveName[]);
+  });
+
+  test('gen1', () => {
+    const p = new Pokemon(1, 'Tauros', {
+      level: 100,
+      ivs: {spc: 20, def: 16},
+      evs: {atk: 200},
+      curHP: 500,
+    });
+
+    // HP DV should be derived
+    expect(p.ivs).toEqual({hp: 20, atk: 31, def: 16, spa: 20, spd: 20, spe: 31});
+    expect(p.evs).toEqual({hp: 252, atk: 200, def: 252, spa: 252, spd: 252, spe: 252});
+    expect(p.stats).toEqual({hp: 343, atk: 298, def: 274, spa: 228, spd: 228, spe: 318});
+
+    // curHP() capped to maxHP
+    expect(p.curHP()).toBe(p.maxHP());
+  });
+
+  test('getForme', () => {
+    expect(Pokemon.getForme(1, 'Gengar')).toBe('Gengar');
+
+    expect(Pokemon.getForme(7, 'Gengar', 'Black Sludge', 'Hypnosis')).toBe('Gengar');
+    expect(Pokemon.getForme(7, 'Gengar', 'Gengarite', 'Hypnosis')).toBe('Gengar-Mega');
+
+    expect(Pokemon.getForme(7, 'Charizard')).toBe('Charizard');
+    expect(Pokemon.getForme(7, 'Charizard', 'Charizardite X')).toBe('Charizard-Mega-X');
+    expect(Pokemon.getForme(7, 'Charizard', 'Charizardite Y')).toBe('Charizard-Mega-Y');
+    expect(Pokemon.getForme(7, 'Mewtwo', 'Choice Specs', 'Psystrike')).toBe('Mewtwo');
+    expect(Pokemon.getForme(7, 'Mewtwo', 'Mewtwonite X', 'Psystrike')).toBe('Mewtwo-Mega-X');
+    expect(Pokemon.getForme(7, 'Mewtwo', 'Mewtwonite Y', 'Psystrike')).toBe('Mewtwo-Mega-Y');
+
+    expect(Pokemon.getForme(7, 'Groudon', 'Choice Band', 'Earthquake')).toBe('Groudon');
+    expect(Pokemon.getForme(7, 'Groudon', 'Red Orb', 'Earthquake')).toBe('Groudon-Primal');
+    expect(Pokemon.getForme(7, 'Kyogre', 'Choice Specs', 'Surf')).toBe('Kyogre');
+    expect(Pokemon.getForme(7, 'Kyogre', 'Blue Orb', 'Surf')).toBe('Kyogre-Primal');
+
+    expect(Pokemon.getForme(7, 'Meloetta', 'Leftovers', 'Psychic')).toBe('Meloetta');
+    expect(Pokemon.getForme(7, 'Meloetta', 'Leftovers', 'Relic Song')).toBe('Meloetta-Pirouette');
+    expect(Pokemon.getForme(7, 'Rayquaza', undefined, 'Earthquake')).toBe('Rayquaza');
+    expect(Pokemon.getForme(7, 'Rayquaza', undefined, 'Dragon Ascent')).toBe('Rayquaza-Mega');
+  });
+
+  test('hasType', () => {
+    const p = new Pokemon(7, 'Gengar');
+    expect(p.hasType('Ghost')).toBe(true);
+    expect(p.hasType('Poison')).toBe(true);
+    expect(p.hasType('Fire')).toBe(false);
+    expect(p.hasType('Ice')).toBe(false);
+  });
+
+  test('Gigantamx weights', () => {
+    expect(new Pokemon(8, 'Venusaur-Gmax').weightkg).toBe(100);
+    expect(new Pokemon(8, 'Venusaur-Gmax', {isDynamaxed: true}).weightkg).toBe(0);
+    expect(new Pokemon(8, 'Venusaur-Gmax', {overrides: {weightkg: 50}}).weightkg).toBe(50);
+  });
+});

package/src/test/stats.test.ts

@@ -0,0 +1,84 @@
+import {Generations} from '../data';
+import type {GenerationNum, StatsTable, StatID} from '../data/interface';
+import {Stats} from '../stats';
+import {getModifiedStat} from '../mechanics/util';
+
+describe('Stats', () => {
+  test('displayStat', () => {
+    expect(Stats.displayStat('hp')).toBe('HP');
+    expect(Stats.displayStat('atk')).toBe('Atk');
+    expect(Stats.displayStat('def')).toBe('Def');
+    expect(Stats.displayStat('spa')).toBe('SpA');
+    expect(Stats.displayStat('spd')).toBe('SpD');
+    expect(Stats.displayStat('spe')).toBe('Spe');
+    expect(Stats.displayStat('spc')).toBe('Spc');
+  });
+
+  test('calcStat', () => {
+    const RBY: StatsTable = {
+      hp: 403,
+      atk: 298,
+      def: 298,
+      spa: 298,
+      spd: 298,
+      spe: 298,
+    };
+    const ADV: StatsTable = {hp: 404, atk: 328, def: 299, spa: 269, spd: 299, spe: 299};
+    for (let gen = 1; gen <= 9; gen++) {
+      for (const s in ADV) {
+        const stat = s as StatID;
+        const val = Stats.calcStat(
+          Generations.get(gen as GenerationNum),
+          stat,
+          100,
+          31,
+          252,
+          100,
+          'Adamant'
+        );
+        expect(val).toBe(gen < 3 ? RBY[stat] : ADV[stat]);
+      }
+    }
+
+    // Shedinja
+    expect(Stats.calcStat(Generations.get(8), 'hp', 1, 31, 252, 100, 'Jolly')).toBe(1);
+    // no nature
+    expect(Stats.calcStat(Generations.get(8), 'atk', 100, 31, 252, 100)).toBe(299);
+  });
+
+  test('dvs', () => {
+    for (let dv = 0; dv <= 15; dv++) {
+      expect(Stats.IVToDV(Stats.DVToIV(dv))).toBe(dv);
+    }
+
+    expect(
+      Stats.getHPDV({
+        atk: Stats.DVToIV(15),
+        def: Stats.DVToIV(15),
+        spc: Stats.DVToIV(15),
+        spe: Stats.DVToIV(15),
+      })
+    ).toBe(15);
+    expect(
+      Stats.getHPDV({
+        atk: Stats.DVToIV(5),
+        def: Stats.DVToIV(15),
+        spc: Stats.DVToIV(13),
+        spe: Stats.DVToIV(13),
+      })
+    ).toBe(15);
+    expect(
+      Stats.getHPDV({
+        atk: Stats.DVToIV(15),
+        def: Stats.DVToIV(3),
+        spc: Stats.DVToIV(11),
+        spe: Stats.DVToIV(10),
+      })
+    ).toBe(13);
+  });
+
+  test('gen 2 modifications', () => {
+    expect(getModifiedStat(158, -1, Generations.get(2))).toBe(104); // Snorlax after Curse
+    expect(getModifiedStat(238, -1, Generations.get(2))).toBe(157); // Skarmory after Curse
+  });
+});

package/src/test/utils.test.ts

@@ -0,0 +1,18 @@
+import {extend} from '../util';
+
+describe('util', () => {
+  test('extend', () => {
+    const obj1 = {a: 1, b: {c: 2}, d: {e: 3}, f: 4};
+    const obj2 = {a: 2, b: {c: 3}, d: 4, e: {f: 5}};
+
+    expect(extend(true, {}, obj1)).toEqual(obj1);
+    expect(extend(true, {}, obj1, obj2)).toEqual({a: 2, b: {c: 3}, d: 4, e: {f: 5}, f: 4});
+    expect(extend(true, {}, obj2, obj1)).toEqual({
+      a: 1,
+      b: {c: 2},
+      d: {e: 3},
+      e: {f: 5},
+      f: 4,
+    });
+  });
+});

package/src/util.ts

@@ -0,0 +1,153 @@
+/* eslint-disable eqeqeq, @typescript-eslint/unbound-method, @typescript-eslint/ban-types */
+import type {ID} from './data/interface';
+
+export function toID(text: any): ID {
+  return ('' + text).toLowerCase().replace(/[^a-z0-9]+/g, '') as ID;
+}
+
+export function error(err: boolean, msg: string) {
+  if (err) {
+    throw new Error(msg);
+  } else {
+    console.log(msg);
+  }
+}
+
+export function assignWithout(
+  a: {[key: string]: any}, b: {[key: string]: any}, exclude: Set<string>
+) {
+  for (const key in b) {
+    if (Object.prototype.hasOwnProperty.call(b, key) && !exclude.has(key)) {
+      a[key] = b[key];
+    }
+  }
+}
+
+// https://github.com/krzkaczor/ts-essentials v6.0.5
+// MIT License Copyright 2018-2019 Chris Kaczor
+export type Primitive = string | number | boolean | bigint | symbol | undefined | null;
+export type Builtin = Primitive | Function | Date | Error | RegExp;
+
+export type IsTuple<T> =
+  T extends [infer A] ? T
+  : T extends [infer A, infer B] ? T
+  : T extends [infer A, infer B, infer C] ? T
+  : T extends [infer A, infer B, infer C, infer D] ? T
+  : T extends [infer A, infer B, infer C, infer D, infer E] ? T
+  : never;
+
+export type DeepPartial<T> =
+  T extends Builtin ? T
+  : T extends Map<infer K, infer V> ? Map<DeepPartial<K>, DeepPartial<V>>
+  : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<DeepPartial<K>, DeepPartial<V>>
+  : T extends Set<infer U> ? Set<DeepPartial<U>>
+  : T extends ReadonlySet<infer U> ? ReadonlySet<DeepPartial<U>>
+  : T extends Array<infer U> ? T extends IsTuple<T>
+    ? { [K in keyof T]?: DeepPartial<T[K]> }
+    : Array<DeepPartial<U>>
+  : T extends Promise<infer U> ? Promise<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+// jQuery JavaScript Library v2.0.3
+// Copyright 2005, 2013 jQuery Foundation, Inc. and other contributors
+const class2Type: {[c: string]: string} = {
+  '[object Boolean]': 'boolean',
+  '[object Number]': 'number',
+  '[object String]': 'string',
+  '[object Function]': 'function',
+  '[object Array]': 'array',
+  '[object Date]': 'date',
+  '[object RegExp]': 'regexp',
+  '[object Object]': 'object',
+  '[object Error]': 'error',
+};
+
+const coreToString = class2Type.toString;
+const coreHasOwn = class2Type.hasOwnProperty;
+
+function isFunction(obj: any) {
+  return getType(obj) === 'function';
+}
+
+function isWindow(obj: any) {
+  return obj != null && obj === obj.window;
+}
+
+function getType(obj: any) {
+  if (obj == null) {
+    return String(obj);
+  }
+  return typeof obj === 'object' || typeof obj === 'function'
+    ? class2Type[coreToString.call(obj)] || 'object'
+    : typeof obj;
+}
+
+function isPlainObject(obj: any) {
+  if (getType(obj) !== 'object' || obj.nodeType || isWindow(obj)) {
+    return false;
+  }
+
+  try {
+    if (obj.constructor && !coreHasOwn.call(obj.constructor.prototype, 'isPrototypeOf')) {
+      return false;
+    }
+  } catch (e) {
+    return false;
+  }
+
+  return true;
+}
+
+export function extend(this: any, ...args: any[]) {
+  let options, name, src, copy, copyIsArray, clone;
+  let target = args[0] || {};
+  let i = 1;
+  let deep = false;
+  const length = args.length;
+
+  if (typeof target === 'boolean') {
+    deep = target;
+    target = args[1] || {};
+    i = 2;
+  }
+
+  if (typeof target !== 'object' && !isFunction(target)) {
+    target = {};
+  }
+
+  if (length === i) {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    target = this;
+    --i;
+  }
+
+  for (; i < length; i++) {
+    if ((options = args[i]) != null) {
+      // tslint:disable-next-line: forin
+      for (name in options) {
+        src = target[name];
+        copy = options[name];
+
+        if (target === copy) {
+          continue;
+        }
+
+        if (deep && copy && (isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) {
+          if (copyIsArray) {
+            copyIsArray = false;
+            clone = src && Array.isArray(src) ? src : [];
+          } else {
+            clone = src && isPlainObject(src) ? src : {};
+          }
+
+          target[name] = extend(deep, clone, copy);
+        } else if (copy !== undefined) {
+          target[name] = copy;
+        }
+      }
+    }
+  }
+
+  return target;
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "dist",
+    "downlevelIteration": true,
+    "tsBuildInfoFile": ".tsbuildinfo"
+  },
+  "exclude": ["dist"]
+}