poi-plugin-lbas-bis 0.1.0

package/src/poi-data.js

@@ -0,0 +1,154 @@
+'use strict';
+
+const RECON_MASTER_IDS = new Set([138, 178, 311, 312]);
+const LAND_BASED_API_TYPE_ROOTS = new Set([17, 21, 22, 25, 26]);
+const AIRCRAFT_EQUIP_TYPES = new Set([
+  6, 7, 8, 9, 10, 11,
+  25, 26,
+  41, 45, 47, 48, 49,
+  53, 54, 56, 57, 58, 59,
+]);
+const FIGHTER_EQUIP_TYPES = new Set([6, 45, 48]);
+const ATTACKER_EQUIP_TYPES = new Set([7, 8, 11, 47, 53, 57, 58, 59]);
+const RECON_EQUIP_TYPES = new Set([9, 10, 41, 49]);
+const SEAPLANE_BOMBER_EQUIP_TYPES = new Set([11]);
+
+function extractOwnedPlanes(poiState) {
+  const masterById = getMasterEquipment(poiState);
+  const ownedEquips = Object.values(poiState?.info?.equips || {});
+
+  return ownedEquips
+    .map((equip) => toPlaneInstance(equip, masterById[equip.api_slotitem_id]))
+    .filter(Boolean);
+}
+
+function extractOptimizationPlanes(poiState, options = {}) {
+  const includeMissing = options.includeMissing === true;
+  const maxCopiesPerMaster = Math.max(1, Number(options.maxCopiesPerMaster) || 4);
+  const missingProficiency = Math.max(0, Math.min(7, Number(options.missingProficiency ?? 7) || 0));
+  const masterById = getMasterEquipment(poiState);
+  const ownedPlanes = extractOwnedPlanes(poiState).map((plane) => ({
+    ...plane,
+    available: true,
+    missing: false,
+  }));
+
+  if (!includeMissing) {
+    return ownedPlanes;
+  }
+
+  const ownedCounts = new Map();
+
+  for (const plane of ownedPlanes) {
+    ownedCounts.set(plane.masterId, (ownedCounts.get(plane.masterId) || 0) + 1);
+  }
+
+  const theoreticalPlanes = Object.values(masterById)
+    .filter(isLbasCandidateMaster)
+    .flatMap((master) => {
+      const masterId = Number(master.api_id) || 0;
+      const ownedCount = ownedCounts.get(masterId) || 0;
+      const missingCount = Math.max(0, maxCopiesPerMaster - ownedCount);
+      return Array.from({ length: missingCount }, (_, index) =>
+        toPlaneInstance(
+          {
+            api_id: `missing-${masterId}-${index + 1}`,
+            api_slotitem_id: masterId,
+            api_level: 0,
+            api_alv: missingProficiency,
+          },
+          master,
+          {
+            available: false,
+            missing: true,
+            copyIndex: index + 1,
+          },
+        ),
+      );
+    })
+    .filter(Boolean);
+
+  return [...ownedPlanes, ...theoreticalPlanes];
+}
+
+function getMasterEquipment(poiState) {
+  const constants = poiState?.const || {};
+  if (constants.$equips) {
+    return constants.$equips;
+  }
+
+  const items = constants.api_mst_slotitem || {};
+  if (Array.isArray(items)) {
+    return Object.fromEntries(items.map((item) => [item.api_id, item]));
+  }
+  return items;
+}
+
+function toPlaneInstance(equip, master, overrides = {}) {
+  if (!equip || !master || !isLbasCandidateMaster(master)) {
+    return null;
+  }
+
+  const torpedo = Number(master.api_raig) || 0;
+  const bombing = Number(master.api_baku) || 0;
+  const antiAir = Number(master.api_tyku) || 0;
+
+  return {
+    instanceId: equip.api_id,
+    masterId: master.api_id || equip.api_slotitem_id,
+    name: master.api_name || `Item ${equip.api_slotitem_id}`,
+    antiAir,
+    intercept: Number(master.api_houk) || 0,
+    antiBomber: Number(master.api_bakk) || 0,
+    radius: Number(master.api_distance) || 0,
+    improvement: Number(equip.api_level) || 0,
+    proficiency: Number(equip.api_alv) || 0,
+    role: classifyRole(master, { antiAir, torpedo, bombing }),
+    isLandBased: isLandBasedMaster(master),
+    torpedo,
+    bombing,
+    available: true,
+    missing: false,
+    ...overrides,
+  };
+}
+
+function isLbasCandidateMaster(master) {
+  const masterId = Number(master.api_id) || 0;
+  const equipType = getEquipType(master);
+  return (
+    (Number(master.api_distance) || 0) > 0 &&
+    (RECON_MASTER_IDS.has(masterId) || AIRCRAFT_EQUIP_TYPES.has(equipType))
+  );
+}
+
+function classifyRole(master, stats) {
+  const masterId = Number(master.api_id) || 0;
+  const equipType = getEquipType(master);
+  if (RECON_MASTER_IDS.has(masterId) || RECON_EQUIP_TYPES.has(equipType)) {
+    return 'recon';
+  }
+  if (SEAPLANE_BOMBER_EQUIP_TYPES.has(equipType)) {
+    return 'seaplaneBomber';
+  }
+  if (ATTACKER_EQUIP_TYPES.has(equipType) || stats.torpedo > 0 || stats.bombing > 0) {
+    return 'attacker';
+  }
+  if (FIGHTER_EQUIP_TYPES.has(equipType) || stats.antiAir > 0) {
+    return 'fighter';
+  }
+  return 'unknown';
+}
+
+function getEquipType(master) {
+  return Number(master.api_type?.[2]) || 0;
+}
+
+function isLandBasedMaster(master) {
+  return LAND_BASED_API_TYPE_ROOTS.has(Number(master.api_type?.[0]) || 0);
+}
+
+module.exports = {
+  extractOptimizationPlanes,
+  extractOwnedPlanes,
+};

