Boat Management System

Overview

The boat management system allows users to track their boats, equipment, and equipment placement for 3D visualization. This is especially useful for trolling setups where precise equipment placement matters.

Key Features

1. Boat Tracking: Store boat specifications, registration, insurance, and condition
2. Equipment Management: Track all boat equipment (electronics, trolling gear, seating, etc.)
3. 3D Visualization: Store 3D coordinates for equipment placement using Three.js
4. Boat Styles: Generic 3D models by boat style (not specific boat models)
5. Trolling Setups: Configure and visualize trolling equipment placement

Entities

Boat

Represents a user's boat with full specifications.

Key Fields:

• Name: User-friendly name (e.g., "The Reel Deal")
• Make, Model, Year: Boat identification
• BrandId: Optional brand reference
• BoatStyle: Style for 3D model (Center Console, Bass Boat, etc.)
• BoatStyleModelId: Reference to 3D model data
• Specifications: Length, Beam, Draft, Weight, Capacity, Max HP
• Hull: Material, Color, Serial Number
• Engine: Make, Model, HP, Year, Hours
• Registration & Insurance: Numbers, expiration dates
• Condition: Current condition status

Relationships:

• User: Owner of the boat
• Brand: Boat manufacturer (optional)
• BoatStyleModel: 3D model reference (optional)
• Equipment: Collection of boat equipment
• EquipmentPlacements: Equipment locations on boat
• FishingSessions: Sessions where boat was used

BoatEquipment

Represents equipment that can be mounted on a boat.

Key Fields:

• EquipmentType: Type of equipment (Livescope, CannonBall, Battery, etc.)
• Name: Equipment name (e.g., "Garmin Livescope LVS34")
• Make, Model: Equipment identification
• BrandId: Optional brand reference
• Type-specific fields: Power, Voltage, Capacity, Weight, Depth, Screen Size, Frequency
• SpecificationsJson: JSON for additional type-specific specs

Equipment Types:

• Electronics: Livescope, Garmin, Lowrance, Humminbird, Radar, Marine Radio, VHF, AIS, Autopilot, GPS, Fishfinder, Sonar, Chartplotter
• Power: Battery, Charger, Inverter, Generator, Solar Panel, Electrical Panel
• Trolling: CannonBall, Downrigger, PlanerBoard, TrollingMotor, Outrigger
• Seating: Seat, CaptainSeat, FishingSeat, Bench, Cushion
• Storage: RodHolder, TackleBox, Cooler, Livewell, Baitwell, StorageBox
• Safety: Anchor, AnchorWinch, Windlass, NavigationLights, Spotlight, Horn, BilgePump
• Fishing: TrollingSetup, RodRack, NetHolder, GaffHolder
• Other: BiminiTop, TTop, Tower, OutriggerPole

Relationships:

• User: Owner of equipment
• Brand: Equipment manufacturer (optional)
• Placements: Where equipment is placed on boats

BoatEquipmentPlacement

Stores the 3D location and orientation of equipment on a boat.

Key Fields:

• BoatId, BoatEquipmentId: What equipment on which boat
• 3D Position: PositionX, PositionY, PositionZ (in boat coordinate system)
• Rotation: RotationX, RotationY, RotationZ (pitch, yaw, roll in degrees)
• Scale: ScaleX, ScaleY, ScaleZ (for size adjustment)
• MountingPointName: Human-readable location (e.g., "Port Side", "Starboard Bow")
• MountingType: How it's mounted (e.g., "Flush Mount", "Rack Mount")
• IsPermanent: Permanent vs removable
• ConfigurationJson: JSON for setup-specific config (e.g., downrigger depth, speed)

Coordinate System:

• Origin (0,0,0): Center-bottom of boat
• X: Port (negative) to Starboard (positive)
• Y: Bottom (negative) to Top (positive)
• Z: Stern (negative) to Bow (positive)

BoatStyleModel

Stores 3D model data for boat styles (Three.js compatible).

Key Fields:

• BoatStyle: Style enum reference
• Name: Model name/version
• ModelDataJson: Three.js geometry data (vertices, faces, normals, UVs)
• ModelLengthFt, ModelBeamFt: Reference dimensions for scaling
• ModelFormat: Format (e.g., "Three.js JSON", "GLTF", "OBJ")
• DefaultMountingPointsJson: Predefined mounting point positions
• PreviewImageUrl, ThumbnailUrl: Preview images

Purpose: Provides generic 3D models by boat style, not specific boat models. Users can customize equipment placement on these generic models.

Usage Examples

Creating a Boat

var boat = new Boat
{
    UserId = userId,
    Name = "The Reel Deal",
    Make = "Ranger",
    Model = "Z520L",
    Year = 2020,
    BrandId = rangerBrandId,
    BoatStyle = BoatStyle.BassBoat,
    LengthFt = 20.5f,
    BeamFt = 7.5f,
    MaxCapacity = 4,
    MaxHorsepower = 250f,
    EngineMake = "Mercury",
    EngineHorsepower = 250f,
    Condition = BoatCondition.Excellent
};
context.Boats.Add(boat);

Adding Equipment

var livescope = new BoatEquipment
{
    UserId = userId,
    EquipmentType = BoatEquipmentType.Livescope,
    Name = "Garmin Livescope LVS34",
    Make = "Garmin",
    Model = "LVS34",
    BrandId = garminBrandId,
    ScreenSize = "9 inch",
    Frequency = "455kHz",
    PowerWatts = 600f
};
context.BoatEquipment.Add(livescope);

