shared-travel-utils.js

// Shared travel utilities for space colonization game
// Pure functions for pathfinding and travel calculations
// Used by both client and server to ensure consistent travel logic

const { TRAVEL_CONFIG } = require('./shared-config.js');
const { positionsEqual, positionToString } = require('./shared-position-utils.js');

// =============================================================================
// PATHFINDING UTILITIES
// =============================================================================

/**
 * Find adjacent nodes for a given position using shared hexagon connections
 * Pure function - no side effects, no game state dependencies
 */
function getAdjacentNodes(position, intersectionNodes) {
  if (!Array.isArray(intersectionNodes)) {
    console.error('getAdjacentNodes: intersectionNodes is not an array:', typeof intersectionNodes);
    return [];
  }

  const currentNodeData = intersectionNodes.find(node => positionsEqual(node.position, position));

  if (!currentNodeData) return [];

  const adjacentPositions = new Set();

  // For each hex this node touches, find consecutive vertices on the same hex
  currentNodeData.connectedHexes.forEach(hexConnection => {
    const currentHexTileIndex = hexConnection.hexData.tileIndex;
    const currentNodePosition = hexConnection.nodePosition; // 0-5 position on hex

    // Find all other nodes that share this hex
    intersectionNodes.forEach(otherNode => {
      if (!positionsEqual(otherNode.position, position)) {
        // Check if other node is on the same hex
        const sharedHex = otherNode.connectedHexes.find(otherHex =>
          otherHex.hexData.tileIndex === currentHexTileIndex
        );

        if (sharedHex) {
          const otherNodePosition = sharedHex.nodePosition;

          // Only adjacent if consecutive positions on hex perimeter (0-1, 1-2, ..., 5-0)
          const positionDiff = Math.abs(currentNodePosition - otherNodePosition);
          const isConsecutive = positionDiff === 1 || positionDiff === 5; // Handle 0↔5 wrap-around

          if (isConsecutive) {
            adjacentPositions.add(positionToString(otherNode.position));
          }
        }
      }
    });
  });

  return Array.from(adjacentPositions).map(posStr => {
    const [x, y] = posStr.split('-').map(Number);
    return { x, y };
  });
}

/**
 * Calculate shortest path between two positions using BFS
 * Returns {distance, path} or null if no path exists
 * Pure function - no side effects, no game state dependencies
 */
function validateTravelPath(fromPosition, toPosition, intersectionNodes) {
  if (!Array.isArray(intersectionNodes)) {
    console.error('validateTravelPath: intersectionNodes is not an array:', typeof intersectionNodes);
    return null;
  }

  if (positionsEqual(fromPosition, toPosition)) {
    return { distance: 0, path: [fromPosition] };
  }

  const queue = [{ position: fromPosition, distance: 0, path: [fromPosition] }];
  const visited = new Set([positionToString(fromPosition)]);

  while (queue.length > 0) {
    const { position, distance, path } = queue.shift();

    // Get adjacent nodes through shared hexagons
    const neighbors = getAdjacentNodes(position, intersectionNodes);

    for (const neighborPosition of neighbors) {
      if (positionsEqual(neighborPosition, toPosition)) {
        return {
          distance: distance + 1,
          path: [...path, neighborPosition]
        };
      }

      const neighborKey = positionToString(neighborPosition);
      if (!visited.has(neighborKey)) {
        visited.add(neighborKey);
        queue.push({
          position: neighborPosition,
          distance: distance + 1,
          path: [...path, neighborPosition]
        });
      }
    }
  }

  return null; // No path found
}

// =============================================================================
// TRAVEL COST CALCULATIONS
// =============================================================================

/**
 * Calculate travel cost based on distance
 * Pure function using shared travel configuration
 */
function calculateTravelCost(distance) {
  const zapCost = distance * TRAVEL_CONFIG.BASE_COST_PER_HOP;
  const snowflakeCost = distance > TRAVEL_CONFIG.LONG_DISTANCE_THRESHOLD ?
    TRAVEL_CONFIG.LONG_DISTANCE_COST : 0;

  return {
    zap: zapCost,
    snowflake: snowflakeCost
  };
}

/**
 * Validate if a player can afford a travel cost
 * Pure function - checks resources against cost
 */
function canAffordTravel(playerResources, travelCost) {
  return playerResources.zap >= travelCost.zap &&
         playerResources.snowflake >= travelCost.snowflake;
}

/**
 * Calculate complete travel information (path + cost)
 * Combines pathfinding with cost calculation
 */
function calculateTravelInfo(fromPosition, toPosition, intersectionNodes) {
  const pathResult = validateTravelPath(fromPosition, toPosition, intersectionNodes);

  if (!pathResult) {
    return null; // No valid path
  }

  const cost = calculateTravelCost(pathResult.distance);

  return {
    distance: pathResult.distance,
    path: pathResult.path,
    cost: cost
  };
}

// =============================================================================
// MODULE EXPORTS
// =============================================================================

module.exports = {
  getAdjacentNodes,
  validateTravelPath,
  calculateTravelCost,
  canAffordTravel,
  calculateTravelInfo
};