package/src/simulator-calc.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const {
+  airStateFor,
+  calculateBaseAirPower,
+  calculateEffectiveRadius,
+  requiredAirForState,
+} = require('./air-power');
+const { calculateBaseDamagePower } = require('./damage');
+const { normalizeSimulatorState } = require('./simulator-state');
+
+function calculateEnemyAirLines(enemyAir) {
+  return {
+    supremacy: requiredAirForState(enemyAir, 'supremacy'),
+    superiority: requiredAirForState(enemyAir, 'superiority'),
+    parity: requiredAirForState(enemyAir, 'parity'),
+    denial: requiredAirForState(enemyAir, 'denial'),
+  };
+}
+
+function calculateSimulatorSummary(state) {
+  const normalized = normalizeSimulatorState(state);
+  const enemyAir = normalized.enemy.enemyAir;
+  const bases = normalized.bases.map((base, baseIndex) => {
+    const loadout = base.slots.map((slot) => slot.plane).filter(Boolean);
+    const airPower = calculateBaseAirPower(loadout);
+    const radius = calculateEffectiveRadius(loadout);
+    const damagePower = calculateBaseDamagePower(loadout);
+    const stateForBase = airStateFor(airPower, enemyAir);
+
+    return {
+      baseIndex,
+      name: base.name,
+      airPower,
+      radius,
+      damagePower,
+      state: stateForBase,
+      loadout,
+    };
+  });
+  const waves = normalized.waves.map((wave, waveIndex) => {
+    const base = bases[wave.baseIndex] || bases[0] || emptyBaseSummary();
+    const stateForWave = airStateFor(base.airPower, enemyAir);
+    return {
+      waveIndex,
+      baseIndex: wave.baseIndex,
+      waveInBase: wave.waveInBase,
+      targetState: wave.targetState,
+      airPower: base.airPower,
+      state: stateForWave,
+      fulfilled: stateForWave.rank >= airStateRank(wave.targetState),
+    };
+  });
+
+  return {
+    bases,
+    waves,
+    enemyAirLines: calculateEnemyAirLines(enemyAir),
+    totalAirPower: bases.reduce((total, base) => total + base.airPower, 0),
+    statusKey: weakestStateKey(waves),
+  };
+}
+
+function emptyBaseSummary() {
+  return {
+    airPower: 0,
+    radius: 0,
+    damagePower: 0,
+    state: airStateFor(0, 0),
+    loadout: [],
+  };
+}
+
+function airStateRank(stateKey) {
+  return airStateFor(requiredAirForState(100, stateKey), 100).rank;
+}
+
+function weakestStateKey(waves) {
+  if (!waves.length) {
+    return 'loss';
+  }
+  return waves.reduce((weakest, wave) =>
+    wave.state.rank < weakest.rank ? wave.state : weakest,
+  waves[0].state).key;
+}
+
+module.exports = {
+  calculateEnemyAirLines,
+  calculateSimulatorSummary,
+};

