Merge branch 'release/2.5.3'

use a smaller shield, add boosters, d rate some internals

.editorconfig

@@ -0,0 +1,21 @@
+root = true
+
+
+[*]
+
+# change these settings to your own preference
+indent_style = space
+indent_size = 4
+
+# we recommend you to keep these unchanged
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[{package,bower}.json]
+indent_style = space
+indent_size = 2

devServer.js

@@ -5,6 +5,7 @@ var config = require('./webpack.config.dev');
 new WebpackDevServer(webpack(config), {
   publicPath: config.output.publicPath,
   hot: true,
+  disableHostCheck: true,
   headers: { "Access-Control-Allow-Origin": "*" },
   historyApiFallback: {
     rewrites: [

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "coriolis_shipyard",
-  "version": "2.5.0",
+  "version": "2.5.2",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
@@ -11961,6 +11961,17 @@
         }
       }
     },
+    "webpack-notifier": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/webpack-notifier/-/webpack-notifier-1.6.0.tgz",
+      "integrity": "sha1-/6yOVf+MRpdSuMG7sBGhbxCYbgI=",
+      "dev": true,
+      "requires": {
+        "node-notifier": "5.1.2",
+        "object-assign": "4.1.1",
+        "strip-ansi": "3.0.1"
+      }
+    },
     "webpack-sources": {
       "version": "0.1.5",
       "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-0.1.5.tgz",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "coriolis_shipyard",
-  "version": "2.5.1",
+  "version": "2.5.3",
   "repository": {
     "type": "git",
     "url": "https://github.com/EDCD/coriolis"
@@ -87,10 +87,11 @@
     "rollup": "0.41",
     "rollup-plugin-node-resolve": "3",
     "style-loader": "^0.16.1",
+    "uglify-js": "^2.4.11",
     "url-loader": "^0.5.8",
     "webpack": "^2.4.1",
     "webpack-dev-server": "^2.4.4",
-    "uglify-js": "^2.4.11"
+    "webpack-notifier": "^1.6.0"
   },
   "dependencies": {
     "babel-polyfill": "*",

src/app/Coriolis.jsx

@@ -12,6 +12,7 @@ import ModalHelp from './components/ModalHelp';
 import ModalImport from './components/ModalImport';
 import ModalPermalink from './components/ModalPermalink';
 import * as CompanionApiUtils from './utils/CompanionApiUtils';
+import * as JournalUtils from './utils/JournalUtils';
 
 import AboutPage from './pages/AboutPage';
 import NotFoundPage from './pages/NotFoundPage';
@@ -92,7 +93,14 @@ export default class Coriolis extends React.Component {
       // Need to decode and gunzip the data, then build the ship
       const data = zlib.inflate(new Buffer(r.params.data, 'base64'), { to: 'string' });
       const json = JSON.parse(data);
-      const ship = CompanionApiUtils.shipFromJson(json);
+      console.log('Ship import data: ');
+      console.log(json);
+      let ship;
+      if (json && json.modules) {
+        ship = CompanionApiUtils.shipFromJson(json);
+      } else if (json && json.Modules) {
+        ship = JournalUtils.shipFromLoadoutJSON(json);
+      }
       r.params.ship = ship.id;
       r.params.code = ship.toString();
       this._setPage(OutfittingPage, r);

src/app/components/ShipSummaryTable.jsx

@@ -53,6 +53,7 @@ export default class ShipSummaryTable extends TranslatedComponent {
             <th rowSpan={2}>{translate('TTD')}</th>
             {/* <th onMouseEnter={termtip.bind(null, 'heat per second')} onMouseLeave={hide} rowSpan={2}>{translate('HPS')}</th> */}
             <th rowSpan={2}>{translate('cargo')}</th>
+            <th rowSpan={2}>{translate('passengers')}</th>
             <th rowSpan={2}>{translate('fuel')}</th>
             <th colSpan={3}>{translate('mass')}</th>
             <th onMouseEnter={termtip.bind(null, 'hull hardness', { cap: 0 })} onMouseLeave={hide} rowSpan={2}>{translate('hrd')}</th>
@@ -86,6 +87,7 @@ export default class ShipSummaryTable extends TranslatedComponent {
             <td onMouseEnter={termtip.bind(null, 'TT_SUMMARY_TTD', { cap: 0 })} onMouseLeave={hide}>{timeToDrain === Infinity ? '∞' : time(timeToDrain)}</td>
             {/* <td>{f1(ship.totalHps)}</td> */}
             <td>{round(ship.cargoCapacity)}{u.T}</td>
+            <td>{ship.passengerCapacity}</td>
             <td>{round(ship.fuelCapacity)}{u.T}</td>
             <td onMouseEnter={termtip.bind(null, 'TT_SUMMARY_HULL_MASS', { cap: 0 })} onMouseLeave={hide}>{ship.hullMass}{u.T}</td>
             <td onMouseEnter={termtip.bind(null, 'TT_SUMMARY_UNLADEN_MASS', { cap: 0 })} onMouseLeave={hide}>{int(ship.unladenMass)}{u.T}</td>

src/app/components/StandardSlot.jsx

@@ -96,7 +96,7 @@ export default class StandardSlot extends TranslatedComponent {
     return (
       <div className={cn('slot', { selected: this.props.selected })} onClick={this.props.onOpen} onContextMenu={stopCtxPropagation}>
         <div className={cn('details-container', { warning: warning && warning(slot.m), disabled: m.grp !== 'bh' && !slot.enabled })}>
-          <div className={'sz'}>{slot.maxClass}</div>
+          <div className={'sz'}>{m.grp == 'bh' ? m.name.charAt(0) : 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, modTT)} onMouseOut={tooltip.bind(null, null)}><Modified /></span> : null }</div>
             <div className={'r'}>{formats.round(mass)}{units.T}</div>

src/app/components/StandardSlotSection.jsx

@@ -235,12 +235,10 @@ export default class StandardSlotSection extends SlotSection {
       <ul>
         <li className='lc' onClick={this._multiPurpose.bind(this, false, 0)}>{translate('Multi-purpose')}</li>
         <li className='lc' onClick={this._multiPurpose.bind(this, true, 2)}>{translate('Combat')}</li>
-        <li className='lc' onClick={this._optimizeCargo.bind(this, false)}>{translate('Trader')}</li>
-        <li className='lc' onClick={this._optimizeCargo.bind(this, true)}>{translate('Shielded Trader')}</li>
+        <li className='lc' onClick={this._optimizeCargo.bind(this, true)}>{translate('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>
+        <li className='lc' onClick={this._optimizeMiner.bind(this, true)}>{translate('Miner')}</li>
         <li className='lc' onClick={this._optimizeRacer.bind(this)}>{translate('Racer')}</li>
       </ul>
     </div>;

src/app/i18n/Language.jsx

@@ -6,6 +6,7 @@ import * as FR from './fr';
 import * as IT from './it';
 import * as RU from './ru';
 import * as PL from './pl';
+import * as PT from './pt';
 import * as d3 from 'd3';
 
 let fallbackTerms = EN.terms;
@@ -25,6 +26,7 @@ export function getLanguage(langCode) {
     case 'it': lang = IT; break;
     case 'ru': lang = RU; break;
     case 'pl': lang = PL; break;
+    case 'pt': lang = PT; break;
     default:
       lang = EN;
   }
@@ -88,5 +90,6 @@ export const Languages = {
   es: 'Español',
   fr: 'Français',
   ru: 'ру́сский',
-  pl: 'polski'
+  pl: 'polski',
+  pt: 'português'
 };

src/app/i18n/pt.js

@@ -0,0 +1,16 @@
+export const formats = {
+  decimal: ',',
+  thousands: '.',
+  grouping: [3],
+  currency: ['', ' €'],
+  dateTime: '%A, %e de %B de %Y, %X',
+  date: '%d/%m/%Y',
+  time: '%H:%M:%S',
+  periods: ['AM', 'PM'],
+  days: ['domingo', 'lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado'],
+  shortDays: ['dom', 'lun', 'mar', 'mié', 'jue', 'vie', 'sáb'],
+  months: ['enero', 'febrero', 'marzo', 'abril', 'mayo', 'junio', 'julio', 'agosto', 'septiembre', 'octubre', 'noviembre', 'diciembre'],
+  shortMonths: ['ene', 'feb', 'mar', 'abr', 'may', 'jun', 'jul', 'ago', 'sep', 'oct', 'nov', 'dic']
+};
+
+export { default as terms } from './pt.json';

src/app/pages/OutfittingPage.jsx

@@ -73,13 +73,10 @@ export default class OutfittingPage extends Page {
     let buildName = params.bn;
     let data = Ships[shipId];   // Retrieve the basic ship properties, slots and defaults
     let savedCode = Persist.getBuild(shipId, buildName);
-
     if (!data) {
       return { error: { message: 'Ship not found: ' + shipId } };
     }
-
     let ship = new Ship(shipId, data.properties, data.slots);          // Create a new Ship instance
-
     if (code) {
       ship.buildFrom(code);  // Populate modules from serialized 'code' URL param
     } else {

src/app/pages/ShipyardPage.jsx

@@ -42,7 +42,7 @@ function countInt(slot) {
     passSlotType = 'pcq';
     passSlotRating = 'B';
   }
-  let passengerBay = passSlotType ? ModuleUtils.findInternal(passSlotType, slot.maxClass, passSlotRating) : null;
+  let passengerBay = passSlotType ? ModuleUtils.findMaxInternal(passSlotType, slot.maxClass, passSlotRating) : null;
   this.maxPassengers += passengerBay ? passengerBay.passengers : 0;
 }
 
@@ -194,6 +194,7 @@ export default class ShipyardPage extends Page {
       <td className='cn'>{s.standard[3]}</td>
       <td className='cn'>{s.standard[4]}</td>
       <td className='cn'>{s.standard[5]}</td>
+      <td className='cn'>{s.standard[6]}</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>
@@ -329,7 +330,7 @@ export default class ShipyardPage extends Page {
                 <th>&nbsp;</th>
                 <th colSpan={4}>{translate('base')}</th>
                 <th colSpan={5}>{translate('max')}</th>
-                <th className='lft' colSpan={6}></th>
+                <th className='lft' colSpan={7}></th>
                 <th className='lft' colSpan={5}></th>
                 <th className='lft' colSpan={8}></th>
               </tr>
@@ -347,7 +348,7 @@ export default class ShipyardPage extends Page {
                 <th className='sortable' onClick={sortShips('maxCargo')}>{translate('cargo')}</th>
                 <th className='sortable' onClick={sortShips('maxPassengers')}>{translate('passengers')}</th>
 
-                <th className='lft' colSpan={6}>{translate('core module classes')}</th>
+                <th className='lft' colSpan={7}>{translate('core module classes')}</th>
                 <th colSpan={5} className='sortable lft' onClick={sortShips('hpCount')}>{translate('hardpoints')}</th>
                 <th colSpan={8} className='sortable lft' onClick={sortShips('intCount')}>{translate('internal compartments')}</th>
               </tr>
@@ -369,7 +370,7 @@ export default class ShipyardPage extends Page {
                 <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' onMouseEnter={termtip.bind(null, 'fuel tank')} onMouseLeave={hide} onClick={sortShips('standard', 6)}>{'ft'}</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>
@@ -395,4 +396,4 @@ export default class ShipyardPage extends Page {
       </div>
     );
   }
-}
+}

src/app/shipyard/ModuleUtils.js

@@ -63,7 +63,6 @@ export function standard(type, id) {
   if (!isNaN(type)) {
     type = StandardArray[type];
   }
-
   let s = Modules.standard[type].find(e => e.id == id || (e.class == id.charAt(0) && e.rating == id.charAt(1)));
   if (s) {
     s = new Module({ template: s });
@@ -196,6 +195,29 @@ export function findInternal(groupName, clss, rating, name) {
   return null;
 }
 
+/**
+ * Finds an internal module based on Class, Rating, Group and/or name.
+ * At least one of Group name or unique module name must be provided.
+ * will start searching at specified class and proceed lower until a
+ * module is found or 0 is hit
+ * Uses findInternal internally
+ *
+ * @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 findMaxInternal(groupName, clss, rating, name) {
+  let foundModule = null;
+  let currentClss = clss;
+  while (currentClss > 0 && foundModule == null) {
+    foundModule = findInternal(groupName, currentClss, rating, name);
+    currentClss = currentClss - 1;
+  }
+  return foundModule;
+}
+
 /**
  * Finds an internal Module ID based on Class, Rating, Group and/or name.
  * At least one ofGroup name or unique module name must be provided

src/app/shipyard/Ship.js

@@ -569,6 +569,7 @@ export default class Ship {
     // Reset Cumulative stats
     this.fuelCapacity = 0;
     this.cargoCapacity = 0;
+    this.passengerCapacity = 0;
     this.ladenMass = 0;
     this.armour = this.baseArmour;
     this.shield = this.baseShieldStrength;
@@ -616,7 +617,7 @@ export default class Ship {
       standard[i].cat = 0;
       standard[i].priority = priorities && priorities[i + 1] ? priorities[i + 1] * 1 : 0;
       standard[i].type = 'SYS';
-      standard[i].m = null; // Resetting 'old' modul if there was one
+      standard[i].m = null; // Resetting 'old' module if there was one
       standard[i].discountedCost = 0;
       if (comps) {
         let module = ModuleUtils.standard(i, comps.standard[i]);
@@ -1188,6 +1189,7 @@ export default class Ship {
     let unladenMass = this.hullMass;
     let cargoCapacity = 0;
     let fuelCapacity = 0;
+    let passengerCapacity = 0;
 
     unladenMass += this.bulkheads.m.getMass();
 
@@ -1209,6 +1211,8 @@ export default class Ship {
           fuelCapacity += slot.m.fuel;
         } else if (slot.m.grp === 'cr') {
           cargoCapacity += slot.m.cargo;
+        } else if (slot.m.grp.slice(0,2) === 'pc') {
+          passengerCapacity += slot.m.passengers
         }
       }
     }
@@ -1224,6 +1228,7 @@ export default class Ship {
     this.unladenMass = unladenMass;
     this.cargoCapacity = cargoCapacity;
     this.fuelCapacity = fuelCapacity;
+    this.passengerCapacity = passengerCapacity;
     this.ladenMass = unladenMass + fuelCapacity + cargoCapacity;
 
     return this;

src/app/shipyard/ShipRoles.js

@@ -1,5 +1,5 @@
-import * as ModuleUtils from './ModuleUtils';
-import { canMount } from '../utils/SlotFunctions';
+import * as ModuleUtils from './ModuleUtils'
+import { canMount } from '../utils/SlotFunctions'
 
 /**
  * Standard / typical role for multi-purpose or combat (if shielded with better bulkheads)
@@ -7,20 +7,20 @@ import { canMount } from '../utils/SlotFunctions';
  * @param {Boolean} shielded      True if shield generator should be included
  * @param {integer} bulkheadIndex Bulkhead to use see Constants.BulkheadNames
  */
-export function multiPurpose(ship, shielded, bulkheadIndex) {
+export function multiPurpose (ship, shielded, bulkheadIndex) {
   ship.useStandard('A')
-      .use(ship.standard[3], ModuleUtils.standard(3, ship.standard[3].maxClass + 'D'))  // D Life Support
-      .use(ship.standard[5], ModuleUtils.standard(5, ship.standard[5].maxClass + 'D'))  // D Sensors
-      .useBulkhead(bulkheadIndex);
+    .use(ship.standard[3], ModuleUtils.standard(3, ship.standard[3].maxClass + 'D'))  // D Life Support
+    .use(ship.standard[5], ModuleUtils.standard(5, ship.standard[5].maxClass + 'D'))  // D Sensors
+    .useBulkhead(bulkheadIndex)
 
   if (shielded) {
-    ship.internal.some(function(slot) {
+    ship.internal.some(function (slot) {
       if (canMount(ship, slot, 'sg')) { // Assuming largest slot can hold an eligible shield
-        ship.use(slot, ModuleUtils.findInternal('sg', slot.maxClass, 'A'));
-        ship.setSlotEnabled(slot, true);
-        return true;
+        ship.use(slot, ModuleUtils.findInternal('sg', slot.maxClass, 'A'))
+        ship.setSlotEnabled(slot, true)
+        return true
       }
-    });
+    })
   }
 }
 
@@ -30,40 +30,55 @@ export function multiPurpose(ship, shielded, bulkheadIndex) {
  * @param  {Boolean} shielded     True if shield generator should be included
  * @param  {Object} standardOpts  [Optional] Standard module optional overrides
  */
-export function trader(ship, shielded, standardOpts) {
-  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;
+export function trader (ship, shielded, standardOpts) {
+  let usedSlots = []
+  let bstCount = 2
+  let sg = ship.getAvailableModules().lightestShieldGenerator(ship.hullMass)
+  ship.useStandard('A')
+    .use(ship.standard[3], ModuleUtils.standard(3, ship.standard[3].maxClass + 'D'))  // D Life Support
+    .use(ship.standard[1], ModuleUtils.standard(1, ship.standard[1].maxClass + 'D'))  // D Life Support
+    .use(ship.standard[4], ModuleUtils.standard(4, ship.standard[4].maxClass + 'D'))  // D Life Support
+    .use(ship.standard[5], ModuleUtils.standard(5, ship.standard[5].maxClass + 'D'))  // D Sensors
+
+  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))
+  shieldInternals.some(function (slot) {
+    if (canMount(ship, slot, 'sg')) { // Assuming largest slot can hold an eligible shield
+      const shield = ModuleUtils.findInternal('sg', slot.maxClass, 'A')
+      if (shield && shield.maxmass > ship.hullMass) {
+        console.log(shield)
+        ship.use(slot, shield)
+        ship.setSlotEnabled(slot, true)
+        usedSlots.push(slot)
+        return true
       }
     }
-  }
+  })
 
   // Fill the empty internals with cargo racks
   for (let i = ship.internal.length; i--;) {
-    let slot = ship.internal[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.use(slot, ModuleUtils.findInternal('cr', slot.maxClass, 'E'))
     }
   }
 
   // Empty the hardpoints
   for (let s of ship.hardpoints) {
-    ship.use(s, null);
+    ship.use(s, null)
   }
-
-  ship.useLightestStandard(standardOpts);
+  for (let s of ship.hardpoints) {
+    if (s.maxClass == 0 && bstCount) {       // Mount up to 2 boosters
+      ship.use(s, ModuleUtils.hardpoints('04'))
+      bstCount--
+    } else {
+      ship.use(s, null)
+    }
+  }
+  // ship.useLightestStandard(standardOpts);
 }
 
 /**
@@ -71,127 +86,127 @@ export function trader(ship, shielded, standardOpts) {
  * @param  {Ship} ship         Ship instance
  * @param  {Boolean} planetary True if Planetary Vehicle Hangar (PVH) should be included
  */
-export function explorer(ship, planetary) {
-  let standardOpts = { ppRating: 'A' },
-      heatSinkCount = 2,  // Fit 2 heat sinks if possible
-      usedSlots = [],
-      sgSlot,
-      fuelScoopSlot,
-      sg = ship.getAvailableModules().lightestShieldGenerator(ship.hullMass);
+export function explorer (ship, planetary) {
+  let standardOpts = {ppRating: 'A'},
+    heatSinkCount = 2,  // Fit 2 heat sinks if possible
+    usedSlots = [],
+    sgSlot,
+    fuelScoopSlot,
+    sg = ship.getAvailableModules().lightestShieldGenerator(ship.hullMass)
 
   if (!planetary) { // Non-planetary explorers don't really need to boost
-    standardOpts.pd = '1D';
+    standardOpts.pd = '1D'
   }
 
   // Cargo hatch can be disabled
-  ship.setSlotEnabled(ship.cargoHatch, false);
+  ship.setSlotEnabled(ship.cargoHatch, false)
 
   // Advanced Discovery Scanner - class 1 or higher
-  const adsOrder = [1, 2, 3, 4, 5, 6, 7, 8];
+  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));
+    .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;
+      ship.use(adsInternals[i], ModuleUtils.internal('2f'))
+      usedSlots.push(adsInternals[i])
+      break
     }
   }
 
   if (planetary) {
     // Planetary Vehicle Hangar - class 2 or higher
-    const pvhOrder = [2, 3, 4, 5, 6, 7, 8, 1];
+    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));
+      .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;
+        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 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));
+    .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;
+      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 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));
+    .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;
+      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 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));
+    .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;
+      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 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));
+    .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
+      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
     }
   }
 
   for (let s of ship.hardpoints) {
     if (s.maxClass == 0 && heatSinkCount) {       // Mount up to 2 heatsinks
-      ship.use(s, ModuleUtils.hardpoints('02'));
-      ship.setSlotEnabled(s, heatSinkCount == 2); // Only enable a single Heatsink
-      heatSinkCount--;
+      ship.use(s, ModuleUtils.hardpoints('02'))
+      ship.setSlotEnabled(s, heatSinkCount == 2) // Only enable a single Heatsink
+      heatSinkCount--
     } else {
-      ship.use(s, null);
+      ship.use(s, null)
     }
   }
 
   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);
