Merge branch 'release/2.2.18'

.gitignore

@@ -4,4 +4,5 @@ build
 *.log
 nginx.pid
 .idea
-/bin
+/bin
+env

ChangeLog.md

@@ -1,4 +1,194 @@
-#2.2.x
+#2.2.18
+  * Change methodology for calculating explorer role; can result in lighter builds
+  * Tidy up layout for module selection and lay everything out in a consistent best-to-worst for both class and grade
+  * Make integrity for module reinforcement packages visible
+  * Clean up breakpoints for modules in available modules list; stops 7- or 8- module long lines
+  * Add damager/range graphs to damage dealt
+  * Reorder panels
+  * Use coriolis-data 2.2.18:
+    * Correct lower efficiency value to be better, not worse
+
+#2.2.17
+  * Use in-game terminology for shield generator optmul and optmass items
+  * Add crew to shipyard and outfitting page information
+  * Use coriolis-data 2.2.17:
+    * Add mass as potential SCB modification
+    * Fix mining laser statistics
+    * Remove non-existent grade 4 and 5 wake scanner modifications
+    * Add number of crew for each ship
+
+#2.2.16
+  * Fix 'Extreme' blueprint roll where some incorrect ranges were chosen
+  * Use coriolis-data 2.2.16:
+    * Fix incorrect thermal load modifiers for dirty drives
+    * Provide explicit information about if values are higher numeric value == better or not
+
+#2.2.15
+  * Ensure that standard slots are repainted when any component changes
+  * Reload page if Safari throws a security error
+  * Handle import of ships with incorrectly-sized slots
+  * Add 'Extreme' blueprint roll: best beneficial and worst detrimental outcome (in place of 'Average' roll)
+  * Display information about Microsoft browser issues when an import fails
+  * Add 'purchase this build' icon link to EDDB
+  * Add 'miner' and 'shielded miner' ship roles
+  * Use coriolis-data 2.2.15:
+    * Fix location of initial cargo rack for Vulture
+    * Fix broken regeneration rate for 6B shield generators
+    * Tidy up breach damage values
+
+#2.2.14
+  * Ensure that jitter is shown correctly when the result of a special effect
+  * Use restyled blueprint information
+  * Use the ship name (if available) rather than the ship model for the window title
+  * Use coriolis-data 2.2.14:
+    * Alter blueprint structure to combine components and features
+    * Make hidden value of modifications its own attribute
+    * Fix incorrect ED ID for class 6 passenger cabins
+
+#2.2.13
+  * Add 'time to drain' summary value.  This is the time to drain the WEP capacitor if firing all enabled weapons
+  * Do not include utility slot DPS/EPS/HPS in summary information
+  * Ensure that auto loader special shows in the tooltip
+  * Ensure that ship mass is recalculated when appropriate
+  * Use coriolis-data 2.2.13:
+    * Add plasma slug special effect for plasma accelerator
+    * Tweak hull costs of ships
+
+#2.2.12
+  * Tidy up old references to coriolis.io
+  * Add ability to add and remove special effects to weapon modifications
+  * Add weapon engineering information to Damage Dealt section
+  * Change shortcut for link from ctrl-l to ctrl-o to avoid clash with location bar
+  * Only show one of power generation or draw in tooltips, according to module
+  * Use coriolis-data 2.2.12:
+    * Add special effects for each blueprint
+    * Add IDs for most Powerplay modules
+
+#2.2.11
+  * Add help system and initial help file
+  * Make absolute damage visible
+  * Add 'average' roll for blueprints
+  * Update spacing for movement summary to make it more readable
+  * Provide damage dealt statistics for both shields and hull
+  * Damage dealt panel only shows enabled weapons
+  * Add engagement range to damage received panel
+  * Handle burst rate of fire as an absolute number rather than a perentage modification
+  * Ensure that clip values are always rounded up
+  * Ensure that focused weapon mod uses range modifier to increase falloff as well
+  * Use coriolis-data 2.2.11:
+    * Remove non-existent chaff launcher capacity blueprint grades
+    * Fix incorrect values for charge enhanced power distributor
+    * Remove incorrect AFMU blueprints
+    * Correct fragment cannon Double Shot blueprint information
+    * Correct Focused weapon blueprint information
+
+#2.2.10
+  * Fix detailed export of module reinforcement packages
+  * Use damagedist for exact breakdown of weapons that have more than one type of damage
+  * Use new-style modification validity data
+  * Provide ability to select engineering blueprint and roll sample values for them
+  * Use coriolis-data 2.2.10:
+    * Fix incorrect base shield values for Cutter and Corvette
+    * Update weapons to have %-based damage distributions
+    * Remove power draw for detailed surface scanner - although shown in outfitting it is not part of active power
+    * Fix incorrect names for lightweight and kinetic armour
+    * Add engineering blueprints
+
+#2.2.9
+  * Use SSL-enabled server for shortlinks
+  * Add falloff for weapons
+  * Use falloff when calculating weapon effectiveness in damage dealt
+  * Add engagement range slider to 'Damage Dealt' section to allow user to see change in weapon effectiveness with range
+  * Use better DPE calculation methodology
+  * Add total DPS and effectiveness information to 'Damage Dealt' section
+  * Use coriolis-data 2.2.9:
+    * Add falloff metric for weapons
+    * Add falloff from range modification
+
+#2.2.8
+  * Fix issue where filling all internals with cargo racks would include restricted slots
+  * Use coriolis-data 2.2.8:
+    * Set military slot of Viper Mk IV to class 3; was incorrectly set as class 2
+    * Update base regeneration rate of prismatic shield generators to values in 2.2.03
+    * Update specials with information in 2.2.03
+
+#2.2.7
+  * Fix resistance diminishing return calculations
+  * Do not allow -100% to be entered as a modification value
+
+#2.2.6
+  * Add pitch/roll/yaw information
+  * Use combination of pitch, roll and yaw to provide a more useful agility metric
+  * Add movement summary to outfitting page
+  * Add standard internal class sizes to shipyard page
+  * Fix issue when importing Viper Mk IV
+  * Ensure ordering of all types of modules (standard, internal, utilities) is consistent
+  * Add rebuilds per bay information for fighter hangars
+  * Add ability to show military compartments
+  * Show module reinforcement package results in defence summary
+  * Use separate speed/rotation/acceleration multipliers for thrusters if available
+  * Obey restricted slot rules when adding all for internal slots
+  * Version URLs to handle changes to ship specifications over time
+  * Do not include disabled shield boosters in calculations
+  * Add 'Damage dealt' section
+  * Add 'Damage received' section
+  * Add 'Piercing' information to hardpoints
+  * Add 'Hardness' information to ship summary
+  * Add module copy functionality - drag module whilst holding 'alt' to copy
+  * Add base resistances to defence summary tooltip
+  * Update shield recovery/regeneration calculations
+  * Pin menu to top of page
+  * Switch to custom shortlink method to avoid google length limitations
+  * Ensure that information is not lost on narrow screens
+  * Do not lose ship selector selection on narrow screens
+  * Reinstate jump range graph
+  * Use coriolis-data 2.2.6:
+    * Update weapons with changed values for 2.2.03
+    * Add individual pitch/roll/yaw statistics for each ship
+    * Remove old and meaningless agility stat
+    * Use sane order for multi-module JSON - coriolis can re-order as it sees fit when displaying modules
+    * Fix cost of fighter hangars
+    * Update Powerplay weapons with current statistics
+    * Add separate min/opt/max multipliers for enhanced thrusters for speed, acceleration and rotation
+    * Add module reinforcement packages
+    * Add military compartments
+    * Fix missing damage value for 2B dumbfires
+    * Update shield recharge rates
+    * Reduce hull mass of Viper to 50T
+    * Fix incorrect optimal mass value for 8A thrusters
+    * Add power draw for detailed surface scanner
+
+#2.2.5
+  * Calculate rate of fire for multi-burst weapons
+  * Add note to disable ghostery in error situation
+  * Use coriolis-data 2.2.5:
+    * Fix incorrect ID for emissive munitions special
+    * Fix rate of fire for burst lasers
+    * Add fragment cannon modifications
+    * Fix internal name of dazzle shell
+
+#2.2.4
+  * Add shortlink for outfitting page
+  * Use coriolis-data 2.2.4:
+    * Fix incorrect ID for class 5 luxury passenger cabin
+    * Add damage type modifier
+    * Change modifications from simple strings to objects, to allow more data-driven behaviour
+    * Add special effects
+  * Modification tooltip now shows special effect
+
+#2.2.3
+  * Fix hull boost calculation - now shows correct % modifier and total armour
+  * Fix import of DiamondBack - can now be imported
+  * Fix import of Beluga - can now be imported
+  * Use coriolis-data 2.2.3:
+    * Fix mismatch between class 5 and class 7 fighter hangars - now shows correct module
+    * Add details for concordant sequence special effect - now shows correct damage
+    * Fix details for thermal shock special effect - now shows correct damage
+    * Add engineer blueprints
+  * Modification tooltip now shows name and grade of modifications for imported builds
+  * Retain import URL unless user changes the build - allows future updates of Coriolis to take advantage of additional build information
+
+#2.2.2
   * Update DPS/HPS/EPS in real-time as modifiers change
   * Use coriolis-data 2.2.2:
     * Add distributor draw modifier to shield generators

README.md

@@ -16,7 +16,7 @@ Chat to us on [Discord](https://discord.gg/0uwCh6R62aPRjk9w)!
 
 ## Development
 
-See the [Developer's Guide](https://github.com/cmmcleod/coriolis/wiki/Developer's-Guide) in the wiki.
+See the [Developer's Guide](https://github.com/EDCD/coriolis/wiki/Developing-for-Coriolis) in the wiki.
 
 
 ### Ship and Module Database

__tests__/fixtures/agility-data.json

@@ -0,0 +1,30 @@
+{
+  "adder": {
+    "t3": {"speed": 205, "boost": 298, "pitch": 35.37, "roll": 93.09, "yaw": 13.03},
+    "t2": {"speed": 209, "boost": 304, "pitch": 36.06, "roll": 94.90, "yaw": 13.29},
+    "t1": {"speed": 213, "boost": 310, "pitch": 36.80, "roll": 96.84, "yaw": 13.56},
+    "t0": {"speed": 218, "boost": 317, "pitch": 37.70, "roll": 99.20, "yaw": 13.89},
+    "t9": {"speed": 220, "boost": 321, "pitch": 38.08, "roll": 100.21, "yaw": 14.03},
+    "t8": {"speed": 225, "boost": 327, "pitch": 38.86, "roll": 102.26, "yaw": 14.32},
+    "t7": {"speed": 230, "boost": 334, "pitch": 39.69, "roll": 104.44, "yaw": 14.62},
+    "t6": {"speed": 234, "boost": 340, "pitch": 40.41, "roll": 106.34, "yaw": 14.89},
+    "t5": {"speed": 242, "boost": 351, "pitch": 41.71, "roll": 109.78, "yaw": 15.37}
+  },
+  "eagle": {
+    "t2": {"speed": 223, "boost": 325, "pitch": 46.45, "roll": 111.48, "yaw": 16.72},
+    "t1": {"speed": 229, "boost": 334, "pitch": 47.69, "roll": 114.46, "yaw": 17.17},
+    "t0": {"speed": 235, "boost": 343, "pitch": 49.00, "roll": 117.60, "yaw": 17.64},
+    "t9": {"speed": 239, "boost": 349, "pitch": 49.80, "roll": 119.53, "yaw": 17.93},
+    "t8": {"speed": 243, "boost": 355, "pitch": 50.70, "roll": 121.69, "yaw": 18.25},
+    "t7": {"speed": 248, "boost": 361, "pitch": 51.62, "roll": 123.89, "yaw": 18.58},
+    "t6": {"speed": 252, "boost": 367, "pitch": 52.46, "roll": 125.91, "yaw": 18.89},
+    "t5": {"speed": 259, "boost": 378, "pitch": 53.99, "roll": 129.56, "yaw": 19.43}
+  },
+  "hauler": {
+    "t4": {"speed": 203, "boost": 305, "pitch": 36.61, "roll": 101.71, "yaw": 14.24},
+    "t3": {"speed": 209, "boost": 314, "pitch": 37.63, "roll": 104.54, "yaw": 14.64},
+    "t2": {"speed": 216, "boost": 324, "pitch": 38.89, "roll": 108.03, "yaw": 15.12},
+    "t1": {"speed": 222, "boost": 333, "pitch": 39.97, "roll": 111.02, "yaw": 15.54},
+    "t0": {"speed": 232, "boost": 348, "pitch": 41.76, "roll": 116.00, "yaw": 16.24}
+  }
+}

__tests__/fixtures/anaconda-test-detailed-export-v4.json

@@ -25,7 +25,7 @@
         "priority": 1,
         "modifications": {
           "pgen": 1000
-	}
+        }
       },
       "thrusters": {
         "class": 6,
@@ -223,6 +223,7 @@
       },
       null,
       null,
+      null,
       {
         "class": 4,
         "rating": "E",
@@ -261,53 +262,65 @@
     "topSpeed": 186.5,
     "boost": 240,
     "boostEnergy": 27,
-    "topBoost": 248.62,
-    "topSpeed": 186.46,
+    "topBoost": 249.34,
+    "topPitch": 25.97,
+    "topRoll": 62.34,
+    "topYaw": 10.39,
+    "topSpeed": 187.01,
     "totalCost": 882362058,
-    "totalDpe": 127.26,
-    "totalDps": 97.74,
-    "totalEps": 22.71,
-    "totalHps": 677.29,
+    "totalDpe": 142.68,
+    "totalDps": 101.13,
+    "totalEps": 18.71,
     "totalExplDpe": 0,
     "totalExplDps": 0,
     "totalExplSDps": 0,
-    "totalHps": 33.28,
-    "totalKinDpe": 103.97,
-    "totalKinDps": 28.92,
-    "totalKinSDps": 21.23,
-    "totalSDps": 85.77,
-    "totalThermDpe": 23.29,
-    "totalThermDps": 68.82,
-    "totalThermSDps": 64.53,
-    "agility": 2,
+    "totalAbsDpe": 3.57,
+    "totalAbsDps": 18.78,
+    "totalAbsSDps": 14.45,
+    "totalHps": 28.28,
+    "totalKinDpe": 117.48,
+    "totalKinDps": 22.27,
+    "totalKinSDps": 16.91,
+    "totalSDps": 89.99,
+    "totalThermDpe": 21.63,
+    "totalThermDps": 60.08,
+    "totalThermSDps": 58.64,
     "baseShieldStrength": 350,
     "baseArmour": 945,
-    "hullExplRes": 0.78,
-    "hullKinRes": 0.73,
+    "hullExplRes": 0.22,
+    "hullKinRes": 0.27,
     "hullMass": 400,
-    "hullThermRes": 1.37,
+    "hullThermRes": -0.36,
     "masslock": 23,
     "pipSpeed": 0.14,
+    "pitch": 25,
     "moduleCostMultiplier": 1,
+    "modulearmour": 0,
+    "moduleprotection": 0,
     "fuelCapacity": 32,
     "cargoCapacity": 128,
-    "ladenMass": 1339.2,
+    "ladenMass": 1323.2,
     "armour": 2227.5,
     "baseArmour": 525,
-    "unladenMass": 1179.2,
+    "unladenMass": 1163.2,
     "powerAvailable": 39.6,
     "powerRetracted": 23.33,
-    "powerDeployed": 34.76,
-    "unladenRange": 18.49,
-    "fullTankRange": 18.12,
-    "ladenRange": 16.39,
-    "unladenFastestRange": 73.21,
-    "ladenFastestRange": 66.15,
+    "powerDeployed": 34.13,
+    "roll": 60,
+    "unladenRange": 18.74,
+    "yaw": 10,
+    "fullTankRange": 18.36,
+    "hardness": 65,
+    "ladenRange": 16.59,
+    "unladenFastestRange": 74.2,
+    "ladenFastestRange": 66.96,
     "maxJumpCount": 4,
     "shield": 833,
     "shieldCells": 1840,
     "shieldExplRes": 0.5,
-    "shieldKinRes": 0.6,
-    "shieldThermRes": 1.2
+    "shieldKinRes": 0.4,
+    "shieldThermRes": -0.2,
+    "timeToDrain": 7.04,
+    "crew": 3
   }
 }

__tests__/fixtures/asp-test-detailed-export-v4.json

@@ -0,0 +1,255 @@
+{
+  "$schema": "http://cdn.coriolis.io/schemas/ship-loadout/4.json#",
+  "name": "Multi-purpose Asp Explorer",
+  "ship": "Asp Explorer",
+  "references": [
+    {
+      "name": "Coriolis.io",
+      "url": "https://coriolis.edcd.io/outfit/asp?code=0pftiFflfddsnf5------020202033c044002v62f2i.AwRj4yvI.CwRgDBldHnJA.H4sIAAAAAAAAA2P858DAwPCXEUhwHPvx%2F78YG5AltB7I%2F8%2F0TwImJboDSPJ%2F%2B%2Ff%2Fv%2FKlX%2F%2F%2Fi3AwMTBIfARK%2FGf%2BJwVSxArStVAYqOjvz%2F%2F%2FJVo5GRhE2IBc4SKQSSz%2FDGEmCa398P8%2F%2F2%2BgTf%2F%2FAwDFxwtofAAAAA%3D%3D&bn=Multi-purpose%20Asp%20Explorer",
+      "code": "0pftiFflfddsnf5------020202033c044002v62f2i.AwRj4yvI.CwRgDBldHnJA.H4sIAAAAAAAAA2P858DAwPCXEUhwHPvx/78YG5AltB7I/8/0TwImJboDSPJ/+/f/v/KlX///i3AwMTBIfARK/Gf+JwVSxArStVAYqOjvz///JVo5GRhE2IBc4SKQSSz/DGEmCa398P8//2+gTf//AwDFxwtofAAAAA==",
+      "shipId": "asp"
+    }
+  ],
+  "components": {
+    "standard": {
+      "bulkheads": "Lightweight Alloy",
+      "cargoHatch": {
+        "enabled": false,
+        "priority": 5
+      },
+      "powerPlant": {
+        "class": 5,
+        "rating": "A",
+        "enabled": true,
+        "priority": 2,
+        "modifications": {
+          "eff": -1850,
+          "pgen": 6,
+          "mass": 431
+        },
+        "blueprint": {
+          "id": 64,
+          "name": "Low emissions",
+          "grade": 1
+        }
+      },
+      "thrusters": {
+        "class": 5,
+        "rating": "D",
+        "enabled": true,
+        "priority": 1,
+        "modifications": {
+          "optmul": 440,
+          "integrity": -266,
+          "thermload": -1326,
+          "optmass": 520,
+          "power": 241
+        },
+        "blueprint": {
+          "id": 24,
+          "name": "Clean",
+          "grade": 1
+        }
+      },
+      "frameShiftDrive": {
+        "class": 5,
+        "rating": "A",
+        "enabled": true,
+        "priority": 1,
+        "modifications": {
+          "mass": 5025,
+          "integrity": -1539,
+          "power": 2437,
+          "optmass": 4870,
+          "maxfuel": 370
+        },
+        "blueprint": {
+          "id": 26,
+          "name": "Increased range",
+          "grade": 5
+        }
+      },
+      "lifeSupport": {
+        "class": 4,
+        "rating": "A",
+        "enabled": true,
+        "priority": 1,
+        "modifications": {
+          "mass": -3923,
+          "integrity": -1797
+        },
+        "blueprint": {
+          "id": 49,
+          "name": "Lightweight",
+          "grade": 1
+        }
+      },
+      "powerDistributor": {
+        "class": 3,
+        "rating": "D",
+        "enabled": true,
+        "priority": 1
+      },
+      "sensors": {
+        "class": 5,
+        "rating": "D",
+        "enabled": true,
+        "priority": 1
+      },
+      "fuelTank": {
+        "class": 5,
+        "rating": "C",
+        "enabled": true,
+        "priority": 1
+      }
+    },
+    "hardpoints": [
+      null,
+      null,
+      null,
+      null,
+      null,
+      null
+    ],
+    "utility": [
+      {
+        "class": 0,
+        "rating": "I",
+        "enabled": true,
+        "priority": 1,
+        "group": "Heat Sink Launcher",
+        "name": "Heat Sink Launcher"
+      },
+      {
+        "class": 0,
+        "rating": "I",
+        "enabled": true,
+        "priority": 1,
+        "group": "Heat Sink Launcher",
+        "name": "Heat Sink Launcher"
+      },
+      {
+        "class": 0,
+        "rating": "I",
+        "enabled": true,
+        "priority": 1,
+        "group": "Heat Sink Launcher",
+        "name": "Heat Sink Launcher"
+      },
+      {
+        "class": 0,
+        "rating": "I",
+        "enabled": true,
+        "priority": 1,
+        "group": "Point Defence",
+        "name": "Point Defence"
+      }
+    ],
+    "internal": [
+      {
+        "class": 6,
+        "rating": "A",
+        "enabled": true,
+        "priority": 1,
+        "group": "Fuel Scoop"
+      },
+      {
+        "class": 5,
+        "rating": "E",
+        "enabled": true,
+        "priority": 2,
+        "group": "Cargo Rack"
+      },
+      {
+        "class": 3,
+        "rating": "A",
+        "enabled": true,
+        "priority": 1,
+        "group": "Shield Generator"
+      },
+      {
+        "class": 3,
+        "rating": "E",
+        "enabled": true,
+        "priority": 2,
+        "group": "Cargo Rack"
+      },
+      {
+        "class": 2,
+        "rating": "G",
+        "enabled": true,
+        "priority": 1,
+        "group": "Planetary Vehicle Hangar"
+      },
+      {
+        "class": 1,
+        "rating": "C",
+        "enabled": true,
+        "priority": 2,
+        "group": "Scanner",
+        "name": "Advanced Discovery Scanner"
+      },
+      {
+        "class": 1,
+        "rating": "C",
+        "enabled": true,
+        "priority": 2,
+        "group": "Scanner",
+        "name": "Detailed Surface Scanner"
+      }
+    ]
+  },
+  "stats": {
+    "class": 2,
+    "hullCost": 6135660,
+    "speed": 250,
+    "boost": 340,
+    "boostEnergy": 13,
+    "agility": 6,
+    "baseShieldStrength": 140,
+    "baseArmour": 210,
+    "hullMass": 280,
+    "masslock": 11,
+    "pipSpeed": 0.13,
+    "moduleCostMultiplier": 1,
+    "fuelCapacity": 32,
+    "cargoCapacity": 40,
+    "ladenMass": 435.26,
+    "armour": 378,
+    "shield": 113.43,
+    "shieldCells": 0,
+    "totalCost": 48402550,
+    "unladenMass": 363.26,
+    "totalDpe": 0,
+    "totalExplDpe": 0,
+    "totalKinDpe": 0,
+    "totalThermDpe": 0,
+    "totalDps": 0,
+    "totalExplDps": 0,
+    "totalKinDps": 0,
+    "totalThermDps": 0,
+    "totalSDps": 0,
+    "totalExplSDps": 0,
+    "totalKinSDps": 0,
+    "totalThermSDps": 0,
+    "totalEps": 1.2,
+    "totalHps": 1,
+    "shieldExplRes": 0.5,
+    "shieldKinRes": 0.6,
+    "shieldThermRes": 1.2,
+    "hullExplRes": 1.4,
+    "hullKinRes": 1.2,
+    "hullThermRes": 1,
+    "powerAvailable": 20.41,
+    "powerRetracted": 11.91,
+    "powerDeployed": 11.91,
+    "unladenRange": 50.45,
+    "fullTankRange": 47.03,
+    "ladenRange": 42.71,
+    "unladenFastestRange": 317.24,
+    "ladenFastestRange": 287.02,
+    "maxJumpCount": 7,
+    "topSpeed": 274.01,
+    "topBoost": 372.65
+  }
+}

__tests__/fixtures/companion-api-import-2.json

@@ -0,0 +1,552 @@
+{
+  "cargo": {
+    "capacity": 32
+  },
+  "free": false,
+  "fuel": {
+    "main": {
+      "capacity": 128
+    },
+    "reserve": {
+      "capacity": 0.81
+    }
+  },
+  "id": 31,
+  "modules": {
+    "Armour": {
+      "module": {
+        "free": false,
+        "id": 128049346,
+        "name": "BelugaLiner_Armour_Grade1",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 0
+      }
+    },
+    "Bobble01": [],
+    "Bobble02": [],
+    "Bobble03": [],
+    "Bobble04": [],
+    "Bobble05": [],
+    "Bobble06": [],
+    "Bobble07": [],
+    "Bobble08": [],
+    "Bobble09": [],
+    "Bobble10": [],
+    "Decal1": {
+      "module": {
+        "free": false,
+        "id": 128667757,
+        "name": "Decal_Explorer_Ranger",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 0
+      }
+    },
+    "Decal2": {
+      "module": {
+        "free": false,
+        "id": 128667742,
+        "name": "Decal_Combat_Deadly",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 0
+      }
+    },
+    "Decal3": {
+      "module": {
+        "free": false,
+        "id": 128667750,
+        "name": "Decal_Trade_Tycoon",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 0
+      }
+    },
+    "EngineColour": [],
+    "FrameShiftDrive": {
+      "module": {
+        "free": false,
+        "id": 128064132,
+        "modifiers": {
+          "engineerID": 300100,
+          "id": 175,
+          "modifiers": [
+            {
+              "name": "mod_mass",
+              "type": 1,
+              "value": 0.4457540512085
+            },
+            {
+              "name": "mod_health",
+              "type": 1,
+              "value": -0.24584779143333
+            },
+            {
+              "name": "mod_passive_power",
+              "type": 1,
+              "value": 0.24457727372646
+            },
+            {
+              "name": "mod_fsd_optimised_mass",
+              "type": 1,
+              "value": 0.49257898330688
+            },
+            {
+              "name": "mod_fsd_max_fuel_per_jump",
+              "type": 2,
+              "value": 0.028505677357316
+            },
+            {
+              "name": "mod_fsd_heat_rate",
+              "type": 2,
+              "value": -0.079360365867615
+            }
+          ],
+          "moduleTags": [
+            16
+          ],
+          "recipeID": 128673694,
+          "slotIndex": 53
+        },
+        "name": "Int_Hyperdrive_Size7_Class5",
+        "on": true,
+        "priority": 0,
+        "recipeLevel": 5,
+        "recipeName": "FSD_LongRange",
+        "recipeValue": 0,
+        "unloaned": 0,
+        "value": 46160201
+      }
+    },
+    "FuelTank": {
+      "module": {
+        "free": false,
+        "id": 128064352,
+        "name": "Int_FuelTank_Size7_Class3",
+        "on": true,
+        "priority": 1,
+        "unloaned": 1602822,
+        "value": 1602822
+      }
+    },
+    "LifeSupport": {
+      "module": {
+        "free": false,
+        "id": 128064174,
+        "name": "Int_LifeSupport_Size8_Class2",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 1569565
+      }
+    },
+    "MainEngines": {
+      "module": {
+        "free": false,
+        "id": 128064094,
+        "modifiers": {
+          "engineerID": 300100,
+          "id": 253,
+          "modifiers": [
+            {
+              "name": "mod_engine_mass_curve_multiplier",
+              "type": 1,
+              "value": 0.098235413432121
+            },
+            {
+              "name": "mod_engine_heat",
+              "type": 1,
+              "value": 0.18069696426392
+            },
+            {
+              "name": "mod_passive_power",
+              "type": 1,
+              "value": 0.033788848668337
+            },
+            {
+              "name": "mod_health",
+              "type": 1,
+              "value": -0.056404989212751
+            },
+            {
+              "name": "mod_engine_mass_curve",
+              "type": 1,
+              "value": -0.027384582906961
+            },
+            {
+              "name": "mod_engine_heat",
+              "type": 2,
+              "value": -0.072683908045292
+            }
+          ],
+          "moduleTags": [
+            17
+          ],
+          "recipeID": 128673655,
+          "slotIndex": 52
+        },
+        "name": "Int_Engine_Size7_Class2",
+        "on": true,
+        "priority": 0,
+        "recipeLevel": 1,
+        "recipeName": "Engine_Dirty",
+        "recipeValue": 0,
+        "unloaned": 0,
+        "value": 1709638
+      }
+    },
+    "MediumHardpoint1": {
+      "module": {
+        "free": false,
+        "id": 128049436,
+        "name": "Hpt_BeamLaser_Turret_Medium",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 1889910
+      }
+    },
+    "MediumHardpoint2": {
+      "module": {
+        "free": false,
+        "id": 128049436,
+        "name": "Hpt_BeamLaser_Turret_Medium",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 1889910
+      }
+    },
+    "MediumHardpoint3": {
+      "module": {
+        "free": false,
+        "id": 128049460,
+        "name": "Hpt_MultiCannon_Gimbal_Medium",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 51300
+      }
+    },
+    "MediumHardpoint4": {
+      "module": {
+        "free": false,
+        "id": 128049460,
+        "name": "Hpt_MultiCannon_Gimbal_Medium",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 51300
+      }
+    },
+    "MediumHardpoint5": {
+      "module": {
+        "free": false,
+        "id": 128049460,
+        "name": "Hpt_MultiCannon_Gimbal_Medium",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 51300
+      }
+    },
+    "PaintJob": {
+      "module": {
+        "free": false,
+        "id": 128732290,
+        "name": "PaintJob_BelugaLiner_Tactical_White",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 0
+      }
+    },
+    "PlanetaryApproachSuite": {
+      "module": {
+        "free": false,
+        "id": 128672317,
+        "name": "Int_PlanetApproachSuite",
+        "on": true,
+        "priority": 1,
+        "unloaned": 450,
+        "value": 450
+      }
+    },
+    "PowerDistributor": {
+      "module": {
+        "free": false,
+        "id": 128064207,
+        "name": "Int_PowerDistributor_Size6_Class5",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 3128120
+      }
+    },
+    "PowerPlant": {
+      "module": {
+        "free": false,
+        "id": 128064057,
+        "modifiers": {
+          "engineerID": 300100,
+          "id": 277,
+          "modifiers": [
+            {
+              "name": "mod_powerplant_power",
+              "type": 1,
+              "value": 0.054692290723324
+            },
+            {
+              "name": "mod_health",
+              "type": 1,
+              "value": -0.033690698444843
+            },
+            {
+              "name": "mod_powerplant_heat",
+              "type": 1,
+              "value": 0.027470717206597
+            },
+            {
+              "name": "mod_powerplant_heat",
+              "type": 2,
+              "value": -0.056317910552025
+            }
+          ],
+          "moduleTags": [
+            18
+          ],
+          "recipeID": 128673765,
+          "slotIndex": 51
+        },
+        "name": "Int_Powerplant_Size6_Class5",
+        "on": true,
+        "priority": 1,
+        "recipeLevel": 1,
+        "recipeName": "PowerPlant_Boosted",
+        "recipeValue": 0,
+        "unloaned": 0,
+        "value": 14561578
+      }
+    },
+    "Radar": {
+      "module": {
+        "free": false,
+        "id": 128064239,
+        "name": "Int_Sensors_Size5_Class2",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 71500
+      }
+    },
+    "Slot01_Size6": {
+      "module": {
+        "free": false,
+        "id": 128666681,
+        "name": "Int_FuelScoop_Size6_Class5",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 25887249
+      }
+    },
+    "Slot02_Size6": {
+      "module": {
+        "free": false,
+        "id": 128064287,
+        "name": "Int_ShieldGenerator_Size6_Class5",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 14561578
+      }
+    },
+    "Slot03_Size6": {
+      "module": {
+        "free": false,
+        "id": 128727927,
+        "name": "Int_PassengerCabin_Size6_Class2",
+        "on": true,
+        "priority": 1,
+        "unloaned": 165808,
+        "value": 165808
+      }
+    },
+    "Slot04_Size6": {
+      "module": {
+        "free": false,
+        "id": 128727928,
+        "name": "Int_PassengerCabin_Size6_Class3",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 497429
+      }
+    },
+    "Slot05_Size5": {
+      "module": {
+        "free": false,
+        "id": 128727925,
+        "name": "Int_PassengerCabin_Size5_Class4",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 1492286
+      }
+    },
+    "Slot06_Size5": {
+      "module": {
+        "free": false,
+        "id": 128064342,
+        "name": "Int_CargoRack_Size5_Class1",
+        "on": true,
+        "priority": 1,
+        "unloaned": 100409,
+        "value": 100409
+      }
+    },
+    "Slot07_Size4": {
+      "module": {
+        "free": false,
+        "id": 128727922,
+        "name": "Int_PassengerCabin_Size4_Class1",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 17059
+      }
+    },
+    "Slot08_Size3": {
+      "module": {
+        "free": false,
+        "id": 128667632,
+        "name": "Int_Repairer_Size3_Class5",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 2361960
+      }
+    },
+    "Slot09_Size3": {
+      "module": {
+        "free": false,
+        "id": 128672289,
+        "name": "Int_BuggyBay_Size2_Class2",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 19440
+      }
+    },
+    "Slot10_Size3": {
+      "module": {
+        "free": false,
+        "id": 128666634,
+        "name": "Int_DetailedSurfaceScanner_Tiny",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 225000
+      }
+    },
+    "Slot11_Size3": {
+      "module": {
+        "free": false,
+        "id": 128663561,
+        "name": "Int_StellarBodyDiscoveryScanner_Advanced",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 1390500
+      }
+    },
+    "TinyHardpoint1": {
+      "module": {
+        "free": false,
+        "id": 128049513,
+        "name": "Hpt_ChaffLauncher_Tiny",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 7650
+      }
+    },
+    "TinyHardpoint2": {
+      "module": {
+        "free": false,
+        "id": 128668536,
+        "name": "Hpt_ShieldBooster_Size0_Class5",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 252900
+      }
+    },
+    "TinyHardpoint3": {
+      "module": {
+        "free": false,
+        "id": 128668536,
+        "name": "Hpt_ShieldBooster_Size0_Class5",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 252900
+      }
+    },
+    "TinyHardpoint4": {
+      "module": {
+        "free": false,
+        "id": 128668536,
+        "name": "Hpt_ShieldBooster_Size0_Class5",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 281000
+      }
+    },
+    "TinyHardpoint5": {
+      "module": {
+        "free": false,
+        "id": 128668536,
+        "name": "Hpt_ShieldBooster_Size0_Class5",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 281000
+      }
+    },
+    "TinyHardpoint6": {
+      "module": {
+        "free": false,
+        "id": 128668536,
+        "name": "Hpt_ShieldBooster_Size0_Class5",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 281000
+      }
+    },
+    "WeaponColour": {
+      "module": {
+        "free": false,
+        "id": 128732194,
+        "name": "WeaponCustomisation_Purple",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 0
+      }
+    }
+  },
+  "name": "BelugaLiner",
+  "value": {
+    "hull": 71688743,
+    "modules": 120812762,
+    "unloaned": 1869489
+  }
+}

__tests__/fixtures/companion-api-import-3.json

@@ -0,0 +1,314 @@
+{
+  "cargo": {
+    "capacity": 264
+  },
+  "free": false,
+  "fuel": {
+    "main": {
+      "capacity": 32
+    },
+    "reserve": {
+      "capacity": 0.52
+    }
+  },
+  "id": 4,
+  "modules": {
+    "Armour": {
+      "module": {
+        "free": false,
+        "id": 128049298,
+        "name": "Type7_Armour_Grade1",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 0
+      }
+    },
+    "Bobble01": [],
+    "Bobble02": [],
+    "Bobble03": [],
+    "Bobble04": [],
+    "Bobble05": [],
+    "Bobble06": [],
+    "Bobble07": [],
+    "Bobble08": [],
+    "Bobble09": [],
+    "Bobble10": [],
+    "Decal1": {
+      "module": {
+        "free": false,
+        "id": 128667746,
+        "name": "Decal_Trade_Dealer",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 0
+      }
+    },
+    "Decal2": {
+      "module": {
+        "free": false,
+        "id": 128667738,
+        "name": "Decal_Combat_Competent",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 0
+      }
+    },
+    "Decal3": {
+      "module": {
+        "free": false,
+        "id": 128667753,
+        "name": "Decal_Explorer_Scout",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 0
+      }
+    },
+    "EngineColour": [],
+    "FrameShiftDrive": {
+      "module": {
+        "free": false,
+        "id": 128064122,
+        "name": "Int_Hyperdrive_Size5_Class5",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 5103953
+      }
+    },
+    "FuelTank": {
+      "module": {
+        "free": false,
+        "id": 128064350,
+        "name": "Int_FuelTank_Size5_Class3",
+        "on": true,
+        "priority": 1,
+        "unloaned": 97754,
+        "value": 97754
+      }
+    },
+    "LifeSupport": {
+      "module": {
+        "free": false,
+        "id": 128064154,
+        "name": "Int_LifeSupport_Size4_Class2",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 28373
+      }
+    },
+    "MainEngines": {
+      "module": {
+        "free": false,
+        "id": 128064087,
+        "name": "Int_Engine_Size5_Class5",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 5103953
+      }
+    },
+    "PaintJob": {
+      "module": {
+        "free": false,
+        "id": 128671422,
+        "name": "PaintJob_Type7_Tactical_White",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 0
+      }
+    },
+    "PlanetaryApproachSuite": {
+      "module": {
+        "free": false,
+        "id": 128672317,
+        "name": "Int_PlanetApproachSuite",
+        "on": true,
+        "priority": 1,
+        "unloaned": 500,
+        "value": 500
+      }
+    },
+    "PowerDistributor": {
+      "module": {
+        "free": false,
+        "id": 128064192,
+        "name": "Int_PowerDistributor_Size3_Class5",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 158331
+      }
+    },
+    "PowerPlant": {
+      "module": {
+        "free": false,
+        "id": 128064047,
+        "name": "Int_Powerplant_Size4_Class5",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 1610080
+      }
+    },
+    "Radar": {
+      "module": {
+        "free": false,
+        "id": 128064229,
+        "name": "Int_Sensors_Size3_Class2",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 10133
+      }
+    },
+    "Slot01_Size6": {
+      "module": {
+        "free": false,
+        "id": 128064343,
+        "name": "Int_CargoRack_Size6_Class1",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 362591
+      }
+    },
+    "Slot02_Size6": {
+      "module": {
+        "free": false,
+        "id": 128064343,
+        "name": "Int_CargoRack_Size6_Class1",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 362591
+      }
+    },
+    "Slot03_Size5": {
+      "module": {
+        "free": false,
+        "id": 128064343,
+        "name": "Int_CargoRack_Size6_Class1",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 362591
+      }
+    },
+    "Slot04_Size5": {
+      "module": {
+        "free": false,
+        "id": 128064342,
+        "name": "Int_CargoRack_Size5_Class1",
+        "on": true,
+        "priority": 1,
+        "unloaned": 111566,
+        "value": 111566
+      }
+    },
+    "Slot05_Size4": {
+      "module": {
+        "free": false,
+        "id": 128064342,
+        "name": "Int_CargoRack_Size5_Class1",
+        "on": true,
+        "priority": 1,
+        "unloaned": 111566,
+        "value": 111566
+      }
+    },
+    "Slot06_Size4": {
+      "module": {
+        "free": false,
+        "id": 128064279,
+        "name": "Int_ShieldGenerator_Size5_Class2",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 189035
+      }
+    },
+    "Slot07_Size2": {
+      "module": {
+        "free": false,
+        "id": 128049549,
+        "name": "Int_DockingComputer_Standard",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 4500
+      }
+    },
+    "Slot08_Size2": {
+      "module": {
+        "free": false,
+        "id": 128064340,
+        "name": "Int_CargoRack_Size3_Class1",
+        "on": true,
+        "priority": 1,
+        "unloaned": 0,
+        "value": 10563
+      }
+    },
+    "SmallHardpoint1": [],
+    "SmallHardpoint2": [],
+    "SmallHardpoint3": [],
+    "SmallHardpoint4": [],
+    "TinyHardpoint1": {
+      "module": {
+        "free": false,
+        "id": 128668536,
+        "name": "Hpt_ShieldBooster_Size0_Class5",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 281000
+      }
+    },
+    "TinyHardpoint2": {
+      "module": {
+        "free": false,
+        "id": 128668536,
+        "name": "Hpt_ShieldBooster_Size0_Class5",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 281000
+      }
+    },
+    "TinyHardpoint3": {
+      "module": {
+        "free": false,
+        "id": 128668536,
+        "name": "Hpt_ShieldBooster_Size0_Class5",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 281000
+      }
+    },
+    "TinyHardpoint4": {
+      "module": {
+        "free": false,
+        "id": 128049513,
+        "name": "Hpt_ChaffLauncher_Tiny",
+        "on": true,
+        "priority": 0,
+        "unloaned": 0,
+        "value": 8500
+      }
+    },
+    "WeaponColour": []
+  },
+  "name": "Type7",
+  "value": {
+    "hull": 16780009,
+    "modules": 14479580,
+    "unloaned": 321386
+  }
+}

__tests__/fixtures/courier-test-detailed-export-v4.json

@@ -0,0 +1,327 @@
+{
+  "$schema": "http://cdn.coriolis.io/schemas/ship-loadout/4.json#",
+  "name": "Multi-purpose Imperial Courier",
+  "ship": "Imperial Courier",
+  "references": [
+    {
+      "name": "Coriolis.io",
+      "url": "https://coriolis.edcd.io/outfit/imperial_courier?code=0patzF5l0das8f31a1a270202000e402t0101-2f.AwRj4zKA.CwRgDBldLiQ%3D.H4sIAAAAAAAAA12OP0tCYRjFj9fuVbvF1du9ekkT8s%2FkIg4NElyIBBd321yaGvwUQTS3N7UFfYygIT9EoyQUJA36ns47XJCWA%2B%2Fz%2Bz3Pe3ImBbDNKaqNPSBoGrL4ngfomKpFGiJ%2BLgHteR1IPjxJT5pF11uSeXNsJVcRfgdC92syWUuK0iMdKZqrjJ%2F0aoA71lJ5oKf38knWcCiptCPdhJIerdS00vlK0qktlqoj983UmqqHjQ33VsW8eazFmaTyULP2hQ4lX8LBme6g%2F6v0TTdbxJ2KhdEIaCw15MF%2FNB0L%2BS2hwEwyFM8KgP%2BqEpWWA3Qu9Z3z9kPWHzakt7Dt%2BAeD7ghSTgEAAA%3D%3D&bn=Multi-purpose%20Imperial%20Courier",
+      "code": "0patzF5l0das8f31a1a270202000e402t0101-2f.AwRj4zKA.CwRgDBldLiQ=.H4sIAAAAAAAAA12OP0tCYRjFj9fuVbvF1du9ekkT8s/kIg4NElyIBBd321yaGvwUQTS3N7UFfYygIT9EoyQUJA36ns47XJCWA+/z+z3Pe3ImBbDNKaqNPSBoGrL4ngfomKpFGiJ+LgHteR1IPjxJT5pF11uSeXNsJVcRfgdC92syWUuK0iMdKZqrjJ/0aoA71lJ5oKf38knWcCiptCPdhJIerdS00vlK0qktlqoj983UmqqHjQ33VsW8eazFmaTyULP2hQ4lX8LBme6g/6v0TTdbxJ2KhdEIaCw15MF/NB0L+S2hwEwyFM8KgP+qEpWWA3Qu9Z3z9kPWHzakt7Dt+AeD7ghSTgEAAA==",
+      "shipId": "imperial_courier"
+    }
+  ],
+  "components": {
+    "standard": {
+      "bulkheads": "Lightweight Alloy",
+      "cargoHatch": {
+        "enabled": false,
+        "priority": 5
+      },
+      "powerPlant": {
+        "class": 4,
+        "rating": "A",
+        "enabled": true,
+        "priority": 2,
+        "modifications": {
+          "pgen": 1052,
+          "integrity": -482,
+          "eff": 974
+        },
+        "blueprint": {
+          "id": 63,
+          "name": "Overcharged",
+          "grade": 1
+        }
+      },
+      "thrusters": {
+        "class": 3,
+        "rating": "A",
+        "enabled": true,
+        "priority": 1,
+        "name": "Enhanced Performance",
+        "modifications": {
+          "optmul": 2476,
+          "thermload": 7023,
+          "power": 1763,
+          "integrity": 165,
+          "optmass": -667
+        },
+        "blueprint": {
+          "id": 22,
+          "name": "Dirty",
+          "grade": 4
+        }
+      },
+      "frameShiftDrive": {
+        "class": 3,
+        "rating": "A",
+        "enabled": true,
+        "priority": 1,
+        "modifications": {
+          "mass": 4082,
+          "integrity": -2422,
+          "power": 1782,
+          "optmass": 4927
+        },
+        "blueprint": {
+          "id": 26,
+          "name": "Increased range",
+          "grade": 5
+        }
+      },
+      "lifeSupport": {
+        "class": 1,
+        "rating": "A",
+        "enabled": true,
+        "priority": 1
+      },
+      "powerDistributor": {
+        "class": 3,
+        "rating": "A",
+        "enabled": true,
+        "priority": 1
+      },
+      "sensors": {
+        "class": 2,
+        "rating": "D",
+        "enabled": true,
+        "priority": 1
+      },
+      "fuelTank": {
+        "class": 3,
+        "rating": "C",
+        "enabled": true,
+        "priority": 1
+      }
+    },
+    "hardpoints": [
+      {
+        "class": 2,
+        "rating": "F",
+        "enabled": true,
+        "priority": 1,
+        "group": "Pulse Laser",
+        "mount": "Fixed",
+        "modifications": {
+          "rof": 5931,
+          "damage": -184,
+          "jitter": 50,
+          "distdraw": -4689,
+          "piercing": 3328
+        },
+        "blueprint": {
+          "id": 89,
+          "name": "Rapid fire",
+          "grade": 5
+        }
+      },
+      {
+        "class": 2,
+        "rating": "F",
+        "enabled": true,
+        "priority": 1,
+        "group": "Pulse Laser",
+        "mount": "Fixed",
+        "modifications": {
+          "rof": 4715,
+          "damage": -97,
+          "jitter": 30,
+          "distdraw": -4548,
+          "piercing": 1057,
+          "integrity": 319
+        },
+        "blueprint": {
+          "id": 89,
+          "name": "Rapid fire",
+          "grade": 5
+        }
+      },
+      {
+        "class": 2,
+        "rating": "F",
+        "enabled": true,
+        "priority": 1,
+        "group": "Multi-cannon",
+        "mount": "Gimballed",
+        "modifications": {
+          "damage": 2437,
+          "distdraw": 5487,
+          "rof": 1120,
+          "jitter": 58,
+          "thermload": 1346,
+          "power": 1009,
+          "integrity": -202,
+          "ammo": -2000
+        },
+        "blueprint": {
+          "id": 88,
+          "name": "Overcharged",
+          "grade": 3,
+          "special": {
+            "id": 3,
+            "name": "Corrosive shell"
+          }
+        }
+      }
+    ],
+    "utility": [
+      {
+        "class": 0,
+        "rating": "I",
+        "enabled": true,
+        "priority": 1,
+        "group": "Heat Sink Launcher",
+        "name": "Heat Sink Launcher",
+        "modifications": {
+          "ammo": 5000,
+          "mass": 17684,
+          "reload": 9707
+        },
+        "blueprint": {
+          "id": 37,
+          "name": "Ammo capacity",
+          "grade": 3
+        }
+      },
+      {
+        "class": 0,
+        "rating": "I",
+        "enabled": true,
+        "priority": 1,
+        "group": "Heat Sink Launcher",
+        "name": "Heat Sink Launcher",
+        "modifications": {
+          "ammo": 5000,
+          "mass": 18520,
+          "reload": 8715
+        },
+        "blueprint": {
+          "id": 37,
+          "name": "Ammo capacity",
+          "grade": 3
+        }
+      },
+      {
+        "class": 0,
+        "rating": "I",
+        "enabled": true,
+        "priority": 1,
+        "group": "Chaff Launcher",
+        "name": "Chaff Launcher"
+      },
+      {
+        "class": 0,
+        "rating": "A",
+        "enabled": true,
+        "priority": 1,
+        "group": "Frame Shift Wake Scanner"
+      }
+    ],
+    "internal": [
+      {
+        "class": 3,
+        "rating": "A",
+        "enabled": true,
+        "priority": 1,
+        "group": "Shield Generator",
+        "modifications": {
+          "optmul": 1888,
+          "explres": 455,
+          "kinres": 546,
+          "thermres": 1092,
+          "brokenregen": -2614,
+          "regen": -876,
+          "distdraw": 463
+        },
+        "blueprint": {
+          "id": 77,
+          "name": "Reinforced",
+          "grade": 3
+        }
+      },
+      {
+        "class": 3,
+        "rating": "A",
+        "enabled": true,
+        "priority": 1,
+        "group": "Fuel Scoop"
+      },
+      {
+        "class": 2,
+        "rating": "E",
+        "enabled": true,
+        "priority": 2,
+        "group": "Cargo Rack"
+      },
+      {
+        "class": 2,
+        "rating": "E",
+        "enabled": true,
+        "priority": 2,
+        "group": "Cargo Rack"
+      },
+      null,
+      {
+        "class": 1,
+        "rating": "C",
+        "enabled": true,
+        "priority": 2,
+        "group": "Scanner",
+        "name": "Advanced Discovery Scanner"
+      }
+    ]
+  },
+  "stats": {
+    "class": 1,
+    "hullCost": 2481550,
+    "speed": 280,
+    "boost": 380,
+    "boostEnergy": 10,
+    "agility": 6,
+    "baseShieldStrength": 200,
+    "baseArmour": 80,
+    "hullMass": 35,
+    "masslock": 7,
+    "pipSpeed": 0.05,
+    "moduleCostMultiplier": 1,
+    "fuelCapacity": 8,
+    "cargoCapacity": 8,
+    "ladenMass": 104.25,
+    "armour": 144,
+    "shield": 404.19,
+    "shieldCells": 0,
+    "totalCost": 14059860,
+    "unladenMass": 88.25,
+    "totalDpe": 32.25,
+    "totalExplDpe": 0,
+    "totalKinDpe": 9.41,
+    "totalThermDpe": 22.84,
+    "totalDps": 53.8,
+    "totalExplDps": 0,
+    "totalKinDps": 17.44,
+    "totalThermDps": 36.35,
+    "totalSDps": 48.99,
+    "totalExplSDps": 0,
+    "totalKinSDps": 12.64,
+    "totalThermSDps": 36.35,
+    "totalEps": 9.84,
+    "totalHps": 12.28,
+    "shieldExplRes": 0.48,
+    "shieldKinRes": 0.55,
+    "shieldThermRes": 1.09,
+    "hullExplRes": 1.4,
+    "hullKinRes": 1.2,
+    "hullThermRes": 1,
+    "powerAvailable": 17.24,
+    "powerRetracted": 11.3,
+    "powerDeployed": 16.41,
+    "unladenRange": 25.57,
+    "fullTankRange": 23.92,
+    "ladenRange": 22.09,
+    "unladenFastestRange": 116.23,
+    "ladenFastestRange": 107,
+    "maxJumpCount": 5,
+    "topSpeed": 386.56,
+    "topBoost": 524.62
+  }
+}

__tests__/fixtures/expected-builds.json

@@ -1,50 +1,50 @@
 {
   "type_6_transporter": {
-    "Cargo": "0p0tdFal8d8s8f4-----04040303430101.Iw1-kA==.Aw1-kA==.",
-    "Miner": "0p5tdFal8d8s8f42l2l---040403451q0101.Iw1-kA==.Aw1-kA==.",
-    "Hopper": "0p0tdFal8d0s8f41717---030302024300-.Iw1-kA==.Aw1-kA==."
+    "Cargo": "A0p0tdFal8d8s8f4-----04040303430101.Iw1/kA==.Aw1/kA==.",
+    "Miner": "A0p5tdFal8d8s8f42l2l---040403451q0101.Iw1/kA==.Aw1/kA==.",
+    "Hopper": "A0p0tdFal8d0s8f41717---030302024300-.Iw1/kA==.Aw1/kA==."
   },
   "type_7_transport": {
-    "Cargo": "0p0tiFfliddsdf5--------0505040403480101.Iw18aQ==.Aw18aQ==.",
-    "Miner": "0pdtiFflid8sdf5--2l2l----0505041v03450000.Iw18aQ==.Aw18aQ==."
+    "Cargo": "A0p0tiFfliddsdf5--------0505040403480101.Iw18aQ==.Aw18aQ==.",
+    "Miner": "A0pdtiFflid8sdf5--2l2l----0505041v03450000.Iw18aQ==.Aw18aQ==."
   },
   "federal_dropship": {
-    "Cargo": "0pdtiFflnddsif4-1717------05040448020201.Iw18aQ==.Aw18aQ==."
+    "Cargo": "A0pdtiFflnddsif4-1717------05040448--020201.Iw18eQ==.Aw18eQ==."
   },
   "asp": {
-    "Miner": "2pftfFflidfskf50s0s24242l2l---04054a1q02022o27.Iw18WQ==.Aw18WQ==."
+    "Miner": "A2pftfFflidfskf50s0s24242l2l---04054a1q02022o27.Iw18WQ==.Aw18WQ==."
   },
   "imperial_clipper": {
-    "Cargo": "0p5tiFflndisnf4--0s0s----0605450302020101.Iw18aQ==.Aw18aQ==.",
-    "Dream": "2pktkFflndpskf40v0v0s0s0404040n4k5n5d2b29292o-.Iw18aQ==.Aw18aQ==.",
-    "Current": "0patkFflndfskf4----------------.Iw18aQ==.Aw18aQ==."
+    "Cargo": "A0p5tiFflndisnf4--0s0s----0605450302020101.Iw18aQ==.Aw18aQ==.",
+    "Dream": "A2pktkFflndpskf40v0v0s0s0404040n4k5n5d2b29292o-.AwRj4yWU1I==.CwBhCYy6YRigzLIA.",
+    "Current": "A0patkFflndfskf4----------------.AwRj4yWU1I==.CwBhCYy6YRigzLIA."
   },
   "type_9_heavy": {
-    "Current": "0patsFklndnsif6---------0706054a0303020224.Iw18eQ==.Aw18eQ==."
+    "Current": "A0patsFklndnsif6---------0706054a0303020224.AwRj4yoo.EwBhEYy6dsg=."
   },
   "python": {
-    "Cargo": "0patnFflidsssf5---------050505040448020201.Iw18eQ==.Aw18eQ==.",
-    "Miner": "0pktkFflidpspf50v0v0v2m2m0404--050505Ce4a1v02022o.Iw18eQ==.Aw18eQ==.",
-    "Dream": "2pptkFfliduspf50v0v0v27270404040m5n5n4f2d2d032t0201.Iw18eQ==.Aw18eQ==.",
-    "Missile": "0pttoFjljdystf52f2g2d2ePh----04044j03---002h.Iw18eQ==.Aw18eQ==."
+    "Cargo": "A0patnFflidsssf5---------050505040448020201.Iw18eQ==.Aw18eQ==.",
+    "Miner": "A0pktkFflidpspf50v0v0v2m2m0404--050505Ce4a1v02022o.Iw18eQ==.IwBhBYy6dkCYg===.",
+    "Dream": "A2pptkFfliduspf50v0v0v27270404040m5n5n4f2d2d032t0201.Iw1+gDBxA===.EwBhEYy6e0WEA===.",
+    "Missile": "A0pttoFjljdystf52f2g2d2ePh----04044j03---002h.Iw18eQ==.Aw18eQ==."
   },
   "anaconda": {
-    "Dream": "4putpFklndzsuf52c0o0o0o1m1m0q0q0404040l0b0100004k5n5n112d2d040303326b.Iw18ZlA=.Aw18ZlA=.",
-    "Cargo": "0patnFklndnsxf5----------------0605050504040445030301.Iw18ZlA=.Aw18ZlA=.",
-    "Current": "0patnFklndksxf5----------------0605050504040403034524.Iw18ZlA=.Aw18ZlA=.",
-    "Explorer": "0patnFklndksxf5--------0202------f7050505040s372f2i4524.Iw18ZlA=.Aw18ZlA=.",
-    "Test": "4putkFklkdzsuf52c0o0o0o1m1m0q0q0404-0l0b0100034k5n052d04--0303326b.Iw18ZlA=.Aw18ZlA=."
+    "Dream": "A4putpFklndzsuf52c0o0o0o1m1m0q0q0404040l0b0100004k5n5n112d2d04-0303326b.AwRj4yo5dyg=.MwBhCYy6duvARiA=.",
+    "Cargo": "A0patnFklndnsxf5----------------06050505040404-45030301.Iw18ZVA=.Aw18ZVA=.",
+    "Current": "A0patnFklndksxf5----------------06050505040404-03034524.Iw18ZVA=.Aw18ZVA=.",
+    "Explorer": "A0patnFklndksxf5--------0202------f7050505040s37-2f2i4524.AwRj4yVKJ9hA.AwhMIyumQRhEA===.",
+    "Test": "A4putkFklkdzsuf52c0o0o0o1m1m0q0q0404-0l0b0100034k5n052d04---0303326b.Iw18ZVA=.Aw18ZVA=."
   },
   "diamondback_explorer": {
-    "Explorer": "0p0tdFfldddsdf5---0202--320p432i2f.Iw1-kA==.Aw1-kA==."
+    "Explorer": "A0p0tdFfldddsdf5---0202--320p432i2f.AwRj4zTI.AwiMIypI."
   },
   "vulture": {
-    "Bounty Hunter": "3patcFalddksff31e1e0404-0l4a5d27662j.Iw19kA==.Aw19kA==."
+    "Bounty Hunter": "A3patcFalddksff31e1e0404-0l4a-5d27662j.AwRj4z2I.MwBhBYy6oJmAjLIA."
   },
   "fer_de_lance": {
-    "Attack": "2pfthFalidpsff31r0s0s0s0s000404-04-4a-5d27-.Iw18aQ==.Aw18aQ==."
+    "Attack": "A2pfthFalidpsff31r0s0s0s0s000404-04-4a-5d27-.Iw18aQ==.CwBhrSu8EZyA."
   },
   "eagle": {
-    "Figther": "4p0t5F5l3d5s5f20p0p24-40532j-.Iw1-EA==.Aw1-EA==."
+    "Figther": "A4p0t5F5l3d5s5f20p0p24-4053-2j-.Iw18kA==.Aw18kA==."
   }
 }

__tests__/test-agility.js

@@ -0,0 +1,90 @@
+import Ship from '../src/app/shipyard/Ship';
+import { Ships } from 'coriolis-data/dist';
+import * as ModuleUtils from '../src/app/shipyard/ModuleUtils';
+
+describe("Agility", function() {
+
+  it("correctly calculates speed", function() {
+    let agilityData = require('./fixtures/agility-data');
+
+    for (let shipId in agilityData) {
+      for (let thrusterId in agilityData[shipId]) {
+        const thrusterData = agilityData[shipId][thrusterId];
+        let shipData = Ships[shipId];
+        let ship = new Ship(shipId, shipData.properties, shipData.slots);
+        ship.buildWith(shipData.defaults);
+        ship.use(ship.standard[1], ModuleUtils.findModule('t', thrusterId));
+
+        expect(Math.round(ship.topSpeed)).toBe(thrusterData.speed);
+      }
+    }
+  });
+
+  it("correctly calculates boost", function() {
+    let agilityData = require('./fixtures/agility-data');
+
+    for (let shipId in agilityData) {
+      for (let thrusterId in agilityData[shipId]) {
+        const thrusterData = agilityData[shipId][thrusterId];
+        let shipData = Ships[shipId];
+        let ship = new Ship(shipId, shipData.properties, shipData.slots);
+        ship.buildWith(shipData.defaults);
+	// Turn off internals to ensure we have enough power to boost
+	for (let internal in ship.internal) {
+          ship.internal[internal].enabled = 0;
+	}
+        ship.use(ship.standard[1], ModuleUtils.findModule('t', thrusterId));
+
+        expect(Math.round(ship.topBoost)).toBe(thrusterData.boost);
+      }
+    }
+  });
+
+  it("correctly calculates pitch", function() {
+    let agilityData = require('./fixtures/agility-data');
+
+    for (let shipId in agilityData) {
+      for (let thrusterId in agilityData[shipId]) {
+        const thrusterData = agilityData[shipId][thrusterId];
+        let shipData = Ships[shipId];
+        let ship = new Ship(shipId, shipData.properties, shipData.slots);
+        ship.buildWith(shipData.defaults);
+        ship.use(ship.standard[1], ModuleUtils.findModule('t', thrusterId));
+
+        expect(Math.round(ship.pitches[4] * 100) / 100).toBeCloseTo(thrusterData.pitch, 1);
+      }
+    }
+  });
+
+  it("correctly calculates roll", function() {
+    let agilityData = require('./fixtures/agility-data');
+
+    for (let shipId in agilityData) {
+      for (let thrusterId in agilityData[shipId]) {
+        const thrusterData = agilityData[shipId][thrusterId];
+        let shipData = Ships[shipId];
+        let ship = new Ship(shipId, shipData.properties, shipData.slots);
+        ship.buildWith(shipData.defaults);
+        ship.use(ship.standard[1], ModuleUtils.findModule('t', thrusterId));
+
+        expect(Math.round(ship.rolls[4] * 100) / 100).toBeCloseTo(thrusterData.roll, 1);
+      }
+    }
+  });
+
+  it("correctly calculates yaw", function() {
+    let agilityData = require('./fixtures/agility-data');
+
+    for (let shipId in agilityData) {
+      for (let thrusterId in agilityData[shipId]) {
+        const thrusterData = agilityData[shipId][thrusterId];
+        let shipData = Ships[shipId];
+        let ship = new Ship(shipId, shipData.properties, shipData.slots);
+        ship.buildWith(shipData.defaults);
+        ship.use(ship.standard[1], ModuleUtils.findModule('t', thrusterId));
+
+        expect(Math.round(ship.yaws[4] * 100) / 100).toBeCloseTo(thrusterData.yaw, 1);
+      }
+    }
+  });
+});

__tests__/test-import.js

@@ -142,12 +142,12 @@ describe('Import Modal', function() {
       expect(modal.state.singleBuild).toBe(true);
       clickProceed();
       expect(MockRouter.go.mock.calls.length).toBe(1);
-      expect(MockRouter.go.mock.calls[0][0]).toBe('/outfit/anaconda/4putkFklkdzsuf52c0o0o0o1m1m0q0q0404-0l0b0100034k5n052d04--0303326b.AwRj4zNKqA==.CwBhCYzBGW9qCTSqs5xA.?bn=Test%20My%20Ship');
+      expect(MockRouter.go.mock.calls[0][0]).toBe('/outfit/anaconda?code=A4putkFklkdzsuf52c0o0o0o1m1m0q0q0404-0l0b0100034k5n052d04---0303326b.AwRj4zNLaA%3D%3D.CwBhCYzBGW9qCTSqq5xA.&bn=Test%20My%20Ship');
     });
 
     it('catches an invalid build', function() {
       const importData = require('./fixtures/anaconda-test-detailed-export-v3');
-      pasteText(JSON.stringify(importData).replace('components', 'comps'));
+      pasteText(JSON.stringify(importData).replace('references', 'refs'));
 
       expect(modal.state.importValid).toBeFalsy();
       expect(modal.state.errorMsg).toEqual('Anaconda Build "Test My Ship": Invalid data');
@@ -167,7 +167,36 @@ describe('Import Modal', function() {
       expect(modal.state.singleBuild).toBe(true);
       clickProceed();
       expect(MockRouter.go.mock.calls.length).toBe(1);
-      expect(MockRouter.go.mock.calls[0][0]).toBe('/outfit/anaconda/4putkFklkdzsuf52c0o0o0o1m1m0q0q0404-0l0b0100034k5n052d04--0303326b.AwRj4zNKqA==.CwBhCYzBGW9qCTSqs5xA.H4sIAAAAAAAAA2MUe8HMwPD-PwDDhxeuCAAAAA==?bn=Test%20My%20Ship');
+      expect(MockRouter.go.mock.calls[0][0]).toBe('/outfit/anaconda?code=A4putkFklkdzsuf52c0o0o0o1m1m0q0q0404-0l0b0100034k5n052d04---0303326b.AwRj4zNLaA%3D%3D.CwBhCYzBGW9qCTSqq5xA.H4sIAAAAAAAAA2MUe8HMwPD%2FPwMcAABTINwTEgAAAA%3D%3D&bn=Test%20My%20Ship');
+    });
+  });
+
+  describe('Import Detailed Engineered V4 Build', function() {
+
+    beforeEach(reset);
+
+    it('imports a valid v4 build', function() {
+      const importData = require('./fixtures/asp-test-detailed-export-v4');
+      pasteText(JSON.stringify(importData));
+
+      expect(modal.state.importValid).toBeTruthy();
+      expect(modal.state.errorMsg).toEqual(null);
+      expect(modal.state.singleBuild).toBe(true);
+      clickProceed();
+      expect(MockRouter.go.mock.calls.length).toBe(1);
+      expect(MockRouter.go.mock.calls[0][0]).toBe('/outfit/asp?code=A0pftiFflfddsnf5------020202033c044002v62f2i.AwRj4yvI.CwRgDBldHnJA.H4sIAAAAAAAAA2P858DAwPCXEUhwHPvx%2F78YG5AltB7I%2F8%2F0TwImJboDSPJ%2F%2B%2Ff%2Fv%2FKlX%2F%2F%2Fi3AwMTBIfARK%2FGf%2BJwVSxArStVAYqOjvz%2F%2F%2FJVo5GRhE2IBc4SKQSSz%2FDGEmCa398P8%2F%2F2%2BgTf%2F%2FAwDFxwtofAAAAA%3D%3D&bn=Multi-purpose%20Asp%20Explorer');
+    });
+
+    it('imports a valid v4 build with modifications', function() {
+      const importData = require('./fixtures/courier-test-detailed-export-v4');
+      pasteText(JSON.stringify(importData));
+
+      expect(modal.state.importValid).toBeTruthy();
+      expect(modal.state.errorMsg).toEqual(null);
+      expect(modal.state.singleBuild).toBe(true);
+      clickProceed();
+      expect(MockRouter.go.mock.calls.length).toBe(1);
+      expect(MockRouter.go.mock.calls[0][0]).toBe('/outfit/imperial_courier?code=A0patzF5l0das8f31a1a270202000e402t0101-2f.AwRj4zKA.CwRgDBldLiQ%3D.H4sIAAAAAAAAA12OP0tCYRjFj9fuVbvF1du9ekkT8s%2FkIg4NElyIBBd321yaGvwUQTS3N7UFfYygIT9EoyQUJA36ns47XJCWA%2B%2Fz%2Bz3Pe3ImBbDNKaqNPSBoGrL4ngfomKpFGiJ%2BLgHteR1IPjxJT5pF11uSeXNsJVcRfgdC92syWUuK0iMdKZqrjJ%2F0aoA71lJ5oKf38knWcCiptCPdhJIerdS00vlK0qktlqoj983UmqqHjQ33VsW8eazFmaTyULP2hQ4lX8LBme6g%2F6v0TTdbxJ2KhdEIaCw15MF%2FNB0L%2BS2hwEwyFM8KgP%2BqEpWWA3Qu9Z3z9kPWHzakt7Dt%2BAeD7ghSTgEAAA%3D%3D&bn=Multi-purpose%20Imperial%20Courier');
     });
   });
 
@@ -200,7 +229,7 @@ describe('Import Modal', function() {
 
     beforeEach(reset);
 
-    it('imports a valid v4 build', function() {
+    it('imports a valid companion API build', function() {
       const importData = require('./fixtures/companion-api-import-1');
       pasteText(JSON.stringify(importData));
 
@@ -209,26 +238,50 @@ describe('Import Modal', function() {
       expect(modal.state.singleBuild).toBe(true);
       clickProceed();
       expect(MockRouter.go.mock.calls.length).toBe(1);
-      expect(MockRouter.go.mock.calls[0][0]).toBe('/outfit/federal_corvette/2putsFklndzsxf50x0x7l28281919040404040402020l06p05sf63c5ifhv66g2f.AwRj4zNaKA==.CwRgDBldUExuBiQqA===.H4sIAAAAAAAAAx2Rzy4DURTGz7TuzHRu47ZjWreKlg5iQ9KFZ9CENyBWtWo8gIUFsamteAIJi0qEWIhdN11ZEN1IwyNYVKRpcXzH5su553f_XyfvKiLTYma-TkScyHVcokoYEdmbBNDsiDla-WUOT5LgyfAshHdvyGyjFFHUQCSrBU8TLT4gYq4DNL_LhNTFN3PwiqdZQyX2C-sekep-Mrs1RIbnDppsIogD1UAtN7JEM9eIzZg8hmhsEU32gFmrdgB_UARvjYEr4QMUMffoxGnV-M8X3hZ_lAO-gmWq2Eq2IVtDOzZ2Hbbuws6KxCKmKUUydgRb3woSiUXMs6Cs7Qt6FCQSi5hxkNKhj6qhfcPU_kU4wYrFMseSOmFXMKbuwZsViUWMlq1sbhvJ_lKyfqTqEJGJyoC5eIpU9x2TRnUswYXyF77BW4Z3qQuv05GDTpfvcDzvSbxJ5DtV_aHS1I4clyB2A5_b-pAL8x_enn626gEAAA==?bn=Imported%20Federal%20Corvette');
+      expect(MockRouter.go.mock.calls[0][0]).toBe('/outfit/federal_corvette?code=A2putsFklndzsxf50x0x7l28281919040404040402020l06p05sf63c5ifr--v66g2f.AwRj4zNaqA%3D%3D.CwRgDBldUExuBiIlUA%3D%3D.H4sIAAAAAAAAA02SPy9DURjG3%2F65vW1v47TXVbeqqF7EQtIIBomRJswsYmISH8BgkFhqFZ9AwlALMYitkXQyEF2k4SMYJNK0dV7PK7nc5ck55%2Fm9z%2FnznpBeJqLvECQbM4hUjZnjO5hyWGfFikAGGjGiku0QuddhQCNdZmdWM9snsDmih4REOdlnNvz9DrPrJIicPdSwoZf8pAnTIpq8x7DYADS%2Bi5DERY85%2BYqpmkc6x%2FWGf6beKCR3YBIZFZCxCgrtczjuOmo4qTf94F4KYuxhz5jjEhXmUJNexFrpIUo02ALN1j9u1JMgD%2FMga1GfbMNRd9iHUwGy%2BpspZF3IBSGvMFJluS%2FuR24FJ2KlV%2Fxju6sQq4lhRsQTUVUJTgegLtS6EUjEE1HPAmUC0KdAjwKJeCKqD8zoURx72gHyDW9nvQhJGHkyUscS1x%2BAZnAlqwU%2FI%2BKJKEvextXrf93eQrR1KUlS5HWwGC61mfOn0oN3IM4OHoBzuuIHj33hS5jT8KeamIYa0sjhgH%2BLfplP4kcwD5Xl3xR1wfeHtqWzBHHX8I9SH9Je%2FgGvXxeungIAAA%3D%3D&bn=Imported%20Federal%20Corvette');
+    });
+
+    it('imports a valid companion API build', function() {
+      const importData = require('./fixtures/companion-api-import-2');
+      pasteText(JSON.stringify(importData));
+
+      expect(modal.state.importValid).toBeTruthy();
+      expect(modal.state.errorMsg).toEqual(null);
+      expect(modal.state.singleBuild).toBe(true);
+      clickProceed();
+      expect(MockRouter.go.mock.calls.length).toBe(1);
+      expect(MockRouter.go.mock.calls[0][0]).toBe('/outfit/beluga?code=A0pktsFplCdpsnf70t0t2727270004040404043c4fmimlmm04mc0iv62i2f.AwRj4yukg%3D%3D%3D.CwRgDBldHi8IUA%3D%3D.H4sIAAAAAAAAA2P8Z8%2FAwPCXEUiIKTMxMPCv%2F%2Ff%2FP8cFIPGf6Z8YTEr0GjMDg%2FJWICERBOTzn%2Fn7%2F7%2FIO5Ai5n9SIEWsQEIoSxAolfbt%2F3%2BJPk4GBhE7YQYGYVmgcuVnf4Aq%2FwMAIrEcGGsAAAA%3D&bn=Imported%20Beluga%20Liner');
+    });
+
+    it('imports a valid companion API build', function() {
+      const importData = require('./fixtures/companion-api-import-3');
+      pasteText(JSON.stringify(importData));
+
+      expect(modal.state.importValid).toBeTruthy();
+      expect(modal.state.errorMsg).toEqual(null);
+      expect(modal.state.singleBuild).toBe(true);
+      clickProceed();
+      expect(MockRouter.go.mock.calls.length).toBe(1);
+      expect(MockRouter.go.mock.calls[0][0]).toBe('/outfit/type_7_transport?code=A0patfFflidasdf5----0404040005050504044d2402.AwRj4yrI.CwRgDBlVK7EiA%3D%3D%3D.&bn=Imported%20Type-7%20Transporter');
     });
   });
 
   describe('Import E:D Shipyard Builds', function() {
 
-    it('imports a valid builds', function() {
-      const imports = require('./fixtures/ed-shipyard-import-valid');
-
-      for (let i = 0; i < imports.length; i++ ) {
-        reset();
-        let fixture = imports[i];
-        pasteText(fixture.buildText);
-        expect(modal.state.importValid).toBeTruthy();
-        expect(modal.state.errorMsg).toEqual(null);
-        clickProceed();
-        expect(MockRouter.go.mock.calls.length).toBe(1);
-        expect(MockRouter.go.mock.calls[0][0]).toBe('/outfit/' + fixture.shipId + '/' + fixture.buildCode + '?bn=' + encodeURIComponent(fixture.buildName));
-      }
-    });
+//    it('imports a valid build', function() {
+//      const imports = require('./fixtures/ed-shipyard-import-valid');
+//
+//      for (let i = 0; i < imports.length; i++ ) {
+//        reset();
+//        let fixture = imports[i];
+//        pasteText(fixture.buildText);
+//        expect(modal.state.importValid).toBeTruthy();
+//        expect(modal.state.errorMsg).toEqual(null);
+//        clickProceed();
+//        expect(MockRouter.go.mock.calls.length).toBe(1);
+//        expect(MockRouter.go.mock.calls[0][0]).toBe('/outfit/' + fixture.shipId + '?code=' + encodeURIComponent(fixture.buildCode) + '&bn=' + encodeURIComponent(fixture.buildName));
+//      }
+//    });
 
     it('catches invalid builds', function() {
       const imports = require('./fixtures/ed-shipyard-import-invalid');

d3-funcs.js

@@ -0,0 +1,11 @@
+export {
+  axisBottom,
+  axisLeft,
+  axisTop,
+  formatLocale,
+  line,
+  scaleBand,
+  scaleLinear,
+  scaleOrdinal,
+  select
+} from 'd3';

package.json

@@ -1,6 +1,6 @@
 {
   "name": "coriolis_shipyard",
-  "version": "2.2.2",
+  "version": "2.2.18",
   "repository": {
     "type": "git",
     "url": "https://github.com/EDCD/coriolis"
@@ -11,6 +11,7 @@
   "engine": "node >= 4.0.0",
   "license": "MIT",
   "scripts": {
+    "prepublish": "rollup -c && uglifyjs d3.js -c -m -o d3.min.js",
     "extract-translations": "grep -hroE \"(translate\\('[^']+'\\))|(tip.bind\\(null, '[^']+')\" src/* | grep -oE \"'[^']+'\" | grep -oE \"[^']+\" | sort -u -f",
     "clean": "rimraf build",
     "start": "node devServer.js",
@@ -31,6 +32,7 @@
       "jsx"
     ],
     "automock": true,
+    "bail": false,
     "unmockedModulePathPatterns": [
       "<rootDir>/node_modules/lodash",
       "<rootDir>/node_modules/react",
@@ -61,6 +63,7 @@
     "babel-preset-react": "*",
     "babel-preset-stage-0": "*",
     "css-loader": "^0.23.0",
+    "d3-selection": "1",
     "eslint": "2.2.0",
     "eslint-plugin-react": "^4.0.0",
     "expose-loader": "^0.7.1",
@@ -76,6 +79,8 @@
     "react-addons-test-utils": "^15.0.1",
     "react-testutils-additions": "^15.1.0",
     "rimraf": "^2.4.3",
+    "rollup": "0.36",
+    "rollup-plugin-node-resolve": "2",
     "style-loader": "^0.13.0",
     "url-loader": "^0.5.6",
     "webpack": "^1.9.6",
@@ -86,7 +91,7 @@
     "classnames": "^2.2.0",
     "browserify-zlib": "ipfs/browserify-zlib",
     "coriolis-data": "EDCD/coriolis-data",
-    "d3": "3.5.16",
+    "d3": "4.6.0",
     "fbemitter": "^2.0.0",
     "lodash": "^4.15.0",
     "lz-string": "^1.4.4",

rollup.config.js

@@ -0,0 +1,9 @@
+import nodeResolve from "rollup-plugin-node-resolve";
+
+export default {
+	  entry: "d3-funcs.js",
+	  format: "umd",
+	  moduleName: "d3",
+	  plugins: [nodeResolve({jsnext: true})],
+	  dest: "d3.js"
+};

src/app/Coriolis.jsx

@@ -6,9 +6,11 @@ import Persist from './stores/Persist';
 
 import Header from './components/Header';
 import Tooltip from './components/Tooltip';
+import ModalExport from './components/ModalExport';
+import ModalHelp from './components/ModalHelp';
 import ModalImport from './components/ModalImport';
+import ModalPermalink from './components/ModalPermalink';
 import * as CompanionApiUtils from './utils/CompanionApiUtils';
-import { outfitURL } from './utils/UrlGenerators'
 
 import AboutPage from './pages/AboutPage';
 import NotFoundPage from './pages/NotFoundPage';
@@ -159,14 +161,26 @@ export default class Coriolis extends React.Component {
         this._hideModal();
         this._closeMenu();
         break;
+      case 72:     // 'h'
+        if (e.ctrlKey || e.metaKey) { // CTRL/CMD + h
+          e.preventDefault();
+          this._showModal(<ModalHelp />);
+        }
+        break;
       case 73:     // 'i'
         if (e.ctrlKey || e.metaKey) { // CTRL/CMD + i
           e.preventDefault();
           this._showModal(<ModalImport />);
         }
         break;
-      case 101010:  // 's'
-        if (e.ctrlKey || e.metaKey) { // CTRL/CMD + i
+      case 79:  // 'o'
+        if (e.ctrlKey || e.metaKey) { // CTRL/CMD + o
+          e.preventDefault();
+          this._showModal(<ModalPermalink url={window.location.href}/>);
+        }
+        break;
+      case 83:  // 's'
+        if (e.ctrlKey || e.metaKey) { // CTRL/CMD + s
           e.preventDefault();
           this.emitter.emit('command', 'save');
         }

src/app/Router.js

@@ -76,7 +76,16 @@ Router.go = function(path, state) {
     if (isStandAlone()) {
       Persist.setState(ctx);
     }
-    history.pushState(ctx.state, ctx.title, ctx.canonicalPath);
+    try {
+      history.pushState(ctx.state, ctx.title, ctx.canonicalPath);
+    } catch (ex) {
+      sessionStorage.setItem('__safari_history_fix', JSON.stringify({
+        state: ctx.state,
+        title: ctx.title,
+        path: ctx.canonicalPath
+      }));
+      location.reload();
+    }
   }
   return ctx;
 };
@@ -99,7 +108,16 @@ Router.replace = function(path, state, dispatch) {
   if (isStandAlone()) {
     Persist.setState(ctx);
   }
-  history.replaceState(ctx.state, ctx.title, ctx.canonicalPath);
+  try {
+    history.replaceState(ctx.state, ctx.title, ctx.canonicalPath);
+  } catch (ex) {
+    sessionStorage.setItem('__safari_history_fix', JSON.stringify({
+      state: ctx.state,
+      title: ctx.title,
+      path: ctx.canonicalPath
+    }));
+    location.reload();
+  }
   return ctx;
 };
 

src/app/components/AvailableModulesMenu.jsx

@@ -7,6 +7,74 @@ import { MountFixed, MountGimballed, MountTurret } from './SvgIcons';
 
 const PRESS_THRESHOLD = 500; // mouse/touch down threshold
 
+/*
+ * Categorisation of module groups
+ */
+const GRPCAT = {
+  'sg': 'shields',
+  'bsg': 'shields',
+  'psg': 'shields',
+  'scb': 'shields',
+  'cc': 'limpet controllers',
+  'fx': 'limpet controllers',
+  'hb': 'limpet controllers',
+  'pc': 'limpet controllers',
+  'pce': 'passenger cabins',
+  'pci': 'passenger cabins',
+  'pcm': 'passenger cabins',
+  'pcq': 'passenger cabins',
+  'fh': 'hangars',
+  'pv': 'hangars',
+  'fs': 'fuel',
+  'ft': 'fuel',
+  'hr': 'structural reinforcement',
+  'mrp': 'structural reinforcement',
+  'bl': 'lasers',
+  'pl': 'lasers',
+  'ul': 'lasers',
+  'ml': 'lasers',
+  'c': 'projectiles',
+  'mc': 'projectiles',
+  'fc': 'projectiles',
+  'pa': 'projectiles',
+  'rg': 'projectiles',
+  'mr': 'ordnance',
+  'tp': 'ordnance',
+  'nl': 'ordnance',
+  // Utilities
+  'cs': 'scanners',
+  'kw': 'scanners',
+  'ws': 'scanners',
+  'ch': 'defence',
+  'po': 'defence',
+  'ec': 'defence',
+};
+// Order here is the order in which items will be shown in the modules menu
+const CATEGORIES = {
+  // Internals
+  'am': ['am'],
+  'cr': ['cr'],
+  'fi': ['fi'],
+  'fuel': ['ft', 'fs'],
+  'hangars': ['fh', 'pv'],
+  'limpet controllers': ['cc', 'fx', 'hb', 'pc'],
+  'passenger cabins': ['pce', 'pci', 'pcm', 'pcq'],
+  'rf': ['rf'],
+  'sc': ['sc'],
+  'shields': ['sg', 'bsg', 'psg', 'scb'],
+  'structural reinforcement': ['hr', 'mrp'],
+  'dc': ['dc'],
+  // Hardpoints
+  'lasers': ['pl', 'ul', 'bl', 'ml'],
+  'projectiles': ['mc', 'c', 'fc', 'pa', 'rg'],
+  'ordnance': ['mr', 'tp', 'nl'],
+  // Utilities
+  'sb': ['sb'],
+  'hs': ['hs'],
+  'defence': ['ch', 'po', 'ec'],
+  'scanners': ['cs', 'kw', 'ws'],
+};
+
 /**
  * Available modules menu
  */
@@ -63,15 +131,55 @@ export default class AvailableModulesMenu extends TranslatedComponent {
     } else {
       list = [];
       // At present time slots with grouped options (Hardpoints and Internal) can be empty
-      list.push(<div className='empty-c upp' key='empty' onClick={onSelect.bind(null, null)} >{translate('empty')}</div>);
-      for (let g in modules) {
-        if (m && g == m.grp) {
-          list.push(<div ref={(elem) => this.groupElem = elem} key={g} className={'select-group cap'}>{translate(g)}</div>);
-        } else {
-          list.push(<div key={g} className={'select-group cap'}>{translate(g)}</div>);
-        }
+      if (m) {
+        list.push(<div className='empty-c upp' key='empty' onClick={onSelect.bind(null, null)} >{translate('empty')}</div>);
+      }
 
-        list.push(buildGroup(g, modules[g]));
+      // Need to regroup the modules by our own categorisation
+      let catmodules = {};
+      // Pre-create to preserve ordering
+      for (let cat in CATEGORIES) {
+        catmodules[cat] = [];
+      }
+      for (let g in modules) {
+        const moduleCategory = GRPCAT[g] || g;
+        const existing = catmodules[moduleCategory] || [];
+        catmodules[moduleCategory] = existing.concat(modules[g]);
+      }
+      
+      for (let category in catmodules) {
+        let categoryHeader = false;
+        // Order through CATEGORIES if present
+        const categories = CATEGORIES[category] || [category];
+        if (categories && categories.length) {
+          for (let n in categories) {
+            const grp = categories[n];
+            // We now have the group and the category.  We might not have any modules, though...
+            if (modules[grp]) {
+              // Decide if we need a category header as well as a group header
+              if (categories.length === 1) {
+                // Show category header instead of group header
+                if (m && grp == m.grp) {
+                  list.push(<div ref={(elem) => this.groupElem = elem} key={category} className={'select-category upp'}>{translate(category)}</div>);
+                } else {
+                  list.push(<div key={category} className={'select-category upp'}>{translate(category)}</div>);
+                }
+              } else {
+                // Show category header as well as group header
+                if (!categoryHeader) {
+                  list.push(<div key={category} className={'select-category upp'}>{translate(category)}</div>);
+                  categoryHeader = true;
+                }
+                if (m && grp == m.grp) {
+                  list.push(<div ref={(elem) => this.groupElem = elem} key={grp} className={'select-group cap'}>{translate(grp)}</div>);
+                } else {
+                  list.push(<div key={grp} className={'select-group cap'}>{translate(grp)}</div>);
+                }
+              }
+              list.push(buildGroup(grp, modules[grp]));
+            }
+          }
+        }
       }
     }
 
@@ -93,8 +201,16 @@ export default class AvailableModulesMenu extends TranslatedComponent {
     let prevClass = null, prevRating = null;
     let elems = [];
 
-    for (let i = 0; i < modules.length; i++) {
-      let m = modules[i];
+    const sortedModules = modules.sort(this._moduleOrder);
+
+    // Calculate the number of items per class.  Used so we don't have long lists with only a few items in each row
+    const tmp = sortedModules.map((v, i) => v['class']).reduce((count, cls) => { count[cls] = ++count[cls] || 1; return count; }, {});
+    const itemsPerClass = Math.max.apply(null, Object.keys(tmp).map(key => tmp[key]));
+
+    let itemsOnThisRow = 0;
+
+    for (let i = 0; i < sortedModules.length; i++) {
+      let m = sortedModules[i];
       let mount = null;
       let disabled = m.maxmass && (mass + (m.mass ? m.mass : 0)) > m.maxmass;
       let active = mountedModule && mountedModule.id === m.id;
@@ -126,8 +242,9 @@ export default class AvailableModulesMenu extends TranslatedComponent {
         case 'T': mount = <MountTurret className={'lg'}/>; break;
       }
 
-      if (i > 0 && modules.length > 3 && m.class != prevClass && (m.rating != prevRating || m.mount) && m.grp != 'pa') {
+      if (itemsOnThisRow == 6 || i > 0 && sortedModules.length > 3 && itemsPerClass > 2 && m.class != prevClass && (m.rating != prevRating || m.mount)) {
         elems.push(<br key={'b' + m.grp + i} />);
+        itemsOnThisRow = 0;
       }
 
       elems.push(
@@ -136,6 +253,7 @@ export default class AvailableModulesMenu extends TranslatedComponent {
           {(mount ? ' ' : '') + m.class + m.rating + (m.missile ? '/' + m.missile : '') + (m.name ? ' ' + translate(m.name) : '')}
         </li>
       );
+      itemsOnThisRow++;
       prevClass = m.class;
       prevRating = m.rating;
     }
@@ -201,6 +319,46 @@ export default class AvailableModulesMenu extends TranslatedComponent {
     this.context.tooltip();
   }
 
+  /**
+   * Order two modules suitably for display in module selection
+   * @param  {Object} a the first module
+   * @param  {Object} b the second module
+   * @return {int}      -1 if the first module should go first, 1 if the second module should go first
+   */
+  _moduleOrder(a, b) {
+    // Named modules go last
+    if (!a.name && b.name) {
+      return -1;
+    }
+    if (a.name && !b.name) {
+      return 1;
+    }
+    // Class ordered from highest (8) to lowest (1)
+    if (a.class < b.class) {
+      return 1;
+    }
+    if (a.class > b.class) {
+      return -1;
+    }
+    // Mount type, if applicable
+    if (a.mount && b.mount && a.mount !== b.mount) {
+      if (a.mount === 'F' || (a.mount === 'G' && b.mount === 'T')) {
+        return -1;
+      } else {
+        return 1;
+      }
+    }
+    // Rating ordered from highest (A) to lowest (E)
+    if (a.rating < b.rating) {
+      return -1;
+    }
+    if (a.rating > b.rating) {
+      return 1;
+    }
+    // Do not attempt to order by name at this point, as that mucks up the order of armour
+    return 0;
+  }
+
   /**
    * Scroll to mounted (if it exists) module group on mount
    */

src/app/components/BarChart.jsx

@@ -1,5 +1,5 @@
 import React from 'react';
-import d3 from 'd3';
+import * as d3 from 'd3';
 import TranslatedComponent from './TranslatedComponent';
 
 const MARGIN = { top: 15, right: 20, bottom: 40, left: 150 };
@@ -68,13 +68,13 @@ export default class BarChart extends TranslatedComponent {
     this._updateDimensions = this._updateDimensions.bind(this);
     this._hideTip = this._hideTip.bind(this);
 
-    let scale = d3.scale.linear();
-    let y0 = d3.scale.ordinal();
-    let y1 = d3.scale.ordinal();
+    let scale = d3.scaleLinear();
+    let y0 = d3.scaleBand();
+    let y1 = d3.scaleBand();
 
-    this.xAxis = d3.svg.axis().scale(scale).ticks(5).outerTickSize(0).orient('bottom').tickFormat(context.language.formats.s2);
-    this.yAxis = d3.svg.axis().scale(y0).outerTickSize(0).orient('left');
-    this.state = { scale, y0, y1, color: d3.scale.ordinal().range(props.colors) };
+    this.xAxis = d3.axisBottom(scale).ticks(5).tickSizeOuter(0).tickFormat(context.language.formats.s2);
+    this.yAxis = d3.axisLeft(y0).tickSizeOuter(0);
+    this.state = { scale, y0, y1, color: d3.scaleOrdinal().range(props.colors) };
   }
 
   /**
@@ -131,8 +131,8 @@ export default class BarChart extends TranslatedComponent {
     let max = data.reduce((max, build) => (properties.reduce(((m, p) => (m > build[p] ? m : build[p])), max)), 0);
 
     this.state.scale.range([0, innerWidth]).domain([0, max]);
-    this.state.y0.domain(data.map(bName)).rangeRoundBands([0, innerHeight], 0.3);
-    this.state.y1.domain(properties).rangeRoundBands([0, this.state.y0.rangeBand()]);
+    this.state.y0.domain(data.map(bName)).range([0, innerHeight], 0.3).padding(0.4);
+    this.state.y1.domain(properties).range([0, this.state.y0.bandwidth()]).padding(0.1);
 
     this.setState({
       barHeight,
@@ -192,7 +192,7 @@ export default class BarChart extends TranslatedComponent {
             x={0}
             y={y1(p)}
             width={scale(build[p])}
-            height={y1.rangeBand()}
+            height={y1.bandwidth()}
             fill={color(p)}
             onMouseOver={this._showTip.bind(this, build, p, propIndex)}
             onMouseOut={this._hideTip}

src/app/components/ComparisonTable.jsx

@@ -3,7 +3,6 @@ import TranslatedComponent from './TranslatedComponent';
 import Link from './Link';
 import cn from 'classnames';
 import { outfitURL } from '../utils/UrlGenerators';
-import { SizeMap } from '../shipyard/Constants';
 
 
 /**
@@ -72,7 +71,7 @@ export default class ComparisonTable extends TranslatedComponent {
    * @return {React.Component}    Table row
    */
   _buildRow(build, facets, formats, units) {
-    let url = outfitURL(build.id, build.toString(), build.buildName)
+    let url = outfitURL(build.id, build.toString(), build.buildName);
     let cells = [
       <td key='s' className='tl'><Link href={url}>{build.name}</Link></td>,
       <td key='bn' className='tl'><Link href={url}>{build.buildName}</Link></td>

src/app/components/DamageDealt.jsx

@@ -0,0 +1,592 @@
+import React from 'react';
+import TranslatedComponent from './TranslatedComponent';
+import { Ships } from 'coriolis-data/dist';
+import ShipSelector from './ShipSelector';
+import { nameComparator } from '../utils/SlotFunctions';
+import { CollapseSection, ExpandSection, MountFixed, MountGimballed, MountTurret } from './SvgIcons';
+import LineChart from '../components/LineChart';
+import Slider from '../components/Slider';
+import * as ModuleUtils from '../shipyard/ModuleUtils';
+import Module from '../shipyard/Module';
+
+const DAMAGE_DEALT_COLORS = ['#FFFFFF', '#FF0000', '#00FF00', '#7777FF', '#FFFF00', '#FF00FF', '#00FFFF', '#777777'];
+
+/**
+ * Generates an internationalization friendly weapon comparator that will
+ * sort by specified property (if provided) then by name/group, class, rating
+ * @param  {function} translate       Translation function
+ * @param  {function} propComparator  Optional property comparator
+ * @param  {boolean} desc             Use descending order
+ * @return {function}                 Comparator function for names
+ */
+export function weaponComparator(translate, propComparator, desc) {
+  return (a, b) => {
+    if (!desc) {  // Flip A and B if ascending order
+      let t = a;
+      a = b;
+      b = t;
+    }
+
+    // If a property comparator is provided use it first
+    let diff = propComparator ? propComparator(a, b) : nameComparator(translate, a, b);
+
+    if (diff) {
+      return diff;
+    }
+
+    // Property matches so sort by name / group, then class, rating
+    if (a.name === b.name && a.grp === b.grp) {
+      if(a.class == b.class) {
+        return a.rating > b.rating ? 1 : -1;
+      }
+      return a.class - b.class;
+    }
+
+    return nameComparator(translate, a, b);
+  };
+}
+
+/**
+ * Damage against a selected ship
+ */
+export default class DamageDealt extends TranslatedComponent {
+  static PropTypes = {
+    ship: React.PropTypes.object.isRequired,
+    chartWidth: React.PropTypes.number.isRequired,
+    code: React.PropTypes.string.isRequired
+  };
+
+  static DEFAULT_AGAINST = Ships['anaconda'];
+
+  /**
+   * Constructor
+   * @param  {Object} props   React Component properties
+   * @param  {Object} context   React Component context
+   */
+  constructor(props, context) {
+    super(props);
+
+    this._sort = this._sort.bind(this);
+    this._onShipChange = this._onShipChange.bind(this);
+    this._onCollapseExpand = this._onCollapseExpand.bind(this);
+
+    const ship = this.props.ship;
+    const against = DamageDealt.DEFAULT_AGAINST;
+    const maxRange = this._calcMaxRange(ship);
+    const range = 1000 / maxRange;
+    const maxDps = this._calcMaxSDps(ship, against);
+    const weaponNames = this._weaponNames(ship, context);
+
+    this.state = {
+      predicate: 'n',
+      desc: true,
+      against,
+      expanded: false,
+      range,
+      maxRange,
+      maxDps,
+      weaponNames,
+      calcHullDpsFunc: this._calcDps.bind(this, context, ship, weaponNames, against, true),
+      calcShieldsDpsFunc: this._calcDps.bind(this, context, ship, weaponNames, against, false)
+    };
+  }
+
+  /**
+   * Set the initial weapons state
+   */
+  componentWillMount() {
+    const data = this._calcWeaponsDps(this.props.ship, this.state.against, this.state.range * this.state.maxRange, true);
+    this.setState({ weapons: data.weapons, totals: data.totals });
+  }
+
+  /**
+   * Set the updated weapons state if our ship changes
+   * @param  {Object} nextProps   Incoming/Next properties
+   * @param  {Object} nextContext Incoming/Next conext
+   * @return {boolean}            Returns true if the component should be rerendered
+   */
+  componentWillReceiveProps(nextProps, nextContext) {
+    if (nextProps.code != this.props.code) {
+      const data = this._calcWeaponsDps(nextProps.ship, this.state.against, this.state.range * this.state.maxRange, this.props.hull);
+      const weaponNames = this._weaponNames(nextProps.ship, nextContext);
+      const maxRange = this._calcMaxRange(nextProps.ship);
+      const maxDps = this._calcMaxSDps(nextProps.ship, this.state.against);
+      this.setState({ weapons: data.weapons,
+                      totals: data.totals,
+                      weaponNames,
+                      maxRange,
+                      maxDps,
+                      calcHullDpsFunc: this._calcDps.bind(this, nextContext, nextProps.ship, weaponNames, this.state.against, true),
+                      calcShieldsDpsFunc: this._calcDps.bind(this, nextContext, nextProps.ship, weaponNames, this.state.against, false) });
+    }
+    return true;
+  }
+
+  /**
+   * Calculate the maximum sustained single-weapon DPS for this ship against another ship
+   * @param  {Object}  ship     The ship
+   * @param  {Object}  against  The target
+   * @return {number}           The maximum sustained single-weapon DPS
+   */
+  _calcMaxSDps(ship, against) {
+    let maxSDps = 0;
+    for (let i = 0; i < ship.hardpoints.length; i++) {
+      if (ship.hardpoints[i].m && ship.hardpoints[i].enabled) {
+        const m = ship.hardpoints[i].m;
+        const thisSDps = m.getClip() ?  (m.getClip() * m.getDps() / m.getRoF()) / ((m.getClip() / m.getRoF()) + m.getReload()) : m.getDps();
+        if (thisSDps > maxSDps) {
+          maxSDps = thisSDps;
+        }
+      }
+    }
+    return maxSDps;
+  }
+
+  /**
+   * Calculate the per-weapon DPS for this ship against another ship at a given range
+   * @param  {Object}  context       The context
+   * @param  {Object}  ship          The ship
+   * @param  {Object}  weaponNames   The names of the weapons for which to calculate DPS
+   * @param  {Object}  against       The target
+   * @param  {bool}    hull          true if to calculate against hull, false if to calculate against shields
+   * @param  {Object}  range         The engagement range
+   * @return {array}                 The array of weapon DPS
+   */
+  _calcDps(context, ship, weaponNames, against, hull, range) {
+    let results = {};
+    let weaponNum = 0;
+    for (let i = 0; i < ship.hardpoints.length; i++) {
+      if (ship.hardpoints[i].m && ship.hardpoints[i].enabled) {
+        const m = ship.hardpoints[i].m;
+        results[weaponNames[weaponNum++]] = this._calcWeaponDps(context, m, against, hull, range);
+      }
+    }
+    return results;
+  }
+
+  /**
+   * Calculate the maximum range of a ship's weapons
+   * @param   {Object}  ship     The ship
+   * @returns {int}              The maximum range, in metres
+   */ 
+  _calcMaxRange(ship) {
+    let maxRange = 1000;
+    for (let i = 0; i < ship.hardpoints.length; i++) {
+      if (ship.hardpoints[i].maxClass > 0 && ship.hardpoints[i].m && ship.hardpoints[i].enabled) {
+        const thisRange = ship.hardpoints[i].m.getRange();
+        if (thisRange > maxRange) {
+          maxRange = thisRange;
+        }
+      }
+    }
+
+    return maxRange;
+  }
+
+  /**
+   * Obtain the weapon names for this ship
+   * @param  {Object}  ship      The ship
+   * @param  {Object}  context   The context
+   * @return {array}             The weapon names
+   */
+  _weaponNames(ship, context) {
+    const translate = context.language.translate;
+    let names = [];
+    let num = 1;
+    for (let i = 0; i < ship.hardpoints.length; i++) {
+      if (ship.hardpoints[i].maxClass > 0 && ship.hardpoints[i].m && ship.hardpoints[i].enabled) {
+        const m = ship.hardpoints[i].m;
+        let name = '' + num++ + ': ' + m.class + m.rating + (m.missile ? '/' + m.missile : '') + ' ' + translate(m.name || m.grp);
+        let engineering;
+        if (m.blueprint && m.blueprint.name) {
+          engineering = translate(m.blueprint.name) + ' ' + translate('grade') + ' ' + m.blueprint.grade;
+          if (m.blueprint.special && m.blueprint.special.id) {
+            engineering += ', ' + translate(m.blueprint.special.name);
+          }
+        }
+        if (engineering) {
+          name = name + ' (' + engineering + ')';
+        }
+        names.push(name);
+      }
+    }
+    return names;
+  }
+
+
+  /**
+   * Calculate a specific weapon DPS for this ship against another ship at a given range
+   * @param  {Object}  context       The context
+   * @param  {Object}  m             The weapon
+   * @param  {Object}  against       The target
+   * @param  {bool}    hull          true if to calculate against hull, false if to calculate against shields
+   * @param  {Object}  range         The engagement range
+   * @return {number}                The weapon DPS
+   */
+  _calcWeaponDps(context, m, against, hull, range) {
+    const translate = context.language.translate;
+    let dropoff = 1;
+    if (m.getFalloff()) {
+      // Calculate the dropoff % due to range
+      if (range > m.getRange()) {
+        // Weapon is out of range
+        dropoff = 0;
+      } else {
+        const falloff = m.getFalloff();
+        if (range > falloff) {
+          const dropoffRange = m.getRange() - falloff;
+          // Assuming straight-line falloff
+          dropoff = 1 - (range - falloff) / dropoffRange;
+        }
+      }
+    }
+    const classRating = `${m.class}${m.rating}${m.missile ? '/' + m.missile : ''}`;
+    let engineering;
+    if (m.blueprint && m.blueprint.name) {
+      engineering = translate(m.blueprint.name) + ' ' + translate('grade') + ' ' + m.blueprint.grade;
+      if (m.blueprint.special && m.blueprint.special.id) {
+        engineering += ', ' + translate(m.blueprint.special.name);
+      }
+    }
+    const effectivenessShields = dropoff;
+    const effectiveDpsShields = m.getDps() * effectivenessShields;
+    const effectiveSDpsShields = (m.getClip() ?  (m.getClip() * m.getDps() / m.getRoF()) / ((m.getClip() / m.getRoF()) + m.getReload()) * effectivenessShields : effectiveDpsShields);
+    const effectivenessHull = (m.getPiercing() >= against.properties.hardness ? 1 : m.getPiercing() / against.properties.hardness) * dropoff;
+    const effectiveDpsHull = m.getDps() * effectivenessHull;
+    const effectiveSDpsHull = (m.getClip() ?  (m.getClip() * m.getDps() / m.getRoF()) / ((m.getClip() / m.getRoF()) + m.getReload()) * effectivenessHull : effectiveDpsHull);
+
+    return hull ? effectiveSDpsHull : effectiveSDpsShields;
+  }
+
+  /**
+   * Calculate the damage dealt by a ship
+   * @param  {Object} ship        The ship which will deal the damage 
+   * @param  {Object} against     The ship against which damage will be dealt
+   * @param  {Object} range       The engagement range
+   * @return {object}             Returns the per-weapon damage
+   */
+  _calcWeaponsDps(ship, against, range) {
+    const translate = this.context.language.translate;
+
+    // Tidy up the range so that it's to 4 decimal places
+    range = Math.round(10000 * range) / 10000;
+
+    // Track totals
+    let totals = {};
+    totals.effectivenessShields = 0;
+    totals.effectiveDpsShields = 0;
+    totals.effectiveSDpsShields = 0;
+    totals.effectivenessHull = 0;
+    totals.effectiveDpsHull = 0;
+    totals.effectiveSDpsHull = 0;
+    let totalDps = 0;
+
+    let weapons = [];
+    for (let i = 0; i < ship.hardpoints.length; i++) {
+      if (ship.hardpoints[i].maxClass > 0 && ship.hardpoints[i].m && ship.hardpoints[i].enabled) {
+        const m = ship.hardpoints[i].m;
+        if (m.getDamage() && m.grp !== 'po') {
+          let dropoff = 1;
+          if (m.getFalloff()) {
+            // Calculate the dropoff % due to range
+            if (range > m.getRange()) {
+              // Weapon is out of range
+              dropoff = 0;
+            } else {
+              const falloff = m.getFalloff();
+              if (range > falloff) {
+                const dropoffRange = m.getRange() - falloff;
+                // Assuming straight-line falloff
+                dropoff = 1 - (range - falloff) / dropoffRange;
+              }
+            }
+          }
+          const classRating = `${m.class}${m.rating}${m.missile ? '/' + m.missile : ''}`;
+          let engineering;
+          if (m.blueprint && m.blueprint.name) {
+            engineering = translate(m.blueprint.name) + ' ' + translate('grade') + ' ' + m.blueprint.grade;
+            if (m.blueprint.special && m.blueprint.special.id >= 0) {
+              engineering += ', ' + translate(m.blueprint.special.name);
+            }
+          }
+
+          // Alter effectiveness as per standard shields (all have the same resistances)
+          const sg = ModuleUtils.findModule('sg', '3v');
+          let effectivenessShields = 0;
+          if (m.getDamageDist().E) {
+            effectivenessShields += m.getDamageDist().E * (1 - sg.getExplosiveResistance());
+          }
+          if (m.getDamageDist().K) {
+            effectivenessShields += m.getDamageDist().K * (1 - sg.getKineticResistance());
+          }
+          if (m.getDamageDist().T) {
+            effectivenessShields += m.getDamageDist().T * (1 - sg.getThermalResistance());
+          }
+          if (m.getDamageDist().A) {
+            effectivenessShields += m.getDamageDist().A;
+          }
+          effectivenessShields *= dropoff;
+          const effectiveDpsShields = m.getDps() * effectivenessShields;
+          const effectiveSDpsShields = (m.getClip() ?  (m.getClip() * m.getDps() / m.getRoF()) / ((m.getClip() / m.getRoF()) + m.getReload()) * effectivenessShields : effectiveDpsShields);
+
+          // Alter effectiveness as per standard hull
+          const bulkheads = new Module({ template: against.bulkheads });
+          let effectivenessHull = 0;
+          if (m.getDamageDist().E) {
+            effectivenessHull += m.getDamageDist().E * (1 - bulkheads.getExplosiveResistance());
+          }
+          if (m.getDamageDist().K) {
+            effectivenessHull += m.getDamageDist().K * (1 - bulkheads.getKineticResistance());
+          }
+          if (m.getDamageDist().T) {
+            effectivenessHull += m.getDamageDist().T * (1 - bulkheads.getThermalResistance());
+          }
+          if (m.getDamageDist().A) {
+            effectivenessHull += m.getDamageDist().A;
+          }
+          effectivenessHull *= Math.min(m.getPiercing() / against.properties.hardness, 1) * dropoff;
+          const effectiveDpsHull = m.getDps() * effectivenessHull;
+          const effectiveSDpsHull = (m.getClip() ?  (m.getClip() * m.getDps() / m.getRoF()) / ((m.getClip() / m.getRoF()) + m.getReload()) * effectivenessHull : effectiveDpsHull);
+          totals.effectiveDpsShields += effectiveDpsShields;
+          totals.effectiveSDpsShields += effectiveSDpsShields;
+          totals.effectiveDpsHull += effectiveDpsHull;
+          totals.effectiveSDpsHull += effectiveSDpsHull;
+          totalDps += m.getDps();
+
+          weapons.push({ id: i,
+                         mount: m.mount,
+                         name: m.name || m.grp,
+                         classRating,
+                         engineering,
+                         effectiveDpsShields,
+                         effectiveSDpsShields,
+                         effectivenessShields,
+                         effectiveDpsHull,
+                         effectiveSDpsHull,
+                         effectivenessHull });
+        }
+      }
+    }
+    totals.effectivenessShields = totalDps == 0 ? 0 : totals.effectiveDpsShields / totalDps;
+    totals.effectivenessHull = totalDps == 0 ? 0 : totals.effectiveDpsHull / totalDps;
+    
+    return { weapons, totals };
+  }
+
+  /**
+   * Triggered when the collapse or expand icons are clicked
+   */
+  _onCollapseExpand() {
+    this.setState({ expanded: !this.state.expanded });
+  }
+
+  /**
+   * Triggered when the ship we compare against changes
+   * @param {string} s the new ship ID
+   */
+  _onShipChange(s) {
+    const against = Ships[s];
+    const data = this._calcWeaponsDps(this.props.ship, against, this.state.range * this.state.maxRange);
+    this.setState({ against,
+                    weapons: data.weapons,
+                    totals: data.totals,
+                    calcHullDpsFunc: this._calcDps.bind(this, this.context, this.props.ship, this.state.weaponNames, against, true),
+                    calcShieldsDpsFunc: this._calcDps.bind(this, this.context, this.props.ship, this.state.weaponNames, against, false) });
+  }
+
+  /**
+   * Set the sort order and sort
+   * @param  {string} predicate Sort predicate
+   */
+  _sortOrder(predicate) {
+    let desc = this.state.desc;
+
+    if (predicate == this.state.predicate) {
+      desc = !desc;
+    } else {
+      desc = true;
+    }
+
+    this._sort(this.props.ship, predicate, desc);
+    this.setState({ predicate, desc });
+  }
+
+  /**
+   * Sorts the weapon list
+   * @param  {Ship} ship          Ship instance
+   * @param  {string} predicate   Sort predicate
+   * @param  {Boolean} desc       Sort order descending
+   */
+  _sort(ship, predicate, desc) {
+    let comp = weaponComparator.bind(null, this.context.language.translate);
+
+    switch (predicate) {
+      case 'n': comp = comp(null, desc); break;
+      case 'edpss': comp = comp((a, b) => a.effectiveDpsShields - b.effectiveDpsShields, desc); break;
+      case 'esdpss': comp = comp((a, b) => a.effectiveSDpsShields - b.effectiveSDpsShields, desc); break;
+      case 'es': comp = comp((a, b) => a.effectivenessShields - b.effectivenessShields, desc); break;
+      case 'edpsh': comp = comp((a, b) => a.effectiveDpsHull - b.effectiveDpsHull, desc); break;
+      case 'esdpsh': comp = comp((a, b) => a.effectiveSDpsHull - b.effectiveSDpsHull, desc); break;
+      case 'eh': comp = comp((a, b) => a.effectivenessHull - b.effectivenessHull, desc); break;
+    }
+
+    this.state.weapons.sort(comp);
+  }
+
+  /**
+   * Render individual rows for hardpoints
+   * @param  {Function} translate   Translate function
+   * @param  {Object}   formats     Localised formats map
+   * @return {array}                The individual rows
+   *
+   */
+  _renderRows(translate, formats) {
+    const { termtip, tooltip } = this.context;
+
+    let rows = [];
+
+    if (this.state.weapons) {
+      for (let i = 0; i < this.state.weapons.length; i++) {
+        const weapon = this.state.weapons[i];
+
+        rows.push(<tr key={weapon.id}>
+                    <td className='ri'>
+                      {weapon.mount == 'F' ? <span onMouseOver={termtip.bind(null, 'fixed')} onMouseOut={tooltip.bind(null, null)}><MountFixed className='icon'/></span> : null}
+                      {weapon.mount == 'G' ? <span onMouseOver={termtip.bind(null, 'gimballed')} onMouseOut={tooltip.bind(null, null)}><MountGimballed /></span> : null}
+                      {weapon.mount == 'T' ? <span onMouseOver={termtip.bind(null, 'turreted')} onMouseOut={tooltip.bind(null, null)}><MountTurret /></span> : null}
+                      {weapon.classRating} {translate(weapon.name)}
+                      {weapon.engineering ? ' (' + weapon.engineering + ')' : null }
+                    </td>
+                    <td className='ri'>{formats.f1(weapon.effectiveDpsShields)}</td>
+                    <td className='ri'>{formats.f1(weapon.effectiveSDpsShields)}</td>
+                    <td className='ri'>{formats.pct(weapon.effectivenessShields)}</td>
+                    <td className='ri'>{formats.f1(weapon.effectiveDpsHull)}</td>
+                    <td className='ri'>{formats.f1(weapon.effectiveSDpsHull)}</td>
+                    <td className='ri'>{formats.pct(weapon.effectivenessHull)}</td>
+                  </tr>);
+      }
+    }
+
+    return rows;
+  }
+
+  /**
+   * Update current range
+   * @param  {number} range Range 0-1
+   */
+  _rangeChange(range) {
+    const data = this._calcWeaponsDps(this.props.ship, this.state.against, this.state.range * this.state.maxRange);
+    this.setState({ range,
+                    weapons: data.weapons,
+                    totals: data.totals });
+  }
+
+  /**
+   * Render damage dealt
+   * @return {React.Component} contents
+   */
+  render() {
+    const { language, onWindowResize, sizeRatio, tooltip, termtip } = this.context;
+    const { formats, translate, units } = language;
+    const { against, expanded, maxRange, range, totals } = this.state;
+    const { ship } = this.props;
+
+    const sortOrder = this._sortOrder;
+    const onCollapseExpand = this._onCollapseExpand;
+
+    const code = ship.getHardpointsString() + '.' + ship.getModificationsString() + '.' + against.properties.name;
+
+    return (
+      <span>
+        <h1>{translate('damage dealt to')} {expanded ? <span onClick={onCollapseExpand}><CollapseSection className='summary'/></span> : <span onClick={onCollapseExpand}><ExpandSection className='summary'/></span>}</h1>
+        {expanded ?  <span>
+        <ShipSelector initial={against} currentMenu={this.props.currentMenu} onChange={this._onShipChange} />
+        <table className='summary' style={{ width: '100%' }}>
+          <thead>
+            <tr className='main'>
+              <th rowSpan='2' className='sortable' onClick={sortOrder.bind(this, 'n')}>{translate('weapon')}</th>
+              <th colSpan='3'>{translate('standard shields')}</th>
+              <th colSpan='3'>{translate('standard armour')}</th>
+            </tr>
+            <tr>
+              <th className='lft sortable' onClick={sortOrder.bind(this, 'edpss')}>{translate('effective dps')}</th>
+              <th className='sortable' onClick={sortOrder.bind(this, 'esdpss')}>{translate('effective sdps')}</th>
+              <th className='sortable' onClick={sortOrder.bind(this, 'es')}>{translate('effectiveness')}</th>
+              <th className='lft sortable' onClick={sortOrder.bind(this, 'edpsh')}>{translate('effective dps')}</th>
+              <th className='sortable' onClick={sortOrder.bind(this, 'esdpsh')}>{translate('effective sdps')}</th>
+              <th className='sortable' onClick={sortOrder.bind(this, 'eh')}>{translate('effectiveness')}</th>
+            </tr>
+          </thead>
+          <tbody>
+            {this._renderRows(translate, formats)}
+          </tbody>
+          <tfoot>
+            <tr className='main'>
+              <td className='ri'><i>{translate('total')}</i></td>
+              <td className='ri'><i>{formats.f1(totals.effectiveDpsShields)}</i></td>
+              <td className='ri'><i>{formats.f1(totals.effectiveSDpsShields)}</i></td>
+              <td className='ri'><i>{formats.pct(totals.effectivenessShields)}</i></td>
+              <td className='ri'><i>{formats.f1(totals.effectiveDpsHull)}</i></td>
+              <td className='ri'><i>{formats.f1(totals.effectiveSDpsHull)}</i></td>
+              <td className='ri'><i>{formats.pct(totals.effectivenessHull)}</i></td>
+            </tr>
+          </tfoot>
+        </table>
+        <table style={{ width: '80%', lineHeight: '1em', backgroundColor: 'transparent', margin: 'auto' }}>
+          <tbody >
+            <tr>
+              <td style={{ verticalAlign: 'top', padding: 0, width: '2.5em' }} onMouseEnter={termtip.bind(null, 'PHRASE_ENGAGEMENT_RANGE')} onMouseLeave={tooltip.bind(null, null)}>{translate('engagement range')}</td>
+              <td>
+                <Slider
+                  axis={true}
+                  onChange={this._rangeChange.bind(this)}
+                  axisUnit={translate('m')}
+                  percent={range}
+                  max={maxRange}
+                  scale={sizeRatio}
+                  onResize={onWindowResize}
+                />
+              </td>
+              <td className='primary' style={{ width: '10em', verticalAlign: 'top', fontSize: '0.9em', textAlign: 'left' }}>
+                {formats.f2(range * maxRange / 1000)}{units.km}
+              </td>
+            </tr>
+          </tbody>
+        </table>
+        <div className='group half'>
+          <h1>{translate('sustained dps against standard shields')}</h1>
+          <LineChart
+            width={this.props.chartWidth}
+            xMax={maxRange}
+            yMax={this.state.maxDps}
+            xLabel={translate('range')}
+            xUnit={translate('m')}
+            yLabel={translate('sdps')}
+            series={this.state.weaponNames}
+            colors={DAMAGE_DEALT_COLORS}
+            func={this.state.calcShieldsDpsFunc}
+            points={200}
+            code={code}
+          />
+        </div>
+        <div className='group half'>
+          <h1>{translate('sustained dps against standard armour')}</h1>
+          <LineChart
+            width={this.props.chartWidth}
+            xMax={maxRange}
+            yMax={this.state.maxDps}
+            xLabel={translate('range')}
+            xUnit={translate('m')}
+            yLabel={translate('sdps')}
+            series={this.state.weaponNames}
+            colors={DAMAGE_DEALT_COLORS}
+            func={this.state.calcHullDpsFunc}
+            points={200}
+            code={code}
+          />
+        </div>
+        </span> : null }
+      </span>
+    );
+  }
+}

src/app/components/DamageReceived.jsx

@@ -0,0 +1,327 @@
+import React from 'react';
+import TranslatedComponent from './TranslatedComponent';
+import { Modules } from 'coriolis-data/dist';
+import { nameComparator } from '../utils/SlotFunctions';
+import { CollapseSection, ExpandSection, MountFixed, MountGimballed, MountTurret } from './SvgIcons';
+import Module from '../shipyard/Module';
+import Slider from '../components/Slider';
+
+/**
+ * Generates an internationalization friendly weapon comparator that will
+ * sort by specified property (if provided) then by name/group, class, rating
+ * @param  {function} translate       Translation function
+ * @param  {function} propComparator  Optional property comparator
+ * @param  {boolean} desc             Use descending order
+ * @return {function}                 Comparator function for names
+ */
+export function weaponComparator(translate, propComparator, desc) {
+  return (a, b) => {
+    if (!desc) {  // Flip A and B if ascending order
+      let t = a;
+      a = b;
+      b = t;
+    }
+
+    // If a property comparator is provided use it first
+    let diff = propComparator ? propComparator(a, b) : nameComparator(translate, a, b);
+
+    if (diff) {
+      return diff;
+    }
+
+    // Property matches so sort by name / group, then class, rating
+    if (a.name === b.name && a.grp === b.grp) {
+      if(a.class == b.class) {
+        return a.rating > b.rating ? 1 : -1;
+      }
+      return a.class - b.class;
+    }
+
+    return nameComparator(translate, a, b);
+  };
+}
+
+/**
+ * Damage received by a selected ship
+ */
+export default class DamageReceived extends TranslatedComponent {
+  static PropTypes = {
+    ship: React.PropTypes.object.isRequired,
+    code: React.PropTypes.string.isRequired
+  };
+
+  /**
+   * Constructor
+   * @param  {Object} props   React Component properties
+   */
+  constructor(props) {
+    super(props);
+
+    this._sort = this._sort.bind(this);
+    this._onCollapseExpand = this._onCollapseExpand.bind(this);
+
+    this.state = {
+      predicate: 'n',
+      desc: true,
+      expanded: false,
+      range: 0.1667,
+      maxRange: 6000
+    };
+  }
+
+  /**
+   * Set the initial weapons state
+   */
+  componentWillMount() {
+    this.setState({ weapons: this._calcWeapons(this.props.ship, this.state.range * this.state.maxRange) });
+  }
+
+  /**
+   * Set the updated weapons state
+   * @param  {Object} nextProps   Incoming/Next properties
+   * @param  {Object} nextContext Incoming/Next conext
+   * @return {boolean}            Returns true if the component should be rerendered
+   */
+  componentWillReceiveProps(nextProps, nextContext) {
+    if (nextProps.code != this.props.code) {
+      this.setState({ weapons: this._calcWeapons(nextProps.ship, this.state.range * this.state.maxRange) });
+    }
+    return true;
+  }
+
+  /**
+   * Calculate the damage received by a ship
+   * @param  {Object} ship        The ship which will receive the damage
+   * @param  {Object} range       The engagement range
+   * @return {boolean}            Returns the per-weapon damage
+   */
+  _calcWeapons(ship, range) {
+    // Tidy up the range so that it's to 4 decimal places
+    range = Math.round(10000 * range) / 10000;
+
+    let weapons = [];
+    for (let grp in Modules.hardpoints) {
+      if (Modules.hardpoints[grp][0].damage && Modules.hardpoints[grp][0].damagedist) {
+        for (let mId in Modules.hardpoints[grp]) {
+          const m = new Module(Modules.hardpoints[grp][mId]);
+          let dropoff = 1;
+          if (m.getFalloff()) {
+            // Calculate the dropoff % due to range
+            if (range > m.getRange()) {
+              // Weapon is out of range
+              dropoff = 0;
+            } else {
+              const falloff = m.getFalloff();
+              if (range > falloff) {
+                const dropoffRange = m.getRange() - falloff;
+                // Assuming straight-line falloff
+                dropoff = 1 - (range - falloff) / dropoffRange;
+              }
+            }
+          }
+          const classRating = `${m.class}${m.rating}${m.missile ? '/' + m.missile : ''}`;
+
+          // Base DPS
+          const baseDps = m.getDps() * dropoff;
+          const baseSDps = m.getClip() ?  ((m.getClip() * baseDps / m.getRoF()) / ((m.getClip() / m.getRoF()) + m.getReload())) * dropoff : baseDps;
+
+          // Effective DPS taking in to account shield resistance
+          let effectivenessShields = 0;
+          if (m.getDamageDist().E) {
+            effectivenessShields += m.getDamageDist().E * (1 - ship.shieldExplRes);
+          }
+          if (m.getDamageDist().K) {
+            effectivenessShields += m.getDamageDist().K * (1 - ship.shieldKinRes);
+          }
+          if (m.getDamageDist().T) {
+            effectivenessShields += m.getDamageDist().T * (1 - ship.shieldThermRes);
+          }
+          if (m.getDamageDist().A) {
+            effectivenessShields += m.getDamageDist().A;
+          }
+          effectivenessShields *= dropoff;
+          const effectiveDpsShields = baseDps * effectivenessShields;
+          const effectiveSDpsShields = baseSDps * effectivenessShields;
+
+          // Effective DPS taking in to account hull hardness and resistance
+          let effectivenessHull = 0;
+          if (m.getDamageDist().E) {
+            effectivenessHull += m.getDamageDist().E * (1 - ship.hullExplRes);
+          }
+          if (m.getDamageDist().K) {
+            effectivenessHull += m.getDamageDist().K * (1 - ship.hullKinRes);
+          }
+          if (m.getDamageDist().T) {
+            effectivenessHull += m.getDamageDist().T * (1 - ship.hullThermRes);
+          }
+          if (m.getDamageDist().A) {
+            effectivenessHull += m.getDamageDist().A;
+          }
+          effectivenessHull *= Math.min(m.getPiercing() / ship.hardness, 1) * dropoff;
+          const effectiveDpsHull = baseDps * effectivenessHull;
+          const effectiveSDpsHull = baseSDps * effectivenessHull;
+
+          weapons.push({ id: m.id,
+                         classRating,
+                         name: m.name || m.grp,
+                         mount: m.mount,
+                         effectiveDpsShields,
+                         effectiveSDpsShields,
+                         effectivenessShields,
+                         effectiveDpsHull,
+                         effectiveSDpsHull,
+                         effectivenessHull });
+        }
+      }
+    }
+
+    return weapons;
+  }
+
+  /**
+   * Triggered when the collapse or expand icons are clicked
+   */
+  _onCollapseExpand() {
+    this.setState({ expanded: !this.state.expanded });
+  }
+
+  /**
+   * Set the sort order and sort
+   * @param  {string} predicate Sort predicate
+   */
+  _sortOrder(predicate) {
+    let desc = this.state.desc;
+
+    if (predicate == this.state.predicate) {
+      desc = !desc;
+    } else {
+      desc = true;
+    }
+
+    this._sort(this.props.ship, predicate, desc);
+    this.setState({ predicate, desc });
+  }
+
+  /**
+   * Sorts the weapon list
+   * @param  {Ship} ship          Ship instance
+   * @param  {string} predicate   Sort predicate
+   * @param  {Boolean} desc       Sort order descending
+   */
+  _sort(ship, predicate, desc) {
+    let comp = weaponComparator.bind(null, this.context.language.translate);
+
+    switch (predicate) {
+      case 'n': comp = comp(null, desc); break;
+      case 'edpss': comp = comp((a, b) => a.effectiveDpsShields - b.effectiveDpsShields, desc); break;
+      case 'esdpss': comp = comp((a, b) => a.effectiveSDpsShields - b.effectiveSDpsShields, desc); break;
+      case 'es': comp = comp((a, b) => a.effectivenessShields - b.effectivenessShields, desc); break;
+      case 'edpsh': comp = comp((a, b) => a.effectiveDpsHull - b.effectiveDpsHull, desc); break;
+      case 'esdpsh': comp = comp((a, b) => a.effectiveSDpsHull - b.effectiveSDpsHull, desc); break;
+      case 'eh': comp = comp((a, b) => a.effectivenessHull - b.effectivenessHull, desc); break;
+    }
+
+    this.state.weapons.sort(comp);
+  }
+
+  /**
+   * Render individual rows for weapons
+   * @param  {Function} translate   Translate function
+   * @param  {Object}   formats     Localised formats map
+   * @return {array}                The individual rows
+   *
+   */
+  _renderRows(translate, formats) {
+    const { termtip, tooltip } = this.context;
+
+    let rows = [];
+
+    for (let i = 0; i < this.state.weapons.length; i++) {
+      const weapon = this.state.weapons[i];
+      rows.push(<tr key={weapon.id}>
+                  <td className='ri'>
+                      {weapon.mount == 'F' ? <span onMouseOver={termtip.bind(null, 'fixed')} onMouseOut={tooltip.bind(null, null)}><MountFixed className='icon'/></span> : null}
+                      {weapon.mount == 'G' ? <span onMouseOver={termtip.bind(null, 'gimballed')} onMouseOut={tooltip.bind(null, null)}><MountGimballed /></span> : null}
+                      {weapon.mount == 'T' ? <span onMouseOver={termtip.bind(null, 'turreted')} onMouseOut={tooltip.bind(null, null)}><MountTurret /></span> : null}
+                    {weapon.classRating} {translate(weapon.name)}
+                  </td>
+                  <td>{formats.round1(weapon.effectiveDpsShields)}</td>
+                  <td>{formats.round1(weapon.effectiveSDpsShields)}</td>
+                  <td>{formats.pct(weapon.effectivenessShields)}</td>
+                  <td>{formats.round1(weapon.effectiveDpsHull)}</td>
+                  <td>{formats.round1(weapon.effectiveSDpsHull)}</td>
+                  <td>{formats.pct(weapon.effectivenessHull)}</td>
+                </tr>);
+    }
+    return rows;
+  }
+
+  /**
+   * Update current range
+   * @param  {number} range Range 0-1
+   */
+  _rangeChange(range) {
+    this.setState({ range, weapons: this._calcWeapons(this.props.ship, this.state.range * this.state.maxRange) });
+  }
+
+  /**
+   * Render damage received
+   * @return {React.Component} contents
+   */
+  render() {
+    const { language, onWindowResize, sizeRatio, tooltip, termtip } = this.context;
+    const { formats, translate, units } = language;
+    const { expanded, maxRange, range } = this.state;
+
+    const sortOrder = this._sortOrder;
+    const onCollapseExpand = this._onCollapseExpand;
+
+    return (
+      <span>
+        <h1>{translate('damage received from')} {expanded ? <span onClick={onCollapseExpand}><CollapseSection className='summary'/></span> : <span onClick={onCollapseExpand}><ExpandSection className='summary'/></span>}</h1>
+	{expanded ? <span>
+        <table className='summary' style={{ width: '100%' }}>
+          <thead>
+          <tr className='main'>
+            <th rowSpan={2} className='sortable' onClick={sortOrder.bind(this, 'n')} >{translate('weapon')}</th>
+            <th colSpan={3} >{translate('against shields')}</th>
+            <th colSpan={3} >{translate('against hull')}</th>
+            </tr>
+          <tr>
+            <th className='sortable lft' onClick={sortOrder.bind(this, 'edpss')} onMouseOver={termtip.bind(null, 'dps')} onMouseOut={tooltip.bind(null, null)}>{translate('DPS')}</th>
+            <th className='sortable' onClick={sortOrder.bind(this, 'esdpss')} onMouseOver={termtip.bind(null, 'sdps')} onMouseOut={tooltip.bind(null, null)}>{translate('SDPS')}</th>
+            <th className='sortable' onClick={sortOrder.bind(this, 'es')} >{translate('effectiveness')}</th>
+            <th className='sortable lft' onClick={sortOrder.bind(this, 'edpsh')} onMouseOver={termtip.bind(null, 'dps')} onMouseOut={tooltip.bind(null, null)}>{translate('DPS')}</th>
+            <th className='sortable' onClick={sortOrder.bind(this, 'esdpsh')} onMouseOver={termtip.bind(null, 'sdps')} onMouseOut={tooltip.bind(null, null)}>{translate('SDPS')}</th>
+            <th className='sortable' onClick={sortOrder.bind(this, 'eh')} >{translate('effectiveness')}</th>
+          </tr>
+          </thead>
+          <tbody>
+            {this._renderRows(translate, formats)}
+          </tbody>
+        </table>
+        <table style={{ width: '80%', lineHeight: '1em', backgroundColor: 'transparent', margin: 'auto' }}>
+          <tbody >
+            <tr>
+              <td style={{ verticalAlign: 'top', padding: 0, width: '2.5em' }} onMouseEnter={termtip.bind(null, 'PHRASE_ENGAGEMENT_RANGE')} onMouseLeave={tooltip.bind(null, null)}>{translate('engagement range')}</td>
+              <td>
+                <Slider
+                  axis={true}
+                  onChange={this._rangeChange.bind(this)}
+                  axisUnit={translate('m')}
+                  percent={range}
+                  max={maxRange}
+                  scale={sizeRatio}
+                  onResize={onWindowResize}
+                />
+              </td>
+              <td className='primary' style={{ width: '10em', verticalAlign: 'top', fontSize: '0.9em', textAlign: 'left' }}>
+                {formats.f2(range * maxRange / 1000)}{units.km}
+              </td>
+            </tr>
+          </tbody>
+        </table></span> : null }
+      </span>
+    );
+  }
+}

src/app/components/DefenceSummary.jsx

@@ -29,6 +29,9 @@ export default class DefenceSummary extends TranslatedComponent {
     let { formats, translate, units } = language;
     let hide = tooltip.bind(null, null);
 
+    const shieldGenerator = ship.findShieldGenerator();
+
+    // Damage values are 1 - resistance values
     return (
       <span>
         <h1>{translate('defence summary')}</h1>
@@ -48,9 +51,18 @@ export default class DefenceSummary extends TranslatedComponent {
             {ship.shield ?
             <tr>
               <td className='le'>{translate('damage from')}</td>
-              <td className='ri' onMouseOver={termtip.bind(null, 'explosive')} onMouseOut={tooltip.bind(null, null)}><DamageExplosive /> {formats.pct1(ship.shieldExplRes || 1)}</td>
-              <td className='ri' onMouseOver={termtip.bind(null, 'kinetic')} onMouseOut={tooltip.bind(null, null)}><DamageKinetic /> {formats.pct1(ship.shieldKinRes || 1)}</td>
-              <td className='ri' onMouseOver={termtip.bind(null, 'thermal')} onMouseOut={tooltip.bind(null, null)}><DamageThermal /> {formats.pct1(ship.shieldThermRes || 1)}</td>
+              <td className='ri'>
+                <span onMouseOver={termtip.bind(null, 'explosive')} onMouseOut={tooltip.bind(null, null)}><DamageExplosive /></span>&nbsp;
+                <span onMouseOver={termtip.bind(null, translate('base') + ' ' + formats.pct1(1 - shieldGenerator.explres))} onMouseOut={tooltip.bind(null, null)}>{formats.pct1(1 - ship.shieldExplRes)}</span>
+              </td>
+              <td className='ri'>
+                <span onMouseOver={termtip.bind(null, 'kinetic')} onMouseOut={tooltip.bind(null, null)}><DamageKinetic /></span>&nbsp;
+                <span onMouseOver={termtip.bind(null, translate('base') + ' ' + formats.pct1(1 - shieldGenerator.kinres))} onMouseOut={tooltip.bind(null, null)}>{formats.pct1(1 - ship.shieldKinRes)}</span>
+              </td>
+              <td className='ri'>
+                <span onMouseOver={termtip.bind(null, 'thermal')} onMouseOut={tooltip.bind(null, null)}><DamageThermal /></span>&nbsp;
+                <span onMouseOver={termtip.bind(null, translate('base') + ' ' + formats.pct1(1 - shieldGenerator.thermres))} onMouseOut={tooltip.bind(null, null)}>{formats.pct1(1 - ship.shieldThermRes)}</span>
+              </td>
             </tr> : null }
 
             { ship.shield && ship.shieldCells ?
@@ -63,10 +75,29 @@ export default class DefenceSummary extends TranslatedComponent {
             </tr>
             <tr>
               <td className='le'>{translate('damage from')}</td>
-              <td className='ri' onMouseOver={termtip.bind(null, 'explosive')} onMouseOut={tooltip.bind(null, null)}><DamageExplosive /> {formats.pct1(ship.hullExplRes || 1)}</td>
-              <td className='ri' onMouseOver={termtip.bind(null, 'kinetic')} onMouseOut={tooltip.bind(null, null)}><DamageKinetic /> {formats.pct1(ship.hullKinRes || 1)}</td>
-              <td className='ri' onMouseOver={termtip.bind(null, 'thermal')} onMouseOut={tooltip.bind(null, null)}><DamageThermal /> {formats.pct1(ship.hullThermRes || 1)}</td>
+              <td className='ri'>
+                <span onMouseOver={termtip.bind(null, 'explosive')} onMouseOut={tooltip.bind(null, null)}><DamageExplosive /></span>&nbsp;
+                <span onMouseOver={termtip.bind(null, translate('base') + ' ' + formats.pct1(1 - ship.bulkheads.m.explres))} onMouseOut={tooltip.bind(null, null)}>{formats.pct1(1 - ship.hullExplRes)}</span></td>
+              <td className='ri'>
+                <span onMouseOver={termtip.bind(null, 'kinetic')} onMouseOut={tooltip.bind(null, null)}><DamageKinetic /></span>&nbsp;
+                <span onMouseOver={termtip.bind(null, translate('base') + ' ' + formats.pct1(1 - ship.bulkheads.m.kinres))} onMouseOut={tooltip.bind(null, null)}>{formats.pct1(1 - ship.hullKinRes)}</span>
+              </td>
+              <td className='ri'>
+                <span onMouseOver={termtip.bind(null, 'thermal')} onMouseOut={tooltip.bind(null, null)}><DamageThermal /></span>&nbsp;
+                <span onMouseOver={termtip.bind(null, translate('base') + ' ' + formats.pct1(1 - ship.bulkheads.m.thermres))} onMouseOut={tooltip.bind(null, null)}>{formats.pct1(1 - ship.hullThermRes)}</span>
+              </td>
             </tr>
+
+	    {ship.modulearmour > 0 ?
+            <tr>
+              <td colSpan='4'><h2>{translate('module armour')}: {formats.int(ship.modulearmour)}</h2></td>
+            </tr> : null }
+
+	    {ship.moduleprotection > 0 ?
+            <tr>
+              <td colSpan='2' className='cn'>{translate('internal protection')} {formats.pct1(ship.moduleprotection)}</td>
+              <td colSpan='2' className='cn'>{translate('external protection')} {formats.pct1(ship.moduleprotection / 2)}</td>
+            </tr> : null }
           </tbody>
         </table>
       </span>

src/app/components/HardpointSlot.jsx

@@ -1,7 +1,7 @@
 import React from 'react';
 import Slot from './Slot';
 import Persist from '../stores/Persist';
-import { DamageKinetic, DamageThermal, DamageExplosive, MountFixed, MountGimballed, MountTurret, ListModifications, Modified } from './SvgIcons';
+import { DamageAbsolute, DamageKinetic, DamageThermal, DamageExplosive, MountFixed, MountGimballed, MountTurret, ListModifications, Modified } from './SvgIcons';
 import { Modifications } from 'coriolis-data/dist';
 import { stopCtxPropagation } from '../utils/UtilityFunctions';
 
@@ -41,20 +41,30 @@ export default class HardpointSlot extends Slot {
       let classRating = `${m.class}${m.rating}${m.missile ? '/' + m.missile : ''}`;
       let { drag, drop } = this.props;
       let { termtip, tooltip } = this.context;
-      let validMods = Modifications.validity[m.grp] || [];
+      let validMods = Modifications.modules[m.grp].modifications || [];
       let showModuleResistances = Persist.showModuleResistances();
 
+      // Modifications tooltip shows blueprint and grade, if available
+      let modTT = translate('modified');
+      if (m && m.blueprint && m.blueprint.name) {
+        modTT = translate(m.blueprint.name) + ' ' + translate('grade') + ' ' + m.blueprint.grade;
+        if (m.blueprint.special && m.blueprint.special.id >= 0) {
+          modTT += ', ' + translate(m.blueprint.special.name);
+        }
+      }
+
       return <div className='details' draggable='true' onDragStart={drag} onDragEnd={drop}>
         <div className={'cb'}>
           <div className={'l'}>
-	  {m.mount && m.mount == 'F' ? <span onMouseOver={termtip.bind(null, 'fixed')} onMouseOut={tooltip.bind(null, null)}><MountFixed /></span> : ''}
-	  {m.mount && m.mount == 'G' ? <span onMouseOver={termtip.bind(null, 'gimballed')} onMouseOut={tooltip.bind(null, null)}><MountGimballed /></span> : ''}
-	  {m.mount && m.mount == 'T' ? <span onMouseOver={termtip.bind(null, 'turreted')} onMouseOut={tooltip.bind(null, null)}><MountTurret /></span> : ''}
-	  {m.type && m.type.match('K') ? <span onMouseOver={termtip.bind(null, 'kinetic')} onMouseOut={tooltip.bind(null, null)}><DamageKinetic /></span> : ''}
-	  {m.type && m.type.match('T') ? <span onMouseOver={termtip.bind(null, 'thermal')} onMouseOut={tooltip.bind(null, null)}><DamageThermal /></span> : ''}
-	  {m.type && m.type.match('E') ? <span onMouseOver={termtip.bind(null, 'explosive')} onMouseOut={tooltip.bind(null, null)}><DamageExplosive /></span> : ''}
-          {classRating} {translate(m.name || m.grp)}{ m.mods && Object.keys(m.mods).length > 0 ? <span className='r' onMouseOver={termtip.bind(null, 'modified')} onMouseOut={tooltip.bind(null, null)}><Modified /></span> : null }
-	  </div>
+          {m.mount && m.mount == 'F' ? <span onMouseOver={termtip.bind(null, 'fixed')} onMouseOut={tooltip.bind(null, null)}><MountFixed /></span> : ''}
+          {m.mount && m.mount == 'G' ? <span onMouseOver={termtip.bind(null, 'gimballed')} onMouseOut={tooltip.bind(null, null)}><MountGimballed /></span> : ''}
+          {m.mount && m.mount == 'T' ? <span onMouseOver={termtip.bind(null, 'turreted')} onMouseOut={tooltip.bind(null, null)}><MountTurret /></span> : ''}
+          {m.getDamageDist() && m.getDamageDist().K ? <span onMouseOver={termtip.bind(null, 'kinetic')} onMouseOut={tooltip.bind(null, null)}><DamageKinetic /></span> : ''}
+          {m.getDamageDist() && m.getDamageDist().T ? <span onMouseOver={termtip.bind(null, 'thermal')} onMouseOut={tooltip.bind(null, null)}><DamageThermal /></span> : ''}
+          {m.getDamageDist() && m.getDamageDist().E ? <span onMouseOver={termtip.bind(null, 'explosive')} onMouseOut={tooltip.bind(null, null)}><DamageExplosive /></span> : ''}
+          {m.getDamageDist() && m.getDamageDist().A ? <span onMouseOver={termtip.bind(null, 'absolute')} onMouseOut={tooltip.bind(null, null)}><DamageAbsolute /></span> : ''}
+          {classRating} {translate(m.name || m.grp)}{ m.mods && Object.keys(m.mods).length > 0 ? <span className='r' onMouseOver={termtip.bind(null, modTT)} onMouseOut={tooltip.bind(null, null)}><Modified /></span> : null }
+          </div>
 
           <div className={'r'}>{formats.round(m.getMass())}{u.T}</div>
         </div>
@@ -65,8 +75,11 @@ export default class HardpointSlot extends Slot {
           { m.getDps() && m.getEps() ? <div className={'l'} onMouseOver={termtip.bind(null, 'dpe')} onMouseOut={tooltip.bind(null, null)}>{translate('DPE')}: {formats.f1(m.getDps() / m.getEps())}</div> : null }
           { m.getRoF() ? <div className={'l'} onMouseOver={termtip.bind(null, 'rof')} onMouseOut={tooltip.bind(null, null)}>{translate('ROF')}: {formats.f1(m.getRoF())}{u.ps}</div> : null }
           { m.getRange() ? <div className={'l'}>{translate('range')} {formats.f1(m.getRange() / 1000)}{u.km}</div> : null }
+          { m.getFalloff() ? <div className={'l'}>{translate('falloff')} {formats.round(m.getFalloff() / 1000)}{u.km}</div> : null }
           { m.getShieldBoost() ? <div className={'l'}>+{formats.pct1(m.getShieldBoost())}</div> : null }
           { m.getAmmo() ? <div className={'l'}>{translate('ammunition')}: {formats.int(m.getClip())}/{formats.int(m.getAmmo())}</div> : null }
+          { m.getShotSpeed() ? <div className={'l'}>{translate('shotspeed')}: {formats.int(m.getShotSpeed())}{u.mps}</div> : null }
+          { m.getPiercing() ? <div className={'l'}>{translate('piercing')}: {formats.int(m.getPiercing())}</div> : null }
           { m.getJitter() ? <div className={'l'}>{translate('jitter')}: {formats.f2(m.getJitter())}°</div> : null }
           { showModuleResistances && m.getExplosiveResistance() ? <div className='l'>{translate('explres')}: {formats.pct(m.getExplosiveResistance())}</div> : null }
           { showModuleResistances && m.getKineticResistance() ? <div className='l'>{translate('kinres')}: {formats.pct(m.getKineticResistance())}</div> : null }

src/app/components/HardpointsSlotSection.jsx

@@ -133,6 +133,10 @@ export default class HardpointsSlotSection extends SlotSection {
         <li className='c' onClick={_fill.bind(this, 'fc', 'G')}><MountGimballed className='lg'/></li>
         <li className='c' onClick={_fill.bind(this, 'fc', 'T')}><MountTurret className='lg'/></li>
       </ul>
+      <div className='select-group cap'>{translate('pa')}</div>
+      <ul>
+        <li className='lc' onClick={_fill.bind(this, 'pa', 'F')}>{translate('pa')}</li>
+      </ul>
       <div className='select-group cap'>{translate('nl')}</div>
       <ul>
         <li className='lc' onClick={_fill.bind(this, 'nl', 'F')}>{translate('nl')}</li>

src/app/components/Header.jsx

@@ -5,12 +5,13 @@ import { Insurance } from '../shipyard/Constants';
 import Link from './Link';
 import ActiveLink from './ActiveLink';
 import cn from 'classnames';
-import { Cogs, CoriolisLogo, Hammer, Rocket, StatsBars } from './SvgIcons';
+import { Cogs, CoriolisLogo, Hammer, Help, Rocket, StatsBars } from './SvgIcons';
 import { Ships } from 'coriolis-data/dist';
 import Persist from '../stores/Persist';
 import { toDetailedExport } from '../shipyard/Serializer';
 import ModalDeleteAll from './ModalDeleteAll';
 import ModalExport from './ModalExport';
+import ModalHelp from './ModalHelp';
 import ModalImport from './ModalImport';
 import Slider from './Slider';
 import { outfitURL } from '../utils/UrlGenerators';
@@ -53,11 +54,11 @@ function selectAll(e) {
  */
 export default class Header extends TranslatedComponent {
 
-  /**
-   * Constructor
-   * @param  {Object} props   React Component properties
-   * @param  {Object} context React Component context
-   */
+	/**
+	 * Constructor
+	 * @param  {Object} props   React Component properties
+	 * @param  {Object} context React Component context
+	 */
   constructor(props, context) {
     super(props);
     this.shipOrder = Object.keys(Ships).sort();
@@ -74,6 +75,7 @@ export default class Header extends TranslatedComponent {
     this._openBuilds = this._openMenu.bind(this, 'b');
     this._openComp = this._openMenu.bind(this, 'comp');
     this._openSettings = this._openMenu.bind(this, 'settings');
+    this._showHelp = this._showHelp.bind(this);
     this.languageOptions = [];
     this.insuranceOptions = [];
     this.state = {
@@ -248,6 +250,17 @@ export default class Header extends TranslatedComponent {
     />);
   }
 
+  /**
+   * Show help modal
+   * @param  {SyntheticEvent} e Event
+   */
+  _showHelp(e) {
+    let translate = this.context.language.translate;
+    e.preventDefault();
+
+    this.context.showModal(<ModalHelp title={translate('help')} />);
+  }
+
   /**
    * Show import modal
    * @param  {SyntheticEvent} e Event
@@ -521,6 +534,12 @@ export default class Header extends TranslatedComponent {
           </div>
           {openedMenu == 'settings' ? this._getSettingsMenu() : null}
         </div>
+
+        <div className='r menu'>
+          <div className={cn('menu-header')} onClick={this._showHelp}>
+            <Help className='xl warning'/>
+          </div>
+        </div>
       </header>
     );
   }

src/app/components/InternalSlot.jsx

@@ -23,39 +23,50 @@ export default class InternalSlot extends Slot {
       let classRating = m.class + m.rating;
       let { drag, drop, ship } = this.props;
       let { termtip, tooltip } = this.context;
-      let validMods = Modifications.validity[m.grp] || [];
+      let validMods = Modifications.modules[m.grp].modifications || [];
       let showModuleResistances = Persist.showModuleResistances();
 
+      // Modifications tooltip shows blueprint and grade, if available
+      let modTT = translate('modified');
+      if (m && m.blueprint && m.blueprint.name) {
+        modTT = translate(m.blueprint.name) + ' ' + translate('grade') + ' ' + m.blueprint.grade;
+      }
+
       let mass = m.getMass() || m.cargo || m.fuel || 0;
       return <div className='details' draggable='true' onDragStart={drag} onDragEnd={drop}>
         <div className={'cb'}>
-          <div className={'l'}>{classRating} {translate(m.name || m.grp)}{m.mods && Object.keys(m.mods).length > 0 ? <span onMouseOver={termtip.bind(null, 'modified')} onMouseOut={tooltip.bind(null, null)}><Modified /></span> : ''}</div>
+          <div className={'l'}>{classRating} {translate(m.name || m.grp)}{m.mods && Object.keys(m.mods).length > 0 ? <span onMouseOver={termtip.bind(null, modTT)} onMouseOut={tooltip.bind(null, null)}><Modified /></span> : ''}</div>
           <div className={'r'}>{formats.round(mass)}{u.T}</div>
         </div>
         <div className={'cb'}>
-          { m.getOptMass() ? <div className={'l'}>{translate('optimal mass')}: {formats.int(m.getOptMass())}{u.T}</div> : null }
-          { m.getMaxMass() ? <div className={'l'}>{translate('max mass')}: {formats.int(m.getMaxMass())}{u.T}</div> : null }
+          { m.getOptMass() ? <div className={'l'}>{translate('optmass', 'sg')}: {formats.int(m.getOptMass())}{u.T}</div> : null }
+          { m.getMaxMass() ? <div className={'l'}>{translate('maxmass', 'sg')}: {formats.int(m.getMaxMass())}{u.T}</div> : null }
           { m.bins ? <div className={'l'}>{m.bins} <u>{translate('bins')}</u></div> : null }
           { m.bays ? <div className={'l'}>{translate('bays')}: {m.bays}</div> : null }
+          { m.rebuildsperbay ? <div className={'l'}>{translate('rebuildsperbay')}: {m.rebuildsperbay}</div> : null }
           { m.rate ? <div className={'l'}>{translate('rate')}: {m.rate}{u.kgs}&nbsp;&nbsp;&nbsp;{translate('refuel time')}: {formats.time(this.props.fuel * 1000 / m.rate)}</div> : null }
           { m.getAmmo() ? <div className={'l'}>{translate('ammunition')}: {formats.gen(m.getAmmo())}</div> : null }
           { m.cells ? <div className={'l'}>{translate('cells')}: {m.cells}</div> : null }
-          { m.shieldreinforcement ? <div className={'l'}>{translate('shieldreinforcement')}: {formats.int(m.getShieldReinforcement())} <u>MJ</u>&nbsp;&nbsp;&nbsp;{translate('total')}: {formats.int(m.cells * m.getShieldReinforcement())}{u.MJ}</div> : null }
+          { m.getShieldReinforcement() ? <div className={'l'}>{translate('shieldreinforcement')}: {formats.int(m.getShieldReinforcement())} <u>MJ</u>&nbsp;&nbsp;&nbsp;{translate('total')}: {formats.int(m.cells * m.getShieldReinforcement())}{u.MJ}</div> : null }
           { m.repair ? <div className={'l'}>{translate('repair')}: {m.repair}</div> : null }
           { m.getFacingLimit() ? <div className={'l'}>{translate('facinglimit')} {formats.f1(m.getFacingLimit())}°</div> : null }
           { m.getRange() ? <div className={'l'}>{translate('range')} {formats.f2(m.getRange())}{u.km}</div> : null }
           { m.getRangeT() ? <div className={'l'}>{translate('ranget')} {formats.f1(m.getRangeT())}{u.s}</div> : null }
-          { m.spinup ? <div className={'l'}>{translate('spinup')}: {formats.f1(m.spinup)}{u.s}</div> : null }
-          { m.time ? <div className={'l'}>{translate('time')}: {formats.time(m.time)}</div> : null }
+          { m.getSpinup() ? <div className={'l'}>{translate('spinup')}: {formats.f1(m.getSpinup())}{u.s}</div> : null }
+          { m.getTime() ? <div className={'l'}>{translate('time')}: {formats.time(m.getTime())}</div> : null }
           { m.maximum ? <div className={'l'}>{translate('max')}: {(m.maximum)}</div> : null }
           { m.rangeLS ? <div className={'l'}>{translate('range')}: {m.rangeLS}{u.Ls}</div> : null }
           { m.rangeLS === null ? <div className={'l'}>∞{u.Ls}</div> : null }
           { m.rangeRating ? <div className={'l'}>{translate('range')}: {m.rangeRating}</div> : null }
           { m.getHullReinforcement() ? <div className={'l'}>+{formats.int(m.getHullReinforcement() + ship.baseArmour * m.getModValue('hullboost') / 10000)} <u className='cap'>{translate('armour')}</u></div> : null }
+          { m.getProtection() ? <div className={'l'}>{formats.rPct(m.getProtection())} <u className='cap'>{translate('protection')}</u></div> : null }
+          { m.getIntegrity() && m.grp === 'mrp' ? <div className={'l'}>{formats.int(m.getIntegrity())} <u className='cap'>{translate('integrity')}</u></div> : null }
           { m.passengers ? <div className={'l'}>{translate('passengers')}: {m.passengers}</div> : null }
           { showModuleResistances && m.getExplosiveResistance() ? <div className='l'>{translate('explres')}: {formats.pct(m.getExplosiveResistance())}</div> : null }
           { showModuleResistances && m.getKineticResistance() ? <div className='l'>{translate('kinres')}: {formats.pct(m.getKineticResistance())}</div> : null }
           { showModuleResistances && m.getThermalResistance() ? <div className='l'>{translate('thermres')}: {formats.pct(m.getThermalResistance())}</div> : null }
+          { m.getRegenerationRate() ? <div className='l'>{translate('regen')}: {formats.round1(m.getRegenerationRate())}{u.ps}</div> : null }
+          { m.getBrokenRegenerationRate() ? <div className='l'>{translate('brokenregen')}: {formats.round1(m.getBrokenRegenerationRate())}{u.ps}</div> : null }
 
 	  { m && validMods.length > 0 ? <div className='r' ><button onClick={this._toggleModifications.bind(this)} onContextMenu={stopCtxPropagation} onMouseOver={termtip.bind(null, 'modifications')} onMouseOut={tooltip.bind(null, null)}><ListModifications /></button></div> : null }
 

src/app/components/InternalSlotSection.jsx

@@ -4,6 +4,7 @@ import SlotSection from './SlotSection';
 import InternalSlot from './InternalSlot';
 import * as ModuleUtils from '../shipyard/ModuleUtils';
 import { stopCtxPropagation } from '../utils/UtilityFunctions';
+import { canMount } from '../utils/SlotFunctions';
 
 /**
  * Internal slot section
@@ -22,6 +23,7 @@ export default class InternalSlotSection extends SlotSection {
     this._fillWithCargo = this._fillWithCargo.bind(this);
     this._fillWithCells = this._fillWithCells.bind(this);
     this._fillWithArmor = this._fillWithArmor.bind(this);
+    this._fillWithModuleReinforcementPackages = this._fillWithModuleReinforcementPackages.bind(this);
     this._fillWithFuelTanks = this._fillWithFuelTanks.bind(this);
     this._fillWithLuxuryCabins = this._fillWithLuxuryCabins.bind(this);
     this._fillWithFirstClassCabins = this._fillWithFirstClassCabins.bind(this);
@@ -46,7 +48,7 @@ export default class InternalSlotSection extends SlotSection {
     let clobber = event.getModifierState('Alt');
     let ship = this.props.ship;
     ship.internal.forEach((slot) => {
-      if (clobber || !slot.m) {
+      if ((clobber || !slot.m) && canMount(ship, slot, 'cr')) {
         ship.use(slot, ModuleUtils.findInternal('cr', slot.maxClass, 'E'));
       }
     });
@@ -62,7 +64,7 @@ export default class InternalSlotSection extends SlotSection {
     let clobber = event.getModifierState('Alt');
     let ship = this.props.ship;
     ship.internal.forEach((slot) => {
-      if (clobber || !slot.m) {
+      if ((clobber || !slot.m) && canMount(ship, slot, 'ft')) {
         ship.use(slot, ModuleUtils.findInternal('ft', slot.maxClass, 'C'));
       }
     });
@@ -78,7 +80,7 @@ export default class InternalSlotSection extends SlotSection {
     let clobber = event.getModifierState('Alt');
     let ship = this.props.ship;
     ship.internal.forEach((slot) => {
-      if (clobber || !slot.m) {
+      if ((clobber || !slot.m) && canMount(ship, slot, 'pcq')) {
         ship.use(slot, ModuleUtils.findInternal('pcq', Math.min(slot.maxClass, 6), 'B')); // Passenger cabins top out at 6
       }
     });
@@ -94,7 +96,7 @@ export default class InternalSlotSection extends SlotSection {
     let clobber = event.getModifierState('Alt');
     let ship = this.props.ship;
     ship.internal.forEach((slot) => {
-      if (clobber || !slot.m) {
+      if ((clobber || !slot.m) && canMount(ship, slot, 'pcm')) {
         ship.use(slot, ModuleUtils.findInternal('pcm', Math.min(slot.maxClass, 6), 'C')); // Passenger cabins top out at 6
       }
     });
@@ -110,7 +112,7 @@ export default class InternalSlotSection extends SlotSection {
     let clobber = event.getModifierState('Alt');
     let ship = this.props.ship;
     ship.internal.forEach((slot) => {
-      if (clobber || !slot.m) {
+      if ((clobber || !slot.m) && canMount(ship, slot, 'pci')) {
         ship.use(slot, ModuleUtils.findInternal('pci', Math.min(slot.maxClass, 6), 'D')); // Passenger cabins top out at 6
       }
     });
@@ -126,7 +128,7 @@ export default class InternalSlotSection extends SlotSection {
     let clobber = event.getModifierState('Alt');
     let ship = this.props.ship;
     ship.internal.forEach((slot) => {
-      if (clobber || !slot.m) {
+      if ((clobber || !slot.m) && canMount(ship, slot, 'pce')) {
         ship.use(slot, ModuleUtils.findInternal('pce', Math.min(slot.maxClass, 6), 'E')); // Passenger cabins top out at 6
       }
     });
@@ -143,7 +145,7 @@ export default class InternalSlotSection extends SlotSection {
     let ship = this.props.ship;
     let chargeCap = 0; // Capacity of single activation
     ship.internal.forEach(function(slot) {
-      if ((!slot.m || (clobber && !ModuleUtils.isShieldGenerator(slot.m.grp))) && (!slot.eligible || slot.eligible.scb)) { // Check eligibility due to passenger ships special case
+      if ((clobber && !(slot.m && ModuleUtils.isShieldGenerator(slot.m.grp)) || !slot.m) && canMount(ship, slot, 'scb')) {
         ship.use(slot, ModuleUtils.findInternal('scb', slot.maxClass, 'A'));
         ship.setSlotEnabled(slot, chargeCap <= ship.shieldStrength); // Don't waste cell capacity on overcharge
         chargeCap += slot.m.recharge;
@@ -161,7 +163,7 @@ export default class InternalSlotSection extends SlotSection {
     let clobber = event.getModifierState('Alt');
     let ship = this.props.ship;
     ship.internal.forEach((slot) => {
-      if (clobber || !slot.m) {
+      if ((clobber || !slot.m) && canMount(ship, slot, 'hr')) {
         ship.use(slot, ModuleUtils.findInternal('hr', Math.min(slot.maxClass, 5), 'D')); // Hull reinforcements top out at 5D
       }
     });
@@ -169,6 +171,22 @@ export default class InternalSlotSection extends SlotSection {
     this._close();
   }
 
+  /**
+   * Fill all slots with Module Reinforcement Packages
+   * @param  {SyntheticEvent} event Event
+   */
+  _fillWithModuleReinforcementPackages(event) {
+    let clobber = event.getModifierState('Alt');
+    let ship = this.props.ship;
+    ship.internal.forEach((slot) => {
+      if ((clobber || !slot.m) && canMount(ship, slot, 'mrp')) {
+        ship.use(slot, ModuleUtils.findInternal('mrp', Math.min(slot.maxClass, 5), 'D')); // Module reinforcements top out at 5D
+      }
+    });
+    this.props.onChange();
+    this._close();
+  }
+
   /**
    * Empty all on section header right click
    */
@@ -226,6 +244,7 @@ export default class InternalSlotSection extends SlotSection {
         <li className='lc' onClick={this._fillWithCargo}>{translate('cargo')}</li>
         <li className='lc' onClick={this._fillWithCells}>{translate('scb')}</li>
         <li className='lc' onClick={this._fillWithArmor}>{translate('hr')}</li>
+        <li className='lc' onClick={this._fillWithModuleReinforcementPackages}>{translate('mrp')}</li>
         <li className='lc' onClick={this._fillWithFuelTanks}>{translate('ft')}</li>
         <li className='lc' onClick={this._fillWithEconomyClassCabins}>{translate('pce')}</li>
         <li className='lc' onClick={this._fillWithBusinessClassCabins}>{translate('pci')}</li>

src/app/components/LineChart.jsx

@@ -1,8 +1,7 @@
 import React from 'react';
-import d3 from 'd3';
+import * as d3 from 'd3';
 import TranslatedComponent from './TranslatedComponent';
 
-const RENDER_POINTS = 20;   // Only render 20 points on the graph
 const MARGIN = { top: 15, right: 20, bottom: 35, left: 60 };
 
 /**
@@ -11,8 +10,10 @@ const MARGIN = { top: 15, right: 20, bottom: 35, left: 60 };
 export default class LineChart extends TranslatedComponent {
 
   static defaultProps = {
+    code: '',
     xMin: 0,
     yMin: 0,
+    points: 20,
     colors: ['#ff8c0d']
   };
 
@@ -26,9 +27,11 @@ export default class LineChart extends TranslatedComponent {
     yLabel: React.PropTypes.string.isRequired,
     yMin: React.PropTypes.number,
     yMax: React.PropTypes.number.isRequired,
-    yUnit: React.PropTypes.string.isRequired,
+    yUnit: React.PropTypes.string,
     series: React.PropTypes.array,
     colors: React.PropTypes.array,
+    points: React.PropTypes.number,
+    code: React.PropTypes.string,
   };
 
   /**
@@ -40,37 +43,25 @@ export default class LineChart extends TranslatedComponent {
     super(props);
 
     this._updateDimensions = this._updateDimensions.bind(this);
-    this._updateSeriesData = this._updateSeriesData.bind(this);
+    this._updateSeries = this._updateSeries.bind(this);
     this._tooltip = this._tooltip.bind(this);
     this._showTip = this._showTip.bind(this);
     this._hideTip = this._hideTip.bind(this);
     this._moveTip = this._moveTip.bind(this);
 
-    let markerElems = [];
-    let detailElems = [<text key='lbl' className='text-tip x' y='1.25em'/>];
-    let xScale = d3.scale.linear();
-    let xAxisScale = d3.scale.linear();
-    let yScale = d3.scale.linear();
-    let series = props.series;
-    let seriesLines = [];
+    const series = props.series;
 
-    this.xAxis = d3.svg.axis().scale(xAxisScale).outerTickSize(0).orient('bottom');
-    this.yAxis = d3.svg.axis().scale(yScale).ticks(6).outerTickSize(0).orient('left');
+    let xScale = d3.scaleLinear();
+    let yScale = d3.scaleLinear();
+    let xAxisScale = d3.scaleLinear();
 
-    for(let i = 0, l = series ? series.length : 1; i < l; i++) {
-      let yAccessor = series ? function(d) { return yScale(d[1][this]); }.bind(series[i]) : (d) => yScale(d[1]);
-      seriesLines.push(d3.svg.line().x((d) => xScale(d[0])).y(yAccessor));
-      detailElems.push(<text key={i} className='text-tip y' y={1.25 * (i + 2) + 'em'}/>);
-      markerElems.push(<circle key={i} className='marker' r='4' />);
-    }
+    this.xAxis = d3.axisBottom(xAxisScale).tickSizeOuter(0);
+    this.yAxis = d3.axisLeft(yScale).ticks(6).tickSizeOuter(0);
 
     this.state = {
       xScale,
       xAxisScale,
       yScale,
-      seriesLines,
-      detailElems,
-      markerElems,
       tipHeight: 2 + (1.2 * (series ? series.length : 0.8))
     };
   }
@@ -98,7 +89,7 @@ export default class LineChart extends TranslatedComponent {
       let yVal = series ? y0[series[i]] : y0;
       yTotal += yVal;
       return (series ? translate(series[i]) : '') + ' ' + formats.f2(yVal);
-    }).append('tspan').attr('class', 'metric').text(' ' + yUnit);
+    }).append('tspan').attr('class', 'metric').text(yUnit ? ' ' + yUnit : '');
 
     tips.selectAll('text').each(function() {
       if (this.getBBox().width > tipWidth) {
@@ -129,7 +120,7 @@ export default class LineChart extends TranslatedComponent {
 
     this.state.xScale.range([0, innerWidth]).domain([xMin, xMax || 1]).clamp(true);
     this.state.xAxisScale.range([0, innerWidth]).domain([xMin, xMax]).clamp(true);
-    this.state.yScale.range([innerHeight, 0]).domain([yMin, yMax]);
+    this.state.yScale.range([innerHeight, 0]).domain([yMin, yMax * 1.1]); // 10% higher than maximum value for tooltip visibility
     this.setState({ innerWidth, outerHeight, innerHeight });
   }
 
@@ -164,27 +155,39 @@ export default class LineChart extends TranslatedComponent {
   }
 
   /**
-   * Update series data generated from props
-   * @param  {Object} props   React Component properties
+   * Update series generated from props
+   * @param   {Object} props   React Component properties
+   * @param   {Object} state   React Component state
    */
-  _updateSeriesData(props) {
-    let { func, xMin, xMax, series } = props;
-    let delta = (xMax - xMin) / RENDER_POINTS;
-    let seriesData = new Array(RENDER_POINTS);
+  _updateSeries(props, state) {
+    let { func, xMin, xMax, series, points } = props;
+    let delta = (xMax - xMin) / points;
+    let seriesData = new Array(points);
 
     if (delta) {
-      seriesData = new Array(RENDER_POINTS);
-      for (let i = 0, x = xMin; i < RENDER_POINTS; i++) {
+      seriesData = new Array(points);
+      for (let i = 0, x = xMin; i < points; i++) {
         seriesData[i] = [x, func(x)];
         x += delta;
       }
-      seriesData[RENDER_POINTS - 1] = [xMax, func(xMax)];
+      seriesData[points - 1] = [xMax, func(xMax)];
     } else {
       let yVal = func(xMin);
       seriesData = [[0, yVal], [1, yVal]];
     }
 
-    this.setState({ seriesData });
+
+    const markerElems = [];
+    const detailElems = [<text key='lbl' className='text-tip x' y='1.25em'/>];
+    const seriesLines = [];
+    for (let i = 0, l = series ? series.length : 1; i < l; i++) {
+      const yAccessor = series ? function(d) { return state.yScale(d[1][this]); }.bind(series[i]) : (d) => state.yScale(d[1]);
+      seriesLines.push(d3.line().x((d, i) => this.state.xScale(d[0])).y(yAccessor));
+      detailElems.push(<text key={i} className='text-tip y' stroke={props.colors[i]} y={1.25 * (i + 2) + 'em'}/>);
+      markerElems.push(<circle key={i} className='marker' r='4' />);
+    }
+
+    this.setState({ markerElems, detailElems, seriesLines, seriesData });
   }
 
   /**
@@ -192,7 +195,7 @@ export default class LineChart extends TranslatedComponent {
    */
   componentWillMount() {
     this._updateDimensions(this.props, this.context.sizeRatio);
-    this._updateSeriesData(this.props);
+    this._updateSeries(this.props, this.state);
   }
 
   /**
@@ -210,8 +213,8 @@ export default class LineChart extends TranslatedComponent {
       this._updateDimensions(nextProps, nextContext.sizeRatio);
     }
 
-    if (domainChanged) {
-      this._updateSeriesData(nextProps);
+    if (props.code != nextProps.code) {
+      this._updateSeries(nextProps, this.state);
     }
   }
 
@@ -227,7 +230,7 @@ export default class LineChart extends TranslatedComponent {
     let { xLabel, yLabel, xUnit, yUnit, colors } = this.props;
     let { innerWidth, outerHeight, innerHeight, tipHeight, detailElems, markerElems, seriesData, seriesLines } = this.state;
     let line = this.line;
-    let lines = seriesLines.map((line, i) => <path key={i} className='line' stroke={colors[i]} strokeWidth='2' d={line(seriesData)} />);
+    let lines = seriesLines.map((line, i) => <path key={i} className='line' fill='none' stroke={colors[i]} strokeWidth='1' d={line(seriesData)} />).reverse();
 
     return <svg style={{ width: '100%', height: outerHeight }}>
       <g transform={`translate(${MARGIN.left},${MARGIN.top})`}>
@@ -241,7 +244,7 @@ export default class LineChart extends TranslatedComponent {
         <g className='y axis' ref={(elem) => d3.select(elem).call(this.yAxis)}>
           <text className='cap' transform='rotate(-90)' y='-50' dy='.1em' x={innerHeight / -2} style={{ textAnchor: 'middle' }}>
             <tspan>{yLabel}</tspan>
-            <tspan className='metric'> ({yUnit})</tspan>
+            { yUnit && <tspan className='metric'> ({yUnit})</tspan> }
           </text>
         </g>
         <g ref={(g) => this.tipContainer = d3.select(g)} style={{ display: 'none' }}>

src/app/components/ModalHelp.jsx

@@ -0,0 +1,48 @@
+/* eslint react/no-danger: 0 */
+import React from 'react';
+import { findDOMNode } from 'react-dom';
+import TranslatedComponent from './TranslatedComponent';
+
+/**
+ * Help Modal
+ */
+export default class ModalHelp extends TranslatedComponent {
+
+  static propTypes = {
+    title: React.PropTypes.string
+  };
+
+  /**
+   * Constructor
+   * @param  {Object} props   React Component properties
+   */
+  constructor(props) {
+    super(props);
+  }
+
+  /**
+   * Focus on textarea and select all
+   */
+  componentDidMount() {
+    const e = findDOMNode(this.refs.exportField);
+    if (e) {
+      e.focus();
+      e.select();
+    }
+  }
+
+  /**
+   * Render the modal
+   * @return {React.Component} Modal Content
+   */
+  render() {
+    const translate = this.context.language.translate;
+    const text = translate('HELP_TEXT');
+
+    return <div className='modal' onClick={ (e) => e.stopPropagation() }>
+      <h2>{translate(this.props.title || 'Help')}</h2>
+      <div dangerouslySetInnerHTML={{ __html: text }} />
+      <button className='r dismiss cap' onClick={this.context.hideModal}>{translate('close')}</button>
+    </div>;
+  }
+}

src/app/components/ModalImport.jsx

@@ -346,6 +346,7 @@ export default class ModalImport extends TranslatedComponent {
         }
       }
     } catch (e) {
+      // console.log(e.stack);
       this.setState({ errorMsg: (typeof e == 'string') ? e : 'Cannot Parse the data!' });
       return;
     }

src/app/components/Modification.jsx

@@ -1,5 +1,4 @@
 import React from 'react';
-import { findDOMNode } from 'react-dom';
 import TranslatedComponent from './TranslatedComponent';
 import cn from 'classnames';
 import NumberEditor from 'react-number-editor';
@@ -13,6 +12,7 @@ export default class Modification extends TranslatedComponent {
     ship: React.PropTypes.object.isRequired,
     m: React.PropTypes.object.isRequired,
     name: React.PropTypes.string.isRequired,
+    value: React.PropTypes.number.isRequired,
     onChange: React.PropTypes.func.isRequired
   };
 
@@ -24,7 +24,7 @@ export default class Modification extends TranslatedComponent {
   constructor(props, context) {
     super(props);
     this.state = {};
-    this.state.value = this.props.m.getModValue(this.props.name) / 100 || 0;
+    this.state.value = props.value;
   }
 
   /**
@@ -42,14 +42,14 @@ export default class Modification extends TranslatedComponent {
       scaledValue = 100000;
       value = 1000;
     }
-    if (scaledValue < -10000) {
-      scaledValue = -10000;
-      value = -100;
+    if (scaledValue < -9999) {
+      scaledValue = -9999;
+      value = -99.99;
     }
 
     let m = this.props.m;
     let ship = this.props.ship;
-    ship.setModification(m, name, scaledValue);
+    ship.setModification(m, name, scaledValue, true);
 
     this.setState({ value });
     this.props.onChange();
@@ -61,11 +61,26 @@ export default class Modification extends TranslatedComponent {
    */
   render() {
     let translate = this.context.language.translate;
-    let name = this.props.name;
+    let { m, name } = this.props;
+
+    if (name === 'damagedist') {
+      // We don't show damage distribution
+      return null;
+    }
+
+    let symbol;
+    if (name === 'jitter') {
+      symbol = '°';
+    } else if (name !== 'burst' && name != 'burstrof') {
+      symbol = '%';
+    }
+    if (symbol) {
+      symbol = ' (' + symbol + ')';
+    }
 
     return (
       <div className={'cb'} key={name}>
-        <div className={'cb'}>{translate(name)}{name === 'jitter' ? ' (°)' : ' (%)'}</div>
+        <div className={'cb'}>{translate(name, m.grp)}{symbol}</div>
         <NumberEditor className={'cb'} style={{ width: '90%', textAlign: 'center' }} step={0.01} stepModifier={1} decimals={2} value={this.state.value} onValueChange={this._updateValue.bind(this)} />
       </div>
     );

src/app/components/ModificationsMenu.jsx

@@ -1,9 +1,8 @@
 import React from 'react';
-import { findDOMNode } from 'react-dom';
+import * as _ from 'lodash';
 import TranslatedComponent from './TranslatedComponent';
-import { stopCtxPropagation } from '../utils/UtilityFunctions';
+import { isEmpty, stopCtxPropagation } from '../utils/UtilityFunctions';
 import cn from 'classnames';
-import { MountFixed, MountGimballed, MountTurret } from './SvgIcons';
 import { Modifications } from 'coriolis-data/dist';
 import Modification from './Modification';
 
@@ -26,23 +25,232 @@ export default class ModificationsMenu extends TranslatedComponent {
   constructor(props, context) {
     super(props);
     this.state = this._initState(props, context);
+
+    this._toggleBlueprintsMenu = this._toggleBlueprintsMenu.bind(this);
+    this._toggleSpecialsMenu = this._toggleSpecialsMenu.bind(this);
+    this._rollWorst = this._rollWorst.bind(this);
+    this._rollRandom = this._rollRandom.bind(this);
+    this._rollBest = this._rollBest.bind(this);
+    this._rollExtreme = this._rollExtreme.bind(this);
+    this._reset = this._reset.bind(this);
   }
 
   /**
-   * Initiate the list of modifications
+   * Initialise state
    * @param  {Object} props   React Component properties
    * @param  {Object} context React Component context
    * @return {Object}         list: Array of React Components
    */
   _initState(props, context) {
-    let { m, onChange, ship } = props;
-    let list = [];
+    let { m } = props;
+    const { language } = context;
+    const translate = language.translate;
 
-    for (let modName of Modifications.validity[m.grp]) {
-      list.push(<Modification key={ modName } ship={ ship } m={ m } name={ modName } onChange={ onChange }/>);
+    // Set up the blueprints
+    let blueprints = [];
+    for (const blueprintName in Modifications.modules[m.grp].blueprints) {
+      for (const grade of Modifications.modules[m.grp].blueprints[blueprintName]) {
+        const close = this._blueprintSelected.bind(this, Modifications.blueprints[blueprintName].id, grade);
+        const key = blueprintName + ':' + grade;
+        blueprints.push(<div style={{ cursor: 'pointer' }} key={ key } onClick={ close }>{translate(Modifications.blueprints[blueprintName].name + ' grade ' + grade)}</div>);
+      }
     }
 
-    return { list };
+    // Set up the special effects
+    let specials = [];
+    if (Modifications.modules[m.grp].specials && Modifications.modules[m.grp].specials.length > 0) {
+      const close = this._specialSelected.bind(this, null);
+      specials.push(<div style={{ cursor: 'pointer' }} key={ 'none' } onClick={ close }>{translate('PHRASE_NO_SPECIAL')}</div>);
+      for (const specialName of Modifications.modules[m.grp].specials) {
+        const close = this._specialSelected.bind(this, specialName);
+        specials.push(<div style={{ cursor: 'pointer' }} key={ specialName } onClick={ close }>{translate(Modifications.specials[specialName].name)}</div>);
+      }
+    }
+
+    // Set up the modifications
+    const modifications = this._setModifications(props);
+
+    const blueprintMenuOpened = false;
+    const specialMenuOpened = false;
+
+    return { blueprintMenuOpened, blueprints, modifications, specialMenuOpened, specials };
+  }
+
+  /**
+   * Initialise the modifications
+   * @param  {Object} props   React Component properties
+   * @return {Object}         list: Array of React Components
+   */
+  _setModifications(props) {
+    const { m, onChange, ship } = props;
+    let modifications = [];
+    for (const modName of Modifications.modules[m.grp].modifications) {
+      if (!Modifications.modifications[modName].hidden) {
+        const key = modName + (m.getModValue(modName) / 100 || 0);
+        modifications.push(<Modification key={ key } ship={ ship } m={ m } name={ modName } value={ m.getModValue(modName) / 100 || 0 } onChange={ onChange }/>);
+      }
+    }
+    return modifications;
+  }
+
+  /**
+   * Toggle the blueprints menu
+   */
+  _toggleBlueprintsMenu() {
+    const blueprintMenuOpened = !this.state.blueprintMenuOpened;
+    this.setState({ blueprintMenuOpened });
+  }
+
+  /**
+   * Activated when a blueprint is selected
+   * @param  {int} blueprintId The ID of the selected blueprint
+   * @param  {int} grade       The grade of the selected blueprint
+   */
+  _blueprintSelected(blueprintId, grade) {
+    const { m } = this.props;
+    const blueprint = Object.assign({}, _.find(Modifications.blueprints, function(o) { return o.id === blueprintId; }));
+    blueprint.grade = grade;
+    m.blueprint = blueprint;
+
+    const blueprintMenuOpened = false;
+    this.setState({ blueprintMenuOpened });
+    this.props.onChange();
+  }
+
+  /**
+   * Toggle the specials menu
+   */
+  _toggleSpecialsMenu() {
+    const specialMenuOpened = !this.state.specialMenuOpened;
+    this.setState({ specialMenuOpened });
+  }
+
+  /**
+   * Activated when a special is selected
+   * @param  {int} special     The name of the selected special
+   */
+  _specialSelected(special) {
+    const { m } = this.props;
+
+    if (m.blueprint) { 
+      if (special === null) {
+        m.blueprint.special = null;
+      } else {
+        m.blueprint.special = Modifications.specials[special];
+      }
+    }
+
+    const specialMenuOpened = false;
+    this.setState({ specialMenuOpened, modifications: this._setModifications(this.props) });
+    this.props.onChange();
+  }
+
+  /**
+   * Set the result of a roll
+   * @param  {object} ship          The ship to which the roll applies
+   * @param  {object} m             The module to which the roll applies
+   * @param  {string} featureName   The modification feature to which the roll applies
+   * @param  {number} value         The value of the roll
+   */
+  _setRollResult(ship, m, featureName, value) {
+    if (Modifications.modifications[featureName].method !== 'overwrite') {
+      if (m.grp == 'sb' && featureName == 'shieldboost') {
+        // Shield boosters are a special case.  Their boost is dependent on their base so we need to calculate the value here
+        value = ((1 + m.shieldboost) * (1 + value) - 1) / m.shieldboost - 1;
+      }
+    }
+
+    if (Modifications.modifications[featureName].type == 'percentage') {
+      ship.setModification(m, featureName, value * 10000);
+    } else if (Modifications.modifications[featureName].type == 'numeric') {
+      ship.setModification(m, featureName, value * 100);
+    } else {
+      ship.setModification(m, featureName, value);
+    }
+  }
+
+  /**
+   * Provide a 'worst' roll within the information we have
+   */
+  _rollWorst() {
+    const { m, ship } = this.props;
+    const features = m.blueprint.grades[m.blueprint.grade].features;
+    for (const featureName in features) {
+      let value = features[featureName][0];
+      this._setRollResult(ship, m, featureName, value);
+    }
+    this.setState({ modifications: this._setModifications(this.props) });
+    this.props.onChange();
+  }
+
+  /**
+   * Provide a random roll within the information we have
+   */
+  _rollRandom() {
+    const { m, ship } = this.props;
+    const features = m.blueprint.grades[m.blueprint.grade].features;
+    for (const featureName in features) {
+      let value = features[featureName][0] + (Math.random() * (features[featureName][1] - features[featureName][0]));
+      this._setRollResult(ship, m, featureName, value);
+    }
+    this.setState({ modifications: this._setModifications(this.props) });
+    this.props.onChange();
+  }
+
+  /**
+   * Provide a 'best' roll within the information we have
+   */
+  _rollBest() {
+    const { m, ship } = this.props;
+    const features = m.blueprint.grades[m.blueprint.grade].features;
+    for (const featureName in features) {
+      let value = features[featureName][1];
+      this._setRollResult(ship, m, featureName, value);
+    }
+    this.setState({ modifications: this._setModifications(this.props) });
+    this.props.onChange();
+  }
+
+  /**
+   * Provide an 'extreme' roll within the information we have
+   */
+  _rollExtreme() {
+    const { m, ship } = this.props;
+    const features = m.blueprint.grades[m.blueprint.grade].features;
+    for (const featureName in features) {
+      let value;
+      if (Modifications.modifications[featureName].higherbetter) {
+        // Higher is better, but is this making it better or worse?
+        if (features[featureName][0] < 0 || (features[featureName][0] === 0 && features[featureName][1] < 0)) {
+          value = features[featureName][0];
+        } else {
+          value = features[featureName][1];
+        }
+      } else {
+        // Higher is worse, but is this making it better or worse?
+        if (features[featureName][0] < 0 || (features[featureName][0] === 0 && features[featureName][1] < 0)) {
+          value = features[featureName][1];
+        } else {
+          value = features[featureName][0];
+        }
+      }
+
+      this._setRollResult(ship, m, featureName, value);
+    }
+    this.setState({ modifications: this._setModifications(this.props) });
+    this.props.onChange();
+  }
+
+  /**
+   * Reset modification information
+   */
+  _reset() {
+    const { m, ship } = this.props;
+    ship.clearModifications(m);
+    ship.clearBlueprint(m);
+
+    this.setState({ modifications: this._setModifications(this.props) });
+    this.props.onChange();
   }
 
   /**
@@ -50,15 +258,73 @@ export default class ModificationsMenu extends TranslatedComponent {
    * @return {React.Component} List
    */
   render() {
-    let { tooltip, termtip } = this.context;
+    const { language, tooltip, termtip } = this.context;
+    const translate = language.translate;
+    const { m } = this.props;
+    const { blueprintMenuOpened, specialMenuOpened } = this.state;
+
+    const _toggleBlueprintsMenu = this._toggleBlueprintsMenu;
+    const _toggleSpecialsMenu = this._toggleSpecialsMenu;
+    const _rollBest = this._rollBest;
+    const _rollExtreme = this._rollExtreme;
+    const _rollWorst = this._rollWorst;
+    const _rollRandom = this._rollRandom;
+    const _reset = this._reset;
+
+    let blueprintLabel;
+    let haveBlueprint = false;
+    if (m.blueprint && !isEmpty(m.blueprint)) {
+      blueprintLabel = translate(m.blueprint.name) + ' ' + translate('grade') + ' ' + m.blueprint.grade;
+      haveBlueprint = true;
+    } else {
+      blueprintLabel = translate('PHRASE_SELECT_BLUEPRINT');
+    }
+
+    let specialLabel;
+    if (m.blueprint && m.blueprint.special) {
+      specialLabel = m.blueprint.special.name;
+    } else {
+      specialLabel = translate('PHRASE_SELECT_SPECIAL');
+    }
+
+    const showBlueprintsMenu = blueprintMenuOpened;
+    const showSpecial = haveBlueprint && this.state.specials.length > 0;
+    const showSpecialsMenu = specialMenuOpened;
+    const showRolls = haveBlueprint && !blueprintMenuOpened && !specialMenuOpened;
+    const showReset = !blueprintMenuOpened && !specialMenuOpened;
+    const showMods = !blueprintMenuOpened && !specialMenuOpened;
+
     return (
       <div
           className={cn('select', this.props.className)}
           onClick={(e) => e.stopPropagation() }
           onContextMenu={stopCtxPropagation}
-          onMouseOver={termtip.bind(null, 'HELP_MODIFICATIONS_MENU')} onMouseOut={tooltip.bind(null, null)} 
       >
-        {this.state.list}
+        <div className={ cn('section-menu', { selected: blueprintMenuOpened })} style={{ cursor: 'pointer' }} onClick={_toggleBlueprintsMenu}>{blueprintLabel}</div>
+        { showBlueprintsMenu ? this.state.blueprints : null }
+        { showSpecial ? <div className={ cn('section-menu', { selected: specialMenuOpened })} style={{ cursor: 'pointer' }} onClick={_toggleSpecialsMenu}>{specialLabel}</div> : null }
+        { showSpecialsMenu ? this.state.specials : null }
+        { showRolls || showReset ?
+            <table style={{ width: '100%', backgroundColor: 'transparent' }}>
+              <tbody>
+          { showRolls ?
+                <tr>
+                  <td> { translate('roll') }: </td>
+                  <td style={{ cursor: 'pointer' }} onClick={_rollWorst} onMouseOver={termtip.bind(null, 'PHRASE_BLUEPRINT_WORST')} onMouseOut={tooltip.bind(null, null)}> { translate('worst') } </td>
+                  <td style={{ cursor: 'pointer' }} onClick={_rollBest}onMouseOver={termtip.bind(null, 'PHRASE_BLUEPRINT_BEST')} onMouseOut={tooltip.bind(null, null)}> { translate('best') } </td>
+                  <td style={{ cursor: 'pointer' }} onClick={_rollExtreme}onMouseOver={termtip.bind(null, 'PHRASE_BLUEPRINT_EXTREME')} onMouseOut={tooltip.bind(null, null)}> { translate('extreme') } </td>
+                  <td style={{ cursor: 'pointer' }} onClick={_rollRandom} onMouseOver={termtip.bind(null, 'PHRASE_BLUEPRINT_RANDOM')} onMouseOut={tooltip.bind(null, null)}> { translate('random') } </td>
+                </tr> : null }
+          { showReset ?
+                <tr>
+                  <td colSpan={'5'} style={{ cursor: 'pointer' }} onClick={_reset}onMouseOver={termtip.bind(null, 'PHRASE_BLUEPRINT_RESET')} onMouseOut={tooltip.bind(null, null)}> { translate('reset') } </td>
+                </tr> : null }
+              </tbody>
+          </table> : null }
+        { showMods ?
+          <span onMouseOver={termtip.bind(null, 'HELP_MODIFICATIONS_MENU')} onMouseOut={tooltip.bind(null, null)} >
+            { this.state.modifications }
+          </span> : null }
       </div>
     );
   }

src/app/components/MovementSummary.jsx

@@ -0,0 +1,90 @@
+import React from 'react';
+import cn from 'classnames';
+import TranslatedComponent from './TranslatedComponent';
+
+/**
+ * Movement summary
+ */
+export default class MovementSummary extends TranslatedComponent {
+  static PropTypes = {
+    ship: React.PropTypes.object.isRequired
+  };
+
+  /**
+   * Constructor
+   * @param  {Object} props   React Component properties
+   */
+  constructor(props) {
+    super(props);
+  }
+
+  /**
+   * Render movement summary
+   * @return {React.Component} contents
+   */
+  render() {
+    let ship = this.props.ship;
+    let { language, tooltip, termtip } = this.context;
+    let { formats, translate, units } = language;
+    let boostMultiplier = ship.topBoost / ship.topSpeed;
+
+    return (
+      <span>
+        <h1>{translate('movement summary')}</h1>
+        <table style={{ marginLeft: 'auto', marginRight: 'auto', lineHeight: '1em', backgroundColor: 'transparent', borderSpacing: '0.5em' }}>
+          <tbody>
+            <tr>
+              <td >&nbsp;</td>
+              <td colSpan='6'>{translate('engine pips')}</td>
+            </tr>
+            <tr>
+              <td>&nbsp;</td>
+              <td>0</td>
+              <td>1</td>
+              <td>2</td>
+              <td>3</td>
+              <td>4</td>
+              <td onMouseOver={termtip.bind(null, '4b')} onMouseOut={tooltip.bind(null, null)}>4B</td>
+            </tr>
+            <tr>
+              <td className='ri'>{translate('speed')} ({units['m/s']})</td>
+              <td className='ri'>{formats.int(ship.speeds[0])}</td>
+              <td className='ri'>{formats.int(ship.speeds[1])}</td>
+              <td className='ri'>{formats.int(ship.speeds[2])}</td>
+              <td className='ri'>{formats.int(ship.speeds[3])}</td>
+              <td className='ri'>{formats.int(ship.speeds[4])}</td>
+              <td className='ri'>{formats.int(ship.speeds[4] * boostMultiplier)}</td>
+            </tr>
+            <tr>
+              <td className='ri'>{translate('pitch')} ({units['°/s']})</td>
+              <td className='ri'>{formats.int(ship.pitches[0])}</td>
+              <td className='ri'>{formats.int(ship.pitches[1])}</td>
+              <td className='ri'>{formats.int(ship.pitches[2])}</td>
+              <td className='ri'>{formats.int(ship.pitches[3])}</td>
+              <td className='ri'>{formats.int(ship.pitches[4])}</td>
+              <td className='ri'>{formats.int(ship.pitches[4] * boostMultiplier)}</td>
+            </tr>
+            <tr>
+              <td className='ri'>{translate('roll')} ({units['°/s']})</td>
+              <td className='ri'>{formats.int(ship.rolls[0])}</td>
+              <td className='ri'>{formats.int(ship.rolls[1])}</td>
+              <td className='ri'>{formats.int(ship.rolls[2])}</td>
+              <td className='ri'>{formats.int(ship.rolls[3])}</td>
+              <td className='ri'>{formats.int(ship.rolls[4])}</td>
+              <td className='ri'>{formats.int(ship.rolls[4] * boostMultiplier)}</td>
+            </tr>
+            <tr>
+              <td className='ri'>{translate('yaw')} ({units['°/s']})</td>
+              <td className='ri'>{formats.int(ship.yaws[0])}</td>
+              <td className='ri'>{formats.int(ship.yaws[1])}</td>
+              <td className='ri'>{formats.int(ship.yaws[2])}</td>
+              <td className='ri'>{formats.int(ship.yaws[3])}</td>
+              <td className='ri'>{formats.int(ship.yaws[4])}</td>
+              <td className='ri'>{formats.int(ship.yaws[4] * boostMultiplier)}</td>
+            </tr>
+          </tbody>
+        </table>
+      </span>
+    );
+  }
+}

src/app/components/OffenceSummary.jsx

@@ -1,7 +1,7 @@
 import React from 'react';
 import cn from 'classnames';
 import TranslatedComponent from './TranslatedComponent';
-import { DamageKinetic, DamageThermal, DamageExplosive } from './SvgIcons';
+import { DamageAbsolute, DamageKinetic, DamageThermal, DamageExplosive } from './SvgIcons';
 
 /**
  * Offence summary
@@ -34,30 +34,33 @@ export default class OffenceSummary extends TranslatedComponent {
         <table className='summary' style={{ marginLeft: 'auto', marginRight: 'auto', lineHeight: '1em', backgroundColor: 'transparent' }}>
           <tbody>
             <tr>
-              <td colSpan='4' className='summary'><h2>{translate('dps')}: {formats.f1(ship.totalDps)}</h2></td>
+              <td colSpan='5' className='summary'><h2>{translate('dps')}: {formats.f1(ship.totalDps)}</h2></td>
             </tr>
             <tr>
               <td className='le'>{translate('damage by')}</td>
+              <td className='ri' onMouseOver={termtip.bind(null, 'absolute')} onMouseOut={tooltip.bind(null, null)}><DamageAbsolute /> {formats.f1(ship.totalAbsDps)}</td>
               <td className='ri' onMouseOver={termtip.bind(null, 'explosive')} onMouseOut={tooltip.bind(null, null)}><DamageExplosive /> {formats.f1(ship.totalExplDps)}</td>
               <td className='ri' onMouseOver={termtip.bind(null, 'kinetic')} onMouseOut={tooltip.bind(null, null)}><DamageKinetic /> {formats.f1(ship.totalKinDps)}</td>
               <td className='ri' onMouseOver={termtip.bind(null, 'thermal')} onMouseOut={tooltip.bind(null, null)}><DamageThermal /> {formats.f1(ship.totalThermDps)}</td>
             </tr>
             
             <tr>
-              <td colSpan='4' className='summary'><h2>{translate('sdps')}: {formats.f1(ship.totalSDps)}</h2></td>
+              <td colSpan='5' className='summary'><h2>{translate('sdps')}: {formats.f1(ship.totalSDps)}</h2></td>
             </tr>
             <tr>
               <td className='le'>{translate('damage by')}</td>
+              <td className='ri' onMouseOver={termtip.bind(null, 'absolute')} onMouseOut={tooltip.bind(null, null)}><DamageAbsolute /> {formats.f1(ship.totalAbsSDps)}</td>
               <td className='ri' onMouseOver={termtip.bind(null, 'explosive')} onMouseOut={tooltip.bind(null, null)}><DamageExplosive /> {formats.f1(ship.totalExplSDps)}</td>
               <td className='ri' onMouseOver={termtip.bind(null, 'kinetic')} onMouseOut={tooltip.bind(null, null)}><DamageKinetic /> {formats.f1(ship.totalKinSDps)}</td>
               <td className='ri' onMouseOver={termtip.bind(null, 'thermal')} onMouseOut={tooltip.bind(null, null)}><DamageThermal /> {formats.f1(ship.totalThermSDps)}</td>
             </tr>
             
             <tr>
-              <td colSpan='4' className='summary'><h2>{translate('dpe')}: {formats.f1(ship.totalDpe)}</h2></td>
+              <td colSpan='5' className='summary'><h2>{translate('dpe')}: {formats.f1(ship.totalDpe)}</h2></td>
             </tr>
             <tr>
               <td className='le'>{translate('damage by')}</td>
+              <td className='ri' onMouseOver={termtip.bind(null, 'absolute')} onMouseOut={tooltip.bind(null, null)}><DamageAbsolute /> {formats.f1(ship.totalAbsDpe)}</td>
               <td className='ri' onMouseOver={termtip.bind(null, 'explosive')} onMouseOut={tooltip.bind(null, null)}><DamageExplosive /> {formats.f1(ship.totalExplDpe)}</td>
               <td className='ri' onMouseOver={termtip.bind(null, 'kinetic')} onMouseOut={tooltip.bind(null, null)}><DamageKinetic /> {formats.f1(ship.totalKinDpe)}</td>
               <td className='ri' onMouseOver={termtip.bind(null, 'thermal')} onMouseOut={tooltip.bind(null, null)}><DamageThermal /> {formats.f1(ship.totalThermDpe)}</td>

src/app/components/PowerBands.jsx

@@ -1,5 +1,5 @@
 import React from 'react';
-import d3 from 'd3';
+import * as d3 from 'd3';
 import cn from 'classnames';
 import TranslatedComponent from './TranslatedComponent';
 import { wrapCtxMenu } from '../utils/UtilityFunctions';
@@ -46,10 +46,10 @@ export default class PowerBands extends TranslatedComponent {
    */
   constructor(props, context) {
     super(props);
-    this.wattScale = d3.scale.linear();
-    this.pctScale = d3.scale.linear().domain([0, 1]);
-    this.wattAxis = d3.svg.axis().scale(this.wattScale).outerTickSize(0).orient('top').tickFormat(context.language.formats.r2);
-    this.pctAxis = d3.svg.axis().scale(this.pctScale).outerTickSize(0).orient('bottom').tickFormat(context.language.formats.rPct);
+    this.wattScale = d3.scaleLinear();
+    this.pctScale = d3.scaleLinear().domain([0, 1]);
+    this.wattAxis = d3.axisTop(this.wattScale).tickSizeOuter(0).tickFormat(context.language.formats.r2);
+    this.pctAxis = d3.axisBottom(this.pctScale).tickSizeOuter(0).tickFormat(context.language.formats.rPct);
 
     this._updateDimensions = this._updateDimensions.bind(this);
     this._updateScales = this._updateScales.bind(this);
@@ -186,9 +186,9 @@ export default class PowerBands extends TranslatedComponent {
 
     let { wattScale, pctScale, context, props, state } = this;
     let { translate, formats } = context.language;
-    let { f2, pct1, rPct, r2 } = formats; // wattFmt, pctFmt, pctAxis, wattAxis
-    let { available, bands, width } = props;
-    let { innerWidth, maxPwr, ret, dep } = state;
+    let { f2, pct1 } = formats; // wattFmt, pctFmt
+    let { available, bands } = props;
+    let { innerWidth, ret, dep } = state;
     let pwrWarningClass = cn('threshold', { exceeded: bands[0].retractedSum * 2 >= available });
     let deployed = [];
     let retracted = [];

src/app/components/ShipSelector.jsx

@@ -0,0 +1,89 @@
+import React from 'react';
+import cn from 'classnames';
+import { Ships } from 'coriolis-data/dist';
+import TranslatedComponent from './TranslatedComponent';
+import { Rocket } from './SvgIcons';
+
+/**
+ * Selector for ships
+ */
+export default class ShipSelector extends TranslatedComponent {
+  static PropTypes = {
+    initial: React.PropTypes.object.isRequired,
+    onChange: React.PropTypes.func.isRequired
+  };
+
+  /**
+   * Constructor
+   * @param  {Object} props   React Component properties
+   */
+  constructor(props) {
+    super(props);
+
+    this.state = { ship : this.props.initial };
+  }
+
+  /**
+   * Generate the ships menu
+   * @return {React.Component} Menu
+   */
+  _getShipsMenu() {
+    const _selectShip = this._selectShip;
+
+    let shipList = [];
+
+    for (let s in Ships) {
+      shipList.push(<div key={s} onClick={_selectShip.bind(this, s)} className='block' >{Ships[s].properties.name}</div>);
+    }
+
+    return shipList;
+  }
+
+  /**
+   * Handle opening the menu
+   * @param  {string}         menu  The ID of the opened menu
+   * @param  {SyntheticEvent} event Event
+   */
+  _openMenu(menu, event) {
+    event.stopPropagation();
+    if (this.props.currentMenu == menu) {
+      menu = null;
+    }
+
+    this.context.openMenu(menu);
+  }
+
+  /**
+   * Handle selection of a ship
+   * @param {string} s  The selected ship ID
+   */
+  _selectShip(s) {
+    this.setState({ ship: Ships[s] });
+
+    this.context.openMenu(null);
+    this.props.onChange(s);
+  }
+
+  /**
+   * Render ship selector
+   * @return {React.Component} contents
+   */
+  render() {
+    const currentMenu = this.props.currentMenu;
+    const ship = this.state.ship;
+
+    return (
+      <div className='shipselector'>
+      <div className='menu'>
+        <div className={cn('menu-header', { selected: currentMenu == 'wds' })} onClick={this._openMenu.bind(this, 'wds')}>
+          <Rocket className='warning' /><span className='menu-item-label'>{ship.properties.name}</span>
+	  {currentMenu == 'wds' ? 
+          <div className='menu-list quad no-wrap' onClick={ (e) => e.stopPropagation() }>
+            {this._getShipsMenu()}
+          </div> : null }
+        </div>
+      </div>
+      </div>
+    );
+  }
+}

src/app/components/ShipSummaryTable.jsx

@@ -1,7 +1,6 @@
 import React from 'react';
 import TranslatedComponent from './TranslatedComponent';
 import cn from 'classnames';
-import { SizeMap } from '../shipyard/Constants';
 import { Warning } from './SvgIcons';
 
 /**
@@ -23,7 +22,7 @@ export default class ShipSummaryTable extends TranslatedComponent {
     let translate = language.translate;
     let u = language.units;
     let formats = language.formats;
-    let { time, int, round, f1, f2, pct } = formats;
+    let { time, int, round, f1, f2 } = formats;
     let sgClassNames = cn({ warning: ship.findInternalByGroup('sg') && !ship.shield, muted: !ship.findInternalByGroup('sg') });
     let sgRecover = '-';
     let sgRecharge = '-';
@@ -42,14 +41,17 @@ export default class ShipSummaryTable extends TranslatedComponent {
             <th rowSpan={2} className={ cn({ 'bg-warning-disabled': !ship.canBoost() }) }>{translate('boost')}</th>
             <th onMouseEnter={termtip.bind(null, 'damage per second')} onMouseLeave={hide} rowSpan={2}>{translate('DPS')}</th>
             <th onMouseEnter={termtip.bind(null, 'energy per second')} onMouseLeave={hide} rowSpan={2}>{translate('EPS')}</th>
+            <th onMouseEnter={termtip.bind(null, 'time to drain WEP capacitor')} onMouseLeave={hide} rowSpan={2}>{translate('TTD')}</th>
             <th onMouseEnter={termtip.bind(null, 'heat per second')} onMouseLeave={hide} rowSpan={2}>{translate('HPS')}</th>
-            <th rowSpan={2}>{translate('armour')}</th>
-            <th rowSpan={2}>{translate('shields')}</th>
+            <th onMouseEnter={termtip.bind(null, 'hull hardness')} onMouseLeave={hide} rowSpan={2}>{translate('hrd')}</th>
+            <th onMouseEnter={termtip.bind(null, 'armour')} onMouseLeave={hide} rowSpan={2}>{translate('arm')}</th>
+            <th onMouseEnter={termtip.bind(null, 'shields')} onMouseLeave={hide} rowSpan={2}>{translate('shld')}</th>
             <th colSpan={3}>{translate('mass')}</th>
             <th rowSpan={2}>{translate('cargo')}</th>
             <th rowSpan={2}>{translate('fuel')}</th>
             <th colSpan={3}>{translate('jump range')}</th>
             <th onMouseEnter={termtip.bind(null, 'PHRASE_FASTEST_RANGE')} onMouseLeave={hide} colSpan={3}>{translate('fastest range')}</th>
+            <th rowSpan={2}>{translate('crew')}</th>
             <th onMouseEnter={termtip.bind(null, 'mass lock factor')} onMouseLeave={hide} rowSpan={2}>{translate('MLF')}</th>
           </tr>
           <tr>
@@ -70,7 +72,9 @@ export default class ShipSummaryTable extends TranslatedComponent {
             <td>{ ship.canBoost() ? <span>{int(ship.topBoost)} {u['m/s']}</span> : <span className='warning'>0 <Warning/></span> }</td>
             <td>{f1(ship.totalDps)}</td>
             <td>{f1(ship.totalEps)}</td>
+            <td>{ship.timeToDrain === Infinity ? '∞' : time(ship.timeToDrain)}</td>
             <td>{f1(ship.totalHps)}</td>
+            <td>{int(ship.hardness)}</td>
             <td>{int(ship.armour)}</td>
             <td className={sgClassNames}>{int(ship.shield)} {u.MJ}</td>
             <td>{ship.hullMass} {u.T}</td>
@@ -84,6 +88,7 @@ export default class ShipSummaryTable extends TranslatedComponent {
             <td>{int(ship.maxJumpCount)}</td>
             <td>{f2(ship.unladenFastestRange)} {u.LY}</td>
             <td>{f2(ship.ladenFastestRange)} {u.LY}</td>
+            <td>{ship.crew}</td>
             <td>{ship.masslock}</td>
           </tr>
         </tbody>

src/app/components/Slot.jsx

@@ -3,8 +3,6 @@ import TranslatedComponent from './TranslatedComponent';
 import cn from 'classnames';
 import AvailableModulesMenu from './AvailableModulesMenu';
 import ModificationsMenu from './ModificationsMenu';
-import { Modifications } from 'coriolis-data/dist';
-import { ListModifications } from './SvgIcons';
 import { diffDetails } from '../utils/SlotFunctions';
 import { wrapCtxMenu } from '../utils/UtilityFunctions';
 import { stopCtxPropagation } from '../utils/UtilityFunctions';

src/app/components/SlotSection.jsx

@@ -64,7 +64,7 @@ export default class SlotSection extends TranslatedComponent {
    * @param  {Object} m    Selected module
    */
   _selectModule(slot, m) {
-    this.props.ship.use(slot, m);
+    this.props.ship.use(slot, m, false);
     this.props.onChange();
     this._close();
   }
@@ -77,7 +77,7 @@ export default class SlotSection extends TranslatedComponent {
   _drag(originSlot, e) {
     e.dataTransfer.setData('text/html', e.currentTarget);
     e.dataTransfer.effectAllowed = 'all';
-    this.setState({ originSlot });
+    this.setState({ originSlot, copy: e.getModifierState('Alt') });
     this._close();
   }
 
@@ -91,7 +91,9 @@ export default class SlotSection extends TranslatedComponent {
     e.stopPropagation();
     let os = this.state.originSlot;
     if (os) {
-      e.dataTransfer.dropEffect = os != targetSlot && canMount(this.props.ship, targetSlot, os.m.grp, os.m.class) ? 'copyMove' : 'none';
+      // Show correct icon
+      const effect = this.state.copy ? 'copy' : 'move';
+      e.dataTransfer.dropEffect = os != targetSlot && canMount(this.props.ship, targetSlot, os.m.grp, os.m.class) ? effect : 'none';
       this.setState({ targetSlot });
     } else {
       e.dataTransfer.dropEffect = 'none';
@@ -114,20 +116,30 @@ export default class SlotSection extends TranslatedComponent {
    * the origin slot will be empty.
    */
   _drop() {
-    let { originSlot, targetSlot } = this.state;
+    let { originSlot, targetSlot, copy } = this.state;
     let m = originSlot.m;
 
-    if (targetSlot && m && canMount(this.props.ship, targetSlot, m.grp, m.class)) {
-      // Swap modules if possible
-      if (targetSlot.m && canMount(this.props.ship, originSlot, targetSlot.m.grp, targetSlot.m.class)) {
-        this.props.ship.use(originSlot, targetSlot.m, true);
-      } else { // Otherwise empty the  origin slot
-        this.props.ship.use(originSlot, null, true);  // Empty but prevent summary update
+    if (copy) {
+      // We want to copy the module in to the target slot
+      if (targetSlot && canMount(this.props.ship, targetSlot, m.grp, m.class)) {
+        const mCopy = m.clone();
+        this.props.ship.use(targetSlot, mCopy, false);
+        this.props.onChange();
+      }
+    } else {
+      // We want to move the module in to the target slot, and swap back any module that was originally in the target slot
+      if (targetSlot && m && canMount(this.props.ship, targetSlot, m.grp, m.class)) {
+        // Swap modules if possible
+        if (targetSlot.m && canMount(this.props.ship, originSlot, targetSlot.m.grp, targetSlot.m.class)) {
+          this.props.ship.use(originSlot, targetSlot.m, true);
+        } else { // Otherwise empty the  origin slot
+          this.props.ship.use(originSlot, null, true);  // Empty but prevent summary update
+        }
+        this.props.ship.use(targetSlot, m); // update target slot
+        this.props.onChange();
       }
-      this.props.ship.use(targetSlot, m); // update target slot
-      this.props.onChange();
     }
-    this.setState({ originSlot: null, targetSlot: null });
+    this.setState({ originSlot: null, targetSlot: null, copy: null });
   }
 
   /**

src/app/components/StandardSlot.jsx

@@ -2,7 +2,6 @@ import React from 'react';
 import cn from 'classnames';
 import Persist from '../stores/Persist';
 import TranslatedComponent from './TranslatedComponent';
-import { jumpRange } from '../shipyard/Calculations';
 import { diffDetails } from '../utils/SlotFunctions';
 import AvailableModulesMenu from './AvailableModulesMenu';
 import ModificationsMenu from './ModificationsMenu';
@@ -46,10 +45,16 @@ export default class StandardSlot extends TranslatedComponent {
     let m = slot.m;
     let classRating = m.class + m.rating;
     let menu;
-    let validMods = m == null ? [] : (Modifications.validity[m.grp] || []);
+    let validMods = m == null ? [] : (Modifications.modules[m.grp].modifications || []);
     let showModuleResistances = Persist.showModuleResistances();
     let mass = m.getMass() || m.cargo || m.fuel || 0;
 
+    // Modifications tooltip shows blueprint and grade, if available
+    let modTT = translate('modified');
+    if (m && m.blueprint && m.blueprint.name) {
+      modTT = translate(m.blueprint.name) + ' ' + translate('grade') + ' ' + m.blueprint.grade;
+    }
+
     if (!selected) {
       // If not selected then sure that modifications flag is unset
       this._modificationsSelected = false;
@@ -81,11 +86,12 @@ export default class StandardSlot extends TranslatedComponent {
         <div className={cn('details-container', { warning: warning && warning(slot.m) })}>
           <div className={'sz'}>{slot.maxClass}</div>
           <div>
-            <div className={'l'}>{classRating} {translate(m.name || m.grp)}{m.mods && Object.keys(m.mods).length > 0 ? <span className='r' onMouseOver={termtip.bind(null, 'modified')} onMouseOut={tooltip.bind(null, null)}><Modified /></span> : null }</div>
+            <div className={'l'}>{classRating} {translate(m.name || m.grp)}{m.mods && Object.keys(m.mods).length > 0 ? <span className='r' onMouseOver={termtip.bind(null, modTT)} onMouseOut={tooltip.bind(null, null)}><Modified /></span> : null }</div>
             <div className={'r'}>{formats.round(mass)}{units.T}</div>
 	    <div/>
             <div className={'cb'}>
-                { m.getOptimalMass() ? <div className='l'>{translate('optimal mass')}: {formats.int(m.getOptimalMass())}{units.T}</div> : null }
+                { m.getMinMass() ? <div className='l'>{translate('minimum mass')}: {formats.int(m.getMinMass())}{units.T}</div> : null }
+                { m.getOptMass() ? <div className='l'>{translate('optimal mass')}: {formats.int(m.getOptMass())}{units.T}</div> : null }
                 { m.getMaxMass() ? <div className='l'>{translate('max mass')}: {formats.int(m.getMaxMass())}{units.T}</div> : null }
                 { m.getRange() ? <div className='l'>{translate('range')}: {formats.f2(m.getRange())}{units.km}</div> : null }
                 { m.time ? <div className='l'>{translate('time')}: {formats.time(m.time)}</div> : null }

src/app/components/StandardSlotSection.jsx

@@ -3,7 +3,6 @@ import cn from 'classnames';
 import SlotSection from './SlotSection';
 import StandardSlot from './StandardSlot';
 import Module from '../shipyard/Module';
-import { diffDetails } from '../utils/SlotFunctions';
 import * as ShipRoles from '../shipyard/ShipRoles';
 import { stopCtxPropagation } from '../utils/UtilityFunctions';
 
@@ -53,6 +52,16 @@ export default class StandardSlotSection extends SlotSection {
     this._close();
   }
 
+  /**
+   * Miner Build
+   * @param  {Boolean} shielded True if shield generator should be included
+   */
+  _optimizeMiner(shielded) {
+    ShipRoles.miner(this.props.ship, shielded);
+    this.props.onChange();
+    this._close();
+  }
+
   /**
    * Explorer role
    * @param  {Boolean} planetary True if Planetary Vehicle Hangar (PVH) should be included
@@ -209,6 +218,8 @@ export default class StandardSlotSection extends SlotSection {
         <li className='lc' onClick={this._optimizeCargo.bind(this, true)}>{translate('Shielded Trader')}</li>
         <li className='lc' onClick={this._optimizeExplorer.bind(this, false)}>{translate('Explorer')}</li>
         <li className={cn('lc', { disabled:  planetaryDisabled })} onClick={!planetaryDisabled && this._optimizeExplorer.bind(this, true)}>{translate('Planetary Explorer')}</li>
+        <li className='lc' onClick={this._optimizeMiner.bind(this, false)}>{translate('Miner')}</li>
+        <li className='lc' onClick={this._optimizeMiner.bind(this, true)}>{translate('Shielded Miner')}</li>
       </ul>
     </div>;
   }

src/app/components/SvgIcons.jsx

@@ -227,6 +227,26 @@ export class LinkIcon extends SvgIcon {
   }
 }
 
+/**
+ * Shopping icon (dollar sign)
+ */
+export class ShoppingIcon extends SvgIcon {
+  /**
+   * Overriden view box
+   * @return {String} view box
+   */
+  viewBox() { return '0 0 200 200'; }
+  /**
+   * Generate the SVG
+   * @return {React.Component} SVG Contents
+   */
+  svg() {
+    return <g>
+      <path d='M94 188v-17c-9-1-16-3-21-6-6-3-11-7-15-14-4-6-6-14-6-23l17-3c2 9 4 16 7 21 5 6 11 9 18 10v-56c-7-1-14-4-22-8-6-3-10-8-13-13-3-6-4-12-4-19 0-13 4-23 13-31 6-5 15-8 26-9v-8h11v8c10 1 18 4 24 9 8 6 12 15 14 26l-18 3c-1-7-4-12-7-16s-8-6-13-7v50l17 6c6 2 10 5 13 8 4 4 7 8 8 13 2 4 3 10 3 15 0 12-4 22-11 31-8 8-18 12-30 13v17H94zm0-153c-7 1-12 3-16 8-4 4-6 9-6 15s2 11 5 16c4 4 9 7 17 9V35zm11 121a28 28 0 0 0 24-28c-1-6-2-11-6-15-3-4-9-7-18-10v53z'/>
+    </g>;
+  }
+}
+
 /**
  * No Power - Lightning bolt + no entry
  */
@@ -319,6 +339,24 @@ export class Warning extends SvgIcon {
   }
 }
 
+/**
+ * Absolute damage
+ */
+export class DamageAbsolute extends SvgIcon {
+  /**
+   * Overriden view box
+   * @return {String} view box
+   */
+  viewBox() { return '0 0 200 200'; }
+  /**
+   * Generate the SVG
+   * @return {React.Component} SVG Contents
+   */
+  svg() {
+    return <ellipse cx='100' cy='100' rx='90' ry='90' fillOpacity='0' />;
+  }
+}
+
 /**
  * Thermal damage
  */
@@ -475,6 +513,52 @@ export class MountTurret extends SvgIcon {
   }
 }
 
+/**
+ * Collapse section
+ */
+export class CollapseSection extends SvgIcon {
+  /**
+   * Overriden view box
+   * @return {String} view box
+   */
+  viewBox() { return '0 0 200 200'; }
+  /**
+   * Generate the SVG
+   * @return {React.Component} SVG Contents
+   */
+  svg() {
+    return <g>
+	     <path d='m 100,180 0,-140' />
+	     <path d='m 100,40 25,45' />
+	     <path d='m 100,40 -25,45' />
+	     <path d='m 20,20 160,0' />
+	   </g>;
+  }
+}
+
+/**
+ * Expand section
+ */
+export class ExpandSection extends SvgIcon {
+  /**
+   * Overriden view box
+   * @return {String} view box
+   */
+  viewBox() { return '0 0 200 200'; }
+  /**
+   * Generate the SVG
+   * @return {React.Component} SVG Contents
+   */
+  svg() {
+    return <g>
+	     <path d='m 100,20 0,140' />
+	     <path d='m 100,160 25,-45' />
+	     <path d='m 100,160 -25,-45' />
+	     <path d='m 20,180 160,0' />
+	   </g>;
+  }
+}
+
 /**
  * Rocket ship
  */
@@ -488,6 +572,25 @@ export class Rocket extends SvgIcon {
   }
 }
 
+/**
+ * Help
+ */
+export class Help extends SvgIcon {
+  /**
+   * Overriden view box
+   * @return {String} view box
+   */
+  viewBox() { return '0 0 200 200'; }
+
+  /**
+   * Generate the SVG
+   * @return {React.Component} SVG Contents
+   */
+  svg() {
+    return <path d="M90.381 140.644a225.03 225.03 0 0 1-.106-5.706c0-7.47 1.058-13.92 3.172-19.346 1.55-4.087 4.052-8.21 7.505-12.367 2.536-3.031 7.1-7.453 13.688-13.267 6.59-5.815 10.872-10.448 12.844-13.9 1.974-3.453 2.96-7.224 2.96-11.312 0-7.4-2.89-13.9-8.667-19.503-5.779-5.602-12.862-8.403-21.248-8.403-8.104 0-14.87 2.536-20.296 7.61-5.427 5.074-8.986 13.003-10.677 23.784L50 65.91c1.762-14.448 6.995-25.511 15.698-33.194 8.704-7.68 20.208-11.522 34.514-11.522 15.152 0 27.237 4.124 36.258 12.369C145.49 41.807 150 51.779 150 63.477c0 6.766-1.585 13.003-4.756 18.712-3.17 5.708-9.372 12.65-18.605 20.824-6.201 5.496-10.253 9.55-12.156 12.156-1.904 2.609-3.312 5.603-4.23 8.986-.915 3.383-1.443 8.88-1.584 16.49H90.38zm-1.163 38.162v-21.67h21.67v21.67h-21.67z"/>;
+  }
+}
+
 /**
  * ListModifications (engineers)
  */

src/app/components/UtilitySlotSection.jsx

@@ -99,11 +99,11 @@ export default class UtilitySlotSection extends SlotSection {
       </ul>
       <div className='select-group cap'>{translate('sb')}</div>
       <ul>
-        <li className='c' onClick={_use.bind(this, 'sb', 'E', null)}>E</li>
-        <li className='c' onClick={_use.bind(this, 'sb', 'D', null)}>D</li>
-        <li className='c' onClick={_use.bind(this, 'sb', 'C', null)}>C</li>
-        <li className='c' onClick={_use.bind(this, 'sb', 'B', null)}>B</li>
         <li className='c' onClick={_use.bind(this, 'sb', 'A', null)}>A</li>
+        <li className='c' onClick={_use.bind(this, 'sb', 'B', null)}>B</li>
+        <li className='c' onClick={_use.bind(this, 'sb', 'C', null)}>C</li>
+        <li className='c' onClick={_use.bind(this, 'sb', 'D', null)}>D</li>
+        <li className='c' onClick={_use.bind(this, 'sb', 'E', null)}>E</li>
       </ul>
       <div className='select-group cap'>{translate('hs')}</div>
       <ul>

src/app/i18n/Language.jsx

@@ -6,7 +6,7 @@ import * as FR from './fr';
 import * as IT from './it';
 import * as RU from './ru';
 import * as PL from './pl';
-import d3 from 'd3';
+import * as d3 from 'd3';
 
 let fallbackTerms = EN.terms;
 
@@ -30,29 +30,30 @@ export function getLanguage(langCode) {
   }
 
   let currentTerms = lang.terms;
-  let d3Locale = d3.locale(lang.formats);
-  let gen = d3Locale.numberFormat('n');
+  let d3Locale = d3.formatLocale(lang.formats);
+  let gen = d3Locale.format('');
+  const round = function(x, n) { const ten_n = Math.pow(10,n); return Math.round(x * ten_n) / ten_n; };
 
   if(lang === EN) {
-    translate = (t) => { return currentTerms[t] || t; };
+    translate = (t, x) => { return currentTerms[t + '_' + x] || currentTerms[t] || t; };
   } else {
-    translate = (t) => { return currentTerms[t] || fallbackTerms[t] || t; };
+    translate = (t, x) => { return currentTerms[t + '_' + x] || currentTerms[t] || fallbackTerms[t + '_' + x] || fallbackTerms[t] || t; };
   }
 
   return {
     formats: {
-      gen,                                    // General number format (.e.g 1,001,001.1234)
-      int: d3Locale.numberFormat(',.0f'),     // Fixed to 0 decimal places (.e.g 1,001)
-      f1: d3Locale.numberFormat(',.1f'),      // Fixed to 1 decimal place (.e.g 1,001.1)
-      f2: d3Locale.numberFormat(',.2f'),      // Fixed to 2 decimal places (.e.g 1,001.10)
-      s2: d3Locale.numberFormat('.2s'),       // SI Format to 2 decimal places (.e.g 1.1k)
-      pct: d3Locale.numberFormat('.2%'),      // % to 2 decimal places (.e.g 5.40%)
-      pct1: d3Locale.numberFormat('.1%'),     // % to 1 decimal places (.e.g 5.4%)
-      r1: d3Locale.numberFormat('.1r'),       // Rounded to 1 significant number (.e.g 512 => 500, 4.122 => 4)
-      r2: d3Locale.numberFormat('.2r'),       // Rounded to 2 significant numbers (.e.g 512 => 510, 4.122 => 4.1)
-      rPct: d3.format('%'),                   // % to 0 decimal places (.e.g 5%)
-      round1: (d) => gen(d3.round(d, 1)),      // Rounded to 0-1 decimal places (.e.g 5.1, 4)
-      round: (d) => gen(d3.round(d, 2)),      // Rounded to 0-2 decimal places (.e.g 5.12, 4.1)
+      gen,                              // General number format (.e.g 1,001,001.1234)
+      int: d3Locale.format(',.0f'),     // Fixed to 0 decimal places (.e.g 1,001)
+      f1: d3Locale.format(',.1f'),      // Fixed to 1 decimal place (.e.g 1,001.1)
+      f2: d3Locale.format(',.2f'),      // Fixed to 2 decimal places (.e.g 1,001.10)
+      s2: d3Locale.format('.2s'),       // SI Format to 2 decimal places (.e.g 1.1k)
+      pct: d3Locale.format('.2%'),      // % to 2 decimal places (.e.g 5.40%)
+      pct1: d3Locale.format('.1%'),     // % to 1 decimal places (.e.g 5.4%)
+      r1: d3Locale.format('.1r'),       // Rounded to 1 significant number (.e.g 512 => 500, 4.122 => 4)
+      r2: d3Locale.format('.2r'),       // Rounded to 2 significant numbers (.e.g 512 => 510, 4.122 => 4.1)
+      rPct: d3Locale.format('.0%'),                   // % to 0 decimal places (.e.g 5%)
+      round1: (d) => gen(round(d, 1)),  // Round to 0-1 decimal places (e.g. 5.1, 4)
+      round: (d) => gen(round(d, 2)),      // Rounded to 0-2 decimal places (.e.g 5.12, 4.1)
       time: (d) => (d < 0 ? '-' : '') + Math.floor(Math.abs(d) / 60) + ':' + ('00' + Math.floor(Math.abs(d) % 60)).substr(-2, 2)
     },
     translate,
@@ -65,7 +66,9 @@ export function getLanguage(langCode) {
       LY: <u> {translate('LY')}</u>,     // Light Years
       MJ: <u> {translate('MJ')}</u>,     // Mega Joules
       'm/s': <u> {translate('m/s')}</u>, // Meters per second
+      '°/s': <u> {translate('°/s')}</u>, // Degrees per second
       MW: <u> {translate('MW')}</u>,     // Mega Watts (same as Mega Joules per second)
+      mps: <u>{translate('m/s')}</u>,    // Metres per second
       ps: <u>{translate('/s')}</u>,           // per second
       pm: <u>{translate('/min')}</u>,         // per minute
       s: <u>{translate('secs')}</u>,         // Seconds

src/app/i18n/en.js

@@ -28,6 +28,16 @@ export const terms = {
   PHRASE_SG_RECOVER: 'Recovery (to 50%) after collapse',
   PHRASE_UNLADEN: 'Ship mass excluding fuel and cargo',
   PHRASE_UPDATE_RDY: 'Update Available! Click to refresh',
+  PHRASE_ENGAGEMENT_RANGE: 'The distance between your ship and its target',
+  PHRASE_SELECT_BLUEPRINT: 'Click to select a blueprint',
+  PHRASE_BLUEPRINT_WORST: 'Worst primary values for this blueprint',
+  PHRASE_BLUEPRINT_RANDOM: 'Random selection between worst and best primary values for this blueprint',
+  PHRASE_BLUEPRINT_BEST: 'Best primary values for this blueprint',
+  PHRASE_BLUEPRINT_EXTREME: 'Best beneficial and worst detrimental primary values for this blueprint',
+  PHRASE_BLUEPRINT_RESET: 'Remove all modifications and blueprint',
+  PHRASE_SELECT_SPECIAL: 'Click to select an experimental effect',
+  PHRASE_NO_SPECIAL: 'No experimental effect',
+  PHRASE_SHOPPING_LIST: 'Stations that sell this build',
 
   HELP_MODIFICATIONS_MENU: 'Click on a number to enter a new value, or drag along the bar for small changes',
 
@@ -59,6 +69,7 @@ export const terms = {
   mc: 'Multi-cannon',
   ml: 'Mining Laser',
   mr: 'Missile Rack',
+  mrp: 'Module Reinforcement Package',
   nl: 'Mine Launcher',
   pa: 'Plasma Accelerator',
   pas: 'Planetary Approach Suite',
@@ -86,15 +97,29 @@ export const terms = {
   ws: 'Frame Shift Wake Scanner',
 
   // Items on the outfitting page
-  // Notification of restricted slot for Orca/Beluga
+  // Notification of restricted slot
   emptyrestricted: 'empty (restricted)',
+  'damage dealt to': 'Damage dealt to',
+  'damage received from': 'Damage received from',
+  'against shields': 'Against shields',
+  'against hull': 'Against hull',
   // 'ammo' was overloaded for outfitting page and modul info, so changed to ammunition for outfitting page
   ammunition: 'Ammo',
 
   // Unit for seconds
   secs: 's',
 
-  // Weapon, offence and defence
+  rebuildsperbay: 'Rebuilds per bay',
+
+  // Blueprint rolls
+  worst: 'Worst',
+  average: 'Average',
+  random: 'Random',
+  best: 'Best',
+  extreme: 'Extreme',
+  reset: 'Reset',
+
+  // Weapon, offence, defence and movement
   dpe: 'Damage per MJ of energy',
   dps: 'Damage per second',
   sdps: 'Sustained damage per second',
@@ -106,12 +131,25 @@ export const terms = {
   'damage by': 'Damage by',
   'damage from': 'Damage from',
   'shield cells': 'Shield cells',
+  'recovery': 'Recovery',
+  'recharge': 'Recharge',
+  'engine pips': 'Engine Pips',
+  '4b': '4 pips and boost',
+  'speed': 'Speed',
+  'pitch': 'Pitch',
+  'roll': 'Roll',
+  'yaw': 'Yaw',
+  'internal protection': 'Internal protection',
+  'external protection': 'External protection',
+  'engagement range': 'Engagement range',
+  'total': 'Total',
 
   // Modifications
   ammo: 'Ammunition maximum',
   boot: 'Boot time',
   brokenregen: 'Broken regeneration rate',
   burst: 'Burst',
+  burstrof: 'Burst rate of fire',
   clip: 'Ammunition clip',
   damage: 'Damage',
   distdraw: 'Distributor draw',
@@ -133,14 +171,16 @@ export const terms = {
   pgen: 'Power generation',
   piercing: 'Piercing',
   power: 'Power draw',
+  protection: 'Protection',
   range: 'Range',
   ranget: 'Range', // Range in time (for FSD interdictor)
   regen: 'Regeneration rate',
-  reload: 'Reload time',
+  reload: 'Reload',
   rof: 'Rate of fire',
   shield: 'Shield',
   shieldboost: 'Shield boost',
   shieldreinforcement: 'Shield reinforcement',
+  shotspeed: 'Shot speed',
   spinup: 'Spin up time',
   syscap: 'Systems capacity',
   sysrate: 'Systems recharge rate',
@@ -148,4 +188,146 @@ export const terms = {
   thermres: 'Thermal resistance',
   wepcap: 'Weapons capacity',
   weprate: 'Weapons recharge rate',
+
+  // Shield generators use a different terminology
+  minmass_sg: 'Minimum hull mass',
+  optmass_sg: 'Optimal hull mass',
+  maxmass_sg: 'Maximum hull mass',
+  minmul_sg: 'Minimum strength',
+  optmul_sg: 'Optimal strength',
+  maxmul_sg: 'Minimum strength',
+
+  // Help text
+  HELP_TEXT: `
+<h1>Introduction</h1>
+Coriolis is a ship builder for Elite: Dangerous.  This help file provides you with the information you need to use Coriolis.
+
+<h1>Importing Your Ship Into Coriolis</h1>
+Often, you will want to start with your existing ship in Coriolis and see how particular changes might affect it, for example upgrading your FSD.  There are a number of tools that can be used to import your ship without you having to create it manually.  This has the added benefit of copying over any engineering modifications that have taken place as well. </p>
+
+<h2>Importing Your Ship From EDDI</h2>
+To import your ship from EDDI first ensure that your connection to the Frontier servers&apos; companion API is working.  To do this check the &apos;Companion App&apos; tab where you should see "Your connection to the companion app is operational".  If not then follow the instructions in the companion app tab in EDDI to connect to the Frontier servers.</p>
+
+Once you have a working companion API connection go to the &apos;Shipyard&apos; tab.  At the right-hand side of each ship is an &apos;Export to Coriolis&apos; button that will open your default web browser in Coriolis with the ship&apos;s build. </p>
+
+Note that Internet Explorer and Edge might not import correctly, due to their internal restrictions on URL length.  If you find that this is the case then please change your default browser to Chrome. </p>
+
+Also, the imported information does not provide any data on the power priority or enabled status of your cargo hatch.  Coriolis sets this item to have a power priority of "5" and to be disabled by default.  You can change this after import in the Power Management section. </p>
+
+<h2>Importing Your Ship From EDMC</h2>
+To import your ship from EDMC once your connection to the Frontier servers&apos; companion API is working go to &apos;Settings -&gt;Configuration&apos; and set the &apos;Preferred Shipyard&apos; to &apos;Coriolis&apos;.  Once this is set up clicking on your ship in the main window will open your default web browser in Coriolis with the ship&apos;s build.</p>
+
+Note that Internet Explorer and Edge might not import correctly, due to their internal restrictions on URL length.  If you find that this is the case then please change your default browser to Chrome. </p>
+
+<h1>Understanding And Using The Outfitting Panels</h1>
+The outfitting page is where you will spend most of your time, and contains the information for your ship.  Information on each of the panels is provided below. </p>
+
+<h2>Key Values</h2>
+Along the top of the screen are some of the key values for your build.  This is a handy reference for the values, but more information is provided for the values in the further panels. </p>
+
+Here, along with most places in Coriolis, acronyms will have tooltips explaining what they mean.  Hover over the acronym to obtain more detail, or look in the glossary at the end of this help.</p>
+
+All values are the highest possible, assuming that you have maximum pips in the relevant capacitor (ENG for speed, WEP for time to drain, etc.).</p>
+
+<h2>Modules</h2>
+The next set of panels laid out horizontally across the screen contain the modules you have put in your build.  From left to right these are the core modules, the internal modules, the hardpoints and the utility mounts.  These represent the available slots in your ship and cannot be altered.  Each slot has a class, or size, and in general any module up to a given size can fit in a given slot (exceptions being bulkheads, life support and sensors in core modules and restricted internal slots, which can only take a subset of module depending on their restrictions). </p>
+
+To add a module to a slot left-click on the slot and select the required module.  Only the modules capable of fitting in the selected slot will be shown. </p>
+
+To remove a module from a slot right-click on the module. </p>
+
+To move a module from one slot to another drag it.  If you instead want to copy the module drag it whilst holding down the &apos;Alt&apos; key. </p>
+
+Clicking on the headings for each set of modules gives you the ability to either select an overall role for your ship (when clicking the core internal header) or a specific module with which you want to fill all applicable slots (when clicking the other headers). </p>
+
+<h2>Offence Summary</h2>
+The offence summary panel provides information about the damage that you deal with your weapons.</p>
+
+The first headline gives an overall damage per second rating: this is the optimum amount of damage the build will do per second according to weapon statistics.  After that is a breakdown of the damage per second the build will do for each type of damage: absolute, explosive, kinetic, and thermal.</p>
+
+The next headline gives an overall sustained damage per second rating: this is the optimum amount of damage the build will do per second over a longer period of time, taking in to account ammunition clip capacities and reload times.  After that is a breakdown of the sustained damage per second the build will do for each type of damage: absolute, explosive, kinetic, and thermal.</p>
+
+The final headline gives an overall damage per energy rating: this is the amount of damage the build will do per unit of weapon capacitor energy expended.  After that is a breakdown of the damage per energy the build will do for each type of damage: absolute, explosive, kinetic, and thermal.</p>
+
+<h2>Defence Summary</h2>
+The defence summary panel provides information about the strength of your defences and the damage that you receive from opponents.</p>
+
+The first headline gives your total shield strength (if you have shields), taking in to account your base shield plus boosters.  After that are the details of how long it will take for your shields to recover from 0 to 50% (recovery time) and from 50% to 100% (recharge time).  The next line provides a breakdown of the shield damage taken from different damage types.  For example, if you damage from kinetic is 60% then it means that a weapon usually dealing 10 points of damage will only deal 6, the rest being resisted by the shield.  Note that this does not include any resistance alterations due to pips in your SYS capacitor.</p>
+
+The second headline gives your total shield cell strength (if you have shield cell banks).  This is the sum of the recharge of all of equipped shield cell banks.</p>
+
+The third headline gives your total armour strength, taking in to account your base armour plus hull reinforcement packages.  The next line provides a breakdown of the hull damage taken from different damage types.  For example, if you damage from kinetic is 120% then it means that a weapon usually dealing 10 points of damage will deal 12.</p>
+
+The fourth headline gives your total module protection strength from module reinforcement packages. The next line provides a breakdown of the protection for both internal and external modules whilst all module reinforcement packages are functioning.  For example, if external module protection is 20% then 10 points of damage will 2 points of damage to the module reinforcement packages and 8 points of damage to the module</p>
+
+<h2>Movement Summary</h2>
+The movement summary panel provides information about the build&apos;s speed and agility.</p>
+
+Along the top of this panel are the number of pips you put in to your ENG capacitor, from 0 to 4 and also include 4 pips and boost (4b).  Along the side of this panel are the names of the metrics.  These are:
+<dl>
+<dt>Speed</dt><dd>The fastest the ship can move, in metres per second</dd>
+<dt>Pitch</dt><dd>The fastest the ship can raise or lower its nose, in degrees per second</dd>
+<dt>Roll</dt><dd>The fastest the ship can roll its body, in degrees per second</dd>
+<dt>Yaw</dt><dd>The fastest the ship can turn its nose left or right, in degrees per second</dd>
+</dl>
+
+<h2>Power Management</h2>
+The power management panel provides information about power usage and priorities.  It allows you to enable and disable individual modules, as well as set power priorities for each module.</p>
+
+<h2>Costs</h2>
+The costs panel provides information about the costs for each of your modules, and the total cost and insurance for your build.  By default Coriolis uses the standard costs, however discounts for your ship, modules and insurance can be altered in the &apos;Settings&apos; at the top-right of the page.</p>
+
+The retrofit costs provides information about the costs of changing the base build for your ship, or your saved build, to the current build.</p>
+
+The reload costs provides information about the costs of reloading your current build.</p>
+
+<h2>Jump Range</h2>
+The jump range panel provides information about the build&apos; jump range.  The graph shows how the build&apos;s jump range changes with the amount of cargo on-board.  The slider can be altered to change the amount of fuel you have on-board.</p>
+
+<h2>Damage Dealt</h2>
+The damage dealt panel provides information about the effectiveness of your build&apos;s weapons against opponents&apos; shields and hull at different engagement distances.</p>
+
+The ship against which you want to check damage dealt can be selected by clicking on the red ship icon or the red ship name at the top of this panel.</p>
+
+The main section of this panel is a table showing your weapons and their effectiveness.  Effectiveness against shields takes in to account the weapon and its engagement range, and assumes standard shield resistances.  Effectiveness against hull takes in to account the weapon and, its engagement range and the target&apos;s hardness, and assumes military grade armour resistances.</p>
+
+Effective DPS and effective SDPS are the equivalent of DPS and SDPS for the weapon.  Effectiveness is a percentage value that shows how effective the DPS of the weapon is compared in reality against the given target compared to the weapon&apos;s stated DPS.  Effectiveness can never go above 100%.</p>
+
+Total effective DPS, SDPS and effectiveness against both shields and hull are provided at the bottom of the table.</p>
+
+At the bottom of this panel you can change your engagement range.  The engagement range is the distance between your ship and your target.  Many weapons suffer from what is known as damage falloff, where their effectiveness decreases the further the distance between your ship and your target.  This allows you to model the effect of engaging at different ranges.
+
+Note that this panel only shows enabled weapons, so if you want to see your overall effectiveness for a subset of your weapons you can disable the undesired weapons in the power management panel.</p>
+
+At the bottom of this panel are two graphs showing how your sustained DPS changes with engagement range.  This shows at a glance how effective each weapon is at different distances.</p>
+
+<h2>Damage Received</h2>
+The damage received panel provides information about the effectiveness of your build&apos;s defences against opponent&apos;s weapons at different engagement range.  Features and functions are the same as the damage dealt panel, except that it does take in to account your build&apos;s resistances.</p>
+
+<h1>Keyboard Shortcuts</h1>
+<dl>
+<dt>Ctrl-e</dt><dd>open export dialogue (outfitting page only)</dd>
+<dt>Ctrl-h</dt><dd>open help dialogue</dd>
+<dt>Ctrl-i</dt><dd>open import dialogue</dd>
+<dt>Ctrl-o</dt><dd>open shortlink dialogue</dd>
+<dt>Esc</dt><dd>close any open dialogue</dd>
+</dl>
+<h1>Glossary</h1>
+<dl>
+<dt>Absolute damage</dt><dd>A type of damage, without any protection.  Absolute damage is always dealt at 100% regardless of if the damage is to shields, hull or modules, and irrespective of resistances</dd>
+<dt>DPS</dt><dd>Damage per second; the amount of damage that a weapon or a ship can deal per second to a target under optimum conditions</dd>
+<dt>EPS</dt><dd>Energy per second; the amount of energy that a weapon or a ship drains from the weapons capacitor per second when firing</dd>
+<dt>HPS</dt><dd>Heat per second; the amount of heat that a weapon or a ship generates per second when firing</dd>
+<dt>Effectivness</dt><dd>A comparison of the maximum DPS of a given weapon to the actual DPS of the given weapon in a specific situation.  DPS can be reduced by range to the target, the target&apos;s hull and shield resistances, and the target&apos;s hardness</dd>
+<dt>Explosive damage</dt><dd>A type of damage, protected against by explosive resistance</dd>
+<dt>Hardness</dt><dd>The inherent resistance to damage of a ship&apos;s hull.  Hardness is defined on a per-ship basis and there is currently nothing that can be done to change it.  Hardness of a ship&apos;s hull is compared to the piercing of weapons: if piercing is higher than hardness the weapon does 100% damage, otherwise it does a fraction of its damage calculated as piercing/hardness</dd>
+<dt>Falloff</dt><dd>The distance at which a weapons starts to do less damage than its stated DPS</dd>
+<dt>Kinetic damage</dt><dd>A type of damage, protected against by kinetic resistance</dd>
+<dt>SDPS</dt><dd>Sustained damage per second; the amount of damage that a weapon or a ship can deal per second to a target, taking in to account ammunition reload</dd>
+<dt>SEPS</dt><dd>Sustained energy per second; the amount of energy that a weapon or a ship drains from the weapons capacitor per second when firing, taking in to account ammunition reload</dd>
+<dt>SHPS</dt><dd>Sustained heat per second; the amount of heat that a weapon or a ship generates per second when firing, taking in to account ammunition reload</dd>
+<dt>Thermal damage</dt><dd>A type of damage, protected against by thermal resistance</dd>
+</dl>
+
+  `,
 };

src/app/pages/AboutPage.jsx

@@ -39,15 +39,6 @@ export default class AboutPage extends Page {
 
       <p>Coriolis is an open source project. Checkout the list of upcoming features and to-do list on github. Any and all contributions and feedback are welcome. If you encounter any bugs please report them and provide as much detail as possible.</p>
 
-      <form action='https://www.paypal.com/cgi-bin/webscr' method='post' target='_blank'>
-        <input type='hidden' name='cmd' value='_s-xclick' />
-        <input type='hidden' name='encrypted' value='-----BEGIN PKCS7-----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-----END PKCS7-----' />
-        <input type='image' src='https://www.paypalobjects.com/en_US/i/btn/btn_donate_LG.gif' name='submit' alt='PayPal - Donate to Coriolis.io' style={{ border:'none' }} />
-        <img alt='' border='0' src='https://www.paypalobjects.com/en_US/i/scr/pixel.gif' width='1' height='1' />
-      </form>
-
-      <p>Help keep the lights on! Donations will be used to cover costs of running and maintaining Coriolis. Thanks for helping!</p>
-
       <h3>Chat</h3>
       <p>You can chat to us on our <a href='https://discord.gg/0uwCh6R62aPRjk9w' target='_blank'>EDCD Discord server</a>.</p>
     </div>;

src/app/pages/ErrorDetails.jsx

@@ -39,9 +39,16 @@ export default class ErrorDetails extends React.Component {
       </div>;
     }
 
+    const importerror = ed && ed.scriptUrl && ed.scriptUrl.indexOf('/import') != -1;
+
     return <div className='error'>
       <h1>Jameson, we have a problem..</h1>
       <h1><small>{error.message}</small></h1>
+      <br/>
+        {importerror ? <div>If you are attempting to import a ship from EDDI or EDMC and are seeing a 'Z_BUF_ERROR' it means that the URL has not been provided correctly.  This is a common problem when using Microsoft Internet Explorer or Microsoft Edge, and you should use another browser instead.</div> : null }
+      <br/>
+      <div>Please note that this site uses Google Analytics to track performance and usage.  If you are blocking cookies, for example using Ghostery, please disable blocking for this site and try again.</div>
+      <br/>
       {content}
     </div>;
   }

src/app/pages/OutfittingPage.jsx

@@ -8,7 +8,7 @@ import Persist from '../stores/Persist';
 import Ship from '../shipyard/Ship';
 import { toDetailedBuild } from '../shipyard/Serializer';
 import { outfitURL } from '../utils/UrlGenerators';
-import { FloppyDisk, Bin, Switch, Download, Reload, Fuel } from '../components/SvgIcons';
+import { FloppyDisk, Bin, Switch, Download, Reload, Fuel, LinkIcon, ShoppingIcon } from '../components/SvgIcons';
 import ShipSummaryTable from '../components/ShipSummaryTable';
 import StandardSlotSection from '../components/StandardSlotSection';
 import HardpointsSlotSection from '../components/HardpointsSlotSection';
@@ -16,10 +16,14 @@ import InternalSlotSection from '../components/InternalSlotSection';
 import UtilitySlotSection from '../components/UtilitySlotSection';
 import OffenceSummary from '../components/OffenceSummary';
 import DefenceSummary from '../components/DefenceSummary';
+import MovementSummary from '../components/MovementSummary';
+import DamageDealt from '../components/DamageDealt';
+import DamageReceived from '../components/DamageReceived';
 import LineChart from '../components/LineChart';
 import PowerManagement from '../components/PowerManagement';
 import CostSection from '../components/CostSection';
 import ModalExport from '../components/ModalExport';
+import ModalPermalink from '../components/ModalPermalink';
 import Slider from '../components/Slider';
 
 const SPEED_SERIES = ['boost', '4 Pips', '2 Pips', '0 Pips'];
@@ -32,7 +36,7 @@ const SPEED_COLORS = ['#0088d2', '#ff8c0d', '#D26D00', '#c06400'];
  * @return {String}           Document title
  */
 function getTitle(shipName, buildName) {
-  return `${shipName}${buildName ? ` - ${buildName}` : ''}`;
+  return buildName ? buildName : shipName;
 }
 
 /**
@@ -48,6 +52,8 @@ export default class OutfittingPage extends Page {
   constructor(props, context) {
     super(props, context);
     this.state = this._initState(context);
+    this._keyDown = this._keyDown.bind(this);
+    this._exportBuild = this._exportBuild.bind(this);
   }
 
   /**
@@ -177,7 +183,7 @@ export default class OutfittingPage extends Page {
     let translate = this.context.language.translate;
     let { buildName, ship } = this.state;
     this.context.showModal(<ModalExport
-      title={buildName + ' ' + translate('export')}
+      title={(buildName || ship.name) + ' ' + translate('export')}
       description={translate('PHRASE_EXPORT_DESC')}
       data={toDetailedBuild(buildName, ship, ship.toString())}
     />);
@@ -233,7 +239,8 @@ export default class OutfittingPage extends Page {
 
     if (elem) {
       this.setState({
-        chartWidth: findDOMNode(this.refs.chartThird).offsetWidth
+        thirdChartWidth: findDOMNode(this.refs.chartThird).offsetWidth,
+        halfChartWidth: findDOMNode(this.refs.chartHalf).offsetWidth
       });
     }
   }
@@ -254,6 +261,7 @@ export default class OutfittingPage extends Page {
    */
   componentWillMount() {
     this.resizeListener = this.context.onWindowResize(this._updateDimensions);
+    document.addEventListener('keydown', this._keyDown);
   }
 
   /**
@@ -270,6 +278,43 @@ export default class OutfittingPage extends Page {
     this.resizeListener.remove();
   }
 
+  /**
+   * Generates the short URL
+   */
+  _genShortlink() {
+    this.context.showModal(<ModalPermalink url={window.location.href}/>);
+  }
+
+  /**
+   * Open up a window for EDDB with a shopping list of our components
+   */
+  _eddbShoppingList() {
+    const ship = this.state.ship;
+
+    const shipId = Ships[ship.id].eddbID;
+    // Provide unique list of non-PP module EDDB IDs
+    const modIds = ship.internal.concat(ship.bulkheads, ship.standard, ship.hardpoints).filter(slot => slot !== null && slot.m !== null && !slot.m.pp).map(slot => slot.m.eddbID).filter((v, i, a) => a.indexOf(v) === i);
+
+    // Open up the relevant URL
+    window.open('https://eddb.io/station?s=' + shipId + '&m=' + modIds.join(','));
+  }
+
+  /**
+   * Handle Key Down
+   * @param  {Event} e  Keyboard Event
+   */
+  _keyDown(e) {
+    // .keyCode will eventually be replaced with .key
+    switch (e.keyCode) {
+      case 69:     // 'e'
+        if (e.ctrlKey || e.metaKey) { // CTRL/CMD + e
+          e.preventDefault();
+          this._exportBuild();
+        }
+        break;
+    }
+  }
+
   /**
    * Render the Page
    * @return {React.Component} The page contents
@@ -278,7 +323,7 @@ export default class OutfittingPage extends Page {
     let state = this.state,
         { language, termtip, tooltip, sizeRatio, onWindowResize } = this.context,
         { translate, units, formats } = language,
-        { ship, code, savedCode, buildName, newBuildName, chartWidth, fuelCapacity, fuelLevel } = state,
+        { ship, code, savedCode, buildName, newBuildName, halfChartWidth, thirdChartWidth, fuelCapacity, fuelLevel } = state,
         hide = tooltip.bind(null, null),
         menu = this.props.currentMenu,
         shipUpdated = this._shipUpdated,
@@ -286,11 +331,8 @@ export default class OutfittingPage extends Page {
         canRename = buildName && newBuildName && buildName != newBuildName,
         canReload = savedCode && canSave,
         hStr = ship.getHardpointsString() + '.' + ship.getModificationsString(),
-        sStr = ship.getStandardString() + '.' + ship.getModificationsString(),
         iStr = ship.getInternalString() + '.' + ship.getModificationsString();
 
-    Router.replace(outfitURL(ship.id, code, buildName));
-
     return (
       <div id='outfit' className={'page'} style={{ fontSize: (sizeRatio * 0.9) + 'em' }}>
         <div id='overview'>
@@ -315,42 +357,49 @@ export default class OutfittingPage extends Page {
             <button onClick={buildName && this._exportBuild} disabled={!buildName} onMouseOver={termtip.bind(null, 'export')} onMouseOut={hide}>
               <Download className='lg'/>
             </button>
+            <button onClick={this._eddbShoppingList} onMouseOver={termtip.bind(null, 'PHRASE_SHOPPING_LIST')} onMouseOut={hide}>
+              <ShoppingIcon className='lg' />
+            </button>
+            <button onClick={this._genShortlink} onMouseOver={termtip.bind(null, 'shortlink')} onMouseOut={hide}>
+              <LinkIcon className='lg' />
+            </button>
           </div>
         </div>
 
-        <ShipSummaryTable ship={ship} code={code} />
-        <StandardSlotSection ship={ship} code={sStr} onChange={shipUpdated} currentMenu={menu} />
+        <ShipSummaryTable ship={ship} code={code || ''} />
+        <StandardSlotSection ship={ship} code={code || ''} onChange={shipUpdated} currentMenu={menu} />
         <InternalSlotSection ship={ship} code={iStr} onChange={shipUpdated} currentMenu={menu} />
-        <HardpointsSlotSection ship={ship} code={hStr} onChange={shipUpdated} currentMenu={menu} />
-        <UtilitySlotSection ship={ship} code={hStr} onChange={shipUpdated} currentMenu={menu} />
-        <PowerManagement ship={ship} code={code} onChange={shipUpdated} />
-        <CostSection ship={ship} buildName={buildName} code={sStr + hStr + iStr} />
+        <HardpointsSlotSection ship={ship} code={hStr || ''} onChange={shipUpdated} currentMenu={menu} />
+        <UtilitySlotSection ship={ship} code={hStr || ''} onChange={shipUpdated} currentMenu={menu} />
 
-        <div ref='chartThird' className='group third'>
+        <div className='group third'>
           <OffenceSummary ship={ship} code={code}/>
         </div>
-
         <div className='group third'>
           <DefenceSummary ship={ship} code={code}/>
         </div>
-
         <div className='group third'>
-          <h1>{translate('speed')}</h1>
-          <LineChart
-            width={chartWidth}
-            xMax={ship.cargoCapacity}
-            yMax={ship.topBoost + 10}
-            xUnit={translate('T')}
-            yUnit={translate('m/s')}
-            yLabel={translate('speed')}
-            series={SPEED_SERIES}
-            colors={SPEED_COLORS}
-            xLabel={translate('cargo')}
-            func={state.speedChartFunc}
-          />
+          <MovementSummary ship={ship} code={code}/>
         </div>
 
-        <div className='group half'>
+        <PowerManagement ship={ship} code={code || ''} onChange={shipUpdated} />
+        <CostSection ship={ship} buildName={buildName} code={code || ''} />
+
+        <div ref='chartHalf' className='group half' />
+        <div className='group half' />
+
+        <div ref='chartThird' className='group third'>
+          <h1>{translate('jump range')}</h1>
+          <LineChart
+            width={thirdChartWidth}
+            xMax={ship.cargoCapacity}
+            yMax={ship.unladenRange}
+            xUnit={translate('T')}
+            yUnit={translate('LY')}
+            yLabel={translate('jump range')}
+            xLabel={translate('cargo')}
+            func={state.jumpRangeChartFunc}
+          />
           <table style={{ width: '100%', lineHeight: '1em', backgroundColor: 'transparent' }}>
             <tbody >
               <tr>
@@ -376,7 +425,15 @@ export default class OutfittingPage extends Page {
           </table>
         </div>
 
+        <div>
+          <DamageDealt ship={ship} code={code} chartWidth={halfChartWidth} currentMenu={menu}/>
+        </div>
+
+        <div>
+          <DamageReceived ship={ship} code={code} currentMenu={menu}/>
+        </div>
       </div>
+
     );
   }
 }
@@ -393,3 +450,43 @@ export default class OutfittingPage extends Page {
 //            func={state.jumpRangeChartFunc}
 //          />
 //        </div>
+//        <div className='group third'>
+//          <h1>{translate('speed')}</h1>
+//          <LineChart
+//            width={chartWidth}
+//            xMax={ship.cargoCapacity}
+//            yMax={ship.topBoost + 10}
+//            xUnit={translate('T')}
+//            yUnit={translate('m/s')}
+//            yLabel={translate('speed')}
+//            series={SPEED_SERIES}
+//            colors={SPEED_COLORS}
+//            xLabel={translate('cargo')}
+//            func={state.speedChartFunc}
+//          />
+//        </div>
+//        <div className='group half'>
+//          <table style={{ width: '100%', lineHeight: '1em', backgroundColor: 'transparent' }}>
+//            <tbody >
+//              <tr>
+//                <td style={{ verticalAlign: 'top', padding: 0, width: '2.5em' }} onMouseEnter={termtip.bind(null, 'fuel level')} onMouseLeave={hide}>
+//                  <Fuel className='xl primary-disabled' />
+//                </td>
+//                <td>
+//                  <Slider
+//                    axis={true}
+//                    onChange={this._fuelChange}
+//                    axisUnit={translate('T')}
+//                    percent={fuelLevel}
+//                    max={fuelCapacity}
+//                    scale={sizeRatio}
+//                    onResize={onWindowResize}
+//                  />
+//                </td>
+//                <td className='primary' style={{ width: '10em', verticalAlign: 'top', fontSize: '0.9em', textAlign: 'left' }}>
+//                  {formats.f2(fuelLevel * fuelCapacity)}{units.T} {formats.pct1(fuelLevel)}
+//                </td>
+//              </tr>
+//            </tbody>
+//          </table>
+//        </div>

src/app/pages/Page.jsx

@@ -39,6 +39,14 @@ export default class Page extends React.Component {
         this[prop] = this[prop].bind(this);
       }
     });
+
+    let fix = sessionStorage.getItem('__safari_history_fix');
+    sessionStorage.removeItem('__safari_history_fix');
+    if (fix) {
+      fix = JSON.parse(fix);
+      history.replaceState(history.state, document.title, location.href);
+      history.pushState(fix.state, fix.title, fix.path);
+    }
   }
 
   /**
@@ -82,4 +90,4 @@ export default class Page extends React.Component {
     return this.renderPage();
   }
 
-}
+}

src/app/pages/ShipyardPage.jsx

@@ -40,7 +40,9 @@ function shipSummary(shipId, shipData) {
     intCount: 0,
     maxCargo: 0,
     hp: [0, 0, 0, 0, 0], // Utility, Small, Medium, Large, Huge
-    int: [0, 0, 0, 0, 0, 0, 0, 0] // Sizes 1 - 8
+    int: [0, 0, 0, 0, 0, 0, 0, 0], // Sizes 1 - 8
+    standard: shipData.slots.standard,
+    agility: shipData.properties.pitch + shipData.properties.yaw + shipData.properties.roll
   };
   Object.assign(summary, shipData.properties);
   let ship = new Ship(shipId, shipData.properties, shipData.slots);
@@ -139,7 +141,9 @@ export default class ShipyardPage extends Page {
       >
       <td className='le'>{s.manufacturer}</td>
       <td className='cap'>{translate(SizeMap[s.class])}</td>
-      <td>{s.agility}</td>
+      <td className='ri'>{fInt(s.agility)}</td>
+      <td className='ri'>{fInt(s.hardness)}</td>
+      <td className='ri'>{fInt(s.crew)}</td>
       <td className='ri'>{fInt(s.speed)}{u['m/s']}</td>
       <td className='ri'>{fInt(s.boost)}{u['m/s']}</td>
       <td className='ri'>{fInt(s.baseArmour)}</td>
@@ -148,6 +152,12 @@ export default class ShipyardPage extends Page {
       <td className='ri'>{fInt(s.topBoost)}{u['m/s']}</td>
       <td className='ri'>{fRound(s.maxJumpRange)}{u.LY}</td>
       <td className='ri'>{fInt(s.maxCargo)}{u.T}</td>
+      <td className='cn'>{s.standard[0]}</td>
+      <td className='cn'>{s.standard[1]}</td>
+      <td className='cn'>{s.standard[2]}</td>
+      <td className='cn'>{s.standard[3]}</td>
+      <td className='cn'>{s.standard[4]}</td>
+      <td className='cn'>{s.standard[5]}</td>
       <td className={cn({ disabled: !s.hp[1] })}>{s.hp[1]}</td>
       <td className={cn({ disabled: !s.hp[2] })}>{s.hp[2]}</td>
       <td className={cn({ disabled: !s.hp[3] })}>{s.hp[3]}</td>
@@ -242,7 +252,6 @@ export default class ShipyardPage extends Page {
 
     return (
       <div className='page' style={{ fontSize: sizeRatio + 'em' }}>
-        <p style={{ textAlign: 'center' }}>This is <strong>Coriolis EDCD Edition</strong> - a temporary clone of <a href='https://coriolis.io/' target='_blank'>https://coriolis.io/</a> with added support for E:D 2.2. For more info see Settings / <Link href="/about" className='block'>About</Link></p>
         <div style={{ whiteSpace: 'nowrap', margin: '0 auto', fontSize: '0.8em', position: 'relative', display: 'inline-block', maxWidth: '100%' }}>
           <table style={{ width: '12em', position: 'absolute', zIndex: 1 }}>
             <thead>
@@ -260,9 +269,12 @@ export default class ShipyardPage extends Page {
               <tr className='main'>
                 <th rowSpan={2} className='sortable' onClick={sortShips('manufacturer')}>{translate('manufacturer')}</th>
                 <th rowSpan={2} className='sortable' onClick={sortShips('class')}>{translate('size')}</th>
-                <th rowSpan={2} className='sortable' onMouseEnter={termtip.bind(null, 'maneuverability')} onMouseLeave={hide} onClick={sortShips('agility')}>{translate('mnv')}</th>
+                <th rowSpan={2} className='sortable' onClick={sortShips('agility')}>{translate('agility')}</th>
+                <th rowSpan={2} className='sortable' onClick={sortShips('hardness')}>{translate('hardness')}</th>
+                <th rowSpan={2} className='sortable' onClick={sortShips('crew')}>{translate('crew')}</th>
                 <th colSpan={4}>{translate('base')}</th>
                 <th colSpan={4}>{translate('max')}</th>
+                <th colSpan={6}>{translate('core module classes')}</th>
                 <th colSpan={5} className='sortable' onClick={sortShips('hpCount')}>{translate('hardpoints')}</th>
                 <th colSpan={8} className='sortable' onClick={sortShips('intCount')}>{translate('internal compartments')}</th>
                 <th rowSpan={2} className='sortable' onClick={sortShips('hullMass')}>{translate('hull')}</th>
@@ -280,6 +292,13 @@ export default class ShipyardPage extends Page {
                 <th className='sortable' onClick={sortShips('maxJumpRange')}>{translate('jump')}</th>
                 <th className='sortable' onClick={sortShips('maxCargo')}>{translate('cargo')}</th>
 
+                <th className='sortable lft' onMouseEnter={termtip.bind(null, 'power plant')} onMouseLeave={hide} onClick={sortShips('standard', 0)}>{'pp'}</th>
+                <th className='sortable' onMouseEnter={termtip.bind(null, 'thrusters')} onMouseLeave={hide} onClick={sortShips('standard', 1)}>{'th'}</th>
+                <th className='sortable' onMouseEnter={termtip.bind(null, 'frame shift drive')} onMouseLeave={hide} onClick={sortShips('standard', 2)}>{'fsd'}</th>
+                <th className='sortable' onMouseEnter={termtip.bind(null, 'life support')} onMouseLeave={hide} onClick={sortShips('standard', 3)}>{'ls'}</th>
+                <th className='sortable' onMouseEnter={termtip.bind(null, 'power distriubtor')} onMouseLeave={hide} onClick={sortShips('standard', 4)}>{'pd'}</th>
+                <th className='sortable' onMouseEnter={termtip.bind(null, 'sensors')} onMouseLeave={hide} onClick={sortShips('standard', 5)}>{'s'}</th>
+
                 <th className='sortable lft' onClick={sortShips('hp',1)}>{translate('S')}</th>
                 <th className='sortable' onClick={sortShips('hp', 2)}>{translate('M')}</th>
                 <th className='sortable' onClick={sortShips('hp', 3)}>{translate('L')}</th>

src/app/shipyard/Calculations.js

@@ -10,7 +10,7 @@ import Module from './Module';
  */
 export function jumpRange(mass, fsd, fuel) {
   let fsdMaxFuelPerJump = fsd instanceof Module ? fsd.getMaxFuelPerJump() : fsd.maxfuel;
-  let fsdOptimalMass = fsd instanceof Module ? fsd.getOptimalMass() : fsd.optmass;
+  let fsdOptimalMass = fsd instanceof Module ? fsd.getOptMass() : fsd.optmass;
   return Math.pow(Math.min(fuel === undefined ? fsdMaxFuelPerJump : fuel, fsdMaxFuelPerJump) / fsd.fuelmul, 1 / fsd.fuelpower) * fsdOptimalMass / mass;
 }
 
@@ -24,7 +24,7 @@ export function jumpRange(mass, fsd, fuel) {
  */
 export function fastestRange(mass, fsd, fuel) {
   let fsdMaxFuelPerJump = fsd instanceof Module ? fsd.getMaxFuelPerJump() : fsd.maxfuel;
-  let fsdOptimalMass = fsd instanceof Module ? fsd.getOptimalMass() : fsd.optmass;
+  let fsdOptimalMass = fsd instanceof Module ? fsd.getOptMass() : fsd.optmass;
   let fuelRemaining = fuel % fsdMaxFuelPerJump;  // Fuel left after making N max jumps
   let jumps = Math.floor(fuel / fsdMaxFuelPerJump);
   mass += fuelRemaining;
@@ -67,32 +67,109 @@ export function shieldStrength(mass, baseShield, sg, multiplier) {
 /**
  * Calculate the a ships speed based on mass, and thrusters.
  *
- * @param  {number} mass        Current mass of the ship
- * @param  {number} baseSpeed   Base speed m/s for ship
- * @param  {number} baseBoost   Base boost speed m/s for ship
- * @param  {object} thrusters   The Thrusters used
- * @param  {number} pipSpeed    Speed pip multiplier
- * @return {object}             Approximate speed by pips
+ * @param {number}   mass       the mass of the ship
+ * @param {number}   baseSpeed  base speed m/s for ship
+ * @param {object}   thrusters  The ship's thrusters
+ * @param {number}   engpip     the multiplier per pip to engines
+ * @return {array}             Speed by pips
  */
-export function speed(mass, baseSpeed, baseBoost, thrusters, pipSpeed) {
+export function speed(mass, baseSpeed, thrusters, engpip) {
+  // thrusters might be a module or a template; handle either here
+  const minMass = thrusters instanceof Module ? thrusters.getMinMass() : thrusters.minmass;
+  const optMass = thrusters instanceof Module ? thrusters.getOptMass() : thrusters.optmass;
+  const maxMass = thrusters instanceof Module ? thrusters.getMaxMass() : thrusters.maxmass;
+  const minMul = thrusters instanceof Module ? thrusters.getMinMul('speed') : (thrusters.minmulspeed ? thrusters.minmulspeed : thrusters.minmul);
+  const optMul = thrusters instanceof Module ? thrusters.getOptMul('speed') : (thrusters.optmulspeed ? thrusters.minmulspeed : thrusters.minmul);
+  const maxMul = thrusters instanceof Module ? thrusters.getMaxMul('speed') : (thrusters.maxmulspeed ? thrusters.minmulspeed : thrusters.minmul);
+
+  let results = normValues(minMass, optMass, maxMass, minMul, optMul, maxMul, mass, baseSpeed, engpip);
+
+  return results;
+}
+
+/**
+ * Calculate pitch of a ship based on mass and thrusters
+ * @param {number}   mass       the mass of the ship
+ * @param {number}   basePitch  base pitch of the ship
+ * @param {object}   thrusters  the ship's thrusters
+ * @param {number}   engpip     the multiplier per pip to engines
+ * @return {array}             Pitch by pips
+ */
+export function pitch(mass, basePitch, thrusters, engpip) {
   // thrusters might be a module or a template; handle either here
   let minMass = thrusters instanceof Module ? thrusters.getMinMass() : thrusters.minmass;
   let optMass = thrusters instanceof Module ? thrusters.getOptMass() : thrusters.optmass;
   let maxMass = thrusters instanceof Module ? thrusters.getMaxMass() : thrusters.maxmass;
-  let minMul = thrusters instanceof Module ? thrusters.getMinMul() : thrusters.minmul;
-  let optMul = thrusters instanceof Module ? thrusters.getOptMul() : thrusters.optmul;
-  let maxMul = thrusters instanceof Module ? thrusters.getMaxMul() : thrusters.maxmul;
+  let minMul = thrusters instanceof Module ? thrusters.getMinMul('rotation') : (thrusters.minmulrotation ? thrusters.minmulrotation : thrusters.minmul);
+  let optMul = thrusters instanceof Module ? thrusters.getOptMul('rotation') : (thrusters.optmulrotation ? thrusters.optmulrotation : thrusters.optmul);
+  let maxMul = thrusters instanceof Module ? thrusters.getMaxMul('rotation') : (thrusters.maxmulrotation ? thrusters.maxmulrotation : thrusters.maxmul);
 
-  let xnorm = Math.min(1, (maxMass - mass) / (maxMass - minMass));
-  let exponent = Math.log((optMul - minMul) / (maxMul - minMul)) / Math.log(Math.min(1, (maxMass - optMass) / (maxMass - minMass)));
-  let ynorm = Math.pow(xnorm, exponent);
-  let mul = minMul + ynorm * (maxMul - minMul);
-  let speed = baseSpeed * mul;
-
-  return {
-    '0 Pips': speed * (1 - (pipSpeed * 4)),
-    '2 Pips': speed * (1 - (pipSpeed * 2)),
-    '4 Pips': speed,
-    'boost': baseBoost * mul
-  };
+  return normValues(minMass, optMass, maxMass, minMul, optMul, maxMul, mass, basePitch, engpip);
+}
+
+/**
+ * Calculate yaw of a ship based on mass and thrusters
+ * @param {number}   mass       the mass of the ship
+ * @param {number}   baseYaw    base yaw of the ship
+ * @param {object}   thrusters  the ship's thrusters
+ * @param {number}   engpip     the multiplier per pip to engines
+ * @return {array}             Yaw by pips
+ */
+export function yaw(mass, baseYaw, thrusters, engpip) {
+  // thrusters might be a module or a template; handle either here
+  let minMass = thrusters instanceof Module ? thrusters.getMinMass() : thrusters.minmass;
+  let optMass = thrusters instanceof Module ? thrusters.getOptMass() : thrusters.optmass;
+  let maxMass = thrusters instanceof Module ? thrusters.getMaxMass() : thrusters.maxmass;
+  let minMul = thrusters instanceof Module ? thrusters.getMinMul('rotation') : (thrusters.minmulrotation ? thrusters.minmulrotation : thrusters.minmul);
+  let optMul = thrusters instanceof Module ? thrusters.getOptMul('rotation') : (thrusters.optmulrotation ? thrusters.optmulrotation : thrusters.optmul);
+  let maxMul = thrusters instanceof Module ? thrusters.getMaxMul('rotation') : (thrusters.maxmulrotation ? thrusters.maxmulrotation : thrusters.maxmul);
+
+  return normValues(minMass, optMass, maxMass, minMul, optMul, maxMul, mass, baseYaw, engpip);
+}
+
+/**
+ * Calculate roll of a ship based on mass and thrusters
+ * @param {number}   mass       the mass of the ship
+ * @param {number}   baseRoll   base roll of the ship
+ * @param {object}   thrusters  the ship's thrusters
+ * @param {number}   engpip     the multiplier per pip to engines
+ * @return {array}             Roll by pips
+ */
+export function roll(mass, baseRoll, thrusters, engpip) {
+  // thrusters might be a module or a template; handle either here
+  let minMass = thrusters instanceof Module ? thrusters.getMinMass() : thrusters.minmass;
+  let optMass = thrusters instanceof Module ? thrusters.getOptMass() : thrusters.optmass;
+  let maxMass = thrusters instanceof Module ? thrusters.getMaxMass() : thrusters.maxmass;
+  let minMul = thrusters instanceof Module ? thrusters.getMinMul('rotation') : (thrusters.minmulrotation ? thrusters.minmulrotation : thrusters.minmul);
+  let optMul = thrusters instanceof Module ? thrusters.getOptMul('rotation') : (thrusters.optmulrotation ? thrusters.optmulrotation : thrusters.optmul);
+  let maxMul = thrusters instanceof Module ? thrusters.getMaxMul('rotation') : (thrusters.maxmulrotation ? thrusters.maxmulrotation : thrusters.maxmul);
+
+  return normValues(minMass, optMass, maxMass, minMul, optMul, maxMul, mass, baseRoll, engpip);
+}
+
+/**
+ * Normalise according to FD's calculations and return suitable values
+ * @param {number}   minMass  the minimum mass of the thrusters
+ * @param {number}   optMass  the optimum mass of the thrusters
+ * @param {number}   maxMass  the maximum mass of the thrusters
+ * @param {number}   minMul   the minimum multiplier of the thrusters
+ * @param {number}   optMul   the optimum multiplier of the thrusters
+ * @param {number}   maxMul   the maximum multiplier of the thrusters
+ * @param {number}   mass     the mass of the ship
+ * @param {base}     base     the base value from which to calculate
+ * @param {number}   engpip   the multiplier per pip to engines
+ * @return {array}            values by pips
+ */
+function normValues(minMass, optMass, maxMass, minMul, optMul, maxMul, mass, base, engpip) {
+  const xnorm = Math.min(1, (maxMass - mass) / (maxMass - minMass));
+  const exponent = Math.log((optMul - minMul) / (maxMul - minMul)) / Math.log(Math.min(1, (maxMass - optMass) / (maxMass - minMass)));
+  const ynorm = Math.pow(xnorm, exponent);
+  const mul = minMul + ynorm * (maxMul - minMul);
+  const res = base * mul;
+
+  return [res * (1 - (engpip * 4)),
+          res * (1 - (engpip * 3)),
+	  res * (1 - (engpip * 2)),
+	  res * (1 - (engpip * 1)),
+	  res];
 }

src/app/shipyard/Constants.js

@@ -33,6 +33,7 @@ export const ModuleGroupToName = {
   fi: 'Frame Shift Drive Interdictor',
   hb: 'Hatch Breaker Limpet Controller',
   hr: 'Hull Reinforcement Package',
+  mrp: 'Module Reinforcement Package',
   rf: 'Refinery',
   scb: 'Shield Cell Bank',
   sg: 'Shield Generator',
@@ -105,8 +106,9 @@ export const BulkheadNames = [
 export const ShipFacets = [
     {                   // 0
       title: 'agility',
-      props: ['agility'],
-      fmt: 'int',
+      props: ['topPitch', 'topRoll', 'topYaw'],
+      lbls: ['pitch', 'roll', 'yaw'],
+      fmt: 'f1',
       i: 0
     },
     {                   // 1
@@ -185,11 +187,18 @@ export const ShipFacets = [
     },
     {                   // 11
       title: 'DPS',
-      props: ['totalDps'],
-      lbls: ['DPS'],
+      props: ['totalDps', 'totalExplDps', 'totalKinDps', 'totalThermDps'],
+      lbls: ['total', 'explosive', 'kinetic', 'thermal'],
       fmt: 'round',
       i: 11
     },
+    {                   // 14
+      title: 'Sustained DPS',
+      props: ['totalSDps', 'totalExplSDps', 'totalKinSDps', 'totalThermSDps'],
+      lbls: ['total', 'explosive', 'kinetic', 'thermal'],
+      fmt: 'round',
+      i: 14
+    },
     {                   // 12
       title: 'EPS',
       props: ['totalEps'],

src/app/shipyard/Module.js

@@ -1,5 +1,5 @@
 import * as ModuleUtils from './ModuleUtils';
-import * as _ from 'lodash';
+import { Modifications } from 'coriolis-data/dist';
 
 /**
  * Module - active module in a ship's buildout
@@ -11,66 +11,154 @@ export default class Module {
    * @param {Object} params   Module parameters.  Either grp/id or template
    */
   constructor(params) {
-    let properties = Object.assign({ grp: null, id: null, template: null, }, params);
+    let properties = Object.assign({ grp: null, id: null, template: null }, params);
 
-    let template;
-    if (properties.template == undefined) {
-      return ModuleUtils.findModule(properties.grp, properties.id);
+    if (properties.class != undefined) {
+      // We already have a fully-formed module; copy the data over
+      for (let p in properties) { this[p] = properties[p]; }
+    } else if (properties.template != undefined) {
+      // We have a template from coriolis-data; copy the data over
+      for (let p in properties.template) { this[p] = properties.template[p]; }
     } else {
-      template = properties.template;
-      if (template) {
-        // Copy all properties from coriolis-data template
-        for (let p in template) { this[p] = template[p]; }
-      }
+      // We don't have a template; find it given the group and ID
+      return ModuleUtils.findModule(properties.grp, properties.id);
     }
   }
 
   /**
-   * Get a value for a given modification
-   * @param {Number} name  The name of the modification
-   * @return {Number}      The value of the modification, as an integer value scaled so that 1.23% == 123
+   * Clone an existing module
+   * @return {Object}  A clone of the existing module
    */
-  getModValue(name) {
-    return this.mods  && this.mods[name] ? this.mods[name] : null;
+  clone() {
+    return new Module(JSON.parse(JSON.stringify(this)));
+  }
+
+  /**
+   * Get a value for a given modification
+   * @param {Number} name The name of the modification
+   * @param {Number} raw  True if the value returned should be raw i.e. without the influence of special effects
+   * @return {object}     The value of the modification. If it is a numeric value then it is returned as an integer value scaled so that 1.23% == 123
+   */
+  getModValue(name, raw) {
+    let result = this.mods  && this.mods[name] ? this.mods[name] : null;
+    if ((!raw) && this.blueprint && this.blueprint.special) {
+      // This module has a special effect, see if we need to alter our returned value
+      const modifierActions = Modifications.modifierActions[this.blueprint.special.edname];
+      if (modifierActions && modifierActions[name]) {
+        // this special effect modifies our returned value
+        const modification = Modifications.modifications[name];
+        if (modification.method === 'additive') {
+          result = result + modifierActions[name];
+        } else if (modification.method === 'overwrite') {
+          result = modifierActions[name];
+        } else {
+          // rate of fire is special, as it's really burst interval.  Handle that here
+          let mod = null;
+          if (name === 'rof') {
+            mod = 1 / (1 + modifierActions[name]) - 1;
+          } else {
+            mod = modifierActions[name];
+          }
+          const multiplier = modification.type === 'percentage' ? 10000 : 100;
+          result = (((1 + result / multiplier) * (1 + mod)) - 1) * multiplier;
+        }
+      }
+    }
+
+    // Sanitise the resultant value to 4dp equivalent
+    return isNaN(result) ? result : Math.round(result);
   }
 
   /**
    * Set a value for a given modification ID
-   * @param {Number} name   The name of the modification
-   * @param {Number} value  The value of the modification, as an integer scaled so that -2.34% == -234
+   * @param {Number} name                 The name of the modification
+   * @param {object} value  The value of the modification. If it is a numeric value then it should be an integer scaled so that -2.34% == -234
+   * @param {bool}   valueiswithspecial   true if the value includes the special effect (when coming from a UI component)
    */
-  setModValue(name, value) {
+  setModValue(name, value, valueiswithspecial) {
     if (!this.mods) {
       this.mods = {};
     }
+    if (valueiswithspecial && this.blueprint && this.blueprint.special) {
+      // This module has a special effect, see if we need to alter the stored value
+      const modifierActions = Modifications.modifierActions[this.blueprint.special.edname];
+      if (modifierActions && modifierActions[name]) {
+        // This special effect modifies the value being set, so we need to revert it prior to storing the value
+        const modification = Modifications.modifications[name];
+        if (modification.method === 'additive') {
+          value = value - modifierActions[name];
+        } else if (modification.method === 'overwrite') {
+          value = null;
+        } else {
+          // rate of fire is special, as it's really burst interval.  Handle that here
+          let mod = null;
+          if (name === 'rof') {
+            mod = 1 / (1 + modifierActions[name]) - 1;
+          } else {
+            mod = modifierActions[name];
+          }
+          value = ((value / 10000 + 1) / (1 + mod) - 1) * 10000;
+        }
+      }
+    }
 
     if (value == null || value == 0) {
       delete this.mods[name];
     } else {
-      // Round just to be sure
-      this.mods[name] = Math.round(value);
+      this.mods[name] = value;
     }
   }
 
   /**
    * Helper to obtain a modified value using standard multipliers
    * @param {String}  name     the name of the modifier to obtain
-   * @param {Boolean} additive Optional true if the value is additive rather than multiplicative
    * @return {Number}          the mass of this module
    */
-  _getModifiedValue(name, additive) {
-    let result = this[name] || (additive ? 0 : null); // Additive NULL === 0
-    if (result != null) {
-      // Jitter is special, being the only non-percentage value (it is in fact degrees)
-      const modValue = name === 'jitter' ? this.getModValue(name) / 100 : this.getModValue(name) / 10000;
-      if (modValue) {
-        if (additive) {
-          result = result + modValue;
-        } else {
-          result = result * (1 + modValue);
-        }
+  _getModifiedValue(name) {
+    const modification = Modifications.modifications[name];
+    let result = this[name];
+
+    if (!result) {
+      if (modification && modification.method === 'additive') {
+        // Additive modifications start at 0 rather than NULL
+        result = 0;
+      } else {
+        result = null;
       }
     }
+
+    if (result != null) {
+      if (modification) {
+        // We store percentages as decimals, so to get them back we need to divide by 10000.  Otherwise
+        // we divide by 100.  Both ways we end up with a value with two decimal places
+        let modValue;
+        if (modification.type === 'percentage') {
+          modValue = this.getModValue(name) / 10000;
+        } else if (modification.type === 'numeric') {
+          modValue = this.getModValue(name) / 100;
+        } else {
+          modValue = this.getModValue(name);
+        }
+        if (modValue) {
+          if (modification.method === 'additive') {
+            result = result + modValue;
+          } else if (modification.method === 'overwrite') {
+            result = modValue;
+          } else {
+            result = result * (1 + modValue);
+          }
+        }
+      }
+    } else {
+      if (name === 'burst') {
+        // Burst is special, as if it can not exist but have a modification
+        result = this.getModValue(name) / 100;
+      } else if (name === 'burstrof') {
+        // Burst rate of fire is special, as if it can not exist but have a modification
+        result = this.getModValue(name) / 100;
+      }
+    }
+
     return result;
   }
 
@@ -122,30 +210,6 @@ export default class Module {
     return this._getModifiedValue('eff');
   }
 
-  /**
-   * Get the maximum mass of this module, taking in to account modifications
-   * @return {Number} the maximum mass of this module
-   */
-  getMaxMass() {
-    return this._getModifiedValue('maxmass');
-  }
-
-  /**
-   * Get the optimal mass of this module, taking in to account modifications
-   * @return {Number} the optimal mass of this module
-   */
-  getOptimalMass() {
-    return this._getModifiedValue('optmass');
-  }
-
-  /**
-   * Get the optimal multiplier of this module, taking in to account modifications
-   * @return {Number} the optimal multiplier of this module
-   */
-  getOptimalMultiplier() {
-    return this._getModifiedValue('optmult');
-  }
-
   /**
    * Get the maximum fuel per jump for this module, taking in to account modifications
    * @return {Number} the maximum fuel per jump of this module
@@ -207,7 +271,7 @@ export default class Module {
    * @return {Number} the kinetic resistance of this module
    */
   getKineticResistance() {
-    return this._getModifiedValue('kinres', true);
+    return this._getModifiedValue('kinres');
   }
 
   /**
@@ -215,7 +279,7 @@ export default class Module {
    * @return {Number} the thermal resistance of this module
    */
   getThermalResistance() {
-    return this._getModifiedValue('thermres', true);
+    return this._getModifiedValue('thermres');
   }
 
   /**
@@ -223,7 +287,7 @@ export default class Module {
    * @return {Number} the explosive resistance of this module
    */
   getExplosiveResistance() {
-    return this._getModifiedValue('explres', true);
+    return this._getModifiedValue('explres');
   }
 
   /**
@@ -250,6 +314,28 @@ export default class Module {
     return this._getModifiedValue('range');
   }
 
+  /**
+   * Get the falloff for this module, taking in to account modifications
+   * @return {Number} the falloff of this module
+   */
+  getFalloff() {
+    if (this.getModValue('fallofffromrange')) {
+      // Falloff from range means what it says, so use range instead of falloff
+      return this.getRange();
+    } else {
+      // Need to find out if we have a focused modification, in which case our falloff is scaled to range
+      if (this.blueprint && this.blueprint.name === 'Focused') {
+        const rangeMod = this.getModValue('range') / 10000;
+        return this.falloff * (1 + rangeMod);
+      } else {
+        // Standard falloff calculation
+        const range = this.getRange();
+        const falloff = this._getModifiedValue('falloff');
+        return (falloff > range ? range : falloff);
+      }
+    }
+  }
+
   /**
    * Get the range (in terms of seconds, for FSDI) for this module, taking in to account modifications
    * @return {Number} the range of this module
@@ -274,6 +360,14 @@ export default class Module {
     return this._getModifiedValue('hullreinforcement');
   }
 
+  /**
+   * Get the protection for this module, taking in to account modifications
+   * @return {Number} the protection of this module
+   */
+  getProtection() {
+    return this._getModifiedValue('protection');
+  }
+
   /**
    * Get the delay for this module, taking in to account modifications
    * @return {Number} the delay of this module
@@ -342,42 +436,60 @@ export default class Module {
 
   /**
    * Get the minimum multiplier for this module, taking in to account modifications
+   * @param {string} type the type for which we are obtaining the multiplier.  Can be 'speed', 'rotation', 'acceleration', or null
    * @return {Number} the minimum multiplier of this module
    */
-  getMinMul() {
+  getMinMul(type = null) {
     // Modifier is optmul
     let result = 0;
-    if (this['minmul']) {
+    if (this['minmul' + type]) {
+      result = this['minmul' + type];
+    } else if (this['minmul']) {
       result = this['minmul'];
-      if (result) {
-        let mult = this.getModValue('optmul') / 10000;
-        if (mult) { result = result * (1 + mult); }
-      }
+    }
+    if (result) {
+      let mult = this.getModValue('optmul') / 10000;
+      if (mult) { result = result * (1 + mult); }
     }
     return result;
   }
 
   /**
    * Get the optimum multiplier for this module, taking in to account modifications
+   * @param {string} type the type for which we are obtaining the multiplier.  Can be 'speed', 'rotation', 'acceleration', or null
    * @return {Number} the optimum multiplier of this module
    */
-  getOptMul() {
-    return this._getModifiedValue('optmul');
+  getOptMul(type = null) {
+    // Modifier is optmul
+    let result = 0;
+    if (this['optmul' + type]) {
+      result = this['optmul' + type];
+    } else if (this['optmul']) {
+      result = this['optmul'];
+    }
+    if (result) {
+      let mult = this.getModValue('optmul') / 10000;
+      if (mult) { result = result * (1 + mult); }
+    }
+    return result;
   }
 
   /**
    * Get the maximum multiplier for this module, taking in to account modifications
+   * @param {string} type the type for which we are obtaining the multiplier.  Can be 'speed', 'rotation', 'acceleration', or null
    * @return {Number} the maximum multiplier of this module
    */
-  getMaxMul() {
+  getMaxMul(type = null) {
     // Modifier is optmul
     let result = 0;
-    if (this['maxmul']) {
+    if (this['maxmul' + type]) {
+      result = this['maxmul' + type];
+    } else if (this['maxmul']) {
       result = this['maxmul'];
-      if (result) {
-        let mult = this.getModValue('optmul') / 10000;
-        if (mult) { result = result * (1 + mult); }
-      }
+    }
+    if (result) {
+      let mult = this.getModValue('optmul') / 10000;
+      if (mult) { result = result * (1 + mult); }
     }
     return result;
   }
@@ -421,7 +533,7 @@ export default class Module {
   getDps() {
     // DPS is a synthetic value
     let damage = this.getDamage();
-    let rpshot = this.getRoundsPerShot() || 1;
+    let rpshot = this.roundspershot || 1;
     let rof = this.getRoF() || 1;
 
     return damage * rpshot * rof;
@@ -434,7 +546,7 @@ export default class Module {
   getEps() {
     // EPS is a synthetic value
     let distdraw = this.getDistDraw();
-    let rpshot = this.getRoundsPerShot() || 1;
+    let rpshot = this.roundspershot || 1;
     let rof = this.getRoF() || 1;
 
     return distdraw * rpshot * rof;
@@ -447,7 +559,7 @@ export default class Module {
   getHps() {
     // HPS is a synthetic value
     let heat = this.getThermalLoad();
-    let rpshot = this.getRoundsPerShot() || 1;
+    let rpshot = this.roundspershot || 1;
     let rof = this.getRoF() || 1;
 
     return heat * rpshot * rof;
@@ -458,7 +570,10 @@ export default class Module {
    * @return {Number} the clip size of this module
    */
   getClip() {
-    return this._getModifiedValue('clip');
+    // Clip size is always rounded up
+    let result = this._getModifiedValue('clip');
+    if (result) { result = Math.ceil(result); }
+    return result;
   }
 
   /**
@@ -478,11 +593,35 @@ export default class Module {
   }
 
   /**
-   * Get the rate of fire for this module, taking in to account modifications
+   * Get the burst size for this module, taking in to account modifications
+   * @return {Number} the burst size of this module
+   */
+  getBurst() {
+    return this._getModifiedValue('burst');
+  }
+
+  /**
+   * Get the burst rate of fire for this module, taking in to account modifications
+   * @return {Number} the burst rate of fire of this module
+   */
+  getBurstRoF() {
+    return this._getModifiedValue('burstrof');
+  }
+
+  /**
+   * Get the rate of fire for this module, taking in to account modifications.
+   * The rate of fire is a combination value, and needs to take in to account
+   * bursts of fire.
+   * Firing goes [burst 1] [burst interval] [burst 2] [burst interval] ... [burst n] [interval]
+   * where 'n' is 'burst', 'burst interval' is '1/burstrof' and 'interval' is '1/rof'
    * @return {Number} the rate of fire for this module
    */
   getRoF() {
-    return this._getModifiedValue('rof');
+    const burst = this.getBurst() || 1;
+    const burstRoF = this.getBurstRoF() || 1;
+    const intRoF = this._getModifiedValue('rof');
+
+    return burst / (((burst - 1) / burstRoF) + 1 / intRoF);
   }
 
   /**
@@ -509,6 +648,14 @@ export default class Module {
     return this._getModifiedValue('shieldreinforcement');
   }
 
+  /**
+   * Get the piercing for this module, taking in to account modifications
+   * @return {Number} the piercing for this module
+   */
+  getPiercing() {
+    return this._getModifiedValue('piercing');
+  }
+
   /**
    * Get the bays for this module, taking in to account modifications
    * @return {Number} the bays for this module
@@ -533,7 +680,6 @@ export default class Module {
     return this._getModifiedValue('cells');
   }
 
-
   /**
    * Get the jitter for this module, taking in to account modifications
    * @return {Number} the jitter for this module
@@ -541,4 +687,36 @@ export default class Module {
   getJitter() {
     return this._getModifiedValue('jitter', true);
   }
+
+  /**
+   * Get the damage distribution for this module, taking in to account modifications
+   * @return {string} the damage distribution for this module
+   */
+  getDamageDist() {
+    return this.getModValue('damagedist') || this.damagedist;
+  }
+
+  /**
+   * Get the shot speed for this module, taking in to account modifications
+   * @return {string} the shot speed for this module
+   */
+  getShotSpeed() {
+    return this._getModifiedValue('shotspeed');
+  }
+
+  /**
+   * Get the spinup for this module, taking in to account modifications
+   * @return {string} the spinup for this module
+   */
+  getSpinup() {
+    return this._getModifiedValue('spinup');
+  }
+
+  /**
+   * Get the time for this module, taking in to account modifications
+   * @return {string} the time for this module
+   */
+  getTime() {
+    return this._getModifiedValue('time');
+  }
 }

src/app/shipyard/ModuleUtils.js

@@ -105,6 +105,59 @@ export function internal(id) {
   return null;
 };
 
+/**
+ * Finds a standard module based on Class, Rating, Group and/or name.
+ * At least one of Group name or unique module name must be provided
+ *
+ * @param  {String} groupName [Optional] Full name or abbreviated name for module group
+ * @param  {integer} clss     module Class
+ * @param  {String} rating    module Rating
+ * @param  {String} name      [Optional] Long/unique name for module -e.g. 'Advanced Discover Scanner'
+ * @return {Object}           The module if found, null if not found
+ */
+export function findStandard(groupName, clss, rating, name) {
+  let groups = {};
+
+  if (groupName) {
+    if (Modules.standard[groupName]) {
+      groups[groupName] = Modules.standard[groupName];
+    } else {
+      let grpCode = ModuleNameToGroup[groupName.toLowerCase()];
+      if (grpCode && Modules.standard[grpCode]) {
+        groups[grpCode] = Modules.standard[grpCode];
+      }
+    }
+  } else if (name) {
+    groups = Modules.standard;
+  }
+
+  for (let g in groups) {
+    let group = groups[g];
+    for (let i = 0, l = group.length; i < l; i++) {
+      if (group[i].class == clss && group[i].rating == rating && ((!name && !group[i].name) || group[i].name == name)) {
+        return group[i];
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Finds a standard Module ID based on Class, Rating, Group and/or name.
+ * At least one of Group name or unique module name must be provided
+ *
+ * @param  {String} groupName [Optional] Full name or abbreviated name for module group
+ * @param  {integer} clss     module Class
+ * @param  {String} rating    Module Rating
+ * @param  {String} name      [Optional] Long/unique name for module -e.g. 'Advanced Discover Scanner'
+ * @return {String}           The id of the module if found, null if not found
+ */
+export function findStandardId(groupName, clss, rating, name) {
+  let i = this.findStandard(groupName, clss, rating, name);
+  return i ? i.id : 0;
+}
+
 /**
  * Finds an internal module based on Class, Rating, Group and/or name.
  * At least one ofGroup name or unique module name must be provided

src/app/shipyard/Serializer.js

@@ -1,13 +1,10 @@
 import { ModuleGroupToName, MountMap, BulkheadNames } from './Constants';
 import { Ships } from 'coriolis-data/dist';
 import Ship from './Ship';
-import * as ModuleUtils from './ModuleUtils';
 import * as Utils from '../utils/UtilityFunctions';
 import LZString from 'lz-string';
 import { outfitURL } from '../utils/UrlGenerators';
 
-const STANDARD = ['powerPlant', 'thrusters', 'frameShiftDrive', 'lifeSupport', 'powerDistributor', 'sensors', 'fuelTank'];
-
 /**
  * Generates ship-loadout JSON Schema standard object
  * @param  {Object} standard model
@@ -30,6 +27,10 @@ function standardToSchema(standard) {
       o.modifications = standard.m.mods;
     }
 
+    if (standard.m.blueprint && Object.keys(standard.m.blueprint).length > 0) {
+      o.blueprint = standard.m.blueprint;
+    }
+
     return o;
   }
   return null;
@@ -62,6 +63,10 @@ function slotToSchema(slot) {
     if (slot.m.mods && Object.keys(slot.m.mods).length > 0) {
       o.modifications = slot.m.mods;
     }
+    if (slot.m.blueprint && Object.keys(slot.m.blueprint).length > 0) {
+      o.blueprint = slot.m.blueprint;
+    }
+
     return o;
   }
   return null;
@@ -80,7 +85,7 @@ export function toDetailedBuild(buildName, ship) {
       code = ship.toString();
 
   let data = {
-    $schema: 'http://cdn.coriolis.io/schemas/ship-loadout/4.json#',
+    $schema: 'https://coriolis.edcd.io/schemas/ship-loadout/4.json#',
     name: buildName,
     ship: ship.name,
     references: [{
@@ -124,61 +129,21 @@ export function toDetailedBuild(buildName, ship) {
  */
 export function fromDetailedBuild(detailedBuild) {
   let shipId = Object.keys(Ships).find((shipId) => Ships[shipId].properties.name.toLowerCase() == detailedBuild.ship.toLowerCase());
-
   if (!shipId) {
     throw 'No such ship: ' + detailedBuild.ship;
   }
 
-  let comps = detailedBuild.components;
-  let stn = comps.standard;
-  let priorities = [stn.cargoHatch && stn.cargoHatch.priority !== undefined ? stn.cargoHatch.priority - 1 : 0];
-  let enabled = [stn.cargoHatch && stn.cargoHatch.enabled !== undefined ? stn.cargoHatch.enabled : true];
   let shipData = Ships[shipId];
   let ship = new Ship(shipId, shipData.properties, shipData.slots);
-  let bulkheads = ModuleUtils.bulkheadIndex(stn.bulkheads);
-  let modifications = new Array(stn.bulkheads.modifications);
 
-  if (bulkheads < 0) {
-    throw 'Invalid bulkheads: ' + stn.bulkheads;
+  if (!detailedBuild.references[0] || !detailedBuild.references[0].code) {
+    throw 'Missing reference code';
   }
 
-  let standard = STANDARD.map((c) => {
-    if (!stn[c].class || !stn[c].rating) {
-      throw 'Invalid value for ' + c;
-    }
-    priorities.push(stn[c].priority === undefined ? 0 : stn[c].priority - 1);
-    enabled.push(stn[c].enabled === undefined ? true : stn[c].enabled);
-    modifications.push(stn[c].modifications);
-    return stn[c].class + stn[c].rating;
-  });
-
-  let internal = comps.internal.map(c => c ? ModuleUtils.findInternalId(c.group, c.class, c.rating, c.name) : 0);
-
-  let hardpoints = comps.hardpoints
-    .map(c => c ? ModuleUtils.findHardpointId(c.group, c.class, c.rating, c.name, MountMap[c.mount], c.missile) : 0)
-    .concat(comps.utility.map(c => c ? ModuleUtils.findHardpointId(c.group, c.class, c.rating, c.name, MountMap[c.mount]) : 0));
-
-  // The ordering of these arrays must match the order in which they are read in Ship.buildWith
-  priorities = priorities.concat(
-    comps.hardpoints.map(c => (!c || c.priority === undefined) ? 0 : c.priority - 1),
-    comps.utility.map(c => (!c || c.priority === undefined) ? 0 : c.priority - 1),
-    comps.internal.map(c => (!c || c.priority === undefined) ? 0 : c.priority - 1)
-  );
-  enabled = enabled.concat(
-    comps.hardpoints.map(c => (!c || c.enabled === undefined) ? true : c.enabled * 1),
-    comps.utility.map(c => (!c || c.enabled === undefined) ? true : c.enabled * 1),
-    comps.internal.map(c => (!c || c.enabled === undefined) ? true : c.enabled * 1)
-  );
-  modifications = modifications.concat(
-    comps.hardpoints.map(c => (c && c.m ? c.m.modifications : null)),
-    comps.utility.map(c => (c && c.m ? c.m.modifications : null)),
-    comps.internal.map(c => (c && c.m ? c.m.modifications : null))
-  );
-
-  ship.buildWith({ bulkheads, standard, hardpoints, internal }, priorities, enabled, modifications);
+  ship.buildFrom(detailedBuild.references[0].code);
 
   return ship;
-};
+}
 
 /**
  * Generates an array of ship-loadout JSON Schema object for export

src/app/shipyard/ShipRoles.js

@@ -31,18 +31,38 @@ export function multiPurpose(ship, shielded, bulkheadIndex) {
  * @param  {Object} standardOpts  [Optional] Standard module optional overrides
  */
 export function trader(ship, shielded, standardOpts) {
-  let sg = shielded ? ship.getAvailableModules().lightestShieldGenerator(ship.hullMass) : null;
+  let usedSlots = [],
+      sg = ship.getAvailableModules().lightestShieldGenerator(ship.hullMass);
+ 
+  // Shield generator if required
+  if (shielded) {
+    const shieldOrder = [1, 2, 3, 4, 5, 6, 7, 8];
+    const shieldInternals = ship.internal.filter(a => usedSlots.indexOf(a) == -1)
+                                         .filter(a => (!a.eligible) || a.eligible.sg)
+                                         .filter(a => a.maxClass >= sg.class)
+                                         .sort((a,b) => shieldOrder.indexOf(a.maxClass) - shieldOrder.indexOf(b.maxClass));
+    for (let i = 0; i < shieldInternals.length; i++) {
+      if (canMount(ship, shieldInternals[i], 'sg')) {
+        ship.use(shieldInternals[i], sg);
+        usedSlots.push(shieldInternals[i]);
+        break;
+      }
+    }
+  }
 
+  // Fill the empty internals with cargo racks
   for (let i = ship.internal.length; i--;) {
     let slot = ship.internal[i];
-    if (sg && canMount(ship, slot, 'sg', sg.class)) {
-      ship.use(slot, sg);
-      sg = null;
-    } else {
+    if (usedSlots.indexOf(slot) == -1 && canMount(ship, slot, 'cr')) {
       ship.use(slot, ModuleUtils.findInternal('cr', slot.maxClass, 'E'));
     }
   }
 
+  // Empty the hardpoints
+  for (let s of ship.hardpoints) {
+    ship.use(s, null);
+  }
+
   ship.useLightestStandard(standardOpts);
 }
 
@@ -53,53 +73,102 @@ export function trader(ship, shielded, standardOpts) {
  */
 export function explorer(ship, planetary) {
   let standardOpts = { ppRating: 'A' },
-      intLength = ship.internal.length,
       heatSinkCount = 2,  // Fit 2 heat sinks if possible
-      afmUnitCount = 2,   // Fit 2 AFM Units if possible
-      shieldNext = planetary,
+      usedSlots = [],
       sgSlot,
       fuelScoopSlot,
-      pvhSlot,
       sg = ship.getAvailableModules().lightestShieldGenerator(ship.hullMass);
 
   if (!planetary) { // Non-planetary explorers don't really need to boost
     standardOpts.pd = '1D';
   }
 
-  ship.setSlotEnabled(ship.cargoHatch, false)
-      .use(ship.internal[--intLength], ModuleUtils.internal('2f'));      // Advanced Discovery Scanner
+  // Cargo hatch can be disabled
+  ship.setSlotEnabled(ship.cargoHatch, false);
 
-  if (!planetary || intLength > 3) {  // Don't mount a DDS on planetary explorer ships too small for both a PVH and DDS
-    ship.use(ship.internal[--intLength], ModuleUtils.internal('2i'));      // Detailed Surface Scanner
+  // Advanced Discovery Scanner - class 1 or higher
+  const adsOrder = [1, 2, 3, 4, 5, 6, 7, 8];
+  const adsInternals = ship.internal.filter(a => usedSlots.indexOf(a) == -1)
+                                    .filter(a => (!a.eligible) || a.eligible.sc)
+                                    .sort((a,b) => adsOrder.indexOf(a.maxClass) - adsOrder.indexOf(b.maxClass));
+  for (let i = 0; i < adsInternals.length; i++) {
+    if (canMount(ship, adsInternals[i], 'sc')) {
+      ship.use(adsInternals[i], ModuleUtils.internal('2f'));
+      usedSlots.push(adsInternals[i]);
+      break;
+    }
   }
 
-  for (let i = 0; i < intLength; i++) {
-    let slot = ship.internal[i];
-    let nextSlot = (i + 1) < intLength ? ship.internal[i + 1] : null;
-    // Fit best possible Fuel Scoop
-    if (!fuelScoopSlot && canMount(ship, slot, 'fs')) {
-      fuelScoopSlot = slot;
-      ship.use(slot, ModuleUtils.findInternal('fs', slot.maxClass, 'A'));
-      ship.setSlotEnabled(slot, true);
-    // Mount a Shield generator if possible AND an AFM Unit has been mounted already (Guarantees at least 1 AFM Unit)
-    } else if (!sgSlot && shieldNext && canMount(ship, slot, 'sg', sg.class) && !canMount(ship, nextSlot, 'sg', sg.class)) {
-      sgSlot = slot;
-      shieldNext = false;
-      ship.use(slot, sg);
-      ship.setSlotEnabled(slot, true);
-    // if planetary explorer and the next slot cannot mount a PVH or the next modul to mount is a SG
-    } else if (planetary && !pvhSlot && canMount(ship, slot, 'pv') && (shieldNext || !canMount(ship, nextSlot, 'pv', 2))) {
-      pvhSlot = slot;
-      ship.use(slot, ModuleUtils.findInternal('pv', Math.min(Math.floor(pvhSlot.maxClass / 2) * 2, 6), 'G'));
-      ship.setSlotEnabled(slot, false);   // Disabled power for PVH
-      shieldNext = !sgSlot;
-    } else if (afmUnitCount > 0 && canMount(ship, slot, 'am')) {
-      afmUnitCount--;
-      ship.use(slot, ModuleUtils.findInternal('am', slot.maxClass, 'A'));
-      ship.setSlotEnabled(slot, false);   // Disabled power for AFM Unit
-      shieldNext = !sgSlot;
-    } else {
-      ship.use(slot, null);
+  if (planetary) {
+    // Planetary Vehicle Hangar - class 2 or higher
+    const pvhOrder = [2, 3, 4, 5, 6, 7, 8, 1];
+    const pvhInternals = ship.internal.filter(a => usedSlots.indexOf(a) == -1)
+                                      .filter(a => (!a.eligible) || a.eligible.pv)
+                                      .sort((a,b) => pvhOrder.indexOf(a.maxClass) - pvhOrder.indexOf(b.maxClass));
+    for (let i = 0; i < pvhInternals.length; i++) {
+      if (canMount(ship, pvhInternals[i], 'pv')) {
+        // Planetary Vehical Hangar only has even classes
+        const pvhClass = pvhInternals[i].maxClass % 2 === 1 ? pvhInternals[i].maxClass - 1 : pvhInternals[i].maxClass;
+        ship.use(pvhInternals[i], ModuleUtils.findInternal('pv', pvhClass, 'G')); // G is lower mass
+        ship.setSlotEnabled(pvhInternals[i], false);   // Disable power for Planetary Vehical Hangar
+        usedSlots.push(pvhInternals[i]);
+        break;
+      }
+    }
+  }
+
+  // Shield generator
+  const shieldOrder = [1, 2, 3, 4, 5, 6, 7, 8];
+  const shieldInternals = ship.internal.filter(a => usedSlots.indexOf(a) == -1)
+                                       .filter(a => (!a.eligible) || a.eligible.sg)
+                                       .filter(a => a.maxClass >= sg.class)
+                                       .sort((a,b) => shieldOrder.indexOf(a.maxClass) - shieldOrder.indexOf(b.maxClass));
+  for (let i = 0; i < shieldInternals.length; i++) {
+    if (canMount(ship, shieldInternals[i], 'sg')) {
+      ship.use(shieldInternals[i], sg);
+      usedSlots.push(shieldInternals[i]);
+      sgSlot = shieldInternals[i];
+      break;
+    }
+  }
+
+  // Detailed Surface Scanner
+  const dssOrder = [1, 2, 3, 4, 5, 6, 7, 8];
+  const dssInternals = ship.internal.filter(a => usedSlots.indexOf(a) == -1)
+                                    .filter(a => (!a.eligible) || a.eligible.sc)
+                                    .sort((a,b) => dssOrder.indexOf(a.maxClass) - dssOrder.indexOf(b.maxClass));
+  for (let i = 0; i < dssInternals.length; i++) {
+    if (canMount(ship, dssInternals[i], 'sc')) {
+      ship.use(dssInternals[i], ModuleUtils.internal('2i'));
+      usedSlots.push(dssInternals[i]);
+      break;
+    }
+  }
+
+  // Fuel scoop - best possible
+  const fuelScoopOrder = [8, 7, 6, 5, 4, 3, 2, 1];
+  const fuelScoopInternals = ship.internal.filter(a => usedSlots.indexOf(a) == -1)
+                                       .filter(a => (!a.eligible) || a.eligible.fs)
+                                       .sort((a,b) => fuelScoopOrder.indexOf(a.maxClass) - fuelScoopOrder.indexOf(b.maxClass));
+  for (let i = 0; i < fuelScoopInternals.length; i++) {
+    if (canMount(ship, fuelScoopInternals[i], 'fs')) {
+      ship.use(fuelScoopInternals[i], ModuleUtils.findInternal('fs', fuelScoopInternals[i].maxClass, 'A'));
+      usedSlots.push(fuelScoopInternals[i]);
+      fuelScoopSlot = fuelScoopInternals[i];
+      break;
+    }
+  }
+
+  // AFMUs - fill as they are 0-weight
+  const afmuOrder = [8, 7, 6, 5, 4, 3, 2, 1];
+  const afmuInternals = ship.internal.filter(a => usedSlots.indexOf(a) == -1)
+                                       .filter(a => (!a.eligible) || a.eligible.pc)
+                                       .sort((a,b) => afmuOrder.indexOf(a.maxClass) - afmuOrder.indexOf(b.maxClass));
+  for (let i = 0; i < afmuInternals.length; i++) {
+    if (canMount(ship, afmuInternals[i], 'am')) {
+      ship.use(afmuInternals[i], ModuleUtils.findInternal('am', afmuInternals[i].maxClass, 'A'));
+      usedSlots.push(afmuInternals[i]);
+      ship.setSlotEnabled(afmuInternals[i], false);   // Disable power for AFM Unit
     }
   }
 
@@ -113,7 +182,7 @@ export function explorer(ship, planetary) {
     }
   }
 
-  if (sgSlot) {
+  if (sgSlot && fuelScoopSlot) {
     // The SG and Fuel scoop to not need to be powered at the same time
     if (sgSlot.m.getPowerUsage() > fuelScoopSlot.m.getPowerUsage()) { // The Shield generator uses the most power
       ship.setSlotEnabled(fuelScoopSlot, false);
@@ -124,3 +193,104 @@ export function explorer(ship, planetary) {
 
   ship.useLightestStandard(standardOpts);
 }
+
+/**
+ * Miner Role
+ * @param  {Ship} ship         Ship instance
+ * @param  {Boolean} shielded  True if shield generator should be included
+ */
+export function miner(ship, shielded) {
+  let standardOpts = { ppRating: 'A' },
+      miningLaserCount = 2,
+      usedSlots = [],
+      sg = ship.getAvailableModules().lightestShieldGenerator(ship.hullMass);
+
+  // Cargo hatch should be enabled
+  ship.setSlotEnabled(ship.cargoHatch, true);
+
+  // 4A or largest possible refinery
+  const refineryOrder = [4, 5, 6, 7, 8, 3, 2, 1];
+  const refineryInternals = ship.internal.filter(a => usedSlots.indexOf(a) == -1)
+                                         .filter(a => (!a.eligible) || a.eligible.rf)
+                                         .sort((a,b) => refineryOrder.indexOf(a.maxClass) - refineryOrder.indexOf(b.maxClass));
+  for (let i = 0; i < refineryInternals.length; i++) {
+    if (canMount(ship, refineryInternals[i], 'rf')) {
+      ship.use(refineryInternals[i], ModuleUtils.findInternal('rf', refineryInternals[i].maxClass, 'A'));
+      usedSlots.push(refineryInternals[i]);
+      break;
+    }
+  }
+
+  // Prospector limpet controller - 3A if possible
+  const prospectorOrder = [3, 4, 5, 6, 7, 8, 2, 1];
+  const prospectorInternals = ship.internal.filter(a => usedSlots.indexOf(a) == -1)
+                                           .filter(a => (!a.eligible) || a.eligible.pc)
+                                           .sort((a,b) => prospectorOrder.indexOf(a.maxClass) - prospectorOrder.indexOf(b.maxClass));
+  for (let i = 0; i < prospectorInternals.length; i++) {
+    if (canMount(ship, prospectorInternals[i], 'pc')) {
+      // Prospector only has odd classes
+      const prospectorClass = prospectorInternals[i].maxClass % 2 === 0 ? prospectorInternals[i].maxClass - 1 : prospectorInternals[i].maxClass;
+      ship.use(prospectorInternals[i], ModuleUtils.findInternal('pc', prospectorClass, 'A'));
+      usedSlots.push(prospectorInternals[i]);
+      break;
+    }
+  }
+
+  // Shield generator if required
+  if (shielded) {
+    const shieldOrder = [1, 2, 3, 4, 5, 6, 7, 8];
+    const shieldInternals = ship.internal.filter(a => usedSlots.indexOf(a) == -1)
+                                         .filter(a => (!a.eligible) || a.eligible.sg)
+                                         .filter(a => a.maxClass >= sg.class)
+                                         .sort((a,b) => shieldOrder.indexOf(a.maxClass) - shieldOrder.indexOf(b.maxClass));
+    for (let i = 0; i < shieldInternals.length; i++) {
+      if (canMount(ship, shieldInternals[i], 'sg')) {
+        ship.use(shieldInternals[i], sg);
+        usedSlots.push(shieldInternals[i]);
+        break;
+      }
+    }
+  }
+
+  // Collector limpet controller if there are enough internals left
+  let collectorLimpetsRequired = Math.max(ship.internal.filter(a => (!a.eligible) || a.eligible.cr).length - 6, 0);
+  if (collectorLimpetsRequired > 0) {
+    const collectorOrder = [1, 2, 3, 4, 5, 6, 7, 8];
+    const collectorInternals = ship.internal.filter(a => usedSlots.indexOf(a) == -1)
+                                            .filter(a => (!a.eligible) || a.eligible.cc)
+                                            .sort((a,b) => collectorOrder.indexOf(a.maxClass) - collectorOrder.indexOf(b.maxClass));
+    for (let i = 0; i < collectorInternals.length && collectorLimpetsRequired > 0; i++) {
+      if (canMount(ship, collectorInternals[i], 'cc')) {
+        // Collector only has odd classes
+        const collectorClass = collectorInternals[i].maxClass % 2 === 0 ? collectorInternals[i].maxClass - 1 : collectorInternals[i].maxClass;
+        ship.use(collectorInternals[i], ModuleUtils.findInternal('cc', collectorClass, 'A'));
+        usedSlots.push(collectorInternals[i]);
+        collectorLimpetsRequired -= collectorInternals[i].m.maximum;
+      }
+    }
+  }
+
+  // Dual mining lasers of highest possible class; remove anything else
+  const miningLaserOrder = [2, 3, 4, 1, 0];
+  const miningLaserHardpoints = ship.hardpoints.concat().sort(function(a,b) {
+    return miningLaserOrder.indexOf(a.maxClass) - miningLaserOrder.indexOf(b.maxClass);
+  });
+  for (let s of miningLaserHardpoints) {
+    if (s.maxClass >= 1 && miningLaserCount) {
+      ship.use(s, ModuleUtils.hardpoints(s.maxClass >= 2 ? '2m' : '2l'));
+      miningLaserCount--;
+    } else {
+      ship.use(s, null);
+    }
+  }
+
+  // Fill the empty internals with cargo racks
+  for (let i = ship.internal.length; i--;) {
+    let slot = ship.internal[i];
+    if (usedSlots.indexOf(slot) == -1 && canMount(ship, slot, 'cr')) {
+      ship.use(slot, ModuleUtils.findInternal('cr', slot.maxClass, 'E'));
+    }
+  }
+
+  ship.useLightestStandard(standardOpts);
+}

src/app/utils/CompanionApiUtils.js

@@ -13,8 +13,8 @@ const SHIP_FD_NAME_TO_CORIOLIS_NAME = {
   'CobraMkIII': 'cobra_mk_iii',
   'CobraMkIV': 'cobra_mk_iv',
   'Cutter': 'imperial_cutter',
-  'DiamondBack': 'diamondback_explorer',
-  'DiamondBackXL': 'diamondback',
+  'DiamondBackXL': 'diamondback_explorer',
+  'DiamondBack': 'diamondback',
   'Eagle': 'eagle',
   'Empire_Courier': 'imperial_courier',
   'Empire_Eagle': 'imperial_eagle',
@@ -33,7 +33,7 @@ const SHIP_FD_NAME_TO_CORIOLIS_NAME = {
   'Type7': 'type_7_transport',
   'Type9': 'type_9_heavy',
   'Viper': 'viper',
-  'Viper_MKIV': 'viper_mk_iv',
+  'Viper_MkIV': 'viper_mk_iv',
   'Vulture': 'vulture'
 };
 
@@ -149,13 +149,13 @@ export function shipFromJson(json) {
     throw 'Unknown bulkheads "' + armourJson.name + '"';
   }
   ship.bulkheads.enabled = true;
-  if (armourJson.modifiers) _addModifications(ship.bulkheads.m, armourJson.modifiers);
+  if (armourJson.modifiers) _addModifications(ship.bulkheads.m, armourJson.modifiers, armourJson.recipeName, armourJson.recipeLevel);
 
   // Add the standard modules
   // Power plant
   const powerplantJson = json.modules.PowerPlant.module;
   const powerplant = _moduleFromEdId(powerplantJson.id);
-  if (powerplantJson.modifiers) _addModifications(powerplant, powerplantJson.modifiers);
+  if (powerplantJson.modifiers) _addModifications(powerplant, powerplantJson.modifiers, powerplantJson.recipeName, powerplantJson.recipeLevel);
   ship.use(ship.standard[0], powerplant, true);
   ship.standard[0].enabled = powerplantJson.on === true;
   ship.standard[0].priority = powerplantJson.priority;
@@ -163,7 +163,7 @@ export function shipFromJson(json) {
   // Thrusters
   const thrustersJson = json.modules.MainEngines.module;
   const thrusters = _moduleFromEdId(thrustersJson.id);
-  if (thrustersJson.modifiers) _addModifications(thrusters, thrustersJson.modifiers);
+  if (thrustersJson.modifiers) _addModifications(thrusters, thrustersJson.modifiers, thrustersJson.recipeName, thrustersJson.recipeLevel);
   ship.use(ship.standard[1], thrusters, true);
   ship.standard[1].enabled = thrustersJson.on === true;
   ship.standard[1].priority = thrustersJson.priority;
@@ -171,7 +171,7 @@ export function shipFromJson(json) {
   // FSD
   const frameshiftdriveJson = json.modules.FrameShiftDrive.module;
   const frameshiftdrive = _moduleFromEdId(frameshiftdriveJson.id);
-  if (frameshiftdriveJson.modifiers) _addModifications(frameshiftdrive, frameshiftdriveJson.modifiers);
+  if (frameshiftdriveJson.modifiers) _addModifications(frameshiftdrive, frameshiftdriveJson.modifiers, frameshiftdriveJson.recipeName, frameshiftdriveJson.recipeLevel);
   ship.use(ship.standard[2], frameshiftdrive, true);
   ship.standard[2].enabled = frameshiftdriveJson.on === true;
   ship.standard[2].priority = frameshiftdriveJson.priority;
@@ -179,7 +179,7 @@ export function shipFromJson(json) {
   // Life support
   const lifesupportJson = json.modules.LifeSupport.module;
   const lifesupport = _moduleFromEdId(lifesupportJson.id);
-  if (lifesupportJson.modifiers)_addModifications(lifesupport, lifesupportJson.modifiers);
+  if (lifesupportJson.modifiers)_addModifications(lifesupport, lifesupportJson.modifiers, lifesupportJson.recipeName, lifesupportJson.recipeLevel);
   ship.use(ship.standard[3], lifesupport, true);
   ship.standard[3].enabled = lifesupportJson.on === true;
   ship.standard[3].priority = lifesupportJson.priority;
@@ -187,7 +187,7 @@ export function shipFromJson(json) {
   // Power distributor
   const powerdistributorJson = json.modules.PowerDistributor.module;
   const powerdistributor = _moduleFromEdId(powerdistributorJson.id);
-  if (powerdistributorJson.modifiers) _addModifications(powerdistributor, powerdistributorJson.modifiers);
+  if (powerdistributorJson.modifiers) _addModifications(powerdistributor, powerdistributorJson.modifiers, powerdistributorJson.recipeName, powerdistributorJson.recipeLevel);
   ship.use(ship.standard[4], powerdistributor, true);
   ship.standard[4].enabled = powerdistributorJson.on === true;
   ship.standard[4].priority = powerdistributorJson.priority;
@@ -195,7 +195,7 @@ export function shipFromJson(json) {
   // Sensors
   const sensorsJson = json.modules.Radar.module;
   const sensors = _moduleFromEdId(sensorsJson.id);
-  if (sensorsJson.modifiers) _addModifications(sensors, sensorsJson.modifiers);
+  if (sensorsJson.modifiers) _addModifications(sensors, sensorsJson.modifiers, sensorsJson.recipeName, sensorsJson.recipeLevel);
   ship.use(ship.standard[5], sensors, true);
   ship.standard[5].enabled = sensorsJson.on === true;
   ship.standard[5].priority = sensorsJson.priority;
@@ -224,12 +224,14 @@ export function shipFromJson(json) {
     // Now that we know what we're looking for, find it
     const hardpointName = HARDPOINT_NUM_TO_CLASS[hardpointClassNum] + 'Hardpoint' + hardpointSlotNum;
     const hardpointSlot = json.modules[hardpointName];
-    if (!hardpointSlot.module) {
+    if (!hardpointSlot) {
+      // This can happen with old imports that don't contain new hardpoints
+    } else if (!hardpointSlot.module) {
       // No module
     } else {
       const hardpointJson = hardpointSlot.module;
       const hardpoint = _moduleFromEdId(hardpointJson.id);
-      if (hardpointJson.modifiers) _addModifications(hardpoint, hardpointJson.modifiers);
+      if (hardpointJson.modifiers) _addModifications(hardpoint, hardpointJson.modifiers, hardpointJson.recipeName, hardpointJson.recipeLevel);
       ship.use(ship.hardpoints[hardpointArrayNum], hardpoint, true);
       ship.hardpoints[hardpointArrayNum].enabled = hardpointJson.on === true;
       ship.hardpoints[hardpointArrayNum].priority = hardpointJson.priority;
@@ -239,24 +241,39 @@ export function shipFromJson(json) {
 
   // Add internal compartments
   let internalSlotNum = 1;
+  let militarySlotNum = 1;
   for (let i in shipTemplate.slots.internal) {
-    const internalClassNum = shipTemplate.slots.internal[i];
+    const isMilitary = isNaN(shipTemplate.slots.internal[i]) ? shipTemplate.slots.internal[i].name == 'Military' : false;
 
+    // The internal slot might be a standard or a military slot.  Military slots have a different naming system
     let internalSlot = null;
-    while (internalSlot === null && internalSlotNum < 99) {
-      // Slot numbers are not contiguous so handle skips
-      const internalName = 'Slot' + (internalSlotNum <= 9 ? '0' : '') + internalSlotNum + '_Size' + internalClassNum;
-      if (json.modules[internalName]) {
-        internalSlot = json.modules[internalName];
+    if (isMilitary) {
+      const internalName = 'Military0' + militarySlotNum;
+      internalSlot = json.modules[internalName];
+      militarySlotNum++;
+    } else {
+      // Slot numbers are not contiguous so handle skips.
+      while (internalSlot === null && internalSlotNum < 99) {
+        // Slot sizes have no relationship to the actual size, either, so check all possibilities
+        for (let slotsize = 0; slotsize < 9; slotsize++) {
+          const internalName = 'Slot' + (internalSlotNum <= 9 ? '0' : '') + internalSlotNum + '_Size' + slotsize;
+          if (json.modules[internalName]) {
+            internalSlot = json.modules[internalName];
+            break;
+          }
+        }
+        internalSlotNum++;
       }
-      internalSlotNum++;
     }
-    if (!internalSlot.module) {
+
+    if (!internalSlot) {
+      // This can happen with old imports that don't contain new slots
+    } else if (!internalSlot.module) {
       // No module
     } else {
       const internalJson = internalSlot.module;
       const internal = _moduleFromEdId(internalJson.id);
-      if (internalJson.modifiers) _addModifications(internal, internalJson.modifiers);
+      if (internalJson.modifiers) _addModifications(internal, internalJson.modifiers, internalJson.recipeName, internalJson.recipeLevel);
       ship.use(ship.internal[i], internal, true);
       ship.internal[i].enabled = internalJson.on === true;
       ship.internal[i].priority = internalJson.priority;
@@ -271,26 +288,64 @@ export function shipFromJson(json) {
  * Add the modifications for a module
  * @param {Module} module the module
  * @param {Object} modifiers the modifiers
+ * @param {Object} blueprint the blueprint of the modification
+ * @param {Object} grade the grade of the modification
  */
-function _addModifications(module, modifiers) {
+function _addModifications(module, modifiers, blueprint, grade) {
   if (!modifiers || !modifiers.modifiers) return;
   
+  let special;
   for (const i in modifiers.modifiers) {
-    // Look up the modifiers to find what we need to do
-    const modifierActions = Modifications.modifierActions[modifiers.modifiers[i].name];
-    const value = modifiers.modifiers[i].value;
+    // Some special modifications
+    if (modifiers.modifiers[i].name === 'mod_weapon_clip_size_override') {
+      // This is a numeric addition to the clip size, but we need to work it out in terms of being a percentage so
+      // that it works the same as other modifications
+      const origClip = module.clip || 1;
+      module.setModValue('clip', ((modifiers.modifiers[i].value  - origClip) / origClip) * 10000);
+    } else if (modifiers.modifiers[i].name === 'mod_weapon_burst_size') {
+      // This is an absolute number that acts as an override
+      module.setModValue('burst', modifiers.modifiers[i].value * 100);
+    } else if (modifiers.modifiers[i].name === 'mod_weapon_burst_rof') {
+      // This is an absolute number that acts as an override
+      module.setModValue('burstrof', modifiers.modifiers[i].value * 100);
+    } else if (modifiers.modifiers[i].name === 'mod_weapon_falloffrange_from_range') {
+      // Obtain the falloff value directly from the range
+      module.setModValue('fallofffromrange', 1);
+    } else if (modifiers.modifiers[i].name && modifiers.modifiers[i].name.startsWith('special_')) {
+      // We don't add special effects directly, but keep a note of them so they can be added when fetching values
+      special = Modifications.specials[modifiers.modifiers[i].name];
+    } else {
+      // Look up the modifiers to find what we need to do
+      const modifierActions = Modifications.modifierActions[modifiers.modifiers[i].name];
+      const value = modifiers.modifiers[i].value;
 
-    // Carry out the required changes
-    for (const action in modifierActions) {
-      const actionValue = modifierActions[action] * value;
-      let mod = module.getModValue(action) / 10000;
-      if (!mod) {
-        mod = 0;
+      // Carry out the required changes
+      for (const action in modifierActions) {
+        if (isNaN(modifierActions[action])) {
+          module.setModValue(action, modifierActions[action]);
+        } else {
+          const actionValue = modifierActions[action] * value;
+          let mod = module.getModValue(action) / 10000;
+          if (!mod) {
+            mod = 0;
+          }
+          module.setModValue(action, ((1 + mod) * (1 + actionValue) - 1) * 10000);
+        }
       }
-      module.setModValue(action, ((1 + mod) * (1 + actionValue) - 1) * 10000);
     }
   }
 
+  // Add the blueprint ID, grade and special
+  if (blueprint) {
+    module.blueprint = Object.assign({}, Modifications.blueprints[blueprint]);
+    if (grade) {
+      module.blueprint.grade = Number(grade);
+    }
+    if (special) {
+      module.blueprint.special = special;
+    }
+  }
+  
   // Need to fix up a few items
 
   // Shield boosters are treated internally as straight modifiers, so rather than (for example)
@@ -355,6 +410,12 @@ function _addModifications(module, modifiers) {
     }
   }
 
+  // Bulkhead boost is based off the inherent boost of the module
+  if (module.grp == 'bh') {
+    const alteredBoost = (1 + module.hullboost) * (1 + module.getModValue('hullboost') / 10000) - 1;
+    module.setModValue('hullboost', (alteredBoost / module.hullboost - 1) * 10000);
+  }
+
   // Jitter is an absolute number, so we need to divide it by 100
   if (module.getModValue('jitter')) {
     module.setModValue('jitter', module.getModValue('jitter') / 100);

src/app/utils/ShortenUrl.js

@@ -1,17 +1,27 @@
 import request from 'superagent';
 
-const SHORTEN_API = 'https://www.googleapis.com/urlshortener/v1/url?key=';
 
+/**
+ * Shorten a URL
+ * @param  {string} url        The URL to shorten
+ * @param  {function} success   Success callback
+ * @param  {function} error     Failure/Error callback
+ */ 
+export default function shorternUrl(url, success, error) {
+  shortenUrlEddp(url, success, error);
+}
+
+const SHORTEN_API_GOOGLE = 'https://www.googleapis.com/urlshortener/v1/url?key=';
 /**
  * Shorten a URL using Google's URL shortener API
  * @param  {string} url        The URL to shorten
  * @param  {function} success   Success callback
  * @param  {function} error     Failure/Error callback
  */
-export default function shortenUrl(url, success, error) {
+function shortenUrlGoogle(url, success, error) {
   if (window.navigator.onLine) {
     try {
-      request.post(SHORTEN_API + window.CORIOLIS_GAPI_KEY)
+      request.post(SHORTEN_API_GOOGLE + window.CORIOLIS_GAPI_KEY)
         .send({ longUrl: url })
         .end(function(err, response) {
           if (err) {
@@ -27,3 +37,30 @@ export default function shortenUrl(url, success, error) {
     error('Not Online');
   }
 }
+
+const SHORTEN_API_EDDP = 'https://eddp.co/u';
+/**
+ * Shorten a URL using EDDP's URL shortener API
+ * @param  {string} url        The URL to shorten
+ * @param  {function} success   Success callback
+ * @param  {function} error     Failure/Error callback
+ */
+function shortenUrlEddp(url, success, error) {
+  if (window.navigator.onLine) {
+    try {
+      request.post(SHORTEN_API_EDDP)
+        .send(url)
+        .end(function(err, response) {
+          if (err) {
+            error('Bad Request');
+          } else {
+            success(response.header['location']);
+          }
+        });
+    } catch (e) {
+      error(e.message ? e.message : e);
+    }
+  } else {
+    error('Not Online');
+  }
+}

src/app/utils/SlotFunctions.js

@@ -143,21 +143,17 @@ export function diffDetails(language, m, mm) {
   let { formats, translate, units } = language;
   let propDiffs = [];
 
-  let mCost = m.cost || 0;
-  let mmCost = mm ? mm.cost : 0;
-  if (mCost != mmCost) propDiffs.push(<div key='cost'>{translate('cost')}: <span className={diffClass(mCost, mmCost, true) }>{mCost ? Math.round(mCost * (1 - Persist.getModuleDiscount())) : 0}{units.CR}</span></div>);
+  // Module-specific items
 
-  let mMass = m.mass || 0;
-  let mmMass = mm ? mm.getMass() : 0;
-  if (mMass != mmMass) propDiffs.push(<div key='mass'>{translate('mass')}: <span className={diffClass(mMass, mmMass, true)}>{diff(formats.round, mMass, mmMass)}{units.T}</span></div>);
-
-  let mPowerGeneration = m.pgen || 0;
-  let mmPowerGeneration = mm ? mm.getPowerGeneration() : 0;
-  if (mPowerGeneration != mmPowerGeneration) propDiffs.push(<div key='pgen'>{translate('pgen')}: <span className={diffClass(mPowerGeneration, mmPowerGeneration, true)}>{diff(formats.round, mPowerGeneration, mmPowerGeneration)}{units.MJ}</span></div>);
-
-  let mPowerUsage = m.power || 0;
-  let mmPowerUsage = mm ? mm.getPowerUsage() : 0;
-  if (mPowerUsage != mmPowerUsage) propDiffs.push(<div key='power'>{translate('power')}: <span className={diffClass(mPowerUsage, mmPowerUsage, true)}>{diff(formats.round, mPowerUsage, mmPowerUsage)}{units.MJ}</span></div>);
+  if (m.grp === 'pp') {
+    let mPowerGeneration = m.pgen || 0;
+    let mmPowerGeneration = mm ? mm.getPowerGeneration() : 0;
+    if (mPowerGeneration != mmPowerGeneration) propDiffs.push(<div key='pgen'>{translate('pgen')}: <span className={diffClass(mPowerGeneration, mmPowerGeneration)}>{diff(formats.round, mPowerGeneration, mmPowerGeneration)}{units.MJ}</span></div>);
+  } else {
+    let mPowerUsage = m.power || 0;
+    let mmPowerUsage = mm ? mm.getPowerUsage() || 0 : 0;
+    if (mPowerUsage != mmPowerUsage) propDiffs.push(<div key='power'>{translate('power')}: <span className={diffClass(mPowerUsage, mmPowerUsage, true)}>{diff(formats.round, mPowerUsage, mmPowerUsage)}{units.MJ}</span></div>);
+  }
 
   let mDps = m.damage * (m.rpshot || 1) * (m.rof || 1) || 0;
   let mmDps = mm ? mm.getDps() || 0 : 0;
@@ -185,6 +181,20 @@ export function diffDetails(language, m, mm) {
     propDiffs.push(<div key='shields'>{translate('shields')}: <span className={sgDiffClass}>{diff(formats.int, newShield, shield)}{units.MJ}</span></div>);
   }
 
+  if (m.grp === 'mrp') {
+    let mProtection = m.protection;
+    let mmProtection = mm ? mm.getProtection() || 0 : 0;
+    if (mProtection != mmProtection) {
+      propDiffs.push(<div key='protection'>{translate('protection')}: <span className={diffClass(mmProtection, mProtection, true)}>{diff(formats.pct, mProtection, mmProtection)}</span></div>);
+    }
+
+    let mIntegrity = m.integrity;
+    let mmIntegrity = mm ? mm.getIntegrity() || 0 : 0;
+    if (mIntegrity != mmIntegrity) {
+      propDiffs.push(<div key='integrity'>{translate('integrity')}: <span className={diffClass(mmIntegrity, mIntegrity, true)}>{diff(formats.round, mIntegrity, mmIntegrity)}</span></div>);
+    }
+  }
+
   if (m.grp == 'pd') {
     propDiffs.push(<div key='wep'>
       {`${translate('WEP')}: `}
@@ -206,6 +216,16 @@ export function diffDetails(language, m, mm) {
     </div>);
   }
 
+  // Common items
+
+  let mCost = m.cost || 0;
+  let mmCost = mm ? mm.cost : 0;
+  if (mCost != mmCost) propDiffs.push(<div key='cost'>{translate('cost')}: <span className={diffClass(mCost, mmCost, true) }>{mCost ? Math.round(mCost * (1 - Persist.getModuleDiscount())) : 0}{units.CR}</span></div>);
+
+  let mMass = m.mass || 0;
+  let mmMass = mm ? mm.getMass() : 0;
+  if (mMass != mmMass) propDiffs.push(<div key='mass'>{translate('mass')}: <span className={diffClass(mMass, mmMass, true)}>{diff(formats.round, mMass, mmMass)}{units.T}</span></div>);
+
   let massDiff = mMass - mmMass;
   let mCap = m.fuel || m.cargo || 0;
   let mmCap = mm ? mm.fuel || mm.cargo || 0 : 0;

src/app/utils/UtilityFunctions.js

@@ -71,3 +71,15 @@ export function shallowEqual(objA, objB) {
 export function fromUrlSafe(data) {
   return data ? data.replace(/-/g, '/').replace(/_/g, '+') : null;
 }
+
+/**
+ * Check if an object is empty
+ * @param {object} obj the object
+ * @return {bool} true if the object is empty, otherwise false
+ */
+export function isEmpty(obj) {
+  for (let key in obj) {
+    if (obj.hasOwnProperty(key)) return false;
+  }
+  return true;
+};

src/images/logo/manifest.json

@@ -1,5 +1,5 @@
 {
-	"name": "Coriolis.io",
+	"name": "Coriolis EDCD Edition",
 	"short_name": "Coriolis",
 	"icons": [
 		{
@@ -27,7 +27,7 @@
 			"density": "4.0"
 		}
 	],
-	"start_url": "http:\/\/coriolis.io",
+	"start_url": "https:\/\/edcd.coriolis.io",
 	"display": "standalone",
 	"orientation": "portrait"
 }

src/index.html

@@ -22,24 +22,24 @@
     <meta name="msapplication-TileImage" content="/mstile-144x144.png">
     <meta name="msapplication-config" content="/browserconfig.xml">
     <meta name="theme-color" content="#000000">
-  </head>
-  <body style="background-color:#000;">
-    <section id="coriolis"></section>
+
     <script>
       window.CORIOLIS_GAPI_KEY = '{%= o.htmlWebpackPlugin.options.gapiKey %}';
       window.CORIOLIS_VERSION = '{%= o.htmlWebpackPlugin.options.version %}';
       window.CORIOLIS_DATE = '{%= new Date().toISOString().slice(0, 10)  %}';
     </script>
+    {% if (o.htmlWebpackPlugin.options.uaTracking) { %}
+    <script>
+      window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments)};ga.l=+new Date;
+      ga('create', '{%= o.htmlWebpackPlugin.options.uaTracking %}', 'auto');
+      ga('send', 'pageview');
+    </script>
+    <script async src='https://www.google-analytics.com/analytics.js'></script>
+    {% } %}
+  </head>
+  <body style="background-color:#000;">
+    <section id="coriolis"></section>
     <script src="{%= o.htmlWebpackPlugin.files.chunks.lib.entry %}" charset="utf-8" crossorigin="anonymous"></script>
     <script src="{%= o.htmlWebpackPlugin.files.chunks.app.entry %}" charset="utf-8" crossorigin="anonymous"></script>
-    <script>
-      {% if (o.htmlWebpackPlugin.options.uaTracking) { %}
-        (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
-        (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
-        m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
-        })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
-        ga('create', '{%= o.htmlWebpackPlugin.options.uaTracking %}', 'auto');
-      {% } %}
-    </script>
   </body>
 </html>

src/less/app.less

@@ -16,6 +16,7 @@
 @import 'tooltip';
 @import 'buttons';
 @import 'error';
+@import 'shipselector';
 @import 'sortable';
 @import 'loader';
 
@@ -41,8 +42,10 @@ div, a, li {
 #coriolis {
   width: 100%;
   height: 100%;
+  padding-top: 48px;
   overflow-y: scroll;
   -webkit-overflow-scrolling: touch;
+  box-sizing: border-box;
 }
 
 .page {

src/less/charts.less

@@ -35,7 +35,8 @@ svg {
     }
 
     text {
-      font-size: 0.8em;
+      font-size: 1.2em;
+      font-family: @fStandard;
       fill: @primary-disabled;
     }
 
@@ -55,7 +56,7 @@ svg {
   }
 
   .label {
-    font-size: 0.75em;
+    font-size: 1.1em;
   }
 
   .text-tip {

src/less/header.less

@@ -20,8 +20,12 @@ header {
   line-height: 3em;
   font-family: @fTitle;
   vertical-align: middle;
-  position: relative;
+  position: absolute;
+  top: 0px;
+  left: 0px;
+  width: 100%;
   z-index: 2;
+  box-sizing: border-box;
   .user-select-none();
 
   .menu {
@@ -186,6 +190,7 @@ header {
   }
 
   .no-wrap {
+    overflow-x: auto;
     white-space: nowrap;
   }
 
@@ -200,4 +205,4 @@ header {
     margin:0px;
     text-transform: uppercase;
   }
-}
+}

src/less/icons.less

@@ -34,8 +34,10 @@
   width: 1.1em;
   height: 1em;
   stoke: @fg;
+  stroke-width: 20;
   fill: transparent;
 
+
   &.sm {
     width: 0.8em;
     height: 0.75em;

src/less/select.less

@@ -55,10 +55,23 @@ select {
     background-color: @primary-disabled;
   }
 
+  .select-category {
+    white-space: nowrap;
+    line-height: 2em;
+    font-size: 1.2em;
+    text-align: center;
+    margin: 0.5em 0;
+    padding-left: 5px;
+    border-top: 3px solid @primary-disabled;
+    border-bottom: 3px solid @primary-disabled;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
   .select-group {
     white-space: nowrap;
     line-height: 1.5em;
-    text-align: left;
+    text-align: center;
     margin: 0.5em 0;
     padding-left: 5px;
     border-top: 1px solid @primary-disabled;
@@ -145,15 +158,6 @@ select {
       width: 4.5em;
       padding: 0.1em 0.2em;
     }
-    ul {
-      width: 17em;
-    }
-  }
-
-  &.standard {
-    ul {
-      width: 16.25em;
-    }
   }
 
 }

src/less/shipselector.less

@@ -0,0 +1,199 @@
+.shipselector {
+  background-color: @bgBlack;
+  margin: 0;
+  padding: 0 0 0 1em;
+  height: 3em;
+  line-height: 3em;
+  font-family: @fTitle;
+  vertical-align: middle;
+  position: relative;
+
+  .user-select-none();
+
+  .menu {
+    position: relative;
+    z-index: 1;
+    cursor: default;
+
+    &.r {
+      .menu-list {
+        right: 0;
+      }
+    }
+
+    .smallTablet({
+      position: static;
+      position: initial;
+    });
+  }
+
+  .menu-header {
+    padding : 0 1em;
+    cursor: pointer;
+    color: @warning;
+    text-transform: uppercase;
+  }
+
+  .menu-list {
+    font-family: @fStandard;
+    position: absolute;
+    padding: 0.5em 1em;
+    box-sizing: border-box;
+    min-width: 100%;
+    overflow-x: hidden;
+    background-color: @bgBlack;
+    font-size: 0.9em;
+    overflow-y: auto;
+    z-index: 0;
+    -webkit-overflow-scrolling: touch;
+    max-height: 500px;
+
+    &::-webkit-scrollbar {
+      width: 0.5em;
+    }
+
+    &::-webkit-scrollbar-track {
+      background-color: transparent;
+    }
+
+    &::-webkit-scrollbar-thumb {
+      background-color: @warning-disabled;
+    }
+
+    input {
+      border: none;
+      background-color: transparent;
+      text-align: right;
+      font-size: 1em;
+      font-family: @fStandard;
+    }
+
+    .smallTablet({
+      max-height: 400px;
+      left: 0;
+      right: 0;
+      border-bottom: 1px solid @bg;
+    });
+
+
+    .tablet({
+      li, a {
+        padding: 0.3em 0;
+      }
+    });
+  }
+
+  .dbl {
+    -webkit-column-count: 2; /* Chrome, Safari, Opera */
+    -moz-column-count: 2; /* Firefox */
+    column-count: 2;
+    ul {
+      min-width: 10em;
+    }
+
+    .smallTablet({
+      -webkit-column-count: 3; /* Chrome, Safari, Opera */
+      -moz-column-count: 3; /* Firefox */
+      column-count: 3;
+
+      ul {
+        min-width: 20em;
+      }
+    });
+
+    .largePhone({
+      -webkit-column-count: 2; /* Chrome, Safari, Opera */
+      -moz-column-count: 2; /* Firefox */
+      column-count: 2;
+    });
+
+    .smallPhone({
+      -webkit-column-count: 1; /* Chrome, Safari, Opera */
+      -moz-column-count: 1; /* Firefox */
+      column-count: 1;
+    });
+  }
+
+  .quad {
+    -webkit-column-count: 4; /* Chrome, Safari, Opera */
+    -moz-column-count: 4; /* Firefox */
+    column-count: 4;
+    ul {
+      min-width: 10em;
+    }
+
+    .smallTablet({
+      -webkit-column-count: 3; /* Chrome, Safari, Opera */
+      -moz-column-count: 3; /* Firefox */
+      column-count: 3;
+
+      ul {
+        min-width: 20em;
+      }
+    });
+
+    .largePhone({
+      -webkit-column-count: 2; /* Chrome, Safari, Opera */
+      -moz-column-count: 2; /* Firefox */
+      column-count: 2;
+    });
+
+    .smallPhone({
+      -webkit-column-count: 1; /* Chrome, Safari, Opera */
+      -moz-column-count: 1; /* Firefox */
+      column-count: 1;
+    });
+  }
+
+  ul {
+    display: inline-block;
+    white-space: nowrap;
+    margin: 0 0 0.5em;
+    padding: 0;
+    line-height: 1.3em;
+  }
+
+  li {
+    white-space: normal;
+    list-style: none;
+    margin-left: 1em;
+    line-height: 1.1em;
+  }
+
+  a {
+    vertical-align: middle;
+    color: @warning;
+    text-decoration: none;
+
+    &:visited {
+      color: @warning;
+    }
+    .no-touch &:hover {
+      color: teal;
+    }
+    &.active {
+      color: @primary;
+    }
+  }
+
+  hr {
+    border: none;
+    border-top: 1px solid @disabled;
+  }
+
+  .no-wrap {
+    white-space: nowrap;
+  }
+
+  .block {
+    display: block;
+    line-height: 1.5em;
+  }
+
+  .title {
+    font-size: 1.3em;
+    display: inline-block;
+    margin:0px;
+    text-transform: uppercase;
+  }
+}

src/schemas/ship-loadout/1.json

@@ -1,6 +1,6 @@
 {
   "$schema":            "http://json-schema.org/draft-04/schema#",
-  "id":                 "http://cdn.coriolis.io/schemas/ship-loadout/1.json#",
+  "id":                 "https://coriolis.edcd.io/schemas/ship-loadout/1.json#",
   "title":              "Ship Loadout",
   "type":               "object",
   "description":        "The details for a specific ship build/loadout. DEPRECATED in favor of Version 3",
@@ -278,4 +278,4 @@
     "standardRatings":  { "enum": ["A", "B", "C", "D", "E"] },
     "allRatings":       { "enum": ["A", "B", "C", "D", "E", "F", "I" ] }
   }
-}
+}

src/schemas/ship-loadout/2.json

@@ -1,6 +1,6 @@
 {
   "$schema":            "http://json-schema.org/draft-04/schema#",
-  "id":                 "http://cdn.coriolis.io/schemas/ship-loadout/2.json#",
+  "id":                 "https://coriolis.edcd.io/schemas/ship-loadout/2.json#",
   "title":              "Ship Loadout",
   "type":               "object",
   "description":        "The details for a specific ship build/loadout. DEPRECATED in favor of Version 3",

src/schemas/ship-loadout/3.json

@@ -1,6 +1,6 @@
 {
   "$schema":            "http://json-schema.org/draft-04/schema#",
-  "id":                 "http://cdn.coriolis.io/schemas/ship-loadout/3.json#",
+  "id":                 "https://coriolis.edcd.io/schemas/ship-loadout/3.json#",
   "title":              "Ship Loadout",
   "type":               "object",
   "description":        "The details for a specific ship build/loadout",

src/schemas/ship-loadout/4.json

@@ -1,6 +1,6 @@
 {
   "$schema":            "http://json-schema.org/draft-04/schema#",
-  "id":                 "http://cdn.coriolis.io/schemas/ship-loadout/4.json#",
+  "id":                 "https://coriolis.edcd.io/schemas/ship-loadout/4.json#",
   "title":              "Ship Loadout",
   "type":               "object",
   "description":        "The details for a specific ship build/loadout",
@@ -68,6 +68,7 @@
                 "rating": { "$ref": "#/definitions/standardRatings" },
                 "enabled": { "type": "boolean" },
                 "priority": { "type": "integer", "minimum": 1, "maximum": 5 },
+                "blueprint": { "type": "object" },
                 "modifications": { "type": "object" }
               }
             },
@@ -82,6 +83,7 @@
                   "description": "The name identifing the thrusters (if applicable), e.g. 'Enhanced Performance'",
                   "type": "string"
                 },
+                "blueprint": { "type": "object" },
                 "modifications": { "type": "object" }
               }
             },
@@ -92,6 +94,7 @@
                 "rating": { "$ref": "#/definitions/standardRatings" },
                 "enabled": { "type": "boolean" },
                 "priority": { "type": "integer", "minimum": 1, "maximum": 5 },
+                "blueprint": { "type": "object" },
                 "modifications": { "type": "object" }
               }
             },
@@ -102,6 +105,7 @@
                 "rating": { "$ref": "#/definitions/standardRatings" },
                 "enabled": { "type": "boolean" },
                 "priority": { "type": "integer", "minimum": 1, "maximum": 5 },
+                "blueprint": { "type": "object" },
                 "modifications": { "type": "object" }
               }
             },
@@ -112,6 +116,7 @@
                 "rating": { "$ref": "#/definitions/standardRatings" },
                 "enabled": { "type": "boolean" },
                 "priority": { "type": "integer", "minimum": 1, "maximum": 5 },
+                "blueprint": { "type": "object" },
                 "modifications": { "type": "object" }
               }
             },
@@ -122,6 +127,7 @@
                 "rating": { "$ref": "#/definitions/standardRatings" },
                 "enabled": { "type": "boolean" },
                 "priority": { "type": "integer", "minimum": 1, "maximum": 5 },
+                "blueprint": { "type": "object" },
                 "modifications": { "type": "object" }
               }
             },
@@ -132,6 +138,7 @@
                 "rating": { "$ref": "#/definitions/standardRatings" },
                 "enabled": { "type": "boolean" },
                 "priority": { "type": "integer", "minimum": 1, "maximum": 5 },
+                "blueprint": { "type": "object" },
                 "modifications": { "type": "object" }
               }
             }
@@ -155,6 +162,7 @@
                 "description": "The name identifying the component (if applicable), e.g. 'Advance Discovery Scanner', or 'Detailed Surface Scanner'",
                 "type": "string"
               },
+              "blueprint": { "type": "object" },
               "modifications": { "type": "object" }
             }
           },
@@ -179,6 +187,7 @@
                 "description": "The name identifing the component (if applicable), e.g. 'Retributor', or 'Mining Lance'",
                 "type": "string"
               },
+              "blueprint": { "type": "object" },
               "modifications": { "type": "object" }
             }
           },
@@ -202,6 +211,7 @@
                 "description": "The name identifing the component (if applicable), e.g. 'Point Defence', or 'Electronic Countermeasure'",
                 "type": "string"
               },
+              "blueprint": { "type": "object" },
               "modifications": { "type": "object" }
             }
           },

webpack.config.prod.js

@@ -7,7 +7,7 @@ var ExtractTextPlugin = require("extract-text-webpack-plugin");
 var AppCachePlugin = require('appcache-webpack-plugin');
 
 var node_modules_dir = path.resolve(__dirname, 'node_modules');
-var d3Path = path.resolve(node_modules_dir, 'd3/d3.min.js');
+var d3Path = path.resolve(__dirname, 'd3.min.js');
 var reactPath = path.resolve(node_modules_dir, 'react/dist/react.min.js');
 var reactDomPath = path.resolve(node_modules_dir, 'react-dom/dist/react-dom.min.js');
 var lzStringPath = path.resolve(node_modules_dir, 'lz-string/libs/lz-string.min.js');