package/src/simulator-state.js

@@ -0,0 +1,216 @@
+'use strict';
+
+const SLOTS_PER_BASE = 4;
+const WAVES_PER_BASE = 2;
+const MIN_BASES = 1;
+const MAX_BASES = 3;
+const DEFAULT_TARGET_RADIUS = 7;
+const DEFAULT_ENEMY_AIR = 72;
+const DEFAULT_TARGET_STATE = 'parity';
+const STATE_OPTIONS = new Set(['denial', 'parity', 'superiority', 'supremacy']);
+const BASE_NAMES = ['第一基地', '第二基地', '第三基地'];
+
+function createEmptySimulatorState(baseCount = 1) {
+  return normalizeSimulatorState({
+    targetRadius: DEFAULT_TARGET_RADIUS,
+    baseCount,
+    candidateMode: 'owned',
+    enemy: createDefaultEnemy(),
+    bases: [],
+    waves: [],
+  });
+}
+
+function normalizeSimulatorState(state = {}) {
+  const baseCount = clampBaseCount(state.baseCount);
+  return {
+    targetRadius: positiveNumber(state.targetRadius, DEFAULT_TARGET_RADIUS),
+    baseCount,
+    candidateMode: state.candidateMode === 'theoretical' ? 'theoretical' : 'owned',
+    enemy: normalizeEnemy(state.enemy),
+    bases: normalizeBases(state.bases, baseCount),
+    waves: normalizeWaves(state.waves, baseCount),
+  };
+}
+
+function setBaseCount(state, baseCount) {
+  return normalizeSimulatorState({
+    ...state,
+    baseCount,
+  });
+}
+
+function setBaseSlot(state, baseIndex, slotIndex, slotPatch) {
+  const normalized = normalizeSimulatorState(state);
+  if (!isValidBaseSlot(baseIndex, slotIndex, normalized.baseCount)) {
+    return normalized;
+  }
+
+  const bases = normalized.bases.map((base, currentBaseIndex) => {
+    if (currentBaseIndex !== baseIndex) {
+      return base;
+    }
+    return {
+      ...base,
+      slots: base.slots.map((slot, currentSlotIndex) =>
+        currentSlotIndex === slotIndex
+          ? { ...slot, ...slotPatch }
+          : slot,
+      ),
+    };
+  });
+
+  return normalizeSimulatorState({
+    ...normalized,
+    bases,
+  });
+}
+
+function setSlotLock(state, baseIndex, slotIndex, locked) {
+  return setBaseSlot(state, baseIndex, slotIndex, { locked: Boolean(locked) });
+}
+
+function setWaveTarget(state, waveIndex, targetState) {
+  const normalized = normalizeSimulatorState(state);
+  if (waveIndex < 0 || waveIndex >= normalized.waves.length) {
+    return normalized;
+  }
+
+  const waves = normalized.waves.map((wave, currentIndex) =>
+    currentIndex === waveIndex
+      ? { ...wave, targetState: normalizeTargetState(targetState) }
+      : wave,
+  );
+
+  return normalizeSimulatorState({
+    ...normalized,
+    waves,
+  });
+}
+
+function simulatorToOptimizerInput(state) {
+  const normalized = normalizeSimulatorState(state);
+  return {
+    baseCount: normalized.baseCount,
+    targetRadius: normalized.targetRadius,
+    enemyAir: normalized.enemy.enemyAir,
+    targetStates: normalized.waves.map((wave) => wave.targetState),
+    lockedBases: normalized.bases.map((base) => ({
+      slots: base.slots.map((slot) => ({
+        plane: slot.locked ? slot.plane : null,
+        locked: Boolean(slot.locked),
+      })),
+    })),
+  };
+}
+
+function createDefaultEnemy() {
+  return {
+    mode: 'manual',
+    enemyAir: DEFAULT_ENEMY_AIR,
+    areaId: null,
+    nodeId: null,
+    ships: Array.from({ length: 6 }, (_, index) => ({
+      id: null,
+      name: '',
+      airPower: index === 0 ? DEFAULT_ENEMY_AIR : 0,
+    })),
+  };
+}
+
+function normalizeEnemy(enemy = {}) {
+  const defaults = createDefaultEnemy();
+  const ships = Array.from({ length: 6 }, (_, index) => {
+    const ship = enemy.ships?.[index] || defaults.ships[index];
+    return {
+      id: ship.id ?? null,
+      name: ship.name || '',
+      airPower: nonNegativeNumber(ship.airPower, defaults.ships[index].airPower),
+    };
+  });
+  const summedAir = ships.reduce((total, ship) => total + ship.airPower, 0);
+  const enemyAir = enemy.enemyAir == null
+    ? summedAir
+    : nonNegativeNumber(enemy.enemyAir, DEFAULT_ENEMY_AIR);
+
+  return {
+    mode: enemy.mode || 'manual',
+    enemyAir,
+    areaId: enemy.areaId ?? null,
+    nodeId: enemy.nodeId ?? null,
+    ships,
+  };
+}
+
+function normalizeBases(bases = [], baseCount) {
+  return Array.from({ length: baseCount }, (_, baseIndex) => {
+    const base = bases[baseIndex] || {};
+    return {
+      name: base.name || BASE_NAMES[baseIndex] || `Base ${baseIndex + 1}`,
+      slots: normalizeSlots(base.slots),
+    };
+  });
+}
+
+function normalizeSlots(slots = []) {
+  return Array.from({ length: SLOTS_PER_BASE }, (_, slotIndex) => {
+    const slot = slots[slotIndex] || {};
+    return {
+      plane: slot.plane || null,
+      locked: Boolean(slot.locked),
+      proficiency: slot.proficiency ?? null,
+      improvement: slot.improvement ?? null,
+    };
+  });
+}
+
+function normalizeWaves(waves = [], baseCount) {
+  return Array.from({ length: baseCount * WAVES_PER_BASE }, (_, waveIndex) => {
+    const wave = waves[waveIndex] || {};
+    return {
+      baseIndex: Math.floor(waveIndex / WAVES_PER_BASE),
+      waveInBase: waveIndex % WAVES_PER_BASE,
+      targetState: normalizeTargetState(wave.targetState),
+    };
+  });
+}
+
+function normalizeTargetState(targetState) {
+  return STATE_OPTIONS.has(targetState) ? targetState : DEFAULT_TARGET_STATE;
+}
+
+function isValidBaseSlot(baseIndex, slotIndex, baseCount) {
+  return (
+    baseIndex >= 0 &&
+    baseIndex < baseCount &&
+    slotIndex >= 0 &&
+    slotIndex < SLOTS_PER_BASE
+  );
+}
+
+function clampBaseCount(value) {
+  const count = Number(value) || MIN_BASES;
+  return Math.max(MIN_BASES, Math.min(MAX_BASES, Math.floor(count)));
+}
+
+function positiveNumber(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : fallback;
+}
+
+function nonNegativeNumber(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number >= 0 ? number : fallback;
+}
+
+module.exports = {
+  SLOTS_PER_BASE,
+  WAVES_PER_BASE,
+  createEmptySimulatorState,
+  normalizeSimulatorState,
+  setBaseCount,
+  setBaseSlot,
+  setSlotLock,
+  setWaveTarget,
+  simulatorToOptimizerInput,
+};

