Started working on DPS calculator.

src/stores/DpsCalcStore.ts

@@ -0,0 +1,125 @@
+import { observable, IObservableArray, computed } from "mobx";
+
+const NORMAL_DAMAGE_FACTOR = 0.2 * 0.9;
+const HEAVY_DAMAGE_FACTOR = NORMAL_DAMAGE_FACTOR * 1.89;
+const SAC_DAMAGE_FACTOR = NORMAL_DAMAGE_FACTOR * 3.32;
+const VJAYA_DAMAGE_FACTOR = NORMAL_DAMAGE_FACTOR * 5.56;
+const CRIT_FACTOR = 1.5;
+
+class WeaponType {
+    constructor(
+        readonly minAtp: number,
+        readonly maxAtp: number
+    ) { }
+}
+
+class Weapon {
+    readonly type: WeaponType;
+
+    /**
+     * Integer from 0 to 100.
+     */
+    @observable attributePercentage: number = 0;
+    @observable grind: number = 0;
+
+    @computed get shiftaAtp(): number {
+        if (this.type.minAtp === this.type.maxAtp) {
+            return 0;
+        } else {
+            return this.type.maxAtp * this.store.shiftaFactor;
+        }
+    }
+
+    @computed get grindAtp(): number {
+        return 2 * this.grind;
+    }
+
+    @computed get minAtp(): number {
+        return this.type.minAtp + this.grindAtp;
+    }
+
+    @computed get maxAtp(): number {
+        return this.type.maxAtp + this.grindAtp + this.shiftaAtp;
+    }
+
+    @computed get finalMinAtp(): number {
+        return this.minAtp
+            + this.store.armorAtp
+            + this.store.shieldAtp
+            + this.store.baseAtp
+            + this.store.baseShiftaAtp;
+    }
+
+    @computed get finalMaxAtp(): number {
+        return this.maxAtp
+            + this.store.armorAtp
+            + this.store.shieldAtp
+            + this.store.baseAtp
+            + this.store.baseShiftaAtp;
+    }
+
+    @computed get minNormalDamage(): number {
+        return (this.finalMinAtp - this.store.enemyDfp) * NORMAL_DAMAGE_FACTOR;
+    }
+
+    @computed get maxNormalDamage(): number {
+        return (this.finalMaxAtp - this.store.enemyDfp) * NORMAL_DAMAGE_FACTOR;
+    }
+
+    @computed get avgNormalDamage(): number {
+        return (this.minNormalDamage + this.maxNormalDamage) / 2;
+    }
+
+    @computed get minHeavyDamage(): number {
+        return (this.finalMinAtp - this.store.enemyDfp) * HEAVY_DAMAGE_FACTOR;
+    }
+
+    @computed get maxHeavyDamage(): number {
+        return (this.finalMaxAtp - this.store.enemyDfp) * HEAVY_DAMAGE_FACTOR;
+    }
+
+    @computed get avgHeavyDamage(): number {
+        return (this.minHeavyDamage + this.maxHeavyDamage) / 2;
+    }
+
+    constructor(
+        private store: DpsCalcStore,
+        type: WeaponType,
+    ) {
+        this.type = type;
+    }
+}
+
+class DpsCalcStore {
+    //
+    // Character Details
+    //
+
+    @observable charAtp: number = 0;
+    @observable magPow: number = 0;
+    @observable armorAtp: number = 0;
+    @observable shieldAtp: number = 0;
+    @observable shiftaLvl: number = 0;
+
+    @computed get baseAtp(): number {
+        return this.charAtp + 2 * this.magPow;
+    }
+
+    @computed get shiftaFactor(): number {
+        return this.shiftaLvl ? 0.013 * (this.shiftaLvl - 1) + 0.1 : 0;
+    }
+
+    @computed get baseShiftaAtp(): number {
+        return this.baseAtp * this.shiftaFactor;
+    }
+
+    @observable readonly weapons: IObservableArray<Weapon> = observable.array();
+
+    //
+    // Enemy Details
+    //
+
+    @observable enemyDfp: number = 0;
+}
+
+export const dpsCalcStore = new DpsCalcStore();