+      ship.setSlotEnabled(fuelScoopSlot, false)
     } else {                                    // The Fuel scoop uses the most power
-      ship.setSlotEnabled(sgSlot, false);
+      ship.setSlotEnabled(sgSlot, false)
     }
   }
 
-  ship.useLightestStandard(standardOpts);
+  ship.useLightestStandard(standardOpts)
 }
 
 /**
@@ -199,187 +214,188 @@ export function explorer(ship, planetary) {
  * @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);
+export function miner (ship, shielded) {
+  shielded = true
+  let standardOpts = {ppRating: 'A'},
+    miningLaserCount = 2,
+    usedSlots = [],
+    sg = ship.getAvailableModules().lightestShieldGenerator(ship.hullMass)
 
   // Cargo hatch should be enabled
-  ship.setSlotEnabled(ship.cargoHatch, true);
+  ship.setSlotEnabled(ship.cargoHatch, true)
 
   // Largest possible refinery
-  const refineryOrder = [4, 5, 6, 7, 8, 3, 2, 1];
+  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));
+    .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', Math.min(refineryInternals[i].maxClass, 4), 'A'));
-      usedSlots.push(refineryInternals[i]);
-      break;
+      ship.use(refineryInternals[i], ModuleUtils.findInternal('rf', Math.min(refineryInternals[i].maxClass, 4), 'A'))
+      usedSlots.push(refineryInternals[i])
+      break
     }
   }
 
   // Prospector limpet controller - 3A if possible
-  const prospectorOrder = [3, 4, 5, 6, 7, 8, 2, 1];
+  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));
+    .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;
+      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 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));
+      .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;
+        ship.use(shieldInternals[i], sg)
+        usedSlots.push(shieldInternals[i])
+        break
       }
     }
   }
 
   // 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);
-  });
+  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--;
+      ship.use(s, ModuleUtils.hardpoints(s.maxClass >= 2 ? '2m' : '2l'))
+      miningLaserCount--
     } else {
-      ship.use(s, null);
+      ship.use(s, null)
     }
   }
 
   // Number of collector limpets required to be active is a function of the size of the ship and the power of the lasers
   const miningLaserDps = ship.hardpoints.filter(h => h.m != null)
-                                        .reduce(function(a, b) {
-                                          return a + b.m.getDps();
-                                        }, 0);
+    .reduce(function (a, b) {
+      return a + b.m.getDps()
+    }, 0)
   // Find out how many internal slots we have, and their potential cargo size
   const potentialCargo = ship.internal.filter(a => usedSlots.indexOf(a) == -1)
-                                      .filter(a => (!a.eligible) || a.eligible.cr)
-                                      .map(b => Math.pow(2, b.maxClass));
+    .filter(a => (!a.eligible) || a.eligible.cr)
+    .map(b => Math.pow(2, b.maxClass))
   // One collector for each 1.25 DPS, multiply by 1.25 for medium ships and 1.5 for large ships as they have further to travel
   // 0 if we only have 1 cargo slot, otherwise minium of 1 and maximum of 6 (excluding size modifier)
-  const sizeModifier = ship.class == 2 ? 1.2 : ship.class == 3 ? 1.5 : 1;
-  let collectorLimpetsRequired = potentialCargo.length == 1 ? 0 : Math.ceil(sizeModifier * Math.min(6, Math.floor(miningLaserDps / 1.25)));
-  
+  const sizeModifier = ship.class == 2 ? 1.2 : ship.class == 3 ? 1.5 : 1
+  let collectorLimpetsRequired = potentialCargo.length == 1 ? 0 : Math.ceil(sizeModifier * Math.min(6, Math.floor(miningLaserDps / 1.25)))
+
   if (collectorLimpetsRequired > 0) {
-    const collectorOrder = [1, 2, 3, 4, 5, 6, 7, 8];
+    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));
+      .filter(a => (!a.eligible) || a.eligible.cc)
+      .sort((a, b) => collectorOrder.indexOf(a.maxClass) - collectorOrder.indexOf(b.maxClass))
     // Always keep at least 2 slots free for cargo racks (1 for shielded)
     for (let i = 0; i < collectorInternals.length - (shielded ? 1 : 2) && 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, 'D'));
-        usedSlots.push(collectorInternals[i]);
-        collectorLimpetsRequired -= collectorInternals[i].m.maximum;
+        const collectorClass = collectorInternals[i].maxClass % 2 === 0 ? collectorInternals[i].maxClass - 1 : collectorInternals[i].maxClass
+        ship.use(collectorInternals[i], ModuleUtils.findInternal('cc', collectorClass, 'D'))
+        usedSlots.push(collectorInternals[i])
+        collectorLimpetsRequired -= collectorInternals[i].m.maximum
       }
     }
   }
 
   // Power distributor to power the mining lasers indefinitely
   const wepRateRequired = ship.hardpoints.filter(h => h.m != null)
-                                          .reduce(function(a, b) {
-                                            return a + b.m.getEps();
-                                          }, 0);
-  standardOpts.pd = ship.getAvailableModules().matchingPowerDist({ weprate: wepRateRequired }).id;
+    .reduce(function (a, b) {
+      return a + b.m.getEps()
+    }, 0)
+  standardOpts.pd = ship.getAvailableModules().matchingPowerDist({weprate: wepRateRequired}).id
 
   // Fill the empty internals with cargo racks
   for (let i = ship.internal.length; i--;) {
-    let slot = ship.internal[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.use(slot, ModuleUtils.findInternal('cr', slot.maxClass, 'E'))
     }
   }
 
-  ship.useLightestStandard(standardOpts);
+  ship.useLightestStandard(standardOpts)
 }
 
 /**
  * Racer Role
  * @param  {Ship} ship         Ship instance
  */