package/src/ui/BaseTable.js

@@ -0,0 +1,134 @@
+'use strict';
+
+const React = require('react');
+
+const h = React.createElement;
+const PROFICIENCY_LABELS = ['-', '|', '||', '|||', '/', '//', '///', '>>'];
+
+function BaseTable(props) {
+  const { bases, equipment, summaries, onSlotPlaneChange, onSlotLockChange, t, styles } = props;
+  return h(
+    'div',
+    { style: styles.tableWrap },
+    h(
+      'table',
+      { style: styles.table },
+      h(
+        'thead',
+        null,
+        h(
+          'tr',
+          null,
+          h('th', { style: styles.th }, t('baseColumn')),
+          h('th', { style: styles.th }, t('equipment')),
+          h('th', { style: styles.th }, t('lock')),
+          h('th', { style: styles.th }, t('proficiency')),
+          h('th', { style: styles.th }, t('baseSummary')),
+        ),
+      ),
+      h(
+        'tbody',
+        null,
+        bases.flatMap((base, baseIndex) =>
+          base.slots.map((slot, slotIndex) =>
+            h(
+              'tr',
+              { key: `base-${baseIndex}-slot-${slotIndex}` },
+              slotIndex === 0
+                ? h('td', { rowSpan: base.slots.length, style: styles.baseName }, base.name)
+                : null,
+              h(
+                'td',
+                { style: styles.td },
+                renderEquipmentSelect({
+                  equipment,
+                  slot,
+                  baseIndex,
+                  slotIndex,
+                  onSlotPlaneChange,
+                  t,
+                  styles,
+                }),
+              ),
+              h(
+                'td',
+                { style: styles.centerTd },
+                h('input', {
+                  type: 'checkbox',
+                  checked: Boolean(slot.locked),
+                  onChange: (event) => onSlotLockChange(baseIndex, slotIndex, event.target.checked),
+                  title: t('lock'),
+                }),
+              ),
+              h(
+                'td',
+                { style: styles.centerTd },
+                h(
+                  'select',
+                  { value: slot.plane?.proficiency ?? '', disabled: true, style: styles.smallSelect },
+                  h('option', { value: '' }, '-'),
+                  PROFICIENCY_LABELS.map((label, index) =>
+                    h('option', { key: index, value: index }, label),
+                  ),
+                ),
+              ),
+              slotIndex === 0
+                ? h(
+                    'td',
+                    { rowSpan: base.slots.length, style: styles.summaryTd },
+                    formatSummary(summaries[baseIndex], t),
+                  )
+                : null,
+            ),
+          ),
+        ),
+      ),
+    ),
+  );
+}
+
+function renderEquipmentSelect(props) {
+  const { equipment, slot, baseIndex, slotIndex, onSlotPlaneChange, t, styles } = props;
+  const options = optionPlanes(equipment, slot.plane);
+  return h(
+    'select',
+    {
+      value: slot.plane ? String(slot.plane.instanceId) : '',
+      onChange: (event) => onSlotPlaneChange(baseIndex, slotIndex, event.target.value),
+      style: styles.select,
+    },
+    h('option', { value: '' }, t('none')),
+    options.map((plane) =>
+      h(
+        'option',
+        { key: String(plane.instanceId), value: String(plane.instanceId) },
+        `${plane.name} #${plane.instanceId}${plane.missing ? ' (未持有)' : ''}`,
+      ),
+    ),
+  );
+}
+
+function optionPlanes(equipment, currentPlane) {
+  const unique = new Map();
+  for (const plane of equipment || []) {
+    unique.set(String(plane.instanceId), plane);
+  }
+  if (currentPlane && !unique.has(String(currentPlane.instanceId))) {
+    unique.set(String(currentPlane.instanceId), currentPlane);
+  }
+  return [...unique.values()];
+}
+
+function formatSummary(summary, t) {
+  if (!summary) {
+    return '-';
+  }
+  return [
+    `${t('airPower')} ${summary.airPower}`,
+    `${t('radius')} ${summary.radius}`,
+    `${t('damagePower')} ${summary.damagePower}`,
+    t(summary.state.key),
+  ].join(' / ');
+}
+
+module.exports = BaseTable;