var downrigger = new BoatEquipment
{
    UserId = userId,
    EquipmentType = BoatEquipmentType.Downrigger,
    Name = "Cannon Mag 10",
    Make = "Cannon",
    Model = "Mag 10",
    BrandId = cannonBrandId,
    DepthFt = 200f,
    WeightLbs = 15f
};
context.BoatEquipment.Add(downrigger);

Placing Equipment on Boat (3D Coordinates)

// Place Livescope on console center
var livescopePlacement = new BoatEquipmentPlacement
{
    BoatId = boat.Id,
    BoatEquipmentId = livescope.Id,
    PositionX = 0f,      // Center (port/starboard)
    PositionY = 3.5f,    // 3.5 feet above bottom
    PositionZ = 2.0f,    // 2 feet forward from stern
    RotationX = 0f,      // No pitch
    RotationY = 0f,      // No yaw
    RotationZ = 0f,      // No roll
    MountingPointName = "Console Center",
    MountingType = "Flush Mount",
    IsPermanent = true
};
context.BoatEquipmentPlacements.Add(livescopePlacement);

// Place Downrigger on port side
var downriggerPlacement = new BoatEquipmentPlacement
{
    BoatId = boat.Id,
    BoatEquipmentId = downrigger.Id,
    PositionX = -3.0f,   // 3 feet to port (left side)
    PositionY = 1.0f,    // 1 foot above bottom
    PositionZ = 4.0f,    // 4 feet forward from stern
    RotationX = 0f,
    RotationY = 45f,     // Angled 45 degrees outward
    RotationZ = 0f,
    MountingPointName = "Port Side",
    MountingType = "Bracket Mount",
    IsPermanent = true,
    ConfigurationJson = "{\"maxDepth\": 200, \"defaultSpeed\": 2.5}"
};
context.BoatEquipmentPlacements.Add(downriggerPlacement);

Querying Boat with Equipment

var boatWithEquipment = context.Boats
    .Include(b => b.EquipmentPlacements)
        .ThenInclude(ep => ep.BoatEquipment)
    .Include(b => b.BoatStyleModel)
    .FirstOrDefault(b => b.Id == boatId);

// Get all equipment positions for 3D rendering
var equipmentPositions = boatWithEquipment.EquipmentPlacements
    .Select(ep => new
    {
        Equipment = ep.BoatEquipment.Name,
        Position = new { ep.PositionX, ep.PositionY, ep.PositionZ },
        Rotation = new { ep.RotationX, ep.RotationY, ep.RotationZ },
        Scale = new { ep.ScaleX, ep.ScaleY, ep.ScaleZ },
        MountingPoint = ep.MountingPointName
    })
    .ToList();

Trolling Setup Configuration

// Create a trolling setup with multiple downriggers
var trollingSetup = new BoatEquipment
{
    UserId = userId,
    EquipmentType = BoatEquipmentType.TrollingSetup,
    Name = "Great Lakes Trolling Setup",
    SpecificationsJson = @"{
        ""downriggers"": [
            {""side"": ""port"", ""depth"": 50, ""speed"": 2.5},
            {""side"": ""starboard"", ""depth"": 60, ""speed"": 2.5}
        ],
        ""planerBoards"": [
            {""side"": ""port"", ""distance"": 100},
            {""side"": ""starboard"", ""distance"": 100}
        ],
        ""cannonBalls"": [
            {""weight"": 10, ""depth"": 50},
            {""weight"": 12, ""depth"": 60}
        ]
    }"
};

3D Visualization Integration

Three.js Integration

The BoatEquipmentPlacement entity stores coordinates compatible with Three.js:

// Frontend: Load boat and equipment placements
const boat = await fetchBoat(boatId);
const placements = await fetchEquipmentPlacements(boatId);

// Load boat 3D model
const loader = new THREE.ObjectLoader();
const boatModel = loader.parse(boat.styleModel.modelDataJson);

// Place equipment
placements.forEach(placement => {
    const equipmentMesh = createEquipmentMesh(placement.equipment);
    
    // Set position
    equipmentMesh.position.set(
        placement.positionX,
        placement.positionY,
        placement.positionZ
    );
    
    // Set rotation (convert degrees to radians)
    equipmentMesh.rotation.set(
        THREE.MathUtils.degToRad(placement.rotationX),
        THREE.MathUtils.degToRad(placement.rotationY),
        THREE.MathUtils.degToRad(placement.rotationZ)
    );
    
    // Set scale
    equipmentMesh.scale.set(
        placement.scaleX,
        placement.scaleY,
        placement.scaleZ
    );
    
    boatModel.add(equipmentMesh);
});

Boat Style Models

Boat styles have generic 3D models stored in BoatStyleModel:

• Center Console: Generic center console boat model
• Bass Boat: Generic bass boat model
• Jon Boat: Generic jon boat model
• etc.

Users select a boat style, and the system loads the corresponding 3D model. Equipment can then be placed on the model using the coordinate system.

Benefits

1. Visual Setup Guides: New fishermen can see how equipment should be arranged
2. Trolling Configuration: Precisely configure trolling setups with visual feedback
3. Equipment Inventory: Track all boat equipment in one place
4. Session Tracking: Link fishing sessions to specific boats
5. Maintenance Records: Track boat condition and usage
6. 3D Visualization: Interactive 3D boat layouts for better understanding

Future Enhancements

• Equipment Templates: Pre-configured equipment setups for common scenarios
• Boat Comparison: Compare equipment setups between boats
• Equipment Sharing: Share equipment placement configurations with other users
• AR Integration: Augmented reality view of equipment placement
• Equipment Recommendations: Suggest equipment based on boat style and fishing method
• Maintenance Scheduling: Track maintenance needs for boat and equipment