-export function racer(ship) {
+export function racer (ship) {
   let standardOpts = {},
-      usedSlots = [],
-      sgSlot,
-      sg = ship.getAvailableModules().lightestShieldGenerator(ship.hullMass);
+    usedSlots = [],
+    sgSlot,
+    sg = ship.getAvailableModules().lightestShieldGenerator(ship.hullMass)
 
   // Cargo hatch can be disabled
-  ship.setSlotEnabled(ship.cargoHatch, false);
+  ship.setSlotEnabled(ship.cargoHatch, false)
 
   // Shield generator
-  const shieldOrder = [1, 2, 3, 4, 5, 6, 7, 8];
+  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));
+    .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;
+      ship.use(shieldInternals[i], sg)
+      usedSlots.push(shieldInternals[i])
+      sgSlot = shieldInternals[i]
+      break
     }
   }
 
   // Empty the hardpoints
   for (let s of ship.hardpoints) {
-    ship.use(s, null);
+    ship.use(s, null)
   }
 
   // Empty the internals
   for (let i = ship.internal.length; i--;) {
-    let slot = ship.internal[i];
+    let slot = ship.internal[i]
     if (usedSlots.indexOf(slot) == -1) {
-      ship.use(slot, null);
+      ship.use(slot, null)
     }
   }
 
   // Best thrusters
   if (ship.standard[1].maxClass === 3) {
-    standardOpts.th = 'tz';
+    standardOpts.th = 'tz'
   } else if (ship.standard[1].maxClass === 2) {
-    standardOpts.th = 'u0';
+    standardOpts.th = 'u0'
   } else {
-    standardOpts.th = ship.standard[1].maxClass + 'A';
+    standardOpts.th = ship.standard[1].maxClass + 'A'
   }
 
   // Best power distributor for more boosting