package/src/ui/EnemyPanel.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const React = require('react');
+
+const h = React.createElement;
+
+function EnemyPanel(props) {
+  const { enemy, lines, onEnemyAirChange, t, styles } = props;
+  return h(
+    'section',
+    { style: styles.enemyPanel },
+    h('h3', { style: styles.sectionTitle }, t('enemyFleet')),
+    h(
+      'div',
+      { style: styles.enemyControls },
+      h(
+        'label',
+        { style: styles.field },
+        h('span', null, t('enemyAir')),
+        h('input', {
+          type: 'number',
+          min: 0,
+          value: enemy.enemyAir,
+          onChange: (event) => onEnemyAirChange(Number(event.target.value)),
+          style: styles.input,
+        }),
+      ),
+      h('div', { style: styles.manualTag }, t('manualMode')),
+    ),
+    h(
+      'table',
+      { style: styles.table },
+      h('thead', null, h('tr', null, h('th', { style: styles.th }, t('enemyShipName')), h('th', { style: styles.th }, t('airPower')))),
+      h(
+        'tbody',
+        null,
+        enemy.ships.map((ship, index) =>
+          h(
+            'tr',
+            { key: `enemy-${index}` },
+            h('td', { style: styles.td }, ship.name || t('none')),
+            h('td', { style: styles.centerTd }, index === 0 ? enemy.enemyAir : ship.airPower),
+          ),
+        ),
+      ),
+    ),
+    h(
+      'div',
+      { style: styles.lines },
+      h('strong', null, `${t('necessaryLines')}: `),
+      `${t('supremacy')} ${lines.supremacy} / ${t('superiority')} ${lines.superiority} / ${t('parity')} ${lines.parity} / ${t('denial')} ${lines.denial}`,
+    ),
+  );
+}
+
+module.exports = EnemyPanel;