src/ui/ApplicationComponent.tsx

@@ -6,13 +6,15 @@ import './ApplicationComponent.css';
 import { withErrorBoundary } from './ErrorBoundary';
 import { HuntOptimizerComponent } from './hunt-optimizer/HuntOptimizerComponent';
 import { QuestEditorComponent } from './quest-editor/QuestEditorComponent';
+import { DpsCalcComponent } from './dps-calc/DpsCalcComponent';
 
 const QuestEditor = withErrorBoundary(QuestEditorComponent);
 const HuntOptimizer = withErrorBoundary(HuntOptimizerComponent);
+const DpsCalc = withErrorBoundary(DpsCalcComponent);
 
 @observer
 export class ApplicationComponent extends React.Component {
-    state = { tool: 'questEditor' }
+    state = { tool: this.initTool() }
 
     render() {
         let toolComponent;
@@ -24,6 +26,9 @@ export class ApplicationComponent extends React.Component {
             case 'huntOptimizer':
                 toolComponent = <HuntOptimizer />;
                 break;
+            case 'dpsCalc':
+                toolComponent = <DpsCalc />;
+                break;
         }
 
         return (
@@ -43,6 +48,9 @@ export class ApplicationComponent extends React.Component {
                         <Menu.Item key="huntOptimizer">
                             Hunt Optimizer
                         </Menu.Item>
+                        {/* <Menu.Item key="dpsCalc">
+                            DPS Calculator
+                        </Menu.Item> */}
                     </Menu>
                 </div>
                 <div className="ApplicationComponent-main">
@@ -55,4 +63,9 @@ export class ApplicationComponent extends React.Component {
     private menuClicked = (e: ClickParam) => {
         this.setState({ tool: e.key });
     };
+
+    private initTool(): string {
+        const param = window.location.search.slice(1).split('&').find(p => p.startsWith('tool='));
+        return param ? param.slice(5) : 'questEditor';
+    }
 }

src/ui/dps-calc/DpsCalcComponent.tsx

@@ -0,0 +1,57 @@
+import { InputNumber } from "antd";
+import { observer } from "mobx-react";
+import React from "react";
+import { dpsCalcStore } from "../../stores/DpsCalcStore";
+
+@observer
+export class DpsCalcComponent extends React.Component {
+    render() {
+        return (
+            <section>
+                <section>
+                    <div>Character ATP:</div>
+                    <InputNumber
+                        value={dpsCalcStore.charAtp}
+                        min={0}
+                        step={1}
+                        onChange={(value) => dpsCalcStore.charAtp = value || 0}
+                    />
+                    <div>MAG POW:</div>
+                    <InputNumber
+                        value={dpsCalcStore.magPow}
+                        min={0}
+                        max={200}
+                        step={1}
+                        onChange={(value) => dpsCalcStore.magPow = value || 0}
+                    />
+                    <div>Armor ATP:</div>
+                    <InputNumber
+                        value={dpsCalcStore.armorAtp}
+                        min={0}
+                        step={1}
+                        onChange={(value) => dpsCalcStore.armorAtp = value || 0}
+                    />
+                    <div>Shield ATP:</div>
+                    <InputNumber
+                        value={dpsCalcStore.shieldAtp}
+                        min={0}
+                        step={1}
+                        onChange={(value) => dpsCalcStore.shieldAtp = value || 0}
+                    />
+                    <div>Shifta level:</div>
+                    <InputNumber
+                        value={dpsCalcStore.shiftaLvl}
+                        min={0}
+                        max={30}
+                        step={1}
+                        onChange={(value) => dpsCalcStore.shiftaLvl = value || 0}
+                    />
+                    <div>Shifta factor:</div>
+                    <div>{dpsCalcStore.shiftaFactor.toFixed(3)}</div>
+                    <div>Base shifta ATP:</div>
+                    <div>{dpsCalcStore.baseShiftaAtp.toFixed(2)}</div>
+                </section>
+            </section>
+        );
+    }
+}