-  standardOpts.pd = ship.standard[4].maxClass + 'A';
+  standardOpts.pd = ship.standard[4].maxClass + 'A'
 
   // Smallest possible FSD drive
-  standardOpts.fsd = '2D';
+  standardOpts.fsd = '2D'
   // Minimal fuel tank
-  standardOpts.ft = '1C';
+  standardOpts.ft = '1C'
 
   // Disable nearly everything
-  standardOpts.fsdDisabled = true;
-  standardOpts.sDisabled = true;
-  standardOpts.pdDisabled = true;
-  standardOpts.lsDisabled = true;
+  standardOpts.fsdDisabled = true
+  standardOpts.sDisabled = true
+  standardOpts.pdDisabled = true
+  standardOpts.lsDisabled = true
 
-  ship.useLightestStandard(standardOpts);
+  ship.useLightestStandard(standardOpts)
 
   // Apply engineering to each module
   // ship.standard[1].m.blueprint = getBlueprint('Engine_Dirty', ship.standard[0]);

src/app/utils/CompanionApiUtils.js

@@ -43,7 +43,7 @@ const SHIP_FD_NAME_TO_CORIOLIS_NAME = {
 };
 
 // Mapping from hardpoint class to name in companion API
-const HARDPOINT_NUM_TO_CLASS = {
+export const HARDPOINT_NUM_TO_CLASS = {
   0: 'Tiny',
   1: 'Small',
   2: 'Medium',
@@ -115,7 +115,7 @@ function _shipModelFromEDName(edName) {
  * @return {string} the Coriolis model of the ship
  */
 export function shipModelFromJson(json) {
-  return _shipModelFromEDName(json.name);
+  return _shipModelFromEDName(json.name || json.Ship);
 }
 
 /**
@@ -145,7 +145,7 @@ export function shipFromJson(json) {
   }
 
   let rootModule;
-  
+
   // Add the bulkheads
   const armourJson = json.modules.Armour.module;
   if (armourJson.name.endsWith('_Armour_Grade1')) {

src/app/utils/JournalUtils.js

@@ -0,0 +1,221 @@
+import Ship from '../shipyard/Ship'
+import { HARDPOINT_NUM_TO_CLASS, shipModelFromJson } from './CompanionApiUtils'
+import { Ships } from 'coriolis-data/dist'
+import Module from '../shipyard/Module'
+import { Modules } from 'coriolis-data/dist'
+
+/**
+ * Obtain a module given its FD Name
+ * @param {string} fdname the FD Name of the module
+ * @return {Module} the module
+ */
+function _moduleFromFdName(fdname) {
+  if (!fdname) return null;
+  fdname = fdname.toLowerCase();
+  // Check standard modules
+  for (const grp in Modules.standard) {
+    if (Modules.standard.hasOwnProperty(grp)) {
+      for (const i in Modules.standard[grp]) {
+        if (Modules.standard[grp][i].symbol && Modules.standard[grp][i].symbol.toLowerCase() === fdname) {
+          // Found it
+          return new Module({ template: Modules.standard[grp][i] });
+        }
+      }
+    }
+  }
+
+  // Check hardpoint modules
+  for (const grp in Modules.hardpoints) {
+    if (Modules.hardpoints.hasOwnProperty(grp)) {
+      for (const i in Modules.hardpoints[grp]) {
+        if (Modules.hardpoints[grp][i].symbol && Modules.hardpoints[grp][i].symbol.toLowerCase() === fdname) {
+          // Found it
+          return new Module({ template: Modules.hardpoints[grp][i] });
+        }
+      }
+    }
+  }
+
+  // Check internal modules
+  for (const grp in Modules.internal) {
+    if (Modules.internal.hasOwnProperty(grp)) {
+      for (const i in Modules.internal[grp]) {
+        if (Modules.internal[grp][i].symbol && Modules.internal[grp][i].symbol.toLowerCase() === fdname) {
+          // Found it
+          return new Module({ template: Modules.internal[grp][i] });
+        }
+      }
+    }
+  }
+  console.log(fdname)
+
+  // Not found
+  return null;
+}
+/**
+ * Build a ship from the journal Loadout event JSON
+ * @param {object} json the Loadout event JSON
+ * @return {Ship} the built ship
+ */
+export function shipFromLoadoutJSON(json) {
+// Start off building a basic ship
+  const shipModel = shipModelFromJson(json);
+  if (!shipModel) {
+    throw 'No such ship found: "' + json.Ship + '"';
+  }
+  const shipTemplate = Ships[shipModel];
+
+  let ship = new Ship(shipModel, shipTemplate.properties, shipTemplate.slots);
+  ship.buildWith(null);
+  // Initial Ship building, don't do engineering yet.
+  for (const module of json.Modules) {
+    switch (module.Slot) {
+      // Cargo Hatch.
+      case 'CargoHatch':
+        ship.cargoHatch.enabled = module.On;
+        ship.cargoHatch.priority = module.Priority;
+        break;
+      // Add the bulkheads
+      case 'Armour':
+        if (module.Item.endsWith('_Armour_Grade1')) {
+          ship.useBulkhead(0, true);
+        } else if (module.Item.endsWith('_Armour_Grade2')) {
+          ship.useBulkhead(1, true);
+        } else if (module.Item.endsWith('_Armour_Grade3')) {
+          ship.useBulkhead(2, true);
+        } else if (module.Item.endsWith('_Armour_Mirrored')) {
+          ship.useBulkhead(3, true);
+        } else if (module.Item.endsWith('_Armour_Reactive')) {
+          ship.useBulkhead(4, true);
+        } else {
+          throw 'Unknown bulkheads "' + module.Item + '"';
+        }
+        ship.bulkheads.enabled = true;
+        break;
+      case 'PowerPlant':
+        const powerplant = _moduleFromFdName(module.Item);
+        ship.use(ship.standard[0], powerplant, true);
+        ship.standard[0].enabled = module.On;
+        ship.standard[0].priority = module.Priority;
+        break;
+      case 'MainEngines':
+        const thrusters = _moduleFromFdName(module.Item);
+        ship.use(ship.standard[1], thrusters, true);
+        ship.standard[1].enabled = module.On;
+        ship.standard[1].priority = module.Priority;
+        break;
+      case 'FrameShiftDrive':
+        const frameshiftdrive = _moduleFromFdName(module.Item);
+        ship.use(ship.standard[2], frameshiftdrive, true);
+        ship.standard[2].enabled = module.On;
+        ship.standard[2].priority = module.Priority;
+        break;
+      case 'LifeSupport':
+        const lifesupport = _moduleFromFdName(module.Item);
+        ship.use(ship.standard[3], lifesupport, true);
+        ship.standard[3].enabled = module.On === true;
+        ship.standard[3].priority = module.Priority;
+        break;
+      case 'PowerDistributor':
+        const powerdistributor = _moduleFromFdName(module.Item);
+        ship.use(ship.standard[4], powerdistributor, true);
+        ship.standard[4].enabled = module.On;
+        ship.standard[4].priority = module.Priority;
+        break;
+      case 'Radar':
+        const sensors = _moduleFromFdName(module.Item);
+        ship.use(ship.standard[5], sensors, true);
+        ship.standard[5].enabled = module.On;
+        ship.standard[5].priority = module.Priority;
+        break;
+      case 'FuelTank':
+        const fueltank = _moduleFromFdName(module.Item);
+        ship.use(ship.standard[6], fueltank, true);
+        ship.standard[6].enabled = true;
+        ship.standard[6].priority = 0;
+        break;
+      default:
+    }
+    if (module.Slot.search(/Hardpoint/) !== -1) {
+      // Add hardpoints
+      let hardpointClassNum = -1;
+      let hardpointSlotNum = -1;
+      let hardpointArrayNum = 0;
+      for (let i in shipTemplate.slots.hardpoints) {
+        if (shipTemplate.slots.hardpoints[i] === hardpointClassNum) {
+          // Another slot of the same class
+          hardpointSlotNum++;
+        } else {
+          // The first slot of a new class
+          hardpointClassNum = shipTemplate.slots.hardpoints[i];
+          hardpointSlotNum = 1;
+        }
+
+        // Now that we know what we're looking for, find it
+        const hardpointName = HARDPOINT_NUM_TO_CLASS[hardpointClassNum] + 'Hardpoint' + hardpointSlotNum;
+        const hardpointSlot = json.Modules.find(elem => elem.Slot === hardpointName);
+        if (!hardpointSlot) {
+          // This can happen with old imports that don't contain new hardpoints
+        } else if (!hardpointSlot) {
+          // No module
+        } else {
+          const hardpoint = _moduleFromFdName(hardpointSlot.Item);
+          ship.use(ship.hardpoints[hardpointArrayNum], hardpoint, true);
+          ship.hardpoints[hardpointArrayNum].enabled = hardpointSlot.On;
+          ship.hardpoints[hardpointArrayNum].priority = hardpointSlot.Priority;
+        }
+        hardpointArrayNum++;
+      }
+    }
+    if (module.Slot.search(/Slot\d/) !== -1) {
+      let internalSlotNum = 1;
+      let militarySlotNum = 1;
+      for (let i in shipTemplate.slots.internal) {
+        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;
+        if (isMilitary) {
+          const internalName = 'Military0' + militarySlotNum;
+          internalSlot = json.Modules.find(elem => elem.Slot === 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.find(elem => elem.Slot === internalName)) {
+                internalSlot = json.Modules.find(elem => elem.Slot === internalName);
+                break;
+              }
+            }
+            internalSlotNum++;
+          }
+        }
+
+        if (!internalSlot) {
+          // This can happen with old imports that don't contain new slots
+        } else if (!internalSlot) {
+          // No module
+        } else {
+          const internalJson = internalSlot;
+          const internal = _moduleFromFdName(internalJson.Item);
+          ship.use(ship.internal[i], internal, true);
+          ship.internal[i].enabled = internalJson.On === true;
+          ship.internal[i].priority = internalJson.Priority;
+        }
+      }
+    }
+
+  }
+  // We don't have any information on it so guess it's priority 5 and disabled
+  if (!ship.cargoHatch) {
+    ship.cargoHatch.enabled = false;
+    ship.cargoHatch.priority = 4;
+  }
+  console.log(ship);
+
+  // Now update the ship's codes before returning it
+  return ship.updatePowerPrioritesString().updatePowerEnabledString().updateModificationsString();
+}

src/index.ejs

@@ -57,7 +57,7 @@
     <!-- Bugsnag -->
     <script
     src="//d2wy8f7a9ursnm.cloudfront.net/bugsnag-3.min.js"
-    data-apikey="2382691c622937f28f8fa82a1bfd797a"></script>
+    data-apikey="ba9fae819372850fb660755341fa6ef5"></script>
 
   </head>
   <body style="background-color:#000;">

src/less/modal.less

@@ -54,6 +54,7 @@ textarea {
     width:100%;
     min-height: 10em;
     resize: vertical;
+    user-select: auto;
     margin:2em 0;
   }
 }

webpack.config.dev.js

@@ -4,6 +4,7 @@ var webpack = require('webpack');
 var pkgJson = require('./package');
 var HtmlWebpackPlugin = require("html-webpack-plugin");
 var ExtractTextPlugin = require("extract-text-webpack-plugin");
+var WebpackNotifierPlugin = require('webpack-notifier');
 
 function CopyDirPlugin(source, destination) {
   this.source = source;
@@ -17,7 +18,7 @@ CopyDirPlugin.prototype.apply = function(compiler) {
 };
 
 module.exports = {
-  devtool: 'eval',
+  devtool: 'source-map',
   devServer: {
     headers: { "Access-Control-Allow-Origin": "*" }
   },
@@ -51,6 +52,7 @@ module.exports = {
         disable: false,
         allChunks: true
     }),
+    new WebpackNotifierPlugin({alwaysNotify: true}),
     new webpack.HotModuleReplacementPlugin(),
     new webpack.NoEmitOnErrorsPlugin()
   ],

webpack.config.prod.js

@@ -23,6 +23,7 @@ module.exports = {
     app: ['babel-polyfill', path.resolve(__dirname, 'src/app/index')],
     lib: ['d3', 'react', 'react-dom', 'classnames', 'fbemitter', 'lz-string']
   },
+  devtool: 'source-map',
   resolve: {
     extensions: ['.js', '.jsx', '.json', '.